阶段二-Day18-Java新特性

于 2023-09-01 20:32:15 发布
阅读量123 收藏 1
点赞数 2
分类专栏： java学习之路 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_59163770/article/details/132610758
版权

一、JDK新特征

1. JDK版本变化

JDK版本发布时间
1.01996/1/23
1.11997/2/19
1.21998/12/4
1.32000/5/8
1.4.02002/2/13
Java SE 5.0 / 1.52004/9/30
Java SE 6.0 / 1.62006/4/1
Java SE 7.0 / 1.72011/7/28
Java SE 8.0 / 1.82014/3/18
Java SE 9.02017/9/21
Java SE 10.02018/3/21
Java SE 11.02018/9/25
Java SE 12.02019/3/19
Java SE 13.02019/9/17
Java SE 14.02020/3/17

其中Java5，Java8是革命性的版本。Java11也将提供长期的支持。Java9,10都是“功能性的版本”，支持时间只有半年左右。

特别是JDK8是JDK5以来最具革命性的版本。主要新特征包括Lambda表达式、函数式接口、方法引用和构造器引用、Stream API、新日期类、接口新变化等。其中的新日期类、接口新变化在前面章节已经讲解。

总的来说，JDK8中的Lambda表达式和Stream 是自Java语言添加泛型(Generics)和注解(annotation)以来最大的变化。

2. Lambda表达式

Lambda适用于只有一个抽象方法的接口(函数式接口)。

1. Lambda表达式引入

  1. 自定义接口

public interface MyInterface {
    public void method();
}

  1. 自定义实现类实现接口

public class  MyClass implements MyInterface{
  public void method() {
    System.out.println("使用类实现接口");
  }
}

  1. 测试

public class Test {
    public static void main(String[] args) {
        //1.使用外部类实现接口
        MyInterface myInterface = new MyClass();
        myInterface.method();

        //2.使用内部类
        MyInterface myInterface1 = new Inner();
        myInterface1.method();

        //3.使用匿名内部类
        MyInterface myInterface2 = new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类");
            }
        };
        myInterface2.method();

        //4.lambda表达式
        MyInterface myInterface3 = () -> {
            System.out.println("lambda表达式");
        };
        myInterface3.method();

    }

    public static class Inner implements MyInterface{
        @Override
        public void method() {
            System.out.println("内部类实现接口");
        }
    }
}
2. Lambda说明

  1. Lambda表达式： Lambda表达式基于数学中的λ演算得名，对应java中的lambda抽象，是一个匿名函数，即没有函数名的函数。

  2. Lambda表达式好处： 使用 Lambda 表达式可使代码变的更加简洁紧凑。并且Lambda表达式可和Stream API等相结合，使代码更加简洁紧凑。Lambda 表达式经常用来替代部分匿名内部类。

  3. Lambda表达式的语法 (parameters) -> expression或 (parameters) ->{ statements; } 参数：要重写的方法的形参列表 -> ：lambda运算符 表达式/语句体：要实现的方法的方法体

  4. Lambda表达式的本质：

    Lambda 表达式是一种匿名函数（不是匿名内部类），简单地说，它是没有声明的方法，也即没有访问修饰符、返回值声明和名字。它实质属于函数式编程的概念。

3. Lambda表达式的使用
3.1 无参，无返回值

  1. 接口

public interface A {
  void test();
}

     2.实现

public class Test01 {
    public static void main(String[] args) {
        //lambda和匿名内部类很像,可以对照参考
        A a = new A() {
            @Override
            public void test() {
                System.out.println("匿名");
            }
        };
        a.test();

        A a1 = () -> {
            System.out.println("lambda");
        };
        a1.test();

        //简化//只有一条执行语句，可以省略{}
        A a2 = () -> System.out.println("lambda");
        a2.test();
    }
}
3.2 单参，无返回值

  1. 接口

public interface B {
  void test(String name);
}

      2. 实现

public class Test02 {
    public static void main(String[] args) {
        B b = (String name) -> {
            System.out.println("你好" + name);
        };
        b.test("世界");

        //简化1:lambda可以简化参数类型,可以自动推断
        B b1 = (name) -> {
            System.out.println("你好" + name);
        };
        b1.test("世界");

        //简化2:只有一个参数,可以去掉括号
        B b2 = name -> {
            System.out.println("你好" + name);
        };
        b2.test("世界");

        //简化3:如果只有一句执行语句,可以省略{}
        B b3 = name -> System.out.println("你好" + name);
        b3.test("世界");
    }
}
3.3 多参，无返回值

  1. 接口

public interface C {
  void test(String name, int age);
}

     2.实现

public class Test03 {
    public static void main(String[] args) {
        C c = (String name,int age) -> {
            System.out.println(name + " " + age);
        };
        c.test("zs",12);

        //简化,自动推断(多于一个参数,不能省略括号)
        C c1 = (name,age) -> {
            System.out.println(name + " " + age);
        };
        c.test("zs",12);

        //简化,只有一个执行语句
        C c2 = (name, age) -> System.out.println(name + " " + age);
        c.test("zs",12);
    }
}
3.4 无惨，有返回值

  1. 接口

public interface D {
  int test();
}

      2.实现

public class Test04 {
    public static void main(String[] args) {
        D d = () -> {
          return 10;  
        };
        System.out.println(d.test());
        
        //简化  只有返回值的代码 可以将{}和return都省略
        D d1 = () -> 10;
        System.out.println(d1.test());
    }
}
3.5 单参，有返回值

  1. 接口

public interface E {
  String test(String name);
}

        2.实现

public class Test05 {
    public static void main(String[] args) {
        E e = (String name) -> {
            return name;
        };
        e.test("zs");

        //简化
        E e1 = (name) -> {
            return name;
        };
        e.test("zs");

        //简化
        E e2 = name -> {
            return name;
        };
        e.test("zs");
        //简化
        E e3 =name -> name;
        e.test("zs");

        //复杂的逻辑的代码，不能简化
        E e4 = aa -> {
            if(Integer.parseInt(aa) > 10){
                return aa;
            }
            return "0";
        };
    }
}
3.6 多参，有返回值

  1. 接口

public interface F {
  int test(String name, int age);
}

        2.实现

public class Test06 {
    public static void main(String[] args) {
        /* 多个参数，有返回值*/
        //使用Lambda表达式
        F f1 = (name, age) -> {
            /* System.out.println(name);*/
            return age;
        };
        System.out.println(f1.test("ls", 20));

        //简化  只返回结果，无其他操作可以简化
        F f2 = (name, age) -> age;
        System.out.println(f2.test("ls", 20));
    }
}
3.7 注意

  1. 有返回值的Lambda表达式，如果方法体只有一条返回语句，可同时省略return和{}。

  2. 虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的抽象方法，不是规定接口中只能有一个方法，称为函数式接口。

3.8 总结

->左面： ​ 参数类型可以省略不写，类型推断。 ​ 如果只有一个参数，()可以省略不写。 ​ ->右侧： ​ {}将方法体的具体内容包裹起来。 ​ 方法体中只有一条执行语句，{}可以省略不写。 ​ 如果执行语句就一条return语句，return 和 {}可以同时省略不写。

3. 函数式接口

1. 认识函数式接口

函数式接口：接口中只能有一个抽象方法，其他的可以有default、static、Object里继承的方法等。

作用：在Java中主要用在Lambda表达式和方法引用（想使用Lambda表达式，接口必须为函数式接口）。

JDK8专门提供了@FunctionalInterface注解，用来进行编译检查。

已经使用过的函数式接口，比如Comparator等，多线程阶段学习的函数式接口有Runnable、Callable等。

注意：Comparable并没有被标记为函数式接口

  1. 演示

@FunctionalInterface
public interface MyInterface {
    //只有一个抽象方法
    public void method();
    //default方法不计
    default void method1(){}
    //static方法不计
    static void method2(){}
    //从Object继承的方法不计
    public boolean equals(Object obj);
    
}
2. 内置的函数式接口

JDK 也提供了大量的内置函数式接口，使得 Lambda 表达式的运用更加方便、高效。这些内置的函数式接口已经可以解决我们开发过程中绝大部分的问题，只有一小部分比较特殊得情况需要我们自己去定义函数式接口。在这里特别介绍四个函数式接口。

  1. Consumer<T>：消费型接口（void accept(T t)）。有参数，无返回值。

  2. Supplier<T>：供给型接口（T get（））。只有返回值，没有入参。

  3. Function<T, R>：函数型接口（R apply（T t））。一个输入参数，一个输出参数，两种类型不可不同、可以一致。

  4. Predicate<T>：断言型接口（boolean test（T t））。输入一个参数，输出一个boolean类型得返回值。

函数式接口方法名输入参数输出参数作用
消费型接口Consumervoid accept(T t)Tvoid对类型为T的对象进行操作
供给型接口SupplierT get（）voidT返回类型为T的对象
函数型接口FunctionR apply（T t）TR对类型为T的对象进行操作，返回类型为R的对象
断言型接口Predicateboolean test（T t）Tboolean对类型为T的对象进行操作，返回布尔类型结果
2.1 消费型接口
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        //将一堆数字添加到集合中
        Collections.addAll(list,2,4,5,78,6);
        //consumer需要和forEach一起使用
        Consumer<Integer> consumer = new Consumer<Integer>() {
            @Override
            public void accept(Integer integer) {
                System.out.println(integer);
            }
        };
        list.forEach(consumer);

        //使用lambda表达式,自动推断类型,i前面不用带类型
        Consumer<Integer> consumer1 = (i) -> System.out.println(i);
        list.forEach(consumer1);
    }
}
2.2 断言型接口
public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,34,56,89,65,87);

        Predicate predicate = new Predicate<Integer>() {
            @Override
            public boolean test(Integer i) {
                if (i < 60){
                    //返回true的删除
                    return true;
                }
                //返回false的保留
                return false;
            }
        };
        list.removeIf(predicate);
        System.out.println(list);

        Predicate<Integer> predicate1 = i -> {
            if (i > 80){
                return true;
            }
            return false;
        };
        list.removeIf(predicate1);
        System.out.println(list);
    }
}

4. 方法引用

有时候，Lambda体中可能仅调用一个方法，而不做任何其它事，对于这种情况，通过一个方法名字来引用这个已存在的方法会更加清晰。方法引用是一个更加紧凑，易读的 Lambda 表达式，注意方法引用是一个 Lambda 表达式，方法引用操作符是双冒号 "::"。

1. 方法引用1
public class Test {
    public static void main(String[] args) {
        //使用匿名内部类实现
        Consumer consumer2 = new Consumer<Integer>() {
            @Override
            public void accept(Integer i) {
                System.out.println(i);
            }
        };

        Consumer<Integer> consumer = i -> System.out.println(i);
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,34,56,89,65,87);

        list.forEach(consumer);

        //方法引用
        /*
        * 接口实现类的方法 :
        * void accept(Integer i)
        * 重写的方法中调用的方法:
        * System.out.println(i)
        * 两个都是对象.方法
        * 在本示例中，println()的参数类型、
        * 返回值类型正好和
        * Consumer接口的accept方法的
        * 参数类型、返回值类型相同，
        * 此时可以采用方法引用来简化语法。
        * */
        Consumer<Integer> consumer1 = System.out::println;
    }
}

5. 流式编程

1. 介绍

Stream作为Java8的一大亮点，它与java.io包里的InputStream和OutputStream是完全不同的概念。

它是对容器对象功能的增强，它专注于对容器对象进行各种非常便利、高效的聚合操作或者大批量数据操作。

Stream API借助于同样新出现的Lambda表达式，极大的提高编程效率和程序可读性。

同时，它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用fork/join并行方式来拆分任务和加速处理过程。所以说，Java8中首次出现的 java.util.stream是一个函数式语言+多核时代综合影响的产物。

Stream有如下三个操作步骤：

一、创建Stream：从一个数据源，如集合、数组中获取流。

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

三、终止操作：一个终止操作，执行中间操作链，并产生结果。

当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”。中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线。

比如map (mapToInt，flatMap 等)、filter、distinct、sorted、peek、limit、skip、parallel、sequential、unordered。

当所有的中间操作完成后，若要将数据从流水线上拿下来，则需要执行终止操作。终止操作将返回一个执行结果，这就是你想要的数据。比如：forEach、forEachOrdered、toArray、reduce、collect、min、max、count、anyMatch、allMatch、noneMatch、findFirst、findAny、iterator。

多个中间操作可以连接起来形成一个流水线，除非流水线上触发终止操作，否则中间操作不会执行任何处理！而在终止操作时一次性全部处理，称作“惰性求值”。

2. 创建Stream串行流
public class Test {
    public static void main(String[] args) {
        //创建集合Stream
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,34,56,89,65,87,80,87,95,100,34,45);
        //通过集合获取流对象
        Stream<Integer> stream = list.stream();
        stream.forEach(System.out::println);

        //创建多个元素Stream
        System.out.println("----------------");
        //获取每个数字的流对象
        Stream stream3 = Stream.of(34,56,89,65,87,80,87,95,100,34,45);
        stream3.forEach(System.out::println);

        //创建数组Stream
        int [] arr = {34,56,89,65,87,80,87,95,100,34,45};
        IntStream stream1 = Arrays.stream(arr);
        stream1.forEach(System.out::println);
    }
}
3. 中间操作和终止操作

public class Test {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,11,45,88,1,3,4);

        Stream<Integer> stream = list.stream();


        /*Stream<Integer> stream1 = */stream.filter((i)->{
            if (i < 10){
                return true;
            }
            return false;
        });

        //jdk8中的stream流是不可复用的，使用一次后就会被关闭，二次使用必须重新创建stream流。
        stream.forEach(System.out::println);
        
    }
}

jdk8中的stream流是不可复用的，使用一次后就会被关闭，二次使用必须重新创建stream流。

public class Test {
  public static void main(String[] args) {
      ArrayList<Integer> list = new ArrayList<>();
      Collections.addAll(list, 5, 4, 4, 3, 2, 1);
      /* 中间操作 */
      Stream<Integer> stream = list.stream()
          .filter(t -> {   //过滤, 获取符合条件元素
              if (t > 1) {
                  return true;
              }
              return false;
          })
          .map(t -> t + 1) //将元素进行相关操作
          .distinct() //去重
          .sorted() //排序
          .skip(1) //跳过1个
          .limit(2); //返回2个
      /* 终止操作 */
      //将数据收集到Set集合中
      //Set<Integer> set = stream.collect(Collectors.toSet());
      //获取最大值
      //Optional<Integer> max = stream.max(Integer::compareTo);
      //System.out.println(max.get());
      //获取最小值
      //Optional<Integer> min = stream.min(Integer::compareTo);
      //System.out.println(min.get());
      //获取元素个数
      //long count = stream.count();
      //System.out.println(count);
      //变为数组
      //Object[] objects = stream.toArray();
      //获取第一个
      //Optional<Integer> first = stream.findFirst();
      //System.out.println(first.get());
      //遍历获取每一个元素
      stream.forEach(System.out::println);
  }
}
4. 创建Stream并行流

简单来说，并行流就是把一个内容分成多个数据块，并用不同的线程分别处理每个数据块的流。

Java 8 中将并行进行了优化，我们可以很容易的对数据进行并行操作。 Stream API 可以声明性地通过 parallel() 与sequential() 在并行流与串行流之间进行切换 。

4.1 Fork/Join

将一个大任务，进行拆分(fork)成若干个小任务（拆到不可再拆时），再将一个一个小任务的运算结果进行 join 汇总 。

4.2 求和
public class Test {
    //创建并行任务,原理将任务拆分成多个子任务
    //通过创建自定义类继承RecursiveTask<Long>类
    //重写compute方法
    //内部类
    public static class SumTask extends RecursiveTask<Long>{
        private long start;
        private long end;
        private final int step = 2000;//自定义步长

        //定义构造方法赋值
        public SumTask(long start,long end){
            this.start = start;
            this.end = end;
        }

        @Override
        protected Long compute() {
            long sum = 0;
            //小于步长, 不再进行任务的拆分
            if (end - start < step){
                for (long i = start; i <= end ; i++) {
                    sum = sum + i;
                }
            } else {
                //继续拆分,取中间值
                long mid = (end + start) / 2;
                //再次创建任务类
                SumTask sumTask1 = new SumTask(start, mid);
                SumTask sumTask2 = new SumTask(mid+1, end);

                //调用java封装好的方法,fork(),执行子任务
                sumTask1.fork();
                sumTask2.fork();
                //子任务执行完获取返回值
                Long join1 = sumTask1.join();
                Long join2 = sumTask2.join();
                sum = join1 + join2;
            }
            return sum;
        }
    }

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.普通方法
        long sum = 0;
        long l1 = System.currentTimeMillis();
        for (long i = 1; i <= 100000000L ; i++) {
            sum += i;
        }
        long l2 = System.currentTimeMillis();
        System.out.println(sum);
        System.out.println(l2 - l1);
        System.out.println("================");

        //2.使用并行流
        //创建并行线程池来执行并行任务提高效率
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        long l3 = System.currentTimeMillis();
        //submit()方法中有一个需要传递一个ForkJoinTask类对象
        //RecursiveTask是ForkJoinTask的子类,可以使用多态
        SumTask sumTask = new SumTask(1, 100000000L);
        forkJoinPool.submit(sumTask);
        long l4 = System.currentTimeMillis();
        System.out.println(sumTask.get());
        System.out.println(l4 - l3);
    }
}
4.3 获取并行流
/*
* 获取并行流
* */
public class Test1 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        Collections.addAll(list,34,56,89,65,87,80,87,95,100,34,45);
        //获取并行流，底层采用ForkJoin框架，结果并不按照集合原有顺序输出
        Stream<Integer> integerStream = list.parallelStream();
        //结果是乱序的,多个线程执行,所以没有顺序
        integerStream.forEach(System.out::println);
    }
}

6. Optional

6.1 介绍

Optional存在的意义就是简化为了防止空指针而进行的if..else等判断的代码。

提供了全局value属性存储值。

6.2 获取Optional对象

  1. 通过Optional.of()方法，传递的参数的值为null，会出现空指针异常。

  2. 通过Optional.ofNullable()方法，创建Optional对象。

public class Test {
    public static void main(String[] args) {
        Test test = null;
        /*Optional<Test> test1 = Optional.of(test);*/
        //提示空指针异常,告诉你该对象为空java.lang.NullPointerException
        Optional<Test> test2 = Optional.ofNullable(test);
        //这里不会报空指针异常,是将一个Optional.empty对象给到了Optional对象
        System.out.println(test2);

    }
    public void aa(){

    }
}
6.3 Optional使用
6.3.1 参数为null, 使用创建参数类型的对象

  1. 如果传递参数值为null, 可以使用orElse(T)或orElseGet(Supplier)进行参数的实例化。

  2. 如果传递参数值不为null, orElse()也会执行, orElseGet()不会执行。

public class Demo {
  public static void main(String[] args) {
    //People people = null;
    People people =new People();
    People t1 = Optional.ofNullable(people).orElse(getPeople("orElse"));
    People t2 = Optional.ofNullable(people).orElseGet(()->getPeople("orElseGet"));
  }
  public static People getPeople(String str){
    System.out.println(str);
    return new People();
  }
}
6.3.2 获取Optional中存储的值

可以通过get()获取到全局value对应的值。

People people =new People();
Optional<People> optional = Optional.ofNullable(people);
People people = optional.get();
6.3.3 判断传递的参数是否为null

ifPresent(Consumer<? super T> consumer) 可以判断是否为null

  1. 为null, 不会执行Consumer的实现。

  2. 不为null, 执行Consumer的实现。

People people =new People();
Optional.ofNullable(people).ifPresent(peo -> peo.setName("zs"));
System.out.println(people.getName());
6.3.4 filter() 过滤
Optional<People> people1 = Optional.ofNullable(people).filter(x -> {
            if (x.getA() > 60) {
                return true;
            } else {
                return false;
            }
        });
6.3.5 map()

​​​​​​​

People people = null;
//  People people =new People("zs", 10);
Optional.ofNullable(people).map(u -> u.getAge()).ifPresent(t -> System.out.println(t)); //对象不为null, 打印结果

酷寒的小蛮蛮
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值