Java函数式编程

概述

学习函数式编程可以是我们的代码更加优雅，开发快速，它跟面向对象不同，面向对象考虑用什么对象完成什么事情，函数式编程更加类似于数学的函数，主要关注的是对数据进行了什么样的操作

Lamda表达式

使用的前提是，它是一个接口，而且只有一个抽象方法。是对匿名内部类写法的简化，也是函数式编程的重要体现。写法是（参数列表）->{方法体}

例子1

Runnable接口

  1. @FunctionalInterface
  2. public interface Runnable {
  3.     public abstract void run();
  4. }

匿名内部类写法

  1. package gdut.edu.test01;
  3. public class Lamda01 {
  4.     public static void main(String[] args) {
  5.         new Thread(new Runnable() {
  6.             @Override
  7.             public void run() {
  8.                 System.out.println("新线程run方法执行了");
  9.             }
  10.         }).start();
  11.     }
  12. }

Lamda表达式写法

  1. package gdut.edu.test01;
  3. public class Lamda02 {
  4.     public static void main(String[] args) {
  5.         new Thread(() -> System.out.println("新线程run方法执行了")).start();
  6.     }
  7. }

例子2

接口

  • Count接口
  1. package gdut.test02;
  3. public interface Count {
  4.     int add(int num1, int num2);
  5. }
  • PrintStr接口
  1. package gdut.test02;
  3. public interface PrintStr {
  4.     void handle(String s);
  5. }

LamdaUtils

  1. package gdut.test02;
  3. public class LamdaUtils {
  4.     public static int add(Count count){
  5.         int num1 = 2;
  6.         int num2 = 3;
  7.         int add = count.add(num1, num2);
  8.         return add;
  9.     }
  10.     public static void printStr(PrintStr printStr){
  11.         String str = "hello world";
  12.         printStr.handle(str);
  13.     }
  14. }

Test

  1. package gdut.test02;
  3. public class Lamda01 {
  4.     public static void main(String[] args) {
  5. //        Count匿名内部类写法
  6.         int res = LamdaUtils.add(new Count() {
  7.             @Override
  8.             public int add(int num1, int num2) {
  9.                 return num1 + num2;
  10.             }
  11.         });
  12.         System.out.println(res);
  13. //        没有简化的lamda表达式写法
  14.         res = LamdaUtils.add((int num1, int num2) -> {
  15.             return num1 + num2;
  16.         });
  17.         System.out.println(res);
  18. //        简化lamda表达式，参数类型可以不写，代码只有一句时，大括号、return、该句代码的分号可以省略
  19.         res = LamdaUtils.add((num1, num2) -> num1 + num2);
  20.         System.out.println(res);
  21. //        PrintStr匿名内部类写法
  22.         LamdaUtils.printStr(new PrintStr() {
  23.             @Override
  24.             public void handle(String s) {
  25.                 System.out.println(s);
  26.             }
  27.         });
  28. //        lamda表达式写法
  29.         LamdaUtils.printStr((String s) -> {
  30.             System.out.println(s);
  31.         });
  32. //        lamda表达式简写,参数类型可以不写，只有一个参数时，小括号可以省略，
  33. //        代码只有一句时，大括号、return、该句代码的分号可以省略
  34.         LamdaUtils.printStr(s -> System.out.println(s));
  36.     }
  37. }

Stream流

概述

Java的Stream流使用的是函数式编程模式，可以用来对集合、数组进行链状流式操作，方便我们对集合、数组操作

常用操作

创建流=>中间操作=>最终操作(一定要有最终操作，否则前面的中间操作无效)

创建stream流

  • 单列集合创建stream流：(集合对象).stream()
  • 数组创建stream流：Arrays.stream(数组)或者Stream.of()
  • 双列集合创建stream流：先转换成单列集合，然后使用(集合对象).stream()创建
  1. package gdut.stream;
  3. import gdut.stream.middle.MapTest;import java.util.*;
  4. import java.util.stream.Stream;
  6. public class BuildStream {
  7.     public static void main(String[] args) {
  8. //        创建stream流
  9. //        单列集合创建stream流,使用(集合对象).stream()
  10.         ArrayList<Integer> integersList = new ArrayList<>();
  11.         Stream<Integer> integerStream = integersList.stream();
  12. //        数组创建Stream流，使用Arrays.stream(数组)或者Stream.of()
  13.         Integer[] arr = {1, 2, 3, 4, 5};
  14.         Stream<Integer> arrStream1 = Arrays.stream(arr);
  15.         Stream<Integer> arrStream2 = Stream.of(arr);
  16. //        双列集合创建stream流，先转换成单列集合再创建
  17.         HashMap<String, Integer> stringIntegerHashMap = new HashMap<>();
  18.         stringIntegerHashMap.put("key1", 1);
  19.         stringIntegerHashMap.put("key2", 2);
  20.         stringIntegerHashMap.put("key3", 3);
  21.         Set<MapTest.Entry<String, Integer>> entrySet = stringIntegerHashMap.entrySet();
  22.         Stream<MapTest.Entry<String, Integer>> entryStream = entrySet.stream();
  23.         Set<String> keySet = stringIntegerHashMap.keySet();
  24.         Stream<String> keyStream = keySet.stream();
  25.     }
  26. }

中间操作

filter

对流中的元素进行过滤，符合条件的留在流中

  • 匿名内部类写法
  1. package gdut.stream;
  3. import java.util.Arrays;
  4. import java.util.function.Consumer;
  5. import java.util.function.Predicate;
  6. import java.util.stream.Stream;
  8. public class Filter {
  9.     public static void main(String[] args) {
  10. //        筛选出数组中大于2的值
  11.         Integer[] arr = {1, 2, 3, 4, 5};
  12.         Stream<Integer> integerStream = Arrays.stream(arr);
  13.         integerStream
  14.                 .filter(new Predicate<Integer>() {
  15.                     @Override
  16.                     public boolean test(Integer integer) {
  17.                         return integer > 2;
  18.                     }
  19.                 })
  20.                 .forEach(new Consumer<Integer>() {
  21.                     @Override
  22.                     public void accept(Integer integer) {
  23.                         System.out.println(integer);
  24.                     }
  25.                 });
  26.     }
  27. }
  • lamda表达式写法
  1. package gdut.stream;
  3. import java.util.Arrays;
  4. import java.util.function.Consumer;
  5. import java.util.function.Predicate;
  6. import java.util.stream.Stream;
  8. public class FilterLamda {
  9.     public static void main(String[] args) {
  10. //        筛选出数组中大于2的值
  11.         Integer[] arr = {1, 2, 3, 4, 5};
  12.         Stream<Integer> integerStream = Arrays.stream(arr);
  13.         integerStream
  14.                 .filter(integer -> integer > 2)
  15.                 .forEach(integer -> System.out.println(integer));
  16.     }
  17. }

map

map操作对流中元素进行计算或者转换类型

  • 匿名内部类写法
  1. package gdut.stream;
  3. import java.util.Arrays;
  4. import java.util.function.Consumer;
  5. import java.util.function.Function;
  6. import java.util.stream.Stream;
  8. public class MapTest {
  9.     public static void main(String[] args) {
  10.         Integer[] arr = {1, 2, 3, 4, 5};
  11. //        map操作可以对流中的元素进行计算或者转换类型
  12.         Stream<Integer> integerStream = Arrays.stream(arr);
  13.         integerStream
  14.                 .map(new Function<Integer, Integer>() {
  15.                     @Override
  16.                     public Integer apply(Integer integer) {
  17. //                对元素加100
  18.                         return integer + 100;
  19.                     }
  20.                 })
  21.                 .map(new Function<Integer, String>() {
  22.                     @Override
  23.                     public String apply(Integer integer) {
  24.                         return integer.toString()+"变成字符串";
  25.                     }
  26.                 })
  27.                 .forEach(new Consumer<String>() {
  28.                     @Override
  29.                     public void accept(String s) {
  30.                         System.out.println(s);
  31.                     }
  32.                 });
  33.     }
  34. }
  • lamda表达式写法
  1. package gdut.stream;
  3. import java.util.Arrays;
  4. import java.util.function.Consumer;
  5. import java.util.function.Function;
  6. import java.util.stream.Stream;
  8. public class MapLamda {
  9.     public static void main(String[] args) {
  10.         Integer[] arr = {1, 2, 3, 4, 5};
  11. //        map操作可以对流中的元素进行计算或者转换类型
  12.         Stream<Integer> integerStream = Arrays.stream(arr);
  13.         integerStream
  14.                 .map(integer -> integer + 100)
  15.                 .map(integer -> integer.toString() + "变成字符串")
  16.                 .forEach(s -> System.out.println(s));
  17.     }
  18. }

distinct

distinct依赖Object的equals方法来判断是否是相同对象，从而去重流中相同的元素

  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.stream.Stream;
  7. public class DistinctTest {
  8.     public static void main(String[] args) {
  9.         List<Student> students = new ArrayList<>();
  10.         for (int i = 0; i < 5; i++) {
  11.             Student student = new Student(i, "student" + i);
  12.             students.add(student);
  13.         }
  14.         students.add(new Student(0, "student0"));//添加一个相同的学生
  15.         Stream<Student> studentStream = students.stream();
  16. //        distinct依赖Object的equals方法来判断是否是相同对象，从而去重流中的元素
  17.         studentStream
  18.                 .distinct()
  19.                 .forEach(student -> System.out.println(student));
  20.     }
  21. }

sorted

对流中的元素进行排序操作，如果调用空参sorted()方法，要求流中的元素实现Comparable接口

  • 匿名内部类写法
  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.Comparator;
  5. import java.util.List;
  6. import java.util.stream.Stream;
  8. public class SortedTest {
  9.     public static void main(String[] args) {
  10.         List<Student> students = new ArrayList<>();
  11.         for (int i = 0; i < 5; i++) {
  12.             Student student = new Student(i, "student" + i);
  13.             students.add(student);
  14.         }
  15.         Stream<Student> studentStream = students.stream();
  16.         studentStream
  17.                 .sorted(new Comparator<Student>() {
  18.                     @Override
  19.                     public int compare(Student o1, Student o2) {
  20.                         return o2.getAge() - o1.getAge();
  21.                     }
  22.                 })
  23.                 .forEach(student -> System.out.println(student));
  24.     }
  25. }
  • lamda表达式写法
  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.stream.Stream;
  7. public class SortedTest {
  8.     public static void main(String[] args) {
  9.         List<Student> students = new ArrayList<>();
  10.         for (int i = 0; i < 5; i++) {
  11.             Student student = new Student(i, "student" + i);
  12.             students.add(student);
  13.         }
  14.         Stream<Student> studentStream = students.stream();
  15.         studentStream
  16.                 .sorted((o1, o2) -> o2.getAge() - o1.getAge())
  17.                 .forEach(student -> System.out.println(student));
  18.     }
  19. }

limit

设置流的最大长度，超出部分会被抛弃

  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  6. public class LimitTest {
  7.     public static void main(String[] args) {
  8.         List<Student> students = new ArrayList<>();
  9.         for (int i = 0; i < 5; i++) {
  10.             Student student = new Student(i, "student" + i);
  11.             students.add(student);
  12.         }
  13.         students.stream()
  14.                 .sorted((student1, student2) -> student2.getAge() - student1.getAge())
  15.                 .limit(2)
  16.                 .forEach(student -> System.out.println(student));
  17.     }
  18. }

skip

跳过流中前n个元素，返回剩余元素

  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  6. public class SkipTest {
  7.     public static void main(String[] args) {
  8.         List<Student> students = new ArrayList<>();
  9.         for (int i = 0; i < 5; i++) {
  10.             Student student = new Student(i, "student" + i);
  11.             students.add(student);
  12.         }
  13. //        skip跳过流中前n个元素，返回剩余元素
  14.         students.stream()
  15.                 .sorted((student1, student2) -> student2.getAge() - student1.getAge())
  16.                 .skip(2)
  17.                 .forEach(student -> System.out.println(student));
  18.     }
  19. }

flatMap

map只能把一个对象转换成另一个对象作为流中的元素，flatMap可以把一个对象转换成多个对象作为流中的元素

  • map转换和flatMap转换对比，匿名内部类写法
  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Consumer;
  6. import java.util.function.Function;
  7. import java.util.stream.Stream;
  9. public class FlatMapTest {
  10.     public static void main(String[] args) {
  11.         List<Student> students = new ArrayList<>();
  12.         ArrayList<String> books = new ArrayList<>();
  13.         books.add("数学");
  14.         books.add("英语");
  15.         books.add("语文");
  16.         for (int i = 0; i < 5; i++) {
  17.             Student student = new Student(i, "student" + i, books);
  18.             students.add(student);
  19.         }
  20.         Stream<Student> studentStream1 = students.stream();
  21.         Stream<Student> studentStream2 = students.stream();
  22. //        使用map
  23.         studentStream1
  24.                 .map(new Function<Student, List<String>>() {
  25.                     @Override
  26.                     public List<String> apply(Student student) {
  27.                         return student.getBooks();
  28.                     }
  29.                 })
  30.                 .forEach(new Consumer<List<String>>() {
  31.                     @Override
  32.                     public void accept(List<String> strings) {
  33.                         System.out.println(strings);
  34.                     }
  35.                 });
  36. //        使用flatMap
  37.         studentStream2
  38.                 .flatMap(new Function<Student, Stream<String>>() {
  39.                     @Override
  40.                     public Stream<String> apply(Student student) {
  41.                         return student.getBooks().stream();
  42.                     }
  43.                 })
  44.                 .distinct()
  45.                 .forEach(new Consumer<String>() {
  46.                     @Override
  47.                     public void accept(String s) {
  48.                         System.out.println(s);
  49.                     }
  50.                 });
  52.     }
  53. }
  • map和flatMap对比，lamda表达式写法
  1. package gdut.stream;
  3. import gdut.stream.middle.Student;import java.util.ArrayList;
  4. import java.util.List;
  5. import java.util.function.Function;
  6. import java.util.stream.Stream;
  8. public class FlatMapLamda {
  9.     public static void main(String[] args) {
  10.         List<Student> students = new ArrayList<>();
  11.         ArrayList<String> books = new ArrayList<>();
  12.         books.add("数学");
  13.         books.add("英语");
  14.         books.add("语文");
  15.         for (int i = 0; i < 5; i++) {
  16.             Student student = new Student(i, "student" + i, books);
  17.             students.add(student);
  18.         }
  19.         Stream<Student> studentStream1 = students.stream();
  20.         Stream<Student> studentStream2 = students.stream();
  21. //        使用map
  22.         studentStream1
  23.                 .map(student -> student.getBooks())
  24.                 .forEach(stringsList -> System.out.println(stringsList));
  25. //        使用flatMap
  26.         studentStream2
  27.                 .flatMap((Function<Student, Stream<String>>) student -> student.getBooks().stream())
  28.                 .distinct()
  29.                 .forEach(s -> System.out.println(s));
  31.     }
  32. }

终结操作

forEach

对流中的元素进行遍历操作

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  5. public class ForEachTest {
  6.     public static void main(String[] args) {
  7.         ArrayList<Integer> integers = new ArrayList<>();
  8.         integers.add(1);
  9.         integers.add(2);
  10.         integers.add(3);
  11.         integers.stream()
  12.                 .forEach(item -> System.out.println(item + 100));
  13.     }
  14. }

count

获取当前流中元素的个数

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  5. public class CountTest {
  6.     public static void main(String[] args) {
  7.         ArrayList<String> strings = new ArrayList<>();
  8.         for (int i = 0; i < 10; i++) {
  9.             strings.add("string" + i);
  10.         }
  11.         long count = strings.stream()
  12.                 .count();
  13.         System.out.println(count);
  15.     }
  16. }

max&min

用来获取流中的最值

  • 匿名内部类写法
  1. package gdut.stream.last;
  3. import gdut.stream.middle.Student;
  5. import java.util.ArrayList;
  6. import java.util.Comparator;
  7. import java.util.Optional;
  9. public class MinMaxTest {
  10.     public static void main(String[] args) {
  11.         ArrayList<Student> students = new ArrayList<>();
  12.         for (int i = 18; i < 100; i++) {
  13.             Student student = new Student(i, "name" + i);
  14.             students.add(student);
  15.         }
  16. //        获取年龄最大或最小的student
  17.         Optional<Student> max = students.stream()
  18.                 .max(new Comparator<Student>() {
  19.                     @Override
  20.                     public int compare(Student stu1, Student stu2) {
  21.                         return stu1.getAge() - stu2.getAge();
  22.                     }
  23.                 });
  24.         Optional<Student> min = students.stream()
  25.                 .min(new Comparator<Student>() {
  26.                     @Override
  27.                     public int compare(Student stu1, Student stu2) {
  28.                         return stu1.getAge() - stu2.getAge();
  29.                     }
  30.                 });
  31.         System.out.println(max.get());
  32.         System.out.println(min.get());
  33.     }
  34. }
  • lamda表达式写法
  1. package gdut.stream.last;
  3. import gdut.stream.middle.Student;
  5. import java.util.ArrayList;
  6. import java.util.Comparator;
  7. import java.util.Optional;
  9. public class MinMaxLamda {
  10.     public static void main(String[] args) {
  11.         ArrayList<Student> students = new ArrayList<>();
  12.         for (int i = 18; i < 100; i++) {
  13.             Student student = new Student(i, "name" + i);
  14.             students.add(student);
  15.         }
  16. //        获取年龄最大或最小的student
  17.         Optional<Student> max = students.stream()
  18.                 .max((stu1, stu2) -> stu1.getAge() - stu2.getAge());
  19.         Optional<Student> min = students.stream()
  20.                 .min((stu1, stu2) -> stu1.getAge() - stu2.getAge());
  21.         System.out.println(max.get());
  22.         System.out.println(min.get());
  23.     }
  24. }

collect

将流中的元素保存为list、set、map

  1. package gdut.stream.last;
  3. import gdut.stream.middle.Student;
  5. import java.util.*;
  6. import java.util.stream.Collectors;
  8. public class CollectTest {
  9.     public static void main(String[] args) {
  10.         ArrayList<Student> students = new ArrayList<>();
  11.         ArrayList<String> books = new ArrayList<>();
  12.         for (int i = 0; i < 5; i++) {
  13.             books.add("book" + i);
  14.         }
  15.         for (int i = 0; i < 5; i++) {
  16.             Student student = new Student(10 + i, "name" + i, books);
  17.             students.add(student);
  18.         }
  19.         students.add(new Student(10, "name0", books));
  20. //        获取一个存放所有作者名的list集合
  21.         List<String> nameList = students.stream()
  22.                 .map(student -> student.getName())
  23.                 .collect(Collectors.toList());
  24.         System.out.println(nameList);
  25. //        获取一个存放所有书名的set集合
  26.         Set<String> bookSet = students.stream()
  27.                 .flatMap(student -> student.getBooks().stream())
  28.                 .collect(Collectors.toSet());
  29.         System.out.println(bookSet);
  30. //        获取一个有作者名和作者的书籍的map(key,value)，注意要去重，key不能重复
  31.         Map<String, List<String>> resultMap = students.stream()
  32.                 .distinct()
  33.                 .collect(Collectors.toMap(student -> student.getName(),student->student.getBooks()));
  34.         Set<Map.Entry<String, List<String>>> entrySet = resultMap.entrySet();
  35.         Iterator<Map.Entry<String, List<String>>> iterator = entrySet.iterator();
  36.         while (iterator.hasNext()) {
  37.             System.out.println(iterator.next());
  38.         }
  39.     }
  40. }

查找与匹配

anyMatch

只要流中有元素符合某个条件就返回true，如果全部不符合就返回false

  • 匿名内部类写法
  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.function.Predicate;
  6. public class AnyMatchTest {
  7.     public static void main(String[] args) {
  8.         ArrayList<Integer> integers = new ArrayList<>();
  9.         for (int i = 0; i < 100; i++) {
  10.             integers.add(i);
  11.         }
  12. //        只要流中有一个元素符合某个条件就返回true，如果全部不符合就返回false
  13.         boolean resFlag = integers.stream()
  14.                 .anyMatch(new Predicate<Integer>() {
  15.                     @Override
  16.                     public boolean test(Integer integer) {
  17.                         return integer > 77;
  18.                     }
  19.                 });
  20.         System.out.println(resFlag);
  21.     }
  22. }
  • lamda表达式写法
  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.function.Predicate;
  6. public class AnyMatchLamda {
  7.     public static void main(String[] args) {
  8.         ArrayList<Integer> integers = new ArrayList<>();
  9.         for (int i = 0; i < 100; i++) {
  10.             integers.add(i);
  11.         }
  12. //        只要流中有一个元素符合某个条件就返回true，如果全部不符合就返回false
  13.         boolean resFlag = integers.stream()
  14.                 .anyMatch(integer -> integer > 77);
  15.         System.out.println(resFlag);
  16.     }
  17. }

allMatch

判断流中是否所有元素都符合某个条件，全部符合返回true，有一个不符合都返回false

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  5. public class AllMatchTest {
  6.     public static void main(String[] args) {
  7.         ArrayList<Integer> integers = new ArrayList<>();
  8.         for (int i = 10; i <100 ; i++) {
  9.             integers.add(i);
  10.         }
  11. //        allMatch判断是否所有元素符合某个条件，全部符合返回true，有一个不符合就返回false
  12.         boolean flag = integers.stream()
  13.                 .allMatch(integer -> integer > 10);
  14.         System.out.println(flag);
  15.     }
  16. }

noneMatch

都不符合某个条件返回true，只要有一个符合某个条件就返回false

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  5. public class NoneMatchTest {
  6.     public static void main(String[] args) {
  7.         ArrayList<Integer> integers = new ArrayList<>();
  8.         for (int i = 0; i < 100; i++) {
  9.             integers.add(i);
  10.         }
  11. //        noneMatch都不符合某个条件，返回true，有一个符合某个条件返回false
  12.         boolean flag = integers.stream()
  13.                 .noneMatch(integer -> integer > 100);
  14.         System.out.println(flag);
  15.     }
  16. }

findAny

获取流中的任意一个元素，但是没有办法保证获取到的一定是流中的第一个元素

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.Optional;
  6. public class FindAnyTest {
  7.     public static void main(String[] args) {
  8.         ArrayList<Integer> integers = new ArrayList<>();
  9.         for (int i = 0; i < 100; i++) {
  10.             integers.add(i);
  11.         }
  12. //        findAny查找出integers中大于18的任意一个数字,没办法保证获取的一定是流中的第一个元素
  13.         Optional<Integer> any = integers.stream()
  14.                 .filter(integer -> integer > 18)
  15.                 .findAny();
  16.         any.ifPresent(integer -> System.out.println(integer));
  18.     }
  19. }

findFirst

获取流中的第一个元素

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.Optional;
  6. public class FindFirstTest {
  7.     public static void main(String[] args) {
  8.         ArrayList<Integer> integers = new ArrayList<>();
  9.         for (int i = 0; i < 100; i++) {
  10.             integers.add(i);
  11.         }
  12. //        findFirst获取流中的第一个元素
  13.         Optional<Integer> first = integers.stream()
  14.                 .findFirst();
  15.         first.ifPresent(integer -> System.out.println(integer));
  16.     }
  17. }

reduce归并

对流中的数据进行操作，最终返回一个值

  • 匿名内部类方式
  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.Optional;
  5. import java.util.function.BinaryOperator;
  7. public class ReduceTest {
  8.     public static void main(String[] args) {
  9.         ArrayList<Integer> integers = new ArrayList<>();
  10.         for (int i = 0; i < 100; i++) {
  11.             integers.add(i);
  12.         }
  13. //        reduce操作，获取流中的最大值，设置初始值为最小值
  14. //        System.out.println(Integer.MIN_VALUE);
  15.         Integer result = integers.stream()
  16.                 .reduce(Integer.MIN_VALUE, new BinaryOperator<Integer>() {
  17.                     @Override
  18.                     public Integer apply(Integer result, Integer element) {
  19.                         return result > element ? result : element;
  20.                     }
  21.                 });
  22.         System.out.println(result);
  23. //        reduce操作，获取流中的最小值，不设置默认值，利用重载方法，底层设置默认值为流中的第一个值
  24.         Optional<Integer> result2 = integers.stream()
  25.                 .reduce(new BinaryOperator<Integer>() {
  26.                     @Override
  27.                     public Integer apply(Integer result, Integer element) {
  28.                         return result > element ? element : result;
  29.                     }
  30.                 });
  31.         result2.ifPresent(res -> System.out.println(res));
  32.     }
  33. }
  • lamda表达式写法
  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.Optional;
  5. import java.util.function.BinaryOperator;
  7. public class ReduceLamda {
  8.     public static void main(String[] args) {
  9.         ArrayList<Integer> integers = new ArrayList<>();
  10.         for (int i = 0; i < 100; i++) {
  11.             integers.add(i);
  12.         }
  13. //        reduce操作，获取流中的最大值，设置初始值为最小值
  14. //        System.out.println(Integer.MIN_VALUE);
  15.         Integer result = integers.stream()
  16.                 .reduce(Integer.MIN_VALUE, (result1, element) -> result1 > element ? result1 : element);
  17.         System.out.println(result);
  18. //        reduce操作，获取流中的最小值，不设置默认值，利用重载方法，底层设置默认值为流中的第一个值
  19.         Optional<Integer> result2 = integers.stream()
  20.                 .reduce((result12, element) -> result12 > element ? element : result12);
  21.         result2.ifPresent(res -> System.out.println(res));
  22.     }
  23. }

注意事项

  • 没有终结操作，中间操作不会执行（惰性求值）
  • 流是一次性的（一旦一个流对象经过终结操作之后，这个流不能再使用）
  • 在流中对数据进行处理，不触碰数据的set方法一般不会影响原数据

Optional

概述

我们在编写代码的时候经常出现空指针异常，使用optional可以写出更加优雅的代码避免出现空指针异常

创建optional对象

  • 创建一个获取Optional的工具类
  1. package gdut.stream.optional;
  3. import gdut.stream.middle.Student;
  5. import java.util.Optional;
  7. public class GetStudentUtils {
  8.     public static Optional<Student> getStudent() {
  9.         Student student = new Student(22, "name");
  10.         return Optional.ofNullable(student);
  11.     }
  12. }
  • 安全消费
  1. package gdut.stream.optional;
  3. import gdut.stream.middle.Student;
  5. import java.util.Optional;
  6. import java.util.function.Consumer;
  8. public class OptionalTest {
  9.     public static void main(String[] args) {
  10.         Optional<Student> student = GetStudentUtils.getStudent();
  11.         student.ifPresent(new Consumer<Student>() {
  12.             @Override
  13.             public void accept(Student student) {
  14.                 System.out.println("student = " + student);
  15.             }
  16.         });
  17.     }
  18. }

optional的一些操作

  1. package gdut.stream.optional;
  3. import gdut.stream.middle.Student;
  5. import java.util.Optional;
  7. public class OptionalTest {
  8.     public static void main(String[] args) {
  9.         Optional<Student> student = GetStudentUtils.getStudent();
  10. //        安全消费
  11.         student.ifPresent(student1 -> System.out.println("student = " + student1));
  12. //        Student student1 = student.get();//这种获取方法不推荐，如果student为null会报java.util.NoSuchElementException: No value present
  13. //        optional也可以像stream流一样过滤
  14.         student.filter(stu -> stu.getAge() > 10).ifPresent(stu -> System.out.println(stu));
  15. //        optional也可以有map操作
  16.         Optional<String> nameStr = student.map(stu -> stu.getName());
  17.         nameStr.ifPresent(str -> System.out.println(str));
  18.     }
  19. }

函数式接口

概述

  • 函数式接口只有一个抽象方法，JDK的函数式接口都加上了@FunctionalInterface注解，无论是否有该注解，只要接口中只有一个抽象方法，都是函数式接口

常见函数式接口

  • Consumer消费接口 
    1. @FunctionalInterface
    2. public interface Consumer<T> {
    3.  /**
    4.   * Performs this operation on the given argument.
    5.   *
    6.   * @param t the input argument
    7.   */
    8.  void accept(T t);
    9. }
  • Function计算转换接口 
  1. @FunctionalInterface
  2. public interface Function<T, R> {
  4.     /**
  5.      * Applies this function to the given argument.
  6.      *
  7.      * @param t the function argument
  8.      * @return the function result
  9.      */
  10.     R apply(T t);
  11. }
  • Predicate判断接口
  1. @FunctionalInterface
  2. public interface Predicate<T> {
  3.     /**
  4.      * Evaluates this predicate on the given argument.
  5.      *
  6.      * @param t the input argument
  7.      * @return {@code true} if the input argument matches the predicate,
  8.      * otherwise {@code false}
  9.      */
  10.     boolean test(T t);
  11. }
  • Supplier生产型接口
  1. @FunctionalInterface
  2. public interface Supplier<T> {
  4.     /**
  5.      * Gets a result.
  6.      *
  7.      * @return a result
  8.      */
  9.     T get();
  10. }

Stream并行流

当流中有大量的元素时，可以使用并行流去提高操作效率，并行流就是把任务分配给多个线程，最总在终结操作将结果汇总

  1. package gdut.stream.last;
  3. import java.util.ArrayList;
  4. import java.util.Optional;
  5. import java.util.function.Consumer;
  7. public class ParallelStreamTest {
  8.     public static void main(String[] args) {
  9.         ArrayList<Integer> integers = new ArrayList<>();
  10.         for (int i = 0; i < 100; i++) {
  11.             integers.add(i);
  12.         }
  13.         Optional<Integer> res = integers.stream().parallel()
  14.                 .peek(new Consumer<Integer>() {
  15.                     @Override
  16.                     public void accept(Integer integer) {
  17.                         System.out.println(integer + Thread.currentThread().getName());
  18.                     }
  19.                 })
  20.                 .filter(num -> num < 10)
  21.                 .reduce((result, element) -> result + element);
  22.         res.ifPresent(System.out::println);
  23.     }
  24. }

方法引用

我们在使用lamda表达式时，如果方法体只有一个方法的调用的时候我们可以使用方法引用来简化代码

推荐用法

我们在使用lamda表达式的时候，方法体只有一个方法的调用，我们不需要考虑如何去写方法引用，用哪种方法引用，方法引用的格式是什么。在写完lamda表达式后，我们只需要根据快捷键(这里我使用的是idea的alt +enter)来尝试其是否可以转换成方法引用的写法。

基本格式

类名或者对象名::方法名

语法了解

引用类的静态方法

  • 格式 类名::方法名
  • 使用前提 在重写方法的时候，方法体只有一行代码，并且这行代码调用了某个类的静态方法，并且我们把重写的抽象方法的所有参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法
  • Cat接口
  1. package gdut.stream.quote;
  3. public interface Cat<T, E> {
  4.     E myCat(T t);
  5. }
  • CatUtils
  1. package gdut.stream.quote;
  3. public class CatUtils {
  4.     public static <T, E> E getCatAge(T t, Cat<T, E> cat) {
  5.         E e = cat.myCat(t);
  6.         return e;
  7.     }
  9.     public <T, E> E get(T t, Cat<T, E> cat) {
  10.         E e = cat.myCat(t);
  11.         return e;
  12.     }
  13. }
  • CatTest
  1. package gdut.stream.quote;
  3. public class CatTest {
  4.     public static void main(String[] args) {
  5.         Integer age = 10;
  6.         String strAge = CatUtils.getCatAge(age, new Cat<Integer, String>() {
  7.             @Override
  8.             public String myCat(Integer integer) {
  9.                 return String.valueOf(integer);
  10.             }
  11.         });
  12.         System.out.println(strAge);
  13.         String strAge2 = CatUtils.getCatAge(age, integer -> String.valueOf(integer));
  14.         System.out.println(strAge2);
  15.         String strAge3 = CatUtils.getCatAge(age, String::valueOf);
  16.         System.out.println(strAge2);
  18.     }
  19. }

引用对象的实例方法

  • 格式 对象名::方法名
  • 使用前提 重写方法时，方法体只有一行代码，并且这行代码调用了某个对象的成员方法，并且我们把要重写的抽象方法所有参数都按照顺序传入了这个成员方法中，这个时候我们就可以引用对象的实例方法
  1. package gdut.stream.quote;
  3. public class CatTest02 {
  4.     public static void main(String[] args) {
  5.         Integer age = 22;
  6.         StringBuffer stringBuffer = new StringBuffer();
  7.         stringBuffer.append("hello+tomcat+");
  8.         StringBuffer catAge = CatUtils.getCatAge(age, new Cat<Integer, StringBuffer>() {
  9.             @Override
  10.             public StringBuffer myCat(Integer integer) {
  11.                 return stringBuffer.append(integer);
  12.             }
  13.         });
  14.         System.out.println(catAge.toString());
  15.         StringBuffer catAge2 = CatUtils.getCatAge(age, integer -> stringBuffer.append(integer));
  16.         System.out.println(catAge2.toString());
  17.         StringBuffer catAge3 = CatUtils.getCatAge(age, stringBuffer::append);
  18.         System.out.println(catAge3.toString());
  19.     }
  20. }

引用类的实例方法

  • 格式 类名::方法名
  • 使用前提 重写方法时，方法体只有一行代码，并且这行代码调用了第一个参数的成员方法，并且把我们重写的抽象方法中剩余参数都按照顺序传入这个成员方法中，这时我们可以使用引用类的实例方法
  • Dog实体类
  1. package gdut.stream.quote;
  3. public class Dog {
  4.     private String name;
  6.     public Dog() {
  7.     }
  9.     public Dog(String name) {
  10.         this.name = name;
  11.     }
  13.     public String getName() {
  14.         return name;
  15.     }
  17.     public void setName(String name) {
  18.         this.name = name;
  19.     }
  21.     @Override
  22.     public String toString() {
  23.         return "Dog{" +
  24.                 "name='" + name + '\'' +
  25.                 '}';
  26.     }
  27. }
  • DogInterface接口
  1. package gdut.stream.quote;
  3. public interface DogInterface<T,N> {
  4.     N aDog(T t);
  5. }
  • DogUtils
  1. package gdut.stream.quote;
  3. public class DogUtils {
  4.     public static <T,N> N getDog(T t,DogInterface<T,N> dog){
  5.         return dog.aDog(t);
  6.     }
  7. }
  • DogTest
  1. package gdut.stream.quote;
  3. public class DogTest {
  4.     public static void main(String[] args) {
  5.         Dog dog = new Dog("hotDog");
  6.         String dogName = DogUtils.getDog(dog, new DogInterface<Dog, String>() {
  7.             @Override
  8.             public String aDog(Dog dog) {
  9.                 return dog.getName();
  10.             }
  11.         });
  12.         System.out.println(dogName);
  13.         String dogName1 = DogUtils.getDog(dog, dog1 -> dog1.getName());
  14.         System.out.println(dogName1);
  15.         String dogName2 = DogUtils.getDog(dog, Dog::getName);
  16.         System.out.println(dogName2);
  17.     }
  18. }