• JDK1.8新特性

     

    目录

     

    一、Lambda表达式

            1.1 匿名内部类的冗余

            1.2 自定义无参无返回值的函数式接口

             1.3 自定义有参有返回值的函数式接口

            二、函数式接口

            2.1 Consumer 消费性函数式接口

            2.2 Supplier 供给型函数式接口

            3.3 Funcation 函数型函数式接口,r>

             3.4 Predicate 断言型函数式接口

            四、方法引用的使用场景

            4.1 方法引用的分类

            4.2 方法引用的举例

            五、Stream流

            5.1 为什么要用Stream流

            5.2 Stream流式思想概述

            5.2.1 获取Stream流对象

            5.2.2   中间操作的方法有哪些

            六、讲解Stream流

            6.1 Stream中的API

            6.1.1  filter 筛选操作

            6.1.2 map 映射操作

            6.1.3 sort排序操作

            6.1.4 提取和组合

            6.1.5 find操作--findFirst和findAny  

            6.1.6 match 匹配操作--allMatch anyMatch

            6.1.7  聚合操作 max min count

            6.1.8 reduce规约操作

            6.2 collect搜集操作

            七、JDK8中日期时间类

            7.1 日期时间

            7.2 把日期时间转化为字符串和字符串解析为日期时间

            7.3 日期时间比较类.

    一、Lambda表达式

            概念：Lambda表达式：特殊的匿名内部类，语法更简洁

                       Lambda表达式允许把函数作为一个方法的参数（函数作为方法参数传递），将代码像数据一样传递

             匿名内部类：无需创建接口的实现类，可以之间创建接口对象

    1.    Runnable runnable=new Runnable() {
    2.          @Override
    3.          public void run() {
    4.  
    5.          }
    6.     };

             调用方法时：传递的参数可以是 基本类型，引用类型

            语法：

            函数式接口: 接口有只有一个抽象方法。这种接口就是函数式接口。

            我们要想使用lambda表示，它的接口必须为函数式接口。

            箭头左边:抽象方法的参数

            ->： 运算符

            箭头右边: 抽象方法的方法体。

            

            1.1 匿名内部类的冗余

    1. public class Test {
    2.     public static void main(String[] args) {
    3.  
    4.  
    5.         //构造函数需要传递一个Runnable target类型的参数。而Runnable它是一个接口。
    6.         MyRunnable my=new MyRunnable();
    7.         Thread t=new Thread(my);
    8.         t.start();
    9.  
    10.  
    11.         //使用匿名内部类
    12.         Runnable runnable=new Runnable() {
    13.             @Override
    14.             public void run() {
    15.                 System.out.println("~~~~~~~~~~~~~~这是匿名内部类");
    16.             }
    17.         };
    18.         Thread t2=new Thread(runnable);
    19.         t2.start();
    20.  
    21.  
    22.  
    23.     }
    24. }
    25. class MyRunnable implements Runnable{
    26.  
    27.     @Override
    28.     public void run() {
    29.         System.out.println("~~~~~~~~~~~~~~这是自定义接口实现类");
    30.     }
    31. }

    分析代码:

    • Thread 类需要 Runnable 接口作为参数，其中的抽象 run 方法是用来指定线程任务内容的核心

    • 为了指定 run 的方法体，不得不需要 Runnable 接口的实现类

    • 为了省去定义一个 Runnable 实现类的麻烦，不得不使用匿名内部类

    • 必须覆盖重写抽象 run 方法，所以方法名称、方法参数、方法返回值不得不再写一遍，且不能写错

    • 而实际上，似乎只有方法体才是关键所在。

                            我们就可以使用Lambda表达式  

    1.  //lambda表达式 没有关注方法的名称 以及方法的返回类型 --lambda表示不会生成字节码文件
    2.         Runnable r=()->{
    3.             System.out.println("这是lambda表达式");
    4.         };
    5.         Thread t3=new Thread(r);
    6.         t3.start();

            1.2 自定义无参无返回值的函数式接口

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         Swimming s=new Swimming() {
    4.             @Override
    5.             public void swiming() {
    6.                 System.out.println("~~~~~~~~~~~~匿名内部类");
    7.             }
    8.         };
    9.         fun(s);
    10.  
    11.  
    12.         Swimming s2=()->{
    13.             System.out.println("lambda表达式============");
    14.         };
    15.         fun(s2);
    16.  
    17.     }
    18.  
    19.     //定义一个方法---传递的参数为接口类型---函数式接口
    20.     public static void fun(Swimming s){
    21.           s.swiming();
    22.     }
    23. }
    24. //它就是函数式接口
    25. @FunctionalInterface
    26. interface Swimming{
    27.     public void swiming();
    28. }

             1.3 自定义有参有返回值的函数式接口

    1. public class Test02 {
    2.     public static void main(String[] args) {
    3.         //无需参数类型
    4.         Operator o = (arr) -> {
    5.             int sum = 0;
    6.             for (int b : arr) {
    7.                 sum += b;
    8.             }
    9.             return sum;
    10.         };
    11.  
    12.  
    13.         fun(o);
    14.     }
    15.  
    16.     public static void fun(Operator operator) {
    17.         int sum[] = {11, 12, 13, 14};
    18.         int sum1 = operator.getSum(sum);
    19.         System.out.println("数组中元素的和:" + sum1);
    20.     }
    21. }
    22.  
    23. interface Operator {
    24.     //求数组中元素的和
    25.     public int getSum(int[] arr);
    26. }

     下面举例演示 java.util.Comparator 接口的使用场景代码，其中的抽象方法定义为：

    • public abstract int compare(T o1, T o2);

    当需要对一个对象集合进行排序时， Collections.sort 方法需要一个 Comparator 接口实例来指定排序的规则。

    1. public class Test03 {
    2.     public static void main(String[] args) {
    3.         List list=new ArrayList<>();
    4.         list.add(new Student("柳昌江",16));
    5.         list.add(new Student("汪豪杰",17));
    6.         list.add(new Student("闫克起",15));
    7.         list.add(new Student("刘洺宇",16));
    8.         //List list,要排序的集合
    9.         // Comparator c： 指明排序的规则
    10. //        Comparator comparator=new Comparator() {
    11. //            //返回0 表示o1和o2 相同 返回大于0
    12. //            @Override
    13. //            public int compare(Student o1, Student o2) {
    14. //                return o1.getAge()-o2.getAge();
    15. //            }
    16. //        };
    17.  
    18.         Comparator comparator=(o1,o2)->{return o2.getAge()-o1.getAge();};
    19.         Collections.sort(list,comparator);
    20.         System.out.println(list);
    21.     }
    22. }
    23.  
    24.  
    25. class Student{
    26.     private String name;
    27.     private Integer age;
    28.  
    29.     @Override
    30.     public String toString() {
    31.         return "Student{" +
    32.                 "name='" + name + '\'' +
    33.                 ", age=" + age +
    34.                 '}';
    35.     }
    36.  
    37.     public String getName() {
    38.         return name;
    39.     }
    40.  
    41.     public void setName(String name) {
    42.         this.name = name;
    43.     }
    44.  
    45.     public Integer getAge() {
    46.         return age;
    47.     }
    48.  
    49.     public void setAge(Integer age) {
    50.         this.age = age;
    51.     }
    52.  
    53.     public Student(String name, Integer age) {
    54.         this.name = name;
    55.         this.age = age;
    56.     }
    57. }

            1.4 详细介绍Lambda表达式

                            什么时候使用lambda表达式？

                            调用某个方法时，该方法需要传递一个函数式接口参数时

            

            二、函数式接口

            概念: 如果一个接口只有一个抽象方法，则该接口称之为函数式接口，函数式接口可以使用Lambda表达式，Lambda表达式会被匹配到这个抽象方法上。

            @FunctionalInterface 注解检测接口是否符合函数式接口

            内置函数式接口的由来

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         Operator o=arr -> arr.length;
    4.         fun(o);
    5.     }
    6.     public static void fun(Operator operator) {
    7.         int sum[] = {11, 12, 13, 14};
    8.         int sum1 = operator.getSum(sum);
    9.         System.out.println("数组中元素的个数:" + sum1);
    10.     }
    11. }
    12.  
    13. interface Operator {
    14.     //求数组中元素的和
    15.     public int getSum(int[] arr);
    16. }

     分析

    我们知道使用Lambda表达式的前提是需要有函数式接口。而Lambda使用时不关心接口名，抽象方法名，只关心抽 象方法的参数列表和返回值类型。因此为了让我们使用Lambda方便，JDK提供了大量常用的函数式接口。 ---无需自定义函数式接口。---如果JDK不提供一些函数式接口，那么每个人需要自定义函数式接口，而且每个人定义的名称不一致。

                    内置的函数式接口都在 java.util.function包下  

             

            2.1 Consumer 消费性函数式接口

            T: 参数的泛型

            void accept(T t);

            方法中有参，无返回值。

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/3 12:11
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo05;
    9.  
    10. import java.util.function.Consumer;
    11.  
    12. /**
    13.  * 消费性函数式接口
    14.  * 有参无返回值
    15.  * 如果需要一个有参返回值的函数式接口，那么我们就可以使用Consumer函数式即可，无需自定义函数式接口
    16.  */
    17. public class Test05 {
    18.     public static void main(String[] args) {
    19.         Consumer consumer=a -> {
    20.             System.out.println("吃烧烤需要花:"+a);
    21.         };
    22.  
    23.         fun(consumer,9999.99);
    24.     }
    25.  
    26.     public static void fun(Consumer consumer,Double money){
    27.         consumer.accept(money);
    28.     }
    29. }
    30.

            2.2 Supplier 供给型函数式接口

            T:表示方法的返回值泛型  T get();

            方法没有参数，有返回值。 当我们需要无参有返回值的函数式接口，就可以使用这种内置

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/3 12:15
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo06;
    9.  
    10. import java.util.function.Supplier;
    11.  
    12. /**
    13.  *  T:表示方法的返回值泛型
    14.  *  方法没有参数，有返回值 当我们需要无参有返回值的函数式接口时，就可以用这种内置
    15.  *  fun是自己写的方法，未来可能调用jdk自带的方法，参数也可能就是上面给的函数式接口。
    16.  */
    17. public class Test06 {
    18.     public static void main(String[] args) {
    19.         Supplier s=()->{
    20.             return "八嘎";
    21.         };
    22.         fun(s);
    23.     }
    24.  
    25.     public static void fun(Supplier supplier){
    26.         String s = supplier.get();
    27.         System.out.println(s);
    28.     }
    29. }
    30.

            3.3 Funcation 函数型函数式接口

            T:参数的泛型
            R: 返回值的泛型
            R apply(T t);
            这种函数式接口需要参数和有返回值。

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/3 12:18
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo07;
    9.  
    10.  
    11. import java.util.function.Function;
    12.  
    13. /**
    14.  *  Funcation 函数型函数式接口
    15.  *  T:参数的泛型
    16.  *  R: 返回值的泛型
    17.  *  R apply(T t);
    18.  *  这种函数式接口需要参数和有返回值
    19.  */
    20. public class Test07 {
    21.     public static void main(String[] args) {
    22.  
    23.         Function function=t->t.length();
    24.  
    25.         fun(function,"hahahahahahahhahahahahahahahhaha");
    26.     }
    27.     public static void fun(Function f,String str){
    28.         Integer apply = f.apply(str);
    29.         System.out.println(apply);
    30.     }
    31. }
    32.

             3.4 Predicate 断言型函数式接口

            boolean test(T t);

            泛型: 参数的类型

            返回值: boolean

            根据参数做相应的条件判断，如果满足条件则返回true,不满足则返回false.

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/4 9:11
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo1104.demo01;
    9.  
    10. import java.util.function.BiPredicate;
    11. import java.util.function.Predicate;
    12.  
    13. /**
    14.  * 断言型函数式接口
    15.  */
    16. public class TestPredicate {
    17.     public static void main(String[] args) {
    18.  
    19.         //根据你传递的字符串，判断字符串的长度是否大于5
    20.         Predicate p=t->{
    21.             return t.length()>5;
    22.         };
    23.  
    24.         boolean baga = p.test("hello baga");
    25.         System.out.println(baga);
    26.  
    27.         //boolean test (T t,U u)
    28.         BiPredicate biPredicate=(t,u)->{
    29.             return t.equals(u);
    30.         };
    31.  
    32.         boolean test = biPredicate.test("baga", "guizi");
    33.         System.out.println(test);
    34.     }
    35. }
    36.

            四、方法引用的使用场景

            我们用Lambda表达式来实现匿名方法。但有些情况下，我们用Lambda表达式仅仅是调用一些已经存在的方法，除了调用方法外，没有其他任何多余的动作，在这种情况下，我们倾向于通过方法名来调用它，而Lambda表达式可以帮助我们实现这一要求，它使得Lambda在调用那些已经拥有方法名的方法的代码更简洁、更容易理解。方法引用可以理解为Lambda表达式的另外一种表现形式。方法引用要比lambda表达式语法更加简洁

            方法引用: 理解为Lambda表达式的另一种表现。它的语法更加简洁。

            方法引用使用的前提: lambda表达式中调用的是已经存在的方法，除了调用方法外，不能有任何其他操作，才可以使用方法引用。

            4.1 方法引用的分类

    类型语法对应的LAMBDA表达式
    静态方法引用类名::staticMethod(args) -> 类名.staticMethod(args)
    实例方法引用inst::instMethod(args) -> inst.instMethod(args)
    对象方法引用类名::instMethod(inst,args) -> inst.instMethod(args)
    构建方法引用类名::new(args) -> new 类名(args)

                                    ::  是方法引用的符号。  

            4.2 方法引用的举例

                  静态方法的引用：当lambda表达式中，通过类名引用了一个已经存在的静态方法时。而且仅有一条语句 

    1. public class Test01 {
    2.     public static void main(String[] args) {
    3.  
    4.         //void accept(T t);
    5.         //Consumer consumer=(arr)->{Test01.sum(arr);};
    6.         //观察: 我们发现lambda表达式中有且仅有一条一句，而且这条语句，是调用了已经存在的方法。
    7.         Consumer<int[]> consumer=Test01::sum;
    8.         int[] arr={1,2,3,4};
    9.         consumer.accept(arr);
    10.     }
    11.  
    12.     public static void sum(int[] arr) {
    13.         int sum = 0;
    14.         for (int a : arr) {
    15.             sum += a;
    16.         }
    17.         System.out.println("数组中元素的和:"+sum);
    18.  
    19.     }
    20. }
    1. public class Test02 {
    2.     public static void main(String[] args) {
    3.  
    4.         List list=new ArrayList<>();
    5.         list.add(2);
    6.         list.add(3);
    7.         list.add(8);
    8.         list.add(4);
    9.         list.add(1);
    10.         //Comparator comparator=(o1,o2)->Integer.compare(o1,o2);
    11.         Comparator comparator=Integer::compare;
    12.         Collections.sort(list,comparator);
    13.  
    14.         System.out.println(list);
    15.     }
    16. }

            实例方法的引用：实例方法引用 inst::instMethod (args) -> inst.instMethod(args) 

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/4 10:16
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo1104.demo03;
    9.  
    10. import java.util.function.Supplier;
    11.  
    12. /**
    13.  * 实例方法引用
    14.  */
    15. public class Test03 {
    16.     public static void main(String[] args) {
    17.         //无参 有返回值
    18.         Teacher teacher=new Teacher("闫克起","35");
    19.  
    20.         //Supplier supplier=()-> teacher.getName();
    21.  
    22.         //方法引用
    23.         Supplier supplier=teacher::getName;
    24.         Supplier supplier1=teacher::getAge;
    25.  
    26.         System.out.println(supplier.get()+"********"+supplier1.get());
    27.  
    28.  
    29.  
    30.     }
    31. }
    32. class Teacher{
    33.     private String name;
    34.     private String age;
    35.  
    36.     @Override
    37.     public String toString() {
    38.         return "Teacher{" +
    39.                 "name='" + name + '\'' +
    40.                 ", age='" + age + '\'' +
    41.                 '}';
    42.     }
    43.  
    44.     public Teacher(String name, String age) {
    45.         this.name = name;
    46.         this.age = age;
    47.     }
    48.  
    49.     public String getName() {
    50.         return name;
    51.     }
    52.  
    53.     public void setName(String name) {
    54.         this.name = name;
    55.     }
    56.  
    57.     public String getAge() {
    58.         return age;
    59.     }
    60.  
    61.     public void setAge(String age) {
    62.         this.age = age;
    63.     }
    64. }
    65.

            对象方法引用 类名::instMethod (inst,args) -> inst.instMethod(args)

            当lambda表达式第一个参数调用方法，而后面的参数作为方法的参数时。 我们可以考虑使用对象方法引用。  

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/4 10:19
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo1104.demo04;
    9.  
    10. import java.util.function.BiPredicate;
    11.  
    12. /**
    13.  * 对象方法引用
    14.  */
    15. public class Test {
    16.     public static void main(String[] args) {
    17.         //比较两个字符串是否一致  断言式函数式接口
    18. //        BiPredicate biPredicate=(o1,o2)->{
    19. //            return o1.equals(o2);
    20. //        };
    21.  
    22.         //对象方法引用
    23.         BiPredicate biPredicate=String::equals;
    24.  
    25.         boolean test = biPredicate.test("八嘎", "baag");
    26.         System.out.println(test);
    27.     }
    28. }
    29.

            构建方法引用 类名::new (args) -> new 类名(args)

            lambda表达式中只有一条语句，而且这条数据是实例一个对象，调用构造方法，而且构造函数的参数和lambda表达式的参数一致。  

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/4 10:23
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo1104.demo05;
    9.  
    10. import java.util.function.Function;
    11. import java.util.function.Supplier;
    12.  
    13. /**
    14.  * 构造方法引用
    15.  */
    16. public class Test {
    17.     public static void main(String[] args) {
    18.         //Function function=(t)->new Teacher(t);
    19.  
    20.         //构造方法引用
    21.         Function function=Teacher::new;
    22.  
    23.         Teacher apply = function.apply("闫克起");
    24.         System.out.println(apply);
    25.  
    26.     }
    27. }
    28. class Teacher{
    29.     private String name;
    30.  
    31.     public Teacher() {
    32.     }
    33.  
    34.     @Override
    35.     public String toString() {
    36.         return "Teacher{" +
    37.                 "name='" + name + '\'' +
    38.                 '}';
    39.     }
    40.  
    41.     public Teacher(String name) {
    42.         this.name = name;
    43.     }
    44.  
    45. }
    46.

            五、Stream流

            Java8的两个重大改变，一个是Lambda表达式，另一个就是本节要讲的Stream API表达式。Stream 是Java8中处理集合的关键抽象概念，它可以对集合进行非常复杂的查找、过滤、筛选等操作.

            这种操作速度，要比操作数据库更快。 引用它基于JVM内存.

            5.1 为什么要用Stream流

    当我们需要对集合中的元素进行操作的时候，除了必需的添加、删除、获取外，最典型的就是集合遍历。我们来体验 集合操作数据的弊端，需求如下：

            一个ArrayList集合中存储有以下数据:张无忌,周芷若,赵敏,张强,张三丰
            需求:1.拿到所有姓张的 2.拿到名字长度为3个字的 3.打印这些数据

            代码如下：

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         ArrayList list = new ArrayList<>();
    4.         Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
    5.  
    6.         //1.获取所有姓张。
    7.         ArrayList newList = new ArrayList<>();
    8.         for(String n:list){
    9.               if(n.startsWith("张")){
    10.                   newList.add(n);
    11.               }
    12.         }
    13.  
    14.         //2. 名字中含有三个的字
    15.         ArrayList newList2 = new ArrayList<>();
    16.         for(String n:newList){
    17.               if(n.length()==3){
    18.                   newList2.add(n);
    19.               }
    20.         }
    21.  
    22.         //3.打印
    23.         for (String s:newList2){
    24.             System.out.println(s);
    25.         }
    26.  
    27.     }
    28. }

            不过循环遍历有个弊端 这段代码中含有三个循环，每一个作用不同：

    1. 首先筛选所有姓张的人；

    2. 然后筛选名字有三个字的人；

    3. 最后进行对结果进行打印输出。

    每当我们需要对集合中的元素进行操作的时候，总是需要进行循环、循环、再循环。这是理所当然的么？不是。循环 是做事情的方式，而不是目的。每个需求都要循环一次，还要搞一个新集合来装数据，如果希望再次遍历，只能再使 用另一个循环从头开始。

                    那Stream能给我们带来怎样更加优雅的写法呢？

                    使用Stream流来体验上面对集合的操作。 

    1. public static void main(String[] args) {
    2.         ArrayList list = new ArrayList<>();
    3.         Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
    4.  
    5.  
    6.        // Consumer consumer=item-> System.out.println(item);
    7.         list.stream()
    8.                 .filter(item->item.startsWith("张"))
    9.                 .filter(item->item.length()==3)
    10.                 .forEach(item-> System.out.println(item));
    11.  
    12.     }

            5.2 Stream流式思想概述

            Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工 处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

            

            5.2.1 获取Stream流对象

            这里获取流对象的方式有三种:    1. 通过集合名获取。 2. 通过Arrays中的静态方法获取streams  3. 通过Stream中的静态方法of

                    拿到流对象后才能操作Stream类中相关的方法

    1. public class Test02 {
    2.     public static void main(String[] args) {
    3.         ArrayList list = new ArrayList<>();
    4.         Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
    5.         //通过集合对象调用stream方法获取
    6.         Stream stream = list.stream();
    7.  
    8.         //通过Arrays数组工具类调用stream方法。
    9.         String [] arr={"张三","李四","王五"};
    10.         Stream stream1 = Arrays.stream(arr);
    11.  
    12.         //通过Stream类中的方法获取Stream流对象
    13.         Stream stream2 = Stream.of("张三", "李四", "王五");
    14.     }
    15. }

            5.2.2   中间操作的方法有哪些

            一个操作的中间链，对数据源的数据进行操作。

            举个简单的例子：

            假设有一个Person类和一个Person列表，现在有两个需求：1）找到年龄大于18岁的人并输出；2）找出所有中国人的数量。

    1. /**
    2.  * Created by Intellij IDEA
    3.  *
    4.  * @author 王俊凯
    5.  * @Date: 2022/11/4 14:27
    6.  * @Version 1.0
    7.  */
    8. package com.wjk.demo1104.demo07;
    9.  
    10. import java.util.ArrayList;
    11. import java.util.List;
    12.  
    13. public class Test02 {
    14.     public static void main(String[] args) {
    15.         List personList = new ArrayList<>();
    16.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    17.         personList.add(new Person("Tom",24,"美国",'M'));
    18.         personList.add(new Person("Harley",22,"英国",'F'));
    19.         personList.add(new Person("向天笑",20,"中国",'M'));
    20.         personList.add(new Person("李康",22,"中国",'M'));
    21.         personList.add(new Person("小梅",20,"中国",'F'));
    22.         personList.add(new Person("何雪",21,"中国",'F'));
    23.         personList.add(new Person("李康",22,"中国",'M'));
    24.         //找出年龄大于18
    25.         personList.stream().filter(item->{
    26.             return item.getAge()>18;
    27.         }).forEach(System.out::println);
    28.  
    29.         System.out.println("*****************************");
    30.  
    31.         //找出所有中国人
    32.         personList.stream().filter(item->item.getCountry().equals("中国")).forEach(System.out::println);
    33.     }
    34. }
    35. class Person {
    36.     private String name;
    37.     private Integer age;
    38.     private String country;
    39.     private char sex;
    40.  
    41.     @Override
    42.     public String toString() {
    43.         return "Person{" +
    44.                 "name='" + name + '\'' +
    45.                 ", age=" + age +
    46.                 ", country='" + country + '\'' +
    47.                 ", sex=" + sex +
    48.                 '}';
    49.     }
    50.  
    51.     public Person() {
    52.     }
    53.  
    54.     public Person(String name, Integer age, String country, char sex) {
    55.         this.name = name;
    56.         this.age = age;
    57.         this.country = country;
    58.         this.sex = sex;
    59.     }
    60.  
    61.     public String getName() {
    62.         return name;
    63.     }
    64.  
    65.     public void setName(String name) {
    66.         this.name = name;
    67.     }
    68.  
    69.     public Integer getAge() {
    70.         return age;
    71.     }
    72.  
    73.     public void setAge(Integer age) {
    74.         this.age = age;
    75.     }
    76.  
    77.     public String getCountry() {
    78.         return country;
    79.     }
    80.  
    81.     public void setCountry(String country) {
    82.         this.country = country;
    83.     }
    84.  
    85.     public char getSex() {
    86.         return sex;
    87.     }
    88.  
    89.     public void setSex(char sex) {
    90.         this.sex = sex;
    91.     }
    92. }
    93.

            六、讲解Stream流

            6.1 Stream中的API

            中间操作api: 一个操作的中间链，对数据源的数据进行操作。而这种操作的返回类型还是一个Stream对象。---中间操作如果没有调用终止操作的api，则中间操作的api不会被执行。

            终止操作api: 一个终止操作，执行中间操作链，并产生结果，返回类型不在是Stream流对象。

            6.1.1  filter 筛选操作

            该方法需要一个断言型函数式接口参数，满足条件的留下，不满足条件的过滤掉。 

    1. public class Test03 {
    2.     public static void main(String[] args) {
    3.         List personList = new ArrayList<>();
    4.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    5.         personList.add(new Person("Tom",24,"美国",'M'));
    6.         personList.add(new Person("Harley",22,"英国",'F'));
    7.         personList.add(new Person("向天笑",20,"中国",'M'));
    8.         personList.add(new Person("李康",22,"中国",'M'));
    9.         personList.add(new Person("小梅",20,"中国",'F'));
    10.         personList.add(new Person("何雪",21,"中国",'F'));
    11.         personList.add(new Person("李康",22,"中国",'M'));
    12.  
    13.         //筛选出年龄大于20
    14. //        personList.stream().filter(item -> item.getAge() > 20).forEach(item-> System.out.println(item));
    15.         
    16.         personList.stream().filter(item -> item.getAge() > 20).forEach(System.out::println);
    17.  
    18.  
    19.     }
    20. }
    21. class Person {
    22.     private String name;
    23.     private Integer age;
    24.     private String country;
    25.     private char sex;
    26.  
    27.     @Override
    28.     public String toString() {
    29.         return "Person{" +
    30.                 "name='" + name + '\'' +
    31.                 ", age=" + age +
    32.                 ", country='" + country + '\'' +
    33.                 ", sex=" + sex +
    34.                 '}';
    35.     }
    36.  
    37.     public Person() {
    38.     }
    39.  
    40.     public Person(String name, Integer age, String country, char sex) {
    41.         this.name = name;
    42.         this.age = age;
    43.         this.country = country;
    44.         this.sex = sex;
    45.     }
    46.  
    47.     public String getName() {
    48.         return name;
    49.     }
    50.  
    51.     public void setName(String name) {
    52.         this.name = name;
    53.     }
    54.  
    55.     public Integer getAge() {
    56.         return age;
    57.     }
    58.  
    59.     public void setAge(Integer age) {
    60.         this.age = age;
    61.     }
    62.  
    63.     public String getCountry() {
    64.         return country;
    65.     }
    66.  
    67.     public void setCountry(String country) {
    68.         this.country = country;
    69.     }
    70.  
    71.     public char getSex() {
    72.         return sex;
    73.     }
    74.  
    75.     public void setSex(char sex) {
    76.         this.sex = sex;
    77.     }
    78. }

            6.1.2 map 映射操作

            map--接收Lambda，将元素转换成其他形式或提取信息。接收一个函数作为参数，该函数会被应用到每个元素上，并将其映射成一个新的元素。

     

    1.  List personList = new ArrayList<>();
    2.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    3.         personList.add(new Person("Tom",24,"美国",'M'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("向天笑",20,"中国",'M'));
    6.         personList.add(new Person("李康",22,"中国",'M'));
    7.         personList.add(new Person("小梅",20,"中国",'F'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11.         //map映射操作--名称
    12.         personList.stream().map(item->item.getName()).forEach(System.out::println);

            6.1.3 sort排序操作

    1.   List personList = new ArrayList<>();
    2.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    3.         personList.add(new Person("Tom",24,"美国",'M'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("向天笑",20,"中国",'M'));
    6.         personList.add(new Person("李康",22,"中国",'M'));
    7.         personList.add(new Person("小梅",20,"中国",'F'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11.         //sort排序操作--年龄
    12.         personList.stream().sorted((o1,o2)->Integer.compare(o1.getAge(),o2.getAge())).forEach(System.out::println);

            6.1.4 提取和组合

            流也可以进行合并、去重、限制、跳过等操作。        filter map sort concat distinct limit skip 

    1. public class Test04 {
    2.     public static void main(String[] args) {
    3.         String[] arr1 = { "a", "b", "c", "d" };
    4.         String[] arr2 = { "d", "e", "f", "g" };
    5.         Stream stream1 = Stream.of(arr1);
    6.         Stream stream2 = Stream.of(arr2);
    7.  
    8.         //合并流
    9.         //Stream.concat(stream1,stream2).forEach(System.out::println);
    10.         //去重--distinct
    11.        // Stream.concat(stream1,stream2).distinct().forEach(System.out::println);
    12.  
    13.         //获取前n个元素--limit
    14.         //Stream.concat(stream1,stream2).limit(5).forEach(System.out::println);
    15.  
    16.         //跳过前n个元素
    17.         Stream.concat(stream1,stream2).skip(2).forEach(System.out::println);
    18.     }
    19. }

            6.1.5 find操作--findFirst和findAny  

    1.   List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11.         //find操作-- findFirst 获取流中第一个元素
    12. //        Optional first = personList.stream().findFirst();
    13. //        System.out.println(first.get());
    14.         //find操作---findAny() 获取流中任意一个元素  必须使用并行流测试
    15.         Optional any = personList.parallelStream().findAny();
    16.         System.out.println(any.get());

            6.1.6 match 匹配操作--allMatch anyMatch

    1.  List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11.         //匹配操作--所有元素都必须匹配条件 才返回true
    12. //        boolean b = personList.stream().allMatch(item -> item.getAge() > 10);
    13. //        System.out.println(b);
    14.         boolean b = personList.stream().anyMatch(item -> item.getAge() > 50);
    15.         System.out.println(b);

            6.1.7  聚合操作 max min count

    1.    List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11.         //聚合操作---count
    12. //        long count = personList.stream().count();
    13. //        System.out.println("个数:"+count);
    14.         //聚合操作---max min
    15.         Optional max = personList.stream().max((o1, o2) -> o1.getAge() - o2.getAge());
    16.         System.out.println(max.get());

            6.1.8 reduce规约操作

    1. public class Test05 {
    2.     public static void main(String[] args) {
    3.         Integer [] arr={2,3,4,5,6,2};
    4.  
    5.         //第一次赋值时，会把集合中的前两个元素赋值于t1 t2   后面会把方法计算的结果赋予t1  在集合的后面的元素赋予t2
    6.         Optional reduce = Arrays.stream(arr).reduce((t1, t2) -> t1+=t2);
    7.         System.out.println(reduce.get());
    8.     }
    9. }

            6.2 collect搜集操作

            计数： count

            平均值： averagingInt、 averagingLong、 averagingDouble

            最值： maxBy、 minBy

            求和： summingInt、 summingLong、 summingDouble

    1.     List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.         personList.add(new Person("李康",22,"中国",'M'));
    10.  
    11. //        Long collect =personList.stream().collect(Collectors.counting());
    12. //        System.out.println(collect);
    13. //        Double collect = personList.stream().collect(Collectors.averagingInt(item -> item.getAge()));
    14. //        System.out.println(collect);
    15. //        Optional collect = personList.stream().collect(Collectors.maxBy(((o1, o2) -> o1.getAge() - o2.getAge())));
    16. //        System.out.println(collect);
    17.  
    18.         Integer collect = personList.stream().collect(Collectors.summingInt(item -> item.getAge()));
    19.         System.out.println(collect);

            搜集为一个新的集合。 

    1.         List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.  
    10. //        Set set = personList.stream().filter(item -> item.getAge() > 20)
    11. //                .filter(item -> item.getCountry().equals("中国"))
    12. //                .map(item -> item.getName())
    13. //                .collect(Collectors.toSet());
    14. //        System.out.println(set);
    15.         Map map = personList.stream().filter(item -> item.getAge() > 20)
    16.                 .filter(item -> item.getCountry().equals("中国"))
    17.                 .collect(Collectors.toMap(item -> item.getName(), item -> item));
    18.         System.out.println(map);

            分组操作

    1.         List personList = new ArrayList<>();
    2.         personList.add(new Person("Tom",24,"美国",'M'));
    3.         personList.add(new Person("欧阳雪",18,"中国",'F'));
    4.         personList.add(new Person("Harley",22,"英国",'F'));
    5.         personList.add(new Person("小梅",20,"中国",'F'));
    6.         personList.add(new Person("向天笑",20,"中国",'M'));
    7.         personList.add(new Person("李康",22,"中国",'M'));
    8.         personList.add(new Person("何雪",21,"中国",'F'));
    9.  
    10.         Map> collect = personList.stream().collect(Collectors.groupingBy(item -> item.getSex()));
    11.         System.out.println(collect);

            七、JDK8中日期时间类

    1. public class Test {
    2.     public static void main(String[] args) {
    3. //        //自定义时间的日期---设计不合理。
    4. //        Date date=new Date(2022,11,5);
    5. //        System.out.println(date);
    6. //
    7. //        //时间格式转化---存在线程安全问题
    8.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    9. //        System.out.println(sdf.format(date));
    10.  
    11.         for (int i = 0; i <10 ; i++) {
    12.                new Thread(new Runnable() {
    13.                    @Override
    14.                    public void run() {
    15.                        try {
    16.                            System.out.println(sdf.parse("2022-11-05"));
    17.                        } catch (ParseException e) {
    18.                            e.printStackTrace();
    19.                        }
    20.                    }
    21.                }).start();
    22.         }
    23.     }
    24. }

            日期时间类设计不合理---两个包下都有Date. Date的年需要从1900算起。

            日期转化类存在线程安全问题。

            jdk8后提供了新的日期时间类以及转化类。java.time包下

            7.1 日期时间

            

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         //创建一个指定日期时间的类
    4.         LocalDateTime dateTime = LocalDateTime.of(2022, 10, 11, 17, 18, 16);
    5.         //创建当前的日期时间对象
    6.         LocalDateTime now = LocalDateTime.now();
    7.  
    8.         System.out.println("指定的日期时间:"+dateTime.toString());
    9.         System.out.println("当前的日期时间:"+now);
    10.     }
    11.  
    12.     private static void getTime(){
    13.         //获取一个指定的时间
    14.         LocalTime time = LocalTime.of(11, 11, 11);
    15.         //获取当前的时间
    16.         LocalTime now = LocalTime.now();
    17.         System.out.println("指定的时间:"+time);
    18.         System.out.println("当前的时间:"+now);
    19.  
    20.         //时间类中常用的方法
    21.         System.out.println("获取时间的小时:"+now.getHour());
    22.         System.out.println("获取时间的分钟:"+now.getMinute());
    23.         System.out.println("获取时间的秒:"+now.getSecond());
    24.         System.out.println("获取时间的纳秒:"+now.getNano());
    25.     }
    26.      private static void getDate(){
    27.         //创建一个LocalDate日期类。--创建指定的日期
    28.         LocalDate date = LocalDate.of(2022, 10, 7);
    29.         //创建一个当前日期
    30.         LocalDate now = LocalDate.now();
    31.  
    32.         System.out.println("指定的日期:"+date);
    33.         System.out.println("当前日期:"+now);
    34.  
    35.         //日期类中的常见的方法
    36.         System.out.println("获取日期的年份:"+now.getYear());
    37.         System.out.println("获取日期的月份:"+now.getMonth().getValue());
    38.         System.out.println("获取日期的星期:"+now.getDayOfWeek().getValue());
    39.     }
    40. }

            7.2 把日期时间转化为字符串和字符串解析为日期时间

            DateTimeFormate 可以进行日期时间和字符串的转化

                    (1) 把日期时间转化为指定格式的字符串。  

    1. public static void main(String[] args) {
    2.         LocalDateTime now = LocalDateTime.now();
    3.         System.out.println("转化前的日期时间:"+now);
    4.         DateTimeFormatter dtf=DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    5.  
    6.         String format = now.format(dtf);
    7.         System.out.println("转化后:"+format);
    8.     }

            （2）把字符串转化为日期时间对象  

    1.     public static void main(String[] args) {
    2.         DateTimeFormatter dtf=DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
    3.         LocalDateTime dateTime = LocalDateTime.parse("2020/11/17 22:22:22", dtf);
    4.         System.out.println(dateTime);
    5.     }

            7.3 日期时间比较类.

                    

    1. public class Test {
    2.     public static void main(String[] args) {
    3.         LocalDate date = LocalDate.of(2020, 11, 1);
    4.         LocalDate now = LocalDate.now();
    5.         //比较两个日期的距离
    6.         Period period = Period.between(date, now);
    7.         System.out.println("相差的年:"+ period.getYears());
    8.         System.out.println("相差的月:"+ period.getMonths());
    9.         System.out.println("相差的天:"+ period.getDays());
    10.  
    11.         LocalTime time = LocalTime.of(8, 12, 12);
    12.         LocalTime now1 = LocalTime.now();
    13.         Duration between = Duration.between(time, now1);
    14.         System.out.println(between.toHours());
    15.         System.out.println(between.toMinutes()); //时间与时间之间相差的分钟
    16.         System.out.println(between.getSeconds());//时间与时间之间相差的秒
    17.  
    18.  
    19.     }
    20. }
  • 相关阅读:
    CSS怎么选择除了第一个子元素外的其余同级子元素
    学内核之十一：ARM64屏障指令使用指南
    java计算机毕业设计web企业档案管理系统源码+mysql数据库+系统+lw文档+部署
    Python 笔记（22）— 变量解析原则（LEGB）、浅拷贝、深拷贝
    连接器公司介绍
    Android SurfaceFlinger导读（01） surfaceFlinger谁写的？他还干了什么？
    pnpm入门教程
    静态模板编译：提高Web性能的利器
    Java备忘录模式剖析及使用场景
    【Pytorch】torch.nn.LeakyReLU()
  • 原文地址：https://blog.csdn.net/wk3510/article/details/127671916