Java8 函数式编程
理解Lambda
什么是Lambda？
对于一个Java变量，我们可以赋给其一个“值”。
如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？
比如，想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量，在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。
当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant，我们可以移除一些没用的声明。
这样，我们就成功的非常优雅的把“一块代码”赋给了一个变量。而“这块代码”，或者说“这个被赋给一个变量的函数”，就是一个Lambda表达式！
但是这里仍然有一个问题，就是变量aBlockOfCode的类型应该是什么？
在Java 8里面，所有的Lambda的类型都是一个接口，而Lambda表达式本身，也就是”那段代码“，需要是这个接口的实现。这是我认为理解Lambda的一个关键所在，简而言之就是，Lambda表达式本身就是一个接口的实现。直接这样说可能还是有点让人困扰，我们继续看看例子。我们给上面的aBlockOfCode加上一个类型：
这种只有一个接口函数需要被实现的接口类型，我们叫它“函数式接口”。为了避免后来的人在这个接口中增加接口函数导致其有多个接口函数需要被实现，变成"非函数接口”，我们可以在这个上面加上一个声明@FunctionalInterface, 这样别人就无法在里面添加新的接口函数了：
这样，我们就得到了一个完整的Lambda表达式声明：
Lambda表达式有什么作用？
最直观的作用就是使得代码变得异常简洁。
我们可以对比一下Lambda表达式和传统的Java对同一个接口的实现：
这两种写法本质上是等价的。但是显然，Java 8中的写法更加优雅简洁。并且，由于Lambda可以直接赋值给一个变量，我们就可以直接把Lambda作为参数传给函数，而传统的Java必须有明确的接口实现的定义，初始化才行。
有些情况下，这个接口实现只需要用到一次。传统的Java 7必须要求你定义一个“污染环境”的接口实现MyInterfaceImpl，而相较之下Java 8的Lambda, 就显得干净很多。
Lambda结合FunctionalInterface Lib, forEach, stream()，method reference等新特性可以使代码变的更加简洁！
假设Person的定义和List的值都给定。现在需要打印出guiltyPersons List里面所有lastName以"Z"开头的人的firstName。
原生态Lambda写法：定义两个函数式接口，定义一个静态函数，调用静态函数并给参数赋值Lambda表达式。
当然可以更简洁。在Java 8中有一个函数式接口的包，里面定义了大量可能用到的函数式接口（java.util.function (Java Platform SE 8 )）。所以，我们在这里压根都不需要定义NameChecker和Executor这两个函数式接口，直接用Java 8函数式接口包里的Predicate和Consumer就可以了——因为他们这一对的接口定义和NameChecker/Executor其实是一样的。
第一步简化，利用函数式接口包：
静态函数里面的for each循环其实是非常碍眼的。这里可以利用Iterable自带的forEach()来替代。forEach()本身可以接受一个Consumer 参数。
第二步简化，用Iterable.forEach()取代foreach loop：
由于静态函数其实只是对List进行了一通操作，这里我们可以甩掉静态函数，直接使用stream()特性来完成。stream()的几个方法都是接受Predicate，Consumer等参数的（java.util.stream (Java Platform SE 8 )）。
第三步简化，利用stream()替代静态函数：
对比最开始的Lambda写法，这里已经非常非常简洁了。但是如果，我们要求变一下，变成print这个人的全部信息，及p -> System.out.println§; 那么还可以利用Method reference来继续简化。所谓Method reference, 就是用已经写好的别的Object/Class的method来代替Lambda expression。格式如下：
第四步简化，如果是println§，则可以利用Method reference代替forEach中的Lambda表达式：
这基本上就是能写的最简洁的版本了。
Lambda配合Optional可以使Java对于null的处理变的异常优雅
这里假设我们有一个person object，以及一个person object的Optional wrapper:
Optional如果不结合Lambda使用的话，并不能使原来繁琐的null check变的简单。
只有当Optional结合Lambda一起使用的时候，才能发挥出其真正的威力！
我们现在就来对比一下下面四种常见的null处理中，Java 8的Lambda+Optional和传统Java两者之间对于null的处理差异。
情况一：存在则开干
情况二：存在则返回，无则返回屁
情况三：存在则返回，无则由函数产生
情况四：夺命连环null检查
由上述四种情况可以清楚地看到，Optional+Lambda可以让我们少写很多ifElse块。尤其是对于情况四那种夺命连环null检查，传统java的写法显得冗长难懂，而新的Optional+Lambda则清新脱俗，清楚简洁。
java重要的函数式接口
什么是函数式接口
函数接口是只有一个抽象方法的接口，用作 Lambda 表达式的类型。使用@FunctionalInterface注解修饰的类，编译器会检测该类是否只有一个抽象方法或接口，否则，会报错。可以有多个默认方法，静态方法。
java8自带的常用函数式接口。
| 函数接口 | 抽象方法 | 功能 | 参数 | 返回类型 |
|---|---|---|---|---|
| Predicate | test(T t) | 判断真假 | T | boolean |
| Consumer | accept(T t) | 消费消息 | T | void |
| Function | R apply(T t) | 将T映射为R（转换功能） | T | R |
| Supplier | T get() | 生产消息 | None | T |
| UnaryOperator | T apply(T t) | 一元操作 | T | T |
| BinaryOperator | apply(T t, U u) | 二元操作 | (T，T) | (T) |
public class Test {
public static void main(String[] args) {
Predicate<Integer> predicate = x -> x > 185;
Student student = new Student("张三", 23, 175);
System.out.println(
"张三的身高高于185吗？：" + predicate.test(student.getStature()));//false
Consumer<String> consumer = System.out::println;
consumer.accept("命运由我不由天");//命运由我不由天
Function<Student, String> function = Student::getName;
String name = function.apply(student);
System.out.println(name);//张三
Supplier<Integer> supplier =
() -> Integer.valueOf(BigDecimal.TEN.toString());
System.out.println(supplier.get());//10
UnaryOperator<Integer> unaryOperator = x-> x*x;
Integer i= unaryOperator.apply(3);
System.out.println(i);//9
BinaryOperator<Integer> operator = (x, y) -> x + y;
Integer sum= operator.apply(2, 3);
System.out.println(sum);//5
test(() -> "我是一个演示的函数式接口");
}
}
本篇所有示例都基于以下三个类。OutstandingClass：班级；Student：学生；SpecialityEnum：特长。
注意：Student::getName例子中这种编写lambda表达式的方式称为方法引用。格式为ClassNmae::methodName。
//自定义函数式接口使用
public interface StringFunc {
String func(String str);
}
public class MyStringOps {
public static String reverse(String str){
String result = "";
for (int i=str.length()-1;i>=0;i--){
result+=str.charAt(i);
}
return result;
}
}
public class MethodRefDemo {
public static String stringOp(StringFunc sf,String str){
return sf.func(str);
}
public static void main(String[] args) {
String inStr = "lambda add power to Java";
// MyStringOps::reverse 相当于实现了接口方法func()
// 并在接口方法func()中作了MyStringOps.reverse()操作
String op = stringOp(MyStringOps::reverse, inStr);
System.out.println(op);
}
}
方法引用
1.类名::静态方法名
2.对象::实例方法名
3.类名::实例方法名
4.类名::new
public class Student {
private String name;
public static int compareStudentByName(Student student1,Student student2){
return student1.getName().compareToIgnoreCase(student2.getName());
}
public int compareByName(Student student){
return this.getName() - student.getName();
}
}
//lambda
students.sort((o1, o2) -> o1.getName() - o2.getName());
//类名::静态方法名
students.sort(Student::compareStudentByName);
//对象::实例方法名
public class StudentComparator {
public int compareStudentByName(Student student1,Student student2){
return student2.getName() - student1.getName();
}
}
StudentComparator studentComparator = new StudentComparator();
students.sort(studentComparator::compareStudentByName);
//类名::实例方法名
students.sort(Student::compareByName);
//类名::new
Supplier<Student> supplier = Student::new;
//sort方法接收一个Comparator函数式接口，接口中唯一的抽象方法compare接收两个参数返回一个int类型值，下方是Comparator接口定义@FunctionalInterface
public interface Comparator<T> {
int compare(T o1, T o2);
}
使用条件:
a. lambda表达式实现函数式接口中的方法 参数列表，返回值类型 与 lambda体的中方法 参数列表，返回值类型必须一致
b. 如果lambda体中参数列表第一个参数是方法的调用者，第二个参数是调用方法的参数，可以使用类名::实例方法名
惰性求值与及早求值
惰性求值：只描述Stream，操作的结果也是Stream，这样的操作称为惰性求值。惰性求值可以像建造者模式一样链式使用，最后再使用及早求值得到最终结果。
| 方法 | 说明 |
|---|---|
| sequential | 返回一个相等的串行的Stream对象，如果原Stream对象已经是串行就可能会返回原对象 |
| parallel | 返回一个相等的并行的Stream对象，如果原Stream对象已经是并行的就会返回原对象 |
| unordered | 返回一个不关心顺序的Stream对象，如果原对象已经是这类型的对象就会返回原对象 |
| onClose | 返回一个相等的Steam对象，同时新的Stream对象在执行Close方法时会调用传入的Runnable对象 |
| close | 关闭Stream对象 |
| filter | 元素过滤：对Stream对象按指定的Predicate进行过滤，返回的Stream对象中仅包含未被过滤的元素 |
| map | 元素一对一转换：使用传入的Function对象对Stream中的所有元素进行处理，返回的Stream对象中的元素为原元素处理后的结果 |
| mapToInt | 元素一对一转换：将原Stream中的使用传入的IntFunction加工后返回一个IntStream对象 |
| flatMap | 元素一对多转换：对原Stream中的所有元素进行操作，每个元素会有一个或者多个结果，然后将返回的所有元素组合成一个统一的Stream并返回； |
| distinct | 去重：返回一个去重后的Stream对象 |
| sorted | 排序：返回排序后的Stream对象 |
| peek | 使用传入的Consumer对象对所有元素进行消费后，返回一个新的包含所有原来元素的Stream对象 |
| limit | 获取有限个元素组成新的Stream对象返回 |
| skip | 抛弃前指定个元素后使用剩下的元素组成新的Stream返回 |
| takeWhile | 如果Stream是有序的（Ordered），那么返回最长命中序列（符合传入的Predicate的最长命中序列）组成的Stream；如果是无序的，那么返回的是所有符合传入的Predicate的元素序列组成的Stream。 |
| dropWhile | 与takeWhile相反，如果是有序的，返回除最长命中序列外的所有元素组成的Stream；如果是无序的，返回所有未命中的元素组成的Stream。 |
及早求值：得到最终的结果而不是Stream，这样的操作称为及早求值。
| 方法 | 说明 |
|---|---|
| iterator | 返回Stream中所有对象的迭代器; |
| spliterator | 返回对所有对象进行的spliterator对象 |
| forEach | 对所有元素进行迭代处理，无返回值 |
| forEachOrdered | 按Stream的Encounter所决定的序列进行迭代处理，无返回值 |
| toArray | 返回所有元素的数组 |
| reduce | 使用一个初始化的值，与Stream中的元素一一做传入的二合运算后返回最终的值。每与一个元素做运算后的结果，再与下一个元素做运算。它不保证会按序列执行整个过程。 |
| collect | 根据传入参数做相关汇聚计算 |
| min | 返回所有元素中最小值的Optional对象；如果Stream中无任何元素，那么返回的Optional对象为Empty |
| max | 与Min相反 |
| count | 所有元素个数 |
| anyMatch | 只要其中有一个元素满足传入的Predicate时返回True，否则返回False |
| allMatch | 所有元素均满足传入的Predicate时返回True，否则False |
| noneMatch | 所有元素均不满足传入的Predicate时返回True，否则False |
| findFirst | 返回第一个元素的Optioanl对象；如果无元素返回的是空的Optional； 如果Stream是无序的，那么任何元素都可能被返回。 |
| findAny | 返回任意一个元素的Optional对象，如果无元素返回的是空的Optioanl。 |
| isParallel | 判断是否当前Stream对象是并行的 |
常用的流
- collect(Collectors.toList()) 将流转换为list，还有toSet()，toMap()等。及早求值
public class TestCase {
public static void main(String[] args) {
List<Student> studentList = Stream.of(new Student("路飞", 22, 175),
new Student("红发", 40, 180),
new Student("白胡子", 50, 185)).collect(Collectors.toList());
System.out.println(studentList);
}
}
//输出结果
//[Student{name='路飞', age=22, stature=175, specialities=null},
//Student{name='红发', age=40, stature=180, specialities=null},
//Student{name='白胡子', age=50, stature=185, specialities=null}]
- filter 起过滤筛选的作用，内部就是Predicate接口。惰性求值
例：筛选出出身高小于180的同学
public class TestCase {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List<Student> list = students.stream()
.filter(stu -> stu.getStature() < 180)
.collect(Collectors.toList());
System.out.println(list);
}
}
//输出结果
//[Student{name='路飞', age=22, stature=175, specialities=null}]
- map 转换功能，内部就是Function接口。惰性求值
例：将student对象转换为String对象，获取student的名字。
public class TestCase {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List<String> names = students.stream().map(student -> student.getName())
.collect(Collectors.toList());
System.out.println(names);
}
}
//输出结果
//[路飞, 红发, 白胡子]
- flatMap 将多个Stream合并为一个Stream。惰性求值
调用Stream.of的静态方法将两个list转换为Stream，再通过flatMap将两个流合并为一个。
public class TestCase {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
List<Student> studentList = Stream.of(students,
Arrays.asList(new Student("艾斯", 25, 183),
new Student("雷利", 48, 176)))
.flatMap(students1 -> students1.stream()).collect(Collectors.toList());
System.out.println(studentList);
}
}
//输出结果
//[Student{name='路飞', age=22, stature=175, specialities=null},
//Student{name='红发', age=40, stature=180, specialities=null},
//Student{name='白胡子', age=50, stature=185, specialities=null},
//Student{name='艾斯', age=25, stature=183, specialities=null},
//Student{name='雷利', age=48, stature=176, specialities=null}]
- max和min 在集合中求最大或最小值。及早求值
max、min接收一个Comparator（例子中使用java8自带的静态函数，只需要传进需要比较值即可。）并且返回一个Optional对象，该对象是java8新增的类，专门为了防止null引发的空指针异常。可以使用max.isPresent()判断是否有值；可以使用max.orElse(new Student())，当值为null时就使用给定值；也可以使用max.orElseGet(() -> new Student());这需要传入一个Supplier的lambda表达式。
public class TestCase {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
Optional<Student> max = students.stream()
.max(Comparator.comparing(stu -> stu.getAge()));
Optional<Student> min = students.stream()
.min(Comparator.comparing(stu -> stu.getAge()));
//判断是否有值
if (max.isPresent()) {
System.out.println(max.get());
}
if (min.isPresent()) {
System.out.println(min.get());
}
}
}
//输出结果
//Student{name='白胡子', age=50, stature=185, specialities=null}
//Student{name='路飞', age=22, stature=175, specialities=null}
- count 统计功能，一般都是结合filter使用，因为先筛选出我们需要的再统计即可。及早求值
public class TestCase {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
long count = students.stream().filter(s1 -> s1.getAge() < 45).count();
System.out.println("年龄小于45岁的人数是：" + count);
}
}
//输出结果
//年龄小于45岁的人数是：2
- reduce 可以实现从一组值中生成一个值。在上述例子中用到的 count 、 min 和 max 方法，因为常用而被纳入标准库中。事实上，这些方法都是 reduce 操作。及早求值
例：我们看得reduce接收了一个初始值为0的累加器，依次取出值与累加器相加，最后累加器的值就是最终的结果。
public class TestCase {
public static void main(String[] args) {
Integer reduce = Stream.of(1, 2, 3, 4).reduce(0, (acc, x) -> acc+ x);
System.out.println(reduce);
}
}
//输出结果
//10
高级集合类及收集器
- 转换成值
收集器，一种通用的、从流生成复杂值的结构。只要将它传给 collect 方法，所有的流就都可以使用它了。以下示例代码中的收集器都是从 java.util.stream.Collectors 类中静态导入的。
public class CollectorsTest {
public static void main(String[] args) {
List<Student> students1 = new ArrayList<>(3);
students1.add(new Student("路飞", 23, 175));
students1.add(new Student("红发", 40, 180));
students1.add(new Student("白胡子", 50, 185));
OutstandingClass ostClass1 = new OutstandingClass("一班", students1);
//复制students1，并移除一个学生
List<Student> students2 = new ArrayList<>(students1);
students2.remove(1);
OutstandingClass ostClass2 = new OutstandingClass("二班", students2);
//将ostClass1、ostClass2转换为Stream
Stream<OutstandingClass> classStream = Stream.of(ostClass1, ostClass2);
OutstandingClass outstandingClass = biggestGroup(classStream);
System.out.println("人数最多的班级是：" + outstandingClass.getName());
System.out.println("一班平均年龄是：" + averageNumberOfStudent(students1));
}
/**
* 获取人数最多的班级
*/
private static OutstandingClass biggestGroup(Stream<OutstandingClass> outstandingClasses) {
return outstandingClasses.collect(Collectors
.maxBy(Comparator.comparing(ostClass -> ostClass.getStudents().size())))
.orElseGet(OutstandingClass::new);
}
/**
* 计算平均年龄
*/
private static double averageNumberOfStudent(List<Student> students) {
return students.stream().collect(Collectors
.averagingInt(Student::getAge));
}
}
//输出结果
//人数最多的班级是：一班
//一班平均年龄是：37.666666666666664
- 转换成块
常用的流操作是将其分解成两个集合 ture 和 false，Collectors.partitioningBy帮我们实现了，接收一个Predicate函数式接口。
例：将学生分为会唱歌与不会唱歌的两个集合。
public class PartitioningByTest {
public static void main(String[] args) {
//省略List<student> students的初始化
Map<Boolean, List<Student>> listMap = students.stream().collect(
Collectors.partitioningBy(student -> student.getSpecialities().
contains(SpecialityEnum.SING)));
}
}
- 数据分组
数据分组是一种更自然的分割数据操作，与将数据分成 ture 和 false 两部分不同，可以使用任意值对数据分组。Collectors.groupingBy接收一个Function做转换。
Collectors.groupingBy与SQL 中的 group by 操作是一样的。
例子：根据学生第一个特长进行分组
public class GroupingByTest {
public static void main(String[] args) {
//省略List<student> students的初始化
Map<SpecialityEnum, List<Student>> listMap =
students.stream().collect(
Collectors.groupingBy(student -> student.getSpecialities().get(0)));
}
}
- 字符串拼接
如果将所有学生的名字拼接起来，怎么做呢？通常只能创建一个StringBuilder，循环拼接。
使用Stream，使用Collectors.joining()简单容易。joining接收三个参数，第一个是分界符，第二个是前缀符，第三个是结束符。也可以不传入参数Collectors.joining()，这样就是直接拼接。
public class JoiningTest {
public static void main(String[] args) {
List<Student> students = new ArrayList<>(3);
students.add(new Student("路飞", 22, 175));
students.add(new Student("红发", 40, 180));
students.add(new Student("白胡子", 50, 185));
String names = students.stream()
.map(Student::getName).collect(Collectors.joining(",","[","]"));
System.out.println(names);
}
}
//输出结果
//[路飞,红发,白胡子]
重复注解
https://blog.csdn.net/weixin_42245133/article/details/99678509
使用lambda得到两个集合的并集、交集、差集
//交集
List<String> jiaoji = list2.stream().filter(x -> list1.contains(x)).collect(Collectors.toList());
jiaoji.stream().forEach(System.out::println);
//并集去重
list1.addAll(list2);
List<String> bingji = list1.stream().distinct().collect(Collectors.toList());
bingji.stream().forEach(System.out::println);
2261
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
