Java8的新特性.pdf

Lambda表达式

适用于比较简单的结构体。避免匿名内部类定义过多的一种函数式编程思想；
接口中只有一个抽象方法，本质就是作为函数式接口的实例

  1. public class test {
  2.     public static void main(String[] args) {
  3.         new Thread(new Runnable() {        //实现匿名内部类
  4.             @Override
  5.             public void run() {
  6.                 for(int i=0;i<5;i++) {
  7.                     System.out.println("a"+i);
  8.                 }
  9.             }
  10.         }).start(); 
  12.         for(int i=0;i<5;i++) {
  13.             System.out.println("b"+i);
  14.         }
  15.     }
  16. }
  18. //jdk8  lambda表达式  一般用于比较简单的线程体
  19. public class test {
  20.     public static void main(String[] args) {
  21.         new Thread(()->{                //关注线程体
  22.                 for(int i=0;i<5;i++) {    //关注内部的核心代码即可 其它的可以简化
  23.                     System.out.println("a"+i);
  24.                 }
  25.             }
  26.         ).start(); 
  28.         for(int i=0;i<5;i++) {
  29.             System.out.println("b"+i);
  30.         }
  31.     }
  32. }

推导过程

  1. interface like{
  2.     void lambda();
  3. }
  5. //1 接口实现
  6. class people1 implements like{
  7.     @Override
  8.     public void lambda() {
  9.         System.out.println("快乐");
  10.     }
  11. }
  13. public class lambdaTest {
  14.     static class people2 implements like{
  15.         //2 静态内部类实现
  16.         @Override
  17.         public void lambda() {
  18.             System.out.println("快乐2");
  19.         }
  20.     }
  21.     public static void main(String[] args) {
  22.         like l1 = new people1();
  23.         like l2 = new people2();
  24.         like l3 = new like() {
  25.             //3 匿名内部类实现
  26.             @Override
  27.             public void lambda() {
  28.                 System.out.println("快乐3");
  29.             }
  30.         };
  32.         like l4 =()->{
  33.             //4 lambda表达式实现
  34.             System.out.println("快乐4");
  35.         };
  37.         l1.lambda();
  38.         l2.lambda();
  39.         l3.lambda();
  40.         l4.lambda();
  42.     }
  43. }

带参数

  1. interface habb{
  2.     void lambda(int a);
  3. } 
  5. class people3 implements habb{
  6.     @Override
  7.     public void lambda(int a) {
  9.     }
  10. }
  12. public class lambdatest2 {
  13.     public static void main(String[] args) {
  14.         habb h1 =(a)->{
  15.             System.out.println("快乐"+a);
  16.         };
  17.         h1.lambda(20);
  19.         //简化 只有一个参数 可以省略小括号
  20.         habb h2 =a->{        
  21.             System.out.println("快乐"+a);
  22.         };
  23.         h2.lambda(30);
  25.         //Lambda 体只有一条语句时，return 与大括号若有，都可以省略
  26.         habb h3 =a->System.out.println("快乐"+a);  
  27.         h3.lambda(50);
  28.     }
  29. }

函数式接口

如果一个接口中，只声明一个抽象方法，则称为函数式接口
可以在接口上用@FunctionalInterface注解检验声明它是一个函数式接口

Java内置四大核心函数式接口
image.png

  1. public class testFunction {
  2.     public static void main(String[] args) {
  3.         //消费型接口原始写法
  4.          happyTime(500, new Consumer<Double>() {
  5.             @Override
  6.             public void accept(Double aDouble) {
  7.                 System.out.println("???"+aDouble);
  8.             }
  9.         });
  10.         //消费型接口lambda写法
  11.         happyTime(500, money-> System.out.println("???"+money));
  13.         List<String> strings = Arrays.asList("a", "b", "ab", "ac");
  14.         filterStrs(strings,s -> s.contains("a")).forEach(System.out::println);
  15.     }
  18.     //消费型接口
  19.     public static void happyTime(double money, Consumer<Double> consumer){
  20.         consumer.accept(money);
  21.     }
  24.     List<String> list = Arrays.asList("a,aa,ab,ac,bc");
  25.     List<String> list2 = filterStrs(list, s -> s.contains("c"));
  26.     //断定型接口
  27.     //根据指定的规则过滤字符串 规则由Predicate 的方法决定
  28.     public static List<String> filterStrs(List<String> list, Predicate<String> pre){
  29.         ArrayList<String> filterList = new ArrayList<>();
  30.         for (String s : list) {
  31.             if (pre.test(s)) {
  32.                 filterList.add(s);
  33.             }
  34.         }
  35.         return filterList;
  36.     }
  37. }

方法引用和构造器的引用

方法引用

当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用；
实现接口的抽象方法的参数列表和返回值类型，必须与方法引用的，方法的参数列表和返回值类型保持一致

具体分为如下的三种情况：
对象 :: 非静态方法
类 :: 静态方法
类 :: 非静态方法

  1. public class testFunction2 {
  3.     //情况一：对象 :: 实例方法 
  4.     @Test
  5.     public void test1(){
  6.         Consumer c1 = str -> System.out.println(str);
  7.         c1.accept("hello1");
  9.         System.out.println("************");
  11.         Consumer c2= System.out::println;
  12.         c2.accept("hello2");
  14.     }
  16.     //Supplier中的T get()
  17.     //user中的String getName()
  18.     @Test
  19.     public void test2() {
  20.         user u1 = new user("h", 10000.00);
  21.         // 先有对象后再调用
  22.         Supplier<String> sup=()->u1.getName();
  23.         System.out.println(sup.get());
  25.         System.out.println("************");
  27.         Supplier<String> sup2=u1::getName;
  28.         System.out.println(sup2.get());
  29.     }
  32.     // 情况二：类 :: 静态方法
  33.     //Comparator中的int compare(T t1,T t2)
  34.     //Integer中的int compare(T t1,T t2)
  35.     @Test
  36.     public void test3(){
  37.         Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1,t2);
  38.         System.out.println(com1.compare(12,21));
  40.         System.out.println("*******************");
  42.         Comparator<Integer> com2 = Integer::compare;
  43.         System.out.println(com2.compare(12,3));
  45.     }
  47.     // 情况三：类 :: 实例方法  (前一个参数作为第二个参数的调用者)
  48.     // Comparator中的int comapre(T t1,T t2)
  49.     // String中的int t1.compareTo(t2)
  50.     @Test
  51.     public void test4() {
  52.         Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
  53.         System.out.println(com1.compare("abc","abd"));
  55.         System.out.println("*******************");
  57.         Comparator<String> com2 = String :: compareTo;
  58.         System.out.println(com2.compare("abd","abm"));
  60.     }
  62.     //BiPredicate中的boolean test(T t1, T t2);
  63.     //String中的boolean t1.equals(t2)
  64.     @Test
  65.     public void test5() {
  66.         BiPredicate<String,String> pre1 = (s1, s2) -> s1.equals(s2);
  67.         System.out.println(pre1.test("abc","abc"));
  69.         System.out.println("*******************");
  71.         BiPredicate<String,String> pre2 = String :: equals;
  72.         System.out.println(pre2.test("abc","abd"));
  73.     }
  75. }

Stream流

使用 Stream对集合数据进行操作计算，可以执行非常复杂的查找、过滤和映射数据等操作
在Java层面对取到的数据流做处理

注：
Stream 自己不会存储元素
Stream 不会改变源对象。相反，它会返回一个持有结果的新Stream
Stream 操作是延迟执行的。等到需要结果的时候才执行（执行终止操作时才执行中间操作链）

Stream 的操作三个步骤

1 创建 Stream
一个数据源（如：集合、数组），获取一个流
2 中间操作
一个中间操作链，对数据源的数据进行处理
3 终止操作(终端操作)
一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

创建

  1. public class streamTest {
  2.     public static List<user> getUsers(){
  3.         List<user> list = new ArrayList<>();
  4.         list.add(new user("h",10000.00));
  5.         list.add(new user("h2",10000.00));
  6.         list.add(new user("h3",10000.00));
  7.         return list;
  8.     }
  11.     //创建 Stream方式一：通过集合
  12.     @Test
  13.     public void test1(){
  14.         List<user> users =streamTest.getUsers();
  15. //        返回一个顺序流
  16.         Stream<user> stream = users.stream();
  18. //        返回一个并行流
  19.         Stream<user> parallelStream = users.parallelStream(); 
  20.     }
  23.     //创建 Stream方式二：通过数组
  24.     @Test
  25.     public void test2(){
  26.         int[] arr = new int[]{1,2,3,4,5,6};
  27.         //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
  28.         IntStream stream = Arrays.stream(arr);
  30.         //自定义类型的数组源
  31.         user e1 = new user("m",1000);
  32.         user e2 = new user("h",2000);
  33.         user[] arr1 = new user[]{e1,e2};
  34.         Stream<user> stream1 = Arrays.stream(arr1);
  35.     }
  37.     //创建 Stream方式三：通过Stream的of()
  38.     @Test
  39.     public void test3(){
  40.         Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);
  41.     }
  43.     //创建 Stream方式四：创建无限流
  44.     @Test
  45.     public void test4(){
  46. //      迭代
  47.         //遍历前10个偶数
  48.         Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);
  50. //      生成
  51.         Stream.generate(Math::random).limit(10).forEach(System.out::println);
  52.         Stream.generate(()->random.nextInt(10)).limit(10).forEach(System.out::println);
  55.     }
  56. }

中间操作
image.png
image.png
image.png

  1.  public static List<user> getUsers(){
  2.         List<user> list = new ArrayList<>();
  3.         list.add(new user("aaa",10000.00,21));
  4.         list.add(new user("bbbb",20000.00,18));
  5.         list.add(new user("cc",30000.00,29));
  6.         return list;
  7.     }
  9.     #筛选与切片
  10.     @Test
  11.     public void test5(){
  12.         Stream<user> stream = streamTest.getUsers().stream();
  13.         //limit skip distinct 用法差不多
  14.         stream.filter(user -> user.getSalary()>10000).forEach(System.out::println);
  15.     }
  17.     #映射
  18.     @Test
  19.     public void test6(){
  20. //  map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，
  21. //  该函数会被应用到每个元素上，并将其映射成一个新的元素。
  22.     List<String> list = Arrays.asList("aaa", "bb", "cccc", "dd");
  24.     //消费型接口
  25.     list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);
  27.     //匹配名字长度大于2的人员
  28.     list.stream().map(user::getName).filter(name->name.length()>2).forEach(System.out::println);
  31. //  flatMap(Function f)接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
  32. //    类似于list的addAll方法   将多维嵌套的数据转换成单维数据
  33.     Stream<Character> characterStream = list.stream().flatMap(streamTest::fromStringToStream);
  34.     characterStream.forEach(System.out::println);    //获取每个集合中每个字符串的每个字符
  35.     }
  37.     //将字符串中的多个字符构成的集合转换为对应的Stream的实例
  38.     public static Stream<Character> fromStringToStream(String str){
  39.         ArrayList<Character> list = new ArrayList<>();
  40.         for(Character c : str.toCharArray()){
  41.             list.add(c);
  42.         }
  43.         return list.stream();
  45.     }
  47.     #排序
  48.     @Test
  49.     public void test7(){
  50. //        sorted()——自然排序
  51.         List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
  52.         list.stream().sorted().forEach(System.out::println);
  54.         //sorted(Comparator com) -- 定制排序
  55.         List<user> users = streamTest.getUsers();
  56.         users.stream().sorted( (e1,e2) -> {
  58.             int ageValue = Double.compare(e1.getAge(),e2.getAge());
  59.             if(ageValue != 0){
  60.                 return ageValue;
  61.             }else{
  62.                 //年纪相等再比较工资
  63.                 return -Double.compare(e1.getSalary(),e2.getSalary());        //从大到小排序
  64.             }
  66.         }).forEach(System.out::println);
  67.     }

终止操作
终端操作会从流的流水线生成结果。流进行了终止操作后，不能再次使用。
image.png
image.png
image.png
image.png

  1.  //1-匹配与查找
  2.     @Test
  3.     public void test11(){
  4.         List<user> users = streamTest.getUsers();
  5. //        allMatch(Predicate p)——检查是否匹配所有元素。
  6.         boolean allMatch = users.stream().allMatch(e -> e.getAge() > 18);
  7.         System.out.println(allMatch);
  9. //        findFirst——返回第一个元素
  10.         Optional<user> user = users.stream().findFirst();
  11.         System.out.println(user);
  13.     }
  15.     @Test
  16.     public void test12(){
  17.         List<user> users = streamTest.getUsers();
  18.         // count——返回流中元素的总个数
  19.         long count = users.stream().filter(e -> e.getSalary() > 5000).count();
  20.         System.out.println(count);
  22. //        max(Comparator c)——返回流中最大值
  23.         Stream<Double> salaryStream = users.stream().map(e -> e.getSalary());
  24.         Optional<Double> maxSalary = salaryStream.max(Double::compare);
  25.         System.out.println(maxSalary);
  27. //        forEach(Consumer c)——内部迭代
  28.         users.stream().forEach(System.out::println);
  30.         //使用集合的遍历操作
  31.         users.forEach(System.out::println);
  32.     }
  34.     //2-归约
  35.     @Test
  36.     public void test13(){
  37. //        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
  38. //        计算1-10的自然数的和
  39.         List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
  40.         Integer sum = list.stream().reduce(0, Integer::sum);
  41.         System.out.println(sum);
  43. //        reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
  44. //        计算所有员工工资的总和
  45.         List<user> users = streamTest.getUsers();
  46.         Stream<Double> salaryStream = users.stream().map(user::getSalary);
  47. //        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
  48.         Optional<Double> sumMoney = salaryStream.reduce((d1, d2) -> d1 + d2);
  49.         System.out.println(sumMoney.get());
  51.     }
  53.     //3-收集
  54.     @Test
  55.     public void test14(){
  56. //collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
  57. //查找工资大于6000的员工，结果返回为一个List或Set
  59.         List<user> users = streamTest.getUsers();
  60.         List<user> userList =users.stream()
  61.             .filter(e -> e.getSalary()>6000).collect(Collectors.toList());
  62.         userList.forEach(System.out::println);
  64.         Set<user> userSet = users.stream()
  65.             .filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());
  67.         userSet.forEach(System.out::println);
  68.     }
  70.     //连接流中每个字符串 
  71.     list.stream().collect(Collectors.joining());  等价  String.join("", list)

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 orElse Throw(Supplier<? extends X> exceptionSupplier) :如果有值则将其返回，否则抛出由Supplier接口实现提供的异常。
    1. #举例 保证当user为空时不影响下面逻辑代码的执行
    2. User user = null;
    3. User optUser = Optional.ofNullable(user).orElse(new User("a",12));
    4. System.out.println(optUser.getName());