目录
== 一、Lambda表达式==
二、函数时(Functional)接口
三、方法引用与构造器引用
四、强大的Stream API
五、Optional类
一、Lambda表达式
Lanmbda表达式举例1
Lanmbda表达式举例2
语法解释
1、举例:(o1,o2) -> Integer.compare(o1,o2);
2、格式
->:Lambda操作符
-> 的左边:Lambda的形参列表(其实就是接口中的抽象方法的形参列表)
-> 的右边:Lambda体(其实就是重写的抽象方法的方法体,是抽象方法的
实现逻辑,也即Lambda 表达式要执行的功能)
Lambda表达式的使用
代码演示
@Test
public void test1(){
//语法格式一:无参,无返回值
Runnable runnable = () -> {
System.out.println("我爱北京故宫");
};
runnable.run();
//语法格式二:Lambda 需要一个参数,但是没有返回值
Consumer<String> con1 = new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
};
con1.accept("重庆火锅");
Consumer<String> con2 = (String s) -> {
System.out.println(s);
};
con2.accept("抄手");
//语法格式三:数据类型可以省略,因为可由编译器推断得到(类型推断)
Consumer<String> con3 = (s) -> {
System.out.println(s);
};
con3.accept("小面");
//语法格式四:Lambda 若只需要一个参数,参数的小阔号可以从省略
Consumer<String> con4 = s -> {
System.out.println(s);
};
con4.accept("大米");
//语法格式五:Lambda 需要两个或两个以上的参数,多条执行语句,并且可以有返回值
Comparator<Integer> com = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1.compareTo(o2);
}
};
Comparator<Integer> com2 = (o1,o2) -> {
System.out.println(o1);
System.out.println(o2);
return o1.compareTo(o2);
};
//语法格式六: 当Lambda体只有一条语句时,return与大括号若有,都可以省略
Comparator<Integer> com3 = (o1,o2) -> o1.compareTo(o2);
Runnable runnable2 = () -> System.out.println("我爱北京故宫");
runnable2.run();
}
总结
- Lambda表达式的本质:作为接口的实例(要求接口时函数式接口)
- ->左边:Lambda形参列表的参数u类型可以省略(类型推断):如果Lambda形参列表只有一个参数,他的一对括号()可以省略,有多个参数就不要省略了
- ->右边:Lambda体:一般应该使用一对大括号{}进行包裹,如果Lambda体只有一条执行语句,return和大括号{}可以省略
二、函数时(Functional)接口
如果一个接口中,只声明了一个抽象方法,则此接口就成为函数式接口
Lambda表达式只能对函数式接口使用
注解@FunctionalInterface
自定义函数式接口
Java内置的四大核心函数式接口
其他接口
使用Lambda表达式后
三、方法引用与构造器引用
方法引用使用的要求:
- 接口中的抽象方法的形参列表和返回值的类型,与方法引用的方法的形参列表和返回值的类型相同(针对情况1和情况2)
方法引用的使用
-
1、使用情景:当要传递个Lambda体的操作,已经有实现的方法了,就可以使用方法引用了
-
2、方法引用,本质上就是Lambda表达式,而Lambda表达式,作为函数式接口的实例,所以方法引用,也式函数式接口的实例
-
3、使用格式:
类(或对象)::方法名
调用者 要调用的方法
4、具体分为如下三种情况
- 情况1 对象::非静态方法
Consumer 中的 void accept(T t)
PrintStream 中的 void println(T t)
//使用Lambda表达式
Consumer<String> con1 = str -> System.out.println(str);
con1.accept("北京");
//使用方法引用
PrintStream ps = System.out;
Consumer<String> con2 = ps::println;
con2.accept("南京");
Suplier 中的 T get()
Employee 中的 String getName()
//使用Lambda表达式
Employee emp = new Employee(1001,"Tom");
Supplier<String> sup1 = () -> "东京"+emp.getName();
System.out.println(sup1.get());
//使用方法引用
Supplier<String> sup2 = emp::getName;
System.out.println(sup2.get());
- 情况2 类::静态方法
Comparator中的int compara(T t1,T t2)
Integer 中的 int compara(T t1,T t2)
//使用Lambda表达式
Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
//使用方法引用
Comparator<Integer> com2 = Integer::compare;
System.out.println(com2.compare(12, 3));
Funcation 中的 Rapply(T t)
Math 中的Long round(Double d)
//使用Lambda表达式
Function<Double,Long> func1 = d -> Math.round(d);
//使用方法引用
Function<Double,Long> func2 = Math :: round;
- 情况3 类::非静态方法(有难度)
Compaare 中的 int compare(T t1,T t2)
String 中的 int t1.compareTo(t2)
//使用Lambda表达式
Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
System.out.println(com1.compare("abc","abd"));
//使用方法引用
Comparator<String> com2 = String::compareTo;
System.out.println(com2.compare("abc","abd"));
BiPredicate中的boolean test(T t1,T t2)
String 中的 boolean t1.equals(t2)
//使用Lambda表达式
BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
System.out.println(pre1.test("abc","abd"));
//使用方法引用
BiPredicate<String,String> pre2 = String::equals;
System.out.println(pre2.test("abc","abd"));
Function中的R apply(T t)
Employee中的String getName()
//使用Lambda表达式
Employee employee = new Employee(1001, "Tom", 23, 2000);
Function<Employee,String> func1 = e -> e.getName();
System.out.println(func1.apply(employee));
//使用方法引用
Function<Employee,String> func2 = Employee::getName;
System.out.println(func2.apply(employee));
构造器引用与项目引用的使用
和方法引用类似.,函数式接口的抽象方法的形参列表和构造器的形参列表一致
抽象方法的返回值类型即为构造器的类型
- 实例一
Suppiler 中的E get()
Employee 的空参构造器: Employee()
//原版写法
Supplier<Employee> sup1 = new Supplier<Employee>() {
@Override
public Employee get() {
return new Employee();
}
};
//Lambda表达式
Supplier<Employee> sup2 = () -> new Employee();
//构造器引用
Supplier<Employee> sup3 = Employee::new;
System.out.println(sup2.get());
- 举例二
Function 中的 get(T t)
Employee中的构造器 Employee(int id);
//Lambda表达式
Function<Integer,Employee> func1 = id -> new Employee(id);
Employee employee = func1.apply(1001);
System.out.println(employee);
//构造器引用(id不用写,)
Function<Integer,Employee> func2 = Employee::new;
- 举例三
BiDunction 中的 apply(T t,U u)
Employee中的构造器Employee(int id, String name)
// Lambda表达式
BiFunction<Integer,String,Employee> biFunc1 = (id,name) -> new Employee(id,name);
Employee employee2 = biFunc1.apply(1002,"Tom");
System.out.println(employee2);
//构造器引用
BiFunction<Integer,String,Employee> biFunc2 = Employee::new;
Employee employee3 = biFunc2.apply(1003,"Lucy");
数组引用
可以把数组看作式一个特殊的类,则写法与构造器一致
//Lambda表达式
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(6);
System.out.println(Arrays.toString(arr2));
四、强大的Stream API
1、创建Stream(Stream的实例化)
方式一:通过集合
//通过集合
List<Employee> employees = EmployeeData.getEmployees();
//default Stream<E> stream() : 返回一个顺序流
Stream<Employee> stream = employees.stream();
//default Stream<E> parallelStream() : 返回一个并行流
Stream<Employee> parallelStream = employees.parallelStream();
方式二:通过数组
//通过数组
int[] arr = new int[]{1,2,3,4,5,6,7};
//调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
IntStream stream1 = Arrays.stream(arr);
Employee employee = new Employee();
方式三:通过Stream类的of()方法![
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mE3oLTFp-1611071288887)(806F967243EB4D7BA762251B20FF05FD)]](https://img-blog.csdnimg.cn/2021012000014039.png)
//通过of()方法
Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);
方式四:创建无限流
//通过of()方法
Stream<Integer> stream2 = Stream.of(1, 2, 3, 4, 5, 6);
//创建无限流
//迭代
//遍历前10 个偶数
Stream.iterate(0,t -> t+2).limit(10).forEach(System.out::println);
//生成
Stream.generate(Math::random).limit(10).forEach(System.out::println);
2、Stream的中间操作
2.1 筛选与切片
@Test//1、筛选与切片
public void test2(){
List<Employee> list = EmployeeData.getEmployees();
Stream<Employee> stream = list.stream();
//filter():查询员工表中的薪资大于7000的员工
stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);
//limit():只要前n个元素
list.stream().limit(3).forEach(System.out::println);
//skip():跳过前n个元素
list.stream().skip(3).forEach(System.out::println);
//distinct():除去相同的元素(equals()和hashCode()判断)
list.stream().distinct().forEach(System.out::println);
}
2.2 映射
@Test//2、映射
public void test3(){
List<String> list = Arrays.asList("aa", "bb", "cc", "dd", "ee", "ff");
List<Employee> employees = EmployeeData.getEmployees();
//map():对每个数据进行运算,得出新的数据
list.stream().map(str -> str.toUpperCase()).forEach(System.out::print);
//练习1:获取员工姓名长度大于3的员工的姓名
Stream<String> namesStream = employees.stream().map(Employee::getName);
namesStream.filter(name -> name.length() > 3);
//flatMap():先map(),再把每个流连起来变成一个流(方法的返回值必须是Stream类型)
//练习2:
//map():按照正常方法得到的是地址
list.stream().map(StreamAPITest::fromStringToStream).forEach(s -> s.forEach(System.out::print));
list.stream().flatMap(StreamAPITest::fromStringToStream).forEach(System.out::print);
}
2.3 排序
@Test//3、排序
public void test5(){
List<Integer> list = Arrays.asList(15,34,53,46,76,35);
//如果要打其他内容,可以这么写
//sorted():自然排序
list.stream().sorted().forEach(s -> System.out.print(s+" "));
//sorted(Comparator com):定制排序
list.stream().sorted((i1,i2) -> -Integer.compare(i1,i2)).forEach(s -> System.out.print(s + " "));
}
3、Stream的终止操作
3.1 匹配与查找
@Test//1、匹配与查找
public void test6(){
List<Integer> list = Arrays.asList(15,34,53,46,76,35);
//allMatch():检查所有元素是否符合条件
System.out.println(list.stream().allMatch(s -> s > 5));
//anyMatch():检查是否存在一个元素 符合条件
System.out.println(list.stream().anyMatch(s -> s > 75));
//noneMatch():allMatch()取反
System.out.println(list.stream().noneMatch(s -> s > 5));
//max():按其中排序的最后一个
System.out.println(list.stream().max(Integer::compare));
//min():按其中排序的第一个
//forEach(): 迭代器
}
3.2 归约
@Test//2、归约
public void test7(){
List<Integer> list = Arrays.asList(15,34,53,46,76,35);
//reduce(T iden, BinaryOperator b):可以将流中元素反复结合起来,得到一个值。返回 T
//练习1:计算list的和 再 +10(sum方法正好是两个参数,可以用方法啊引用(BiFunction接口))
System.out.println(list.stream().reduce(10, Integer::sum));
System.out.println(list.stream().reduce(10, (i1, i2) -> i1 + i2));
//reduce(BinaryOperator b):可以将流中元素反复结合起来,得到一个值。返回 Optional<T>
}
3.3 收集
@Test//3、收集
public void test8(){
List<Integer> list = Arrays.asList(15,34,53,46,76,35);
//collect(Collector c):把流转换为其他类型
Set<Integer> set = list.stream().filter(i -> i > 50).collect(Collectors.toSet());
}
强大的Stream API : Collectors
五、Optional类
Optional类的创建
使用
代码演示
@Test
public void test1() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
// 如果女朋友存在就打印女朋友的信息
opt.ifPresent(System.out::println);
}
@Test
public void test2() {
Boy b = new Boy("张三");
Optional<Girl> opt = Optional.ofNullable(b.getGrilFriend());
// 如果有女朋友就返回他的女朋友,否则只能欣赏“嫦娥”了
Girl girl = opt.orElse(new Girl("嫦娥"));
System.out.println("他的女朋友是: " + girl.getName());
}
@Test
public void test3(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
//判断opt中员工对象是否满足条件,如果满足就保留,否则返回空
Optional<Employee> emp = opt.filter(e -> e.getSalary()>10000);
System.out.println(emp);
}
@Test
public void test4(){
Optional<Employee> opt = Optional.of(new Employee("张三", 8888));
//如果opt中员工对象不为空,就涨薪10%
Optional<Employee> emp = opt.map(e ->
{e.setSalary(e.getSalary()%1.1);return e;});
System.out.println(emp);
}