关于Java你不知道的那些事之Java8新特性[Lambda表达式和函数式接口]

Java8新特性[Lambda表达式和函数式接口]

Java8新特性[Lambda表达式和函数式接口]

前言
实例代码
策略设计模式
匿名内部类
Lambda表达式
学习Lambda
语法格式

1、无参，无返回值
2、有一个参数，有返回值
3、有多个参数，一个返回值
4、有多个参数，只有一条语句

类型推断

函数式接口
场景
训练
Java内置函数接口

Comsumer 消费型接口
Supplier 供给型接口
Function 函数型接口
Predicate 断言型接口
扩展

总结

前言

为什么要用Lambda表达式?
Lambda是一个匿名函数，我们可以把Lambda表达式理解为是一段可以传递的代码，将代码像数据一样传递，这样可以写出更简洁、更灵活的代码，作为一个更紧凑的代码风格，使Java语言表达能力得到了提升

实例代码
Lambda表达式最先替代的就是匿名内部类，假设原来我们写一个Comparator比较函数，采用匿名内部类的方式
/**
* 原来使用匿名内部类
*/
public static void test() {
// 使用匿名内部类，重写Intger的 compare方法
Comparator comparator = new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return Integer.compare(o1, o2);
}
};

 // 传入比较的方法 TreeSet<Integer> ts = new TreeSet<>(comparator);}

123456789101112131415
复制代码
然后在采用Lambda表达式后
/**
* 使用Lambda表达式解决匿名内部类需要编写大量模板语言的问题
*/
public static void test2() {
Comparator comparator = (x, y) -> Integer.compare(x, y);

 // 传入比较的方法 TreeSet<Integer> ts = new TreeSet<>(comparator);}

123456789
复制代码
策略设计模式
假设我们现在有一个需求，就是查找出员工里面年龄超过35的，我们使用策略设计模式
/**

• 员工类

• @author: 陌溪

• @create: 2020-04-05-12:13
  */
  public class Employee {
  private String name;
  private int age;
  private double salary;

  // set get
  }
  12345678910111213
  复制代码
  然后创建一个接口，这里就是判定条件
  /**

• 接口

• @param
  */
  public interface MyPredicte {
  public boolean test(T t);
  }

12345678
复制代码
我们实现这个接口
/**

• 按年龄过滤

• @author: 陌溪

• @create: 2020-04-05-12:23
  */
  public class FilterEmployeeByAge implements MyPredicte {

  @Override
  public boolean test(Employee employee) {
  return employee.getAge() > 35;
  }
  }
  12345678910111213
  复制代码
  然后在具体的例子中使用
  /**

  • 获取当前公司员工年龄大于35
    */
    public static void test3() {
    List employees = Arrays.asList(
    new Employee("张三", 18, 3333),
    new Employee("李四", 38, 55555),
    new Employee("王五", 50, 6666.66),
    new Employee("赵六", 16, 77777.77),
    new Employee("田七", 8, 8888.88)
    );

    MyPredicte mp = new FilterEmployeeByAge();
    List emps = new ArrayList<>();
    for (Employee emp : emps) {
    if(mp.test(emp)) {
    emps.add(emp);
    }
    }
    }
    1234567891011121314151617181920
    复制代码
    当某一天需求变更了，变成需要查找金额大于60000的，那么只需要在编写一个实现类即可
    /**

• 按薪资过滤

• @author: 轻狂书生FS

• @create: 2020-10-05-12:23
  */
  public class FilterEmployeeBySalary implements MyPredicte {

  @Override
  public boolean test(Employee employee) {
  return employee.getSalary() > 60000;
  }
  }

1234567891011121314
复制代码
那么具体使用只需要更改为
/**
* 获取当前公司薪资大于60000
*/
public static void test3() {
List employees = Arrays.asList(
new Employee("张三", 18, 3333),
new Employee("李四", 38, 55555),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 77777.77),
new Employee("田七", 8, 8888.88)
);

 MyPredicte<Employee> mp = new FilterEmployeeBySalary(); List<Employee> emps = new ArrayList<>(); for (Employee emp : emps) {  if(mp.test(emp)) {   emps.add(emp);  } }}

1234567891011121314151617181920
复制代码
这样一个方法，被称为策略设计模式
匿名内部类
使用上面的策略设计模式，我们会发现一个问题，就是每当我需要增加一个条件的时候，就需要增加一个实现类，如果条件多了的话，那么就会有很多实现类，那么为了优化，我们可以采取匿名内部类的方式
/**
* 优化方式，采用匿名内部类的方式
*/
public static void test5() {
List employees = Arrays.asList(
new Employee("张三", 18, 3333),
new Employee("李四", 38, 55555),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 77777.77),
new Employee("田七", 8, 8888.88)
);

 // 匿名内部类 filterEmployee(employees, new MyPredicte<Employee>() {  @Override  public boolean test(Employee employee) {   return employee.getSalary() <= 5000;  } });}

1234567891011121314151617181920
复制代码
直接在内部类中，使用我们的过滤条件
Lambda表达式
/**
* 使用Lambda表达式优化
*/
public static void test6() {
List employees = Arrays.asList(
new Employee("张三", 18, 3333),
new Employee("李四", 38, 55555),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 77777.77),
new Employee("田七", 8, 8888.88)
);

 List<Employee> list = filterEmployee(employees, (e) -> e.getSalary() <= 5000); list.forEach(System.out::println);}

123456789101112131415
复制代码
或者
/**
* 不使用策略模式
*/
public static void test7() {
List employees = Arrays.asList(
new Employee("张三", 18, 3333),
new Employee("李四", 38, 55555),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 77777.77),
new Employee("田七", 8, 8888.88)
);
employees.stream().filter(e-> e.getSalary() >= 5000).limit(2).forEach(System.out::println);

 System.out.println("========="); employees.stream().map(Employee::getName).forEach(System.out::println);}

12345678910111213141516
复制代码
学习Lambda
Lambda表达式基础语法：Java8中引入了一个新的操作符 "->" 该操作符称为箭头操作符 或 Lambda操作符
箭头操作符将Lambda表达式拆分为两部分：

左侧：Lambda表达式的参数列表（可以想象成，是上面定义的接口中抽象方法参数的列表）
右侧：Lambda表达式中，所需要执行的功能，即Lambda体（需要对抽象方法实现的功能）

语法格式
1、无参，无返回值
格式：
() -> System.out.println("hello");
1
复制代码
举例：
public static void test() {
Runnable r = new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
};

 System.out.println("========="); Runnable runnable = () -> {  System.out.println("hello lambda"); };}

1234567891011121314
复制代码
JDK1.8以后，调用Lambda外的值，不需要增加final字段，它默认已经添加了final
int n = 10;
Runnable runnable = () -> {
System.out.println("hello lambda" + n);
};
1234
复制代码
2、有一个参数，有返回值
格式：
(x) -> System.out.println(x);
或 (一个参数时，小括号可以省略不写)
x -> System.out.println(x);
123
复制代码
实例：
public static void test2() {
Consumer consumer = (x) -> System.out.println(x);
consumer.accept("我在bilibili");
}
1234
复制代码
3、有多个参数，一个返回值
/**
* 多个参数，有返回值
/
public static void test3() {
Comparator comparator = (x, y) -> {
System.out.println("函数式接口");
return Integer.compare(x, y);
};
}
123456789
复制代码
4、有多个参数，只有一条语句
这个时候，可以省略大括号 和 return
/*
* 多个参数，函数体只有一条，并且有返回值时
/
public static void test4() {
Comparator comparator = (x, y) -> Integer.compare(x, y);
}
1234567
复制代码
类型推断
Lambda中，表达式的参数列表的数据类型可以省略不写，因为JVM编译器通过上下文推断出，数据类型，即"类型推断"。
(Integer x, Integer y) -> Integer.compare(x, y);
1
复制代码
但是底层的类型检查还是有的，只是JDK底层帮我们做了类型检查这件事
函数式接口
Lambda表达式需要"函数式接口"的支持
函数式接口：接口中只有一个抽象方法的接口，称为函数式接口，如：
/*

• 函数式接口
  /
  public interface MyPredicte {
  public boolean test(T t);
  }
  123456
  复制代码
  可以使用注解 @FunctionalInterface 修饰的，则为函数式接口
  /*
• 接口，用于解决重复条件
• @param
  */
  @FunctionalInterface
  public interface MyPredicte {
  public boolean test(T t);
  }

123456789
复制代码
场景
对一个数进行某种运算
首先创建一个函数式接口
@FunctionalInterface
public interface MyFun {
public Integer getValue(Integer value);
}
1234
复制代码
然后在定义一个方法，把方法作为参数传递
/**
* 需求：对一个数进行运算
/
public static void test5() {
Integer value = operation(100, (x) -> xx);
System.out.println(value);
}

public static Integer operation(Integer num, MyFun myFun) { return myFun.getValue(num);}

1234567891011
复制代码
训练

调用Collections.sort()方法，通过定制排序比较两个Employee（先比较年龄比，年龄相同比较姓名），使用Lambda表达式
public static void test() {
List employees = Arrays.asList(
new Employee("张三", 18, 3333),
new Employee("李四", 38, 55555),
new Employee("王五", 50, 6666.66),
new Employee("赵六", 16, 77777.77),
new Employee("田七", 8, 8888.88)
);
Collections.sort(employees, (e1, e2) -> {
if(e1.getAge() == e2.getAge()) {
return e1.getName().compareTo(e2.getName());
} else {
return Integer.compare(e1.getAge(), e2.getAge());
}
});

employees.stream().map(Employee::getName).forEach(System.out::println);

}
复制代码
123456789101112131415161718

Java内置函数接口
Comsumer 消费型接口
格式：Comsumer
传入参数，然后对参数进行操作，没有返回值
/**
* 消费型接口
/
public static void test() {
happy(1000, (m) -> System.out.println("消费成功：" + m + "元"));
}
public static void happy(double money, Consumer consumer) {
consumer.accept(money);
}
123456789
复制代码
Supplier 供给型接口
格式：Supplier
T get();
传入参数，对参数进行操作，然后有返回值
/*
* 供给型接口，供给功能如何实现
*/
public static void test2() {
List list = getNumList(10, () -> {
Integer a = (int)(Math.random() * 10);
return a;
});

 list.stream().forEach(System.out::println);}/** * 产生指定个数的整数 * @param n * @return */public static List<Integer> getNumList(Integer n, Supplier<Integer> supplier) { List<Integer> list = new ArrayList<>(); for (int i = 0; i < n; i++) {  list.add(supplier.get()); } return list;}

123456789101112131415161718192021222324
复制代码
最后输出结果
0
5
9
4
4
3
4
5
0
3
12345678910
复制代码
Function 函数型接口
格式：Function<T,R>
R apply(T t);
/**
* 函数型接口
* Function<T, R>
*/
public static void test3() {
String str = strHandler("abcdefg", (x) -> {
return x.toUpperCase().substring(0, 5);
});
System.out.println(str);
}

/** * 需求：用于处理字符串 */public static String strHandler(String str, Function<String, String> function) { // 使用apply方法进行处理，怎么处理需要具体实现 return function.apply(str);}

123456789101112131415161718
复制代码
输出结果：
ABCDE
1
复制代码
Predicate 断言型接口
格式：Predicate， 用于做一些判断
/**
* 断言型接口(把长度大于3的str过滤出来)
*/
public static void test4() {
List list = Arrays.asList("abc", "abcd", "df", "cgg", "aaab");
List result = strPredict(list, (x) -> x.length() > 3);
result.forEach(item -> {
System.out.println(item);
});
}

/** * 将满足条件的字符串，放入到集合中 */public static List<String> strPredict(List<String> list, Predicate<String> predicate) { List<String> result = new ArrayList<>(); list.forEach(item -> {  if(predicate.test(item)) {   result.add(item);  } }); return result;}

1234567891011121314151617181920212223
复制代码
扩展
上述的四大核心接口，并不能被适用于一个特殊的应用场景，只能满足大部分的需求
因为他们对于参数的参入有局限性

同时后面针对这样的情况，后面也使用子接口，进行了解决

总结了2020面试题，这份面试题的包含的模块分为19个模块，分别是： Java 基础、容器、多线程、反射、对象拷贝、Java Web 、异常、网络、设计模式、Spring/Spring MVC、Spring Boot/Spring Cloud、Hibernate、MyBatis、RabbitMQ、Kafka、Zookeeper、MySQL、Redis、JVM 。
关注公众号：有故事的程序员，回复【电子书】获取上述资料。

原文转载：http://www.shaoqun.com/a/490666.html

递四方：https://www.ikjzd.com/w/1066

斑马物联网：https://www.ikjzd.com/w/1316

华翰物流：https://www.ikjzd.com/w/1799

Java8新特性[Lambda表达式和函数式接口]Java8新特性[Lambda表达式和函数式接口]前言实例代码策略设计模式匿名内部类Lambda表达式学习Lambda语法格式1、无参，无返回值2、有一个参数，有返回值3、有多个参数，一个返回值4、有多个参数，只有一条语句类型推断函数式接口场景训练Java内置函数接口Comsumer消费型接口Supplier供给型接口Function函数型接口Pr
jpgoodbuy：jpgoodbuy
tiki：tiki
深圳福田口岸到香港哪个购物区最近？：深圳福田口岸到香港哪个购物区最近？
英国有哪些热门景点？：英国有哪些热门景点？
秋季斯日格大典 ：秋季斯日格大典