Lambda表达式
Lambda是一个匿名函数
,可以理解为是一段可以传递的代码
(将代码像数据一样进行传递)
Lambda表达式的使用(6种情况)
1、举例:(o1,o2)-> Integer.compare(o1,o2);
2、格式:
-> :Lambda操作符 或 箭头操作符
->:左边:Lambda形参列表(其实就是接口中的抽象方法的形参列表)
->:右边:Lambda体(其实就是重写的抽象方法的方法体)
3、Lambda表达式的本质:作为(函数式)接口的实例
4、接口只能是函数式接口
语法格式一:无参,无返回值
Runnable r2 = () -> System.out.println("Hello lambda2");
//语法格式一:无参,无返回值
@Test
public void lambdaTest1(){
Runnable r1 = new Runnable() {
@Override
public void run() {
System.out.println("Hello Lambda1");
}
};
r1.run();
Runnable r2 = () -> {
System.out.println("Hello lambda2");
};
r2.run();
}
语法格式二:Lambda 需要一个参数,但是没有返回值
Consumer<String> con2 = (String s) -> {
System.out.println(s);
};
//语法格式二:Lambda 需要一个参数,但是没有返回值
@Test
public void lambdaTest2(){
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con1.accept("Hello lambda1");
Consumer<String> con2 = (String s) -> {
System.out.println(s);
};
con2.accept("Hello lambda2");
}
语法格式三:数据类型可以省略
,因为可由编译器推断得出,称为“类型推断
”
Consumer<String> con2 = (s) -> {
System.out.println(s);
};
//语法格式三:数据类型可以省略,因为可由编译器推断得出,称为“类型推断”
@Test
public void lambdaTest3(){
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con1.accept("Hello lambda1");
Consumer<String> con2 = (s) -> {
System.out.println(s);
};
con2.accept("Hello lambda2");
}
语法格式四:Lambda 若只需要一个参数时,参数的小括号可以省略
Consumer<String> con2 = s -> {
System.out.println(s);
};
//语法格式四:Lambda 若只需要一个参数时,参数的小括号可以省略
@Test
public void lambdaTest4(){
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con1.accept("Hello lambda1");
Consumer<String> con2 = s -> {
System.out.println(s);
};
con2.accept("Hello lambda2");
}
语法格式五:Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com2 = (o1,o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
//语法格式五:Lambda 需要两个或以上的参数,多条执行语句,并且可以有返回值
@Test
public void lambdaTest5(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12, 63));
Comparator<Integer> com2 = (o1,o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
System.out.println(com2.compare(96, 10));
}
语法格式六:当 Lambda 体只有一条
语句时,return 与大括号
若有,都可以省略
Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
//语法格式六:当 Lambda 体只有一条语句时,return 与大括号若有,都可以省略
@Test
public void lambdaTest6(){
Comparator<Integer> com1 = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
System.out.println(com1.compare(12, 63));
Comparator<Integer> com2 = (o1,o2) -> o1.compareTo(o2);
System.out.println(com2.compare(100, 96));
}
总结
- ->左边:lambda形参列表的参数类型可以省略(类型推断):如果lambda形参列表只有一个参数,其一对()括号可以省略
- ->右边:lambda体应该是由一对{}包裹;如果lambda体只有一条执行语句(可能是return语句),可以省略这一对{}和return关键字
函数式(Functional)接口
如果一个接口中,只声明了一个抽象方法,就是函数时接口
可以在一个接口上使用@FunctionalInterface注解,检查它是否是一个函数式接口
以前用匿名实现类表示的现在都可以用Lambda表达式来写
方法引用与构造器引用
当要传递给Lambda体的操作,已经有实现的方法了,可以使用方法引用
方法引用,本质上就是lambda表达式,而lambda表达式作为函数式接口的实例。所以方法引用,也是函数式接口的实例
要求:实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致
(针对情况一和二)
有三种主要使用情况:
- 对象::非静态方法名
- 类::静态方法名
- 类::非静态方法名
方法引用
情况一:对象::非静态方法名
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1(){
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("北京");
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("beijing");
}
情况二:类::静态方法名
//Comparator中的void compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3(){
Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
System.out.println(com1.compare(12, 22));
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(22, 12));
}
//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4(){
Function<Double,Long> func1 = d -> Math.round(d);
System.out.println(func1.apply(12.3));
Function<Double,Long> func2 = Math::round;
System.out.println(func2.apply(22.4));
}
情况三:类::非静态方法名
//Comparator中的int comapre(T t1,T t2)
//String中的int t1.compareTo(t2)
@Test
public void test5(){
Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
System.out.println(com1.compare("ab", "abc"));
Comparator<String> com2 = String::compareTo;
System.out.println(com2.compare("ab", "abo"));
}
//BiPredicate中的boolean test(T t1,T t2)
//String中的boolean t1.equals(t2)
@Test
public void test6(){
BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
System.out.println(pre1.test("abc", "abc"));
BiPredicate<String,String> pre2 = String :: equals;
System.out.println(pre2.test("abc", "abe"));
}
//Function中的R apply(T t)
//Employee中的String getName()
@Test
public void test7(){
Employee emp = new Employee(1001,"jack",23,8000);
Function<Employee,String> func1 = e -> e.getName();
System.out.println(func1.apply(emp));
Function<Employee,String> func2 = Employee::getName;
System.out.println(func2.apply(emp));
}
构造器的引用
和方法引用类似,函数式接口的抽象方法的形参列表和构造器的相残列表一致。抽象方法的返回值类型即为构造器所属的类的类型
//构造器引用
//Supplier中的T get()
//Employee的空参构造器:Employee()
@Test
public void test1(){
Supplier<Employee> sup = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
System.out.println(sup.get());
Supplier<Employee> sup1 = () -> new Employee();
System.out.println(sup1.get());
Supplier<Employee> sup2 = Employee :: new;
System.out.println(sup2.get());
}
//Function中的R apply(T t)
@Test
public void test2(){
Function<Integer,Employee> func1 = id -> new Employee(id);
Employee employee = func1.apply(1003);
System.out.println(employee);
Function<Integer,Employee> func2 = Employee :: new;
Employee employee1 = func2.apply(1002);
System.out.println(employee1);
}
//BiFunction中的R apply(T t,U u)
@Test
public void test3(){
BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
System.out.println(func1.apply(1001, "Tom"));
BiFunction<Integer,String,Employee> func2 = Employee :: new;
System.out.println(func2.apply(1102, "jack"));
}
数组引用
可以把数组看做是一个特殊的类,则写法与构造器引用一致
//数组引用
//Function中的R apply(T t)
@Test
public void test4(){
Function<Integer,String[]> func1 = length ->new String[length];
String[] arr1 = func1.apply(5);
System.out.println(Arrays.toString(arr1));
Function<Integer,String[]> func2 = String[] :: new;
String[] arr2 = func2.apply(10);
System.out.println(Arrays.toString(arr2));
}
强大的Stream API
使用Stream API对集合数据进行操作,就类似于使用SQL执行的数据库查询
Stream和Collection集合的区别:Collection是一种静态的内存数据结构,而Stream是有关计算的。前者是主要面向内存,存储在内存中,后者主要是面向CPU,通过CPU实现计算。集合讲的是数据,Stream讲的是计算
- Stream自己不会存储元素
- Stream不会改变源对象,相反,他们会返回一个持有结果的新Stream
- Stream操作是延迟执行的。这意味着他们会等到需要结果的时候才执行
Stream的操作三个步骤:
- 1、创建Stream(Stream的实例化)
- 2、一系列的中间操作(过滤、映射…)
- 3、终止操作(终端操作)
说明:
- 一个中间操作链,对数据源的数据进行处理
- 一旦执行终止操作,就执行中间操作链,并产生结果。之后,不会再被使用
创建Stream的四种方式
创建Stream方式一:通过集合
//创建Stream方式一:通过集合
@Test
public void test1(){
List<Employee> employees = EmployeeData.getEmployees();
//default Stream<E> stream():返回一个顺序流
Stream<Employee> stream = employees.stream();
//default Stream<E> parallelStream():返回一个并行流
Stream<Employee> employeeStream = employees.parallelStream();
}
创建Stream方式二:通过数组
//创建Stream方式二:通过数组
@Test
public void test2(){
int[] arr = new int[]{1,2,3,4,5,6};
//调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
IntStream stream = Arrays.stream(arr);
Employee e1 = new Employee(1001,"Tom");
Employee e2 = new Employee(1002,"Jerry");
Employee[] arr1 = new Employee[]{e1,e2};
Stream<Employee> stream1 = Arrays.stream(arr1);
}
创建Stream方式三:通过Stream的of()
//创建Stream方式三:通过Stream的of()
@Test
public void test3(){
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);//这里的1,2,3,4...不是int类型而是Integer包装类型
}
创建Stream方式四:创建无限流
//创建Stream方式四:创建无限流
@Test
public void test4(){
//迭代
//public static<T> Stream<T> iterate(final T seed,final UnaryOperator<T> f)
//遍历前10个偶数
Stream.iterate(0,t -> t + 2).limit(10).forEach(System.out::println);
//生成
//public static<T> Stream<T> generate(Supplier<T> s)
Stream.generate(Math::random).limit(10).forEach(System.out::println);
}
Stream的中间操作
筛选与切片
//1、筛选与切片
@Test
public void test1(){
List<Employee> list = EmployeeData.getEmployees();
//filter(Predicate p)--接收 Lambda,从流中排除某些元素
Stream<Employee> stream = list.stream();
//查询员工表中薪资大于7000的员工信息
stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
System.out.println();
//limit(n)--载断流,使其元素不超过给定数量
list.stream().limit(3).forEach(System.out::println);//输出前三个
System.out.println();
//skip(n)--跳过元素,返回一个扔掉了前n个元素的流。若流中元素不足n个,则返回一个空流。与 limit(n) 互补
list.stream().skip(3).forEach(System.out::println);//跳过前三个
System.out.println();
//distinct()--筛选,通过流所生成元素的 hashCode() 和 equals() 去除重复元素
list.add(new Employee(1010,"刘强东",40,8000));
list.add(new Employee(1010,"刘强东",40,8000));
list.add(new Employee(1010,"刘强东",40,8000));
list.add(new Employee(1010,"刘强东",40,8000));
// System.out.println(list);
list.stream().distinct().forEach(System.out::println);//去除重复的元素
}
映射
//2、映射
@Test
public void test2(){
//map(Function f)--接收一个函数作为参数,该函数会被应用到每个元素上,并将其映射成一个新的元素
List<String> list = Arrays.asList("aa","bb","cc","dd");
list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
System.out.println();
//练习:获取员工姓名长度大于3的员工的姓名
List<Employee> employees = EmployeeData.getEmployees();
Stream<String> stringStream = employees.stream().map(e -> e.getName());
stringStream.filter(name -> name.length() > 3).forEach(System.out::println);
System.out.println();
//flatMap(Function f)--接收一个函数作为参数,将流中的每个值都换成另一个流,然后把所有流连接成一个流
Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
characterStream.forEach(System.out::println);
}
//将字符串中的多个字符构成的集合二转换为对应的Stream的实例
public static Stream<Character> fromStringToStream(String str){
ArrayList<Character> list = new ArrayList<>();
for(Character c : str.toCharArray()){
list.add(c);
}
return list.stream();
排序
//3、排序
@Test
public void test4(){
//sorted() 产生一个新流,其中按自然顺序排序(自然排序)
List<Integer> list = Arrays.asList(12,43,85,24,96,10,-85);
list.stream().sorted().forEach(System.out::println);
//抛异常,原因:Employee没有实现Comparable接口
// List<Employee> employees = EmployeeData.getEmployees();
// employees.stream().sorted().forEach(System.out::println);
//sorted(Comparator com) 产生一个新流,其中按比较器顺序排序(定制排序)
List<Employee> employees = EmployeeData.getEmployees();
employees.stream().sorted((e1,e2) -> {
int ageValue = Integer.compare(e1.getAge(),e2.getAge());//按照年龄从小到大排序
if(ageValue !=0){
return ageValue;//如果年龄不相等,按年龄从小到大排序
}else{
return -Double.compare(e1.getSalary(),e2.getSalary());//如果年龄相等按工资从高到底排序
}
}).forEach(System.out::println);
}
Stream的终止操作
匹配与查找
//1、匹配与查找
@Test
public void test1(){
List<Employee> employees = EmployeeData.getEmployees();
// allMatch(Predicate p) 检查是否匹配所有元素
//练习:是否所有的员工的年龄都大于18
boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
System.out.println(allMatch);
System.out.println();
// anyMatch(Predicate p) 检查是否至少匹配一个元素
//练习:是否存在员工的工资大于10000
boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
System.out.println(anyMatch);
System.out.println();
// noneMatch(Predicate p) 检查是否没有匹配所有元素
//练习:是否存在员工姓:“雷”
boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
System.out.println(noneMatch);
System.out.println();
// findFirst() 返回第一个元素
Optional<Employee> employee = employees.stream().findFirst();
System.out.println(employee);
System.out.println();
// findAny() 返回当前流中的任意元素
Optional<Employee> employee1 = employees.parallelStream().findAny();
System.out.println(employee1);
}
@Test
public void test2(){
List<Employee> employees = EmployeeData.getEmployees();
// count() 返回流中元素总数
long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
System.out.println(count);
System.out.println();
// max(Comparator c) 返回流中最大值
//练习:返回最高的工资
Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
Optional<Double> maxSalary = salaryStream.max(Double::compare);
System.out.println(maxSalary);
System.out.println();
// min(Comparator c) 返回流中最小值
//练习:返回最低工资的员工
Optional<Employee> minSalary = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println(minSalary);
System.out.println();
// forEach(Consumer c)--内部迭代
employees.stream().forEach(System.out::println);
// 使用集合的遍历操作
employees.forEach(System.out::println);
System.out.println();
// 内部迭代(使用 Collection 接口需要用户去做迭代,称为外部迭代。相反,Stream API 使用内部迭代——它帮你把迭代做了)
}
归纳
//2、归约
@Test
public void test3(){
// reduce(T iden, BinaryOperator b) 可以将流中元素反复结合起来,得到一个值。返回 T
//练习:计算1-10的自然数的和
List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
Integer sum = list.stream().reduce(0, Integer::sum);
System.out.println(sum);
System.out.println();
// reduce(BinaryOperator b) 可以将流中元素反复结合起来,得到一个值。返回 Optional<T>
//练习:计算公司所有员工工资的总和
List<Employee> employees = EmployeeData.getEmployees();
Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
Optional<Double> sum1 = salaryStream.reduce(Double::sum);
System.out.println(sum1);
}
收集
//3、收集
@Test
public void test4(){
// collect(Collector c)--将流转换为其他形式。接收一个 Collector接口的实现,用于给Stream中元素做汇总的方法
//练习:查找工资大于6000的员工,结果返回为一个list或Set
List<Employee> employees = EmployeeData.getEmployees();
List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());
employeeList.forEach(System.out::println);
Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
employeeSet.forEach(System.out::println);
}
Optional类
Optional类(java.util.Optional)是一个容器类,它可以保存类型T的值,代表这个值存在。或者仅仅保存null,表示这个值不存在。原来用null表示一个值不存在,现在Optional可以更好的表达这个概念。并且可以避免空指针异常。
创建Optional类对象的方法
- Optional.of(T t) : 创建一个 Optional 实例,t必须非空;
- Optional.empty() : 创建一个空的 Optional 实例
- Optional.ofNullable(T t):t可以为null
判断Optional容器中是否包含对象
- boolean isPresent() : 判断是否包含对象
- void ifPresent(Consumer<? super T> consumer) :如果有值,就执行Consumer接口的实现代码,并且该值会作为参数传给它
获取Optional容器的对象
- T get(): 如果调用对象包含值,返回该值,否则抛异常
- T orElse(T other) :如果有值则将其返回,否则返回指定的other对象。
- T orElseGet(Supplier<? extends T> other) :如果有值则将其返回,否则返回由Supplier接口实现提供的对象。
- T orElseThrow(Supplier<? extends X> exceptionSupplier) :如果有值则将其返回,否则抛出由Supplier接口实现提供的异常