16-Java8新特性

最新推荐文章于 2024-08-06 08:15:00 发布
最新推荐文章于 2024-08-06 08:15:00 发布
阅读量292 收藏
点赞数
分类专栏： Java基础 文章标签： java lambda stream
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Wuyikkk/article/details/105763474
版权

一、Lambda表达式

1.基本语法

  • 1.举例： (o1,o2) -> Integer.compare(o1,o2);
  • 2.格式：
  •  -> :lambda操作符 或 箭头操作符

  •  ->左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表

  •  ->右边：lambda体 （其实就是重写的抽象方法的方法体

2.语法格式的6种情况

语法格式一：无参，无返回值

Runnable r1 = () -> { System.out.println("Hello Lambda!"); };

语法格式二：Lambda 需要一个参数，但是没有返回值。

Consumer<String> con = (String str) -> { System.out.println(Str); };

语法格式三：数据类型可以省略数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

Consumer<String> con = (str) -> { System.out.println(str); };

语法格式四：Lambda 若只需要一个参数时，若只需要一个参数时，参数的小括号可以省略

Consumer<String> con = str -> { System.out.println(str); };

语法格式五：Lambda 需要两个或以上的参数，多条执行语句，并且可以有返回值

Comparator<Integer> com = (x,y) -> {
	System.out.println("实现函数式接口方法");
	return Integer.compare(x,y);
};

语法格式六：当 Lambda 体只有体只有一条一条语句时，语句时，return 与大括号与大括号若有，都可以省略

Comparator<Integer> com = (x,y) -> Integer.compare(x,y);

总结：

  • 左边：lambda形参列表的参数类型可以省略(类型推断)；如果lambda形参列表只一个参数，其一对()也可以省略
  • 右边：lambda体应该使用一对{}包裹；如果lambda体只一条执行语句（可能是return语句，省略这一对{}和return关键字

二、函数式接口

1.说明

如果一个接口中，只声明了一个抽象方法，则此接口就称为函数式接口。
我们可以在一个接口上使用 @FunctionalInterface 注解，这样做可以检查它是否是一个函数式接口。
Lambda表达式的本质：作为函数式接口的实例

2.为Lambda表达式提供的4个基本的函数式接口

在这里插入图片描述

3.总结

  1. 何时使用lambda表达式？
    当需要对一个函数式接口实例化的时候，可以使用lambda表达式。
  2. 何时使用给定的函数式接口？
    如果我们开发中需要定义一个函数式接口，首先看看在已有的jdk提供的函数式接口是否提供了能满足需求的函数式接口。如果有，则直接调用即可，不需要自己再自定义了。

三、方法引用

1.理解

方法引用可以看做是Lambda表达式深层次的表达。换句话说，方法引用就是Lambda表达式，也就是函数式接口的一个实例，通过方法的名字来指向一个方法。

当要传递给Lambda体的操作，已经实现的方法了，可以使用方法引用。

2.格式及情况

  • 类(或对象) :: 方法名

  • 情况1 对象 :: 非静态方法

  • 情况2 类 :: 静态方法

  • 情况3 类 :: 非静态方法

3.说明

使用要求

  1. 要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的形参列表和返回值类型相同！（针对于情况1和情况2）
  2. 当函数式接口方法的第一个参数是需要引用方法的调用者，并且第二个参数是需要引用方法的参数(或无参数)时：ClassName::methodName（针对于情况3）

使用建议

  1. 如果给函数式接口提供实例，恰好满足方法引用的使用情境，就可以考虑使用方法引用给函数式接口提供实例。如果不熟悉方法引用，那么还可以使用lambda表达式。

4.举例

// 情况一：对象 :: 实例方法
//Consumer中的void accept(T t)
//PrintStream中的void println(T t)
@Test
public void test1() {
	Consumer<String> con1 = str -> System.out.println(str);
	con1.accept("北京");

	System.out.println("*******************");
	PrintStream ps = System.out;
	Consumer<String> con2 = ps::println;
	con2.accept("beijing");
}

//Supplier中的T get()
//Employee中的String getName()
@Test
public void test2() {
	Employee emp = new Employee(1001,"Tom",23,5600);

	Supplier<String> sup1 = () -> emp.getName();
	System.out.println(sup1.get());

	System.out.println("*******************");
	Supplier<String> sup2 = emp::getName;
	System.out.println(sup2.get());

}

// 情况二：类 :: 静态方法
//Comparator中的int compare(T t1,T t2)
//Integer中的int compare(T t1,T t2)
@Test
public void test3() {
	Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
	System.out.println(com1.compare(12,21));

	System.out.println("*******************");

	Comparator<Integer> com2 = Integer::compare;
	System.out.println(com2.compare(12,3));

}

//Function中的R apply(T t)
//Math中的Long round(Double d)
@Test
public void test4() {
	Function<Double,Long> func = new Function<Double, Long>() {
		@Override
		public Long apply(Double d) {
			return Math.round(d);
		}
	};

	System.out.println("*******************");

	Function<Double,Long> func1 = d -> Math.round(d);
	System.out.println(func1.apply(12.3));

	System.out.println("*******************");

	Function<Double,Long> func2 = Math::round;
	System.out.println(func2.apply(12.6));
}

// 情况：类 :: 实例方法  (难度)
// Comparator中的int comapre(T t1,T t2)
// String中的int t1.compareTo(t2)
@Test
public void test5() {
	Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
	System.out.println(com1.compare("abc","abd"));

	System.out.println("*******************");

	Comparator<String> com2 = String :: compareTo;
	System.out.println(com2.compare("abd","abm"));
}

//BiPredicate中的boolean test(T t1, T t2);
//String中的boolean t1.equals(t2)
@Test
public void test6() {
	BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
	System.out.println(pre1.test("abc","abc"));

	System.out.println("*******************");
	BiPredicate<String,String> pre2 = String :: equals;
	System.out.println(pre2.test("abc","abd"));
}

// Function中的R apply(T t)
// Employee中的String getName();
@Test
public void test7() {
	Employee employee = new Employee(1001, "Jerry", 23, 6000);


	Function<Employee,String> func1 = e -> e.getName();
	System.out.println(func1.apply(employee));

	System.out.println("*******************");

	Function<Employee,String> func2 = Employee::getName;
	System.out.println(func2.apply(employee));


}

四、构造器引用和数组引用

1.构造器引用

构造器引用格式：

  • 类名::new

使用要求：

  • 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型。

2.举例

//Supplier中的T get()
   //Employee的空参构造器：Employee()
   @Test
   public void test1(){

       Supplier<Employee> sup = new Supplier<Employee>() {
           @Override
           public Employee get() {
               return new Employee();
           }
       };
       System.out.println("*******************");

       Supplier<Employee>  sup1 = () -> new Employee();
       System.out.println(sup1.get());

       System.out.println("*******************");

       Supplier<Employee>  sup2 = Employee :: new;
       System.out.println(sup2.get());
   }

//Function中的R apply(T t)
   @Test
   public void test2(){
       Function<Integer,Employee> func1 = id -> new Employee(id);
       Employee employee = func1.apply(1001);
       System.out.println(employee);

       System.out.println("*******************");

       Function<Integer,Employee> func2 = Employee :: new;
       Employee employee1 = func2.apply(1002);
       System.out.println(employee1);

   }

//BiFunction中的R apply(T t,U u)
   @Test
   public void test3(){
       BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
       System.out.println(func1.apply(1001,"Tom"));

       System.out.println("*******************");

       BiFunction<Integer,String,Employee> func2 = Employee :: new;
       System.out.println(func2.apply(1002,"Tom"));

   }

3.数组引用

格式：

  • 数组类型[ ] :: new

4.举例

//Function中的R apply(T t)
@Test
public void test4(){
    Function<Integer,String[]> func1 = length -> new String[length];
    String[] arr1 = func1.apply(5);
    System.out.println(Arrays.toString(arr1));

    System.out.println("*******************");

    Function<Integer,String[]> func2 = String[] :: new;
    String[] arr2 = func2.apply(10);
    System.out.println(Arrays.toString(arr2));

}

五、StreamAPI

1.说明

  1. Stream关注的是对数据的运算，与CPU打交道
    集合关注的是数据的存储，与内存打交道

  2. java8提供了一套api,使用这套api可以对内存中的数据进行过滤、排序、映射、归约等操作。类似于sql对数据库中表的相关操作。

2.注意

  1. Stream 自己不会存储元素。
  2. Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
  3. Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

3.使用流程

  1. Stream的实例化
  2. 一系列的中间操作（过滤、映射、…)
  3. 终止操作

注：

  • 创建的中间操作链，会对数据源的数据进行处理
  • 一旦执行终止操作，就执行中间操作链，并产生结果。之后，不会再被使用

4.举例

实例化

//创建 Stream方式一：通过集合
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

//        default Stream<E> stream() : 返回一个顺序流
        Stream<Employee> stream = employees.stream();

//        default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> parallelStream = employees.parallelStream();

    }

    //创建 Stream方式二：通过数组
    @Test
    public void test2(){
        int[] arr = new int[]{1,2,3,4,5,6};
        //调用Arrays类的static <T> Stream<T> stream(T[] array): 返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee e1 = new Employee(1001,"Tom");
        Employee e2 = new Employee(1002,"Jerry");
        Employee[] arr1 = new Employee[]{e1,e2};
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }
    //创建 Stream方式三：通过Stream的of()
    @Test
    public void test3(){

        Stream<Integer> stream = Stream.of(1, 2, 3, 4, 5, 6);

    }

    //创建 Stream方式四：创建无限流
    @Test
    public void test4(){

//      迭代
//      public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);


//      生成
//      public static<T> Stream<T> generate(Supplier<T> s)
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }

中间操作

 //1-筛选与切片
    @Test
    public void test1(){
        List<Employee> list = EmployeeData.getEmployees();
//        filter(Predicate p)——接收 Lambda ， 从流中排除某些元素。
        Stream<Employee> stream = list.stream();
        //练习：查询员工表中薪资大于7000的员工信息
        stream.filter(e -> e.getSalary() > 7000).forEach(System.out::println);

        System.out.println();
//        limit(n)——截断流，使其元素不超过给定数量。
        list.stream().limit(3).forEach(System.out::println);
        System.out.println();

//        skip(n) —— 跳过元素，返回一个扔掉了前 n 个元素的流。若流中元素不足 n 个，则返回一个空流。与 limit(n) 互补
        list.stream().skip(3).forEach(System.out::println);

        System.out.println();
//        distinct()——筛选，通过流所生成元素的 hashCode() 和 equals() 去除重复元素

        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",41,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));
        list.add(new Employee(1010,"刘强东",40,8000));

//        System.out.println(list);

        list.stream().distinct().forEach(System.out::println);
    }

    //映射
    @Test
    public void test2(){
//        map(Function f)——接收一个函数作为参数，将元素转换成其他形式或提取信息，该函数会被应用到每个元素上，并将其映射成一个新的元素。
        List<String> list = Arrays.asList("aa", "bb", "cc", "dd");
        list.stream().map(str -> str.toUpperCase()).forEach(System.out::println);

//        练习1：获取员工姓名长度大于3的员工的姓名。
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<String> namesStream = employees.stream().map(Employee::getName);
        namesStream.filter(name -> name.length() > 3).forEach(System.out::println);
        System.out.println();
        //练习2：
        Stream<Stream<Character>> streamStream = list.stream().map(StreamAPITest1::fromStringToStream);
        streamStream.forEach(s ->{
            s.forEach(System.out::println);
        });
        System.out.println();
//        flatMap(Function f)——接收一个函数作为参数，将流中的每个值都换成另一个流，然后把所有流连接成一个流。
        Stream<Character> characterStream = list.stream().flatMap(StreamAPITest1::fromStringToStream);
        characterStream.forEach(System.out::println);

    }

    //将字符串中的多个字符构成的集合转换为对应的Stream的实例
    public static Stream<Character> fromStringToStream(String str){//aa
        ArrayList<Character> list = new ArrayList<>();
        for(Character c : str.toCharArray()){
            list.add(c);
        }
       return list.stream();

    }



    @Test
    public void test3(){
        ArrayList list1 = new ArrayList();
        list1.add(1);
        list1.add(2);
        list1.add(3);

        ArrayList list2 = new ArrayList();
        list2.add(4);
        list2.add(5);
        list2.add(6);

//        list1.add(list2);
        list1.addAll(list2);
        System.out.println(list1);

    }

    //3-排序
    @Test
    public void test4(){
//        sorted()——自然排序
        List<Integer> list = Arrays.asList(12, 43, 65, 34, 87, 0, -98, 7);
        list.stream().sorted().forEach(System.out::println);
        //抛异常，原因:Employee没有实现Comparable接口
//        List<Employee> employees = EmployeeData.getEmployees();
//        employees.stream().sorted().forEach(System.out::println);


//        sorted(Comparator com)——定制排序

        List<Employee> employees = EmployeeData.getEmployees();
        employees.stream().sorted( (e1,e2) -> {

           int ageValue = Integer.compare(e1.getAge(),e2.getAge());
           if(ageValue != 0){
               return ageValue;
           }else{
               return -Double.compare(e1.getSalary(),e2.getSalary());
           }

        }).forEach(System.out::println);
    }

终止操作

 //1-匹配与查找
    @Test
    public void test1(){
        List<Employee> employees = EmployeeData.getEmployees();

//        allMatch(Predicate p)——检查是否匹配所有元素。
//          练习：是否所有的员工的年龄都大于18
        boolean allMatch = employees.stream().allMatch(e -> e.getAge() > 18);
        System.out.println(allMatch);

//        anyMatch(Predicate p)——检查是否至少匹配一个元素。
//         练习：是否存在员工的工资大于 10000
        boolean anyMatch = employees.stream().anyMatch(e -> e.getSalary() > 10000);
        System.out.println(anyMatch);

//        noneMatch(Predicate p)——检查是否没有匹配的元素。
//          练习：是否存在员工姓“雷”
        boolean noneMatch = employees.stream().noneMatch(e -> e.getName().startsWith("雷"));
        System.out.println(noneMatch);
//        findFirst——返回第一个元素
        Optional<Employee> employee = employees.stream().findFirst();
        System.out.println(employee);
//        findAny——返回当前流中的任意元素
        Optional<Employee> employee1 = employees.parallelStream().findAny();
        System.out.println(employee1);

    }

    @Test
    public void test2(){
        List<Employee> employees = EmployeeData.getEmployees();
        // count——返回流中元素的总个数
        long count = employees.stream().filter(e -> e.getSalary() > 5000).count();
        System.out.println(count);
//        max(Comparator c)——返回流中最大值
//        练习：返回最高的工资：
        Stream<Double> salaryStream = employees.stream().map(e -> e.getSalary());
        Optional<Double> maxSalary = salaryStream.max(Double::compare);
        System.out.println(maxSalary);
//        min(Comparator c)——返回流中最小值
//        练习：返回最低工资的员工
        Optional<Employee> employee = employees.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
        System.out.println(employee);
        System.out.println();
//        forEach(Consumer c)——内部迭代
        employees.stream().forEach(System.out::println);

        //使用集合的遍历操作
        employees.forEach(System.out::println);
    }

    //2-归约
    @Test
    public void test3(){
//        reduce(T identity, BinaryOperator)——可以将流中元素反复结合起来，得到一个值。返回 T
//        练习1：计算1-10的自然数的和
        List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
        Integer sum = list.stream().reduce(0, Integer::sum);
        System.out.println(sum);


//        reduce(BinaryOperator) ——可以将流中元素反复结合起来，得到一个值。返回 Optional<T>
//        练习2：计算公司所有员工工资的总和
        List<Employee> employees = EmployeeData.getEmployees();
        Stream<Double> salaryStream = employees.stream().map(Employee::getSalary);
//        Optional<Double> sumMoney = salaryStream.reduce(Double::sum);
        Optional<Double> sumMoney = salaryStream.reduce((d1,d2) -> d1 + d2);
        System.out.println(sumMoney.get());

    }

    //3-收集
    @Test
    public void test4(){
//        collect(Collector c)——将流转换为其他形式。接收一个 Collector接口的实现，用于给Stream中元素做汇总的方法
//        练习1：查找工资大于6000的员工，结果返回为一个List或Set

        List<Employee> employees = EmployeeData.getEmployees();
        List<Employee> employeeList = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toList());

        employeeList.forEach(System.out::println);
        System.out.println();
        Set<Employee> employeeSet = employees.stream().filter(e -> e.getSalary() > 6000).collect(Collectors.toSet());

        employeeSet.forEach(System.out::println);




    }

六、Optional类

1.说明

  • Optional 类(java.util.Optional) 是一个容器类，它可以保存类型T的值，代表这个值存在。或者仅仅保存null，表示这个值不存在。原来用 null 表示一个值不存在，现在 Optional 可以更好的表达这个概念。并且可以避免空指针异常。
  • 为了解决Java中的空指针而生

2.举例

@Test
    public void test1(){
        //empty():创建的Optional对象内部的value = null
        Optional<Object> op1 = Optional.empty();
        if(!op1.isPresent()){//Optional封装的数据是否包含数据
            System.out.println("数据为空");

        }
        System.out.println(op1);
        System.out.println(op1.isPresent());
        //如果Optional封装的数据value为空，则get()报错。否则，value不为空时，返回value.
//        System.out.println(op1.get());

    }

    @Test
    public void test2(){
        String str = "hello";
//        str = null;
        //of(T t):封装数据t生成Optional对象。要求t非空，否则报错。
        Optional<String> op1 = Optional.of(str);
        //get()通常与of()方法搭配使用。用于获取内部的封装的数据value
        String str1 = op1.get();
        System.out.println(str1);

    }

    @Test
    public void test3(){
        String str = "beijing";
        str = null;
        //ofNullable(T t) ：封装数据t赋给Optional内部的value。不要求t非空
        Optional<String> op1 = Optional.ofNullable(str);
        //orElse(T t1):如果Optional内部的value非空，则返回此value值。如果
        //value为空，则返回t1.
        String str2 = op1.orElse("shanghai");

        System.out.println(str2);//


    }
Wuyikkk
关注
专栏目录
Java16新特性及代码示例
java_topper的博客
03-22 612
你好啊，我是大阳。 Java 16 于 2021 年 3 月 16 日发布。在这篇文章中，我们将介绍添加的一些特性以及一些代码示例。 Java16的主要更新内容如下： 时段支持 添加Stream.toList方法 instanceof的模式匹配 密封类（第二次预览版） record纪录类（标准版） 1. 时段支持 DateTimeFormatter的新增功能，可以表示一天中的时段，例如“上午”、“下午” package cn.dayangshuo.collectors; import java.tim
Java8-11新特性
weixin_46925850的博客
11-11 1747
Java8-11新特性
探索 Java 16 中引入的新特性
penggerhe的博客
04-26 215
此外，Java 16 还改进了 lambda 表达式的性能。总之，Java 16 引入了许多新特性和增强，使得开发者可以更轻松地编写高质量的 Java 程序，并提高了程序的性能和可维护性。新的垃圾回收器:Java 16 中引入了一种新的垃圾回收器，名为“标记 - 清除”垃圾回收器，它比传统的垃圾回收器更具效率。增强的 JVM 支持:Java 16 中的 JVM 得到了增强，支持新的硬件加速技术，例如虚拟化和并行处理。改进的并发支持:Java 16 中的并发支持得到了改进，提供了更好的线程管理和并发性能。
Java 16 新特性
wang_luwei的博客
06-16 904
Java 16 在 2021 年 3 月 16 日正式发布，在语法上的新特性更新比较多，主要是一些之前版本引入的预览特性正式发布。比如Java14中的打包工具、instanceof、Record类Java 16 全部的新特性，请看官网：JDK 16 发行说明Java各个版本的文档入口：Java平台，标准版文档Java各个版本下载：https://jdk.java.net/archive/改进 在 Java 14 中已经提出，在 Java 15 中继续预览，而现在，在 Java 16 中成为正式功能。在之前
Java 16 新特性(JKD16)
最新发布
qq_40698086的博客
08-06 693
Java 16 是 Java 15 的更新版本，引入了许多新的特性和改进。
JDK 16 新特性
CoderChronicle的博客
03-07 1060
Java 16 在 2021 年 3 月 16 日正式发布，不是长久支持版本，这次更新没有带来很多语法上的改动，但是也带来了不少新的实用功能。
探索Java 16的宇宙：新特性全解析与实战演练
赵KK的博客
03-21 291
Java 16的新特性无疑为Java开发者带来了更多的便利和可能性。无论是记录类型、模式匹配，还是新的垃圾回收器和HTTP客户端API的增强，都标志着Java语言和生态系统的进步。作为一名Java高级架构师，我鼓励大家积极尝试这些新特性，并将它们应用到实际项目中。你的每一次互动都是对我最大的支持。让我们一起在Java的世界中不断探索和成长！🚀。
java8stream源码-learn-java8:java8新特性学习
06-04
java8流源码Java8InAction 该存储库包含 Java 8 实战：Lambdas、Streams 和函数式编程一书中示例和测验的所有源代码。 您可以在这里购买这本书：或在亚马逊上 所有示例的源代码都可以在目录中找到 第 1 章：Java 8：...
JDK-Mac系统和Windows系统安装及Java版本新特性（java9 - java19）
04-30
8. Java 16： - 密封接口（Sealed Interfaces）：进一步控制继承。 - Vector API：硬件加速的向量操作。 9. Java 17（LTS）： - 转换为长期支持版本，企业级应用的首选。 - Switch表达式增强：添加_Yield关键字...
计算机后端-Java-Java核心基础-第30章 动态代理与Java8新特性 16. 方法引用的使用情况2.avi
05-23
计算机后端-Java-Java核心基础-第30章 动态代理与Java8新特性 16. 方法引用的使用情况
JAVA8新特性(吐血整理)
热门推荐
yitian_66的博客
07-12 11万+
一、Java 8 Lambda 表达式... 31.1 语法... 31.2 Lambda 表达式实例... 3Java8Tester.java 文件... 31.3 变量作用域... 5Java8Tester.java 文件... 5Java8Tester.java 文件... 5二、Java 8 方法引用... 72.1方法引用... 72.2方法引用实例... 8Java8Tester.j...
JDK16新特性总结
qq_41144042的博客
08-10 330
1： Vector API（孵化器） 1清晰简洁的 API：API 应能够清晰简洁地表达广泛的矢量计算，这些矢量计算由一系列矢量操作组成，这些矢量操作通常在循环内组成，可能还有控制流 2平台无关：API 应与架构无关，支持在支持向量硬件指令的多个 CPU 架构上的运行时实现 3在 x64 和 AArch64 架构上可靠的运行时编译和性能：Java 运行时，特别是 HotSpot C2 编译器，应在有能力的 x64 架构上将向量操作序列编译为相应的向量硬件指令序...
不停歇的 Java 即将发布 JDK 16，新特性速览！
CSDN资讯
12-02 1万+
Java 16 有哪些新特性呢？
JDK16新特性
蓝影铁哥的博客
12-01 1168
JDK16新特性
Java8新特性
08-05
Java8发布到现在至少3年了，但是对Lambda表达式不熟悉、看不懂、不会用的现象非常常见。 即使是升级到JDK1.8了，但是很多开发者依然是停留在1.8之前的开发方式，使用的也是非常老旧和过时的API，遇到函数式接口也是依然使用匿名内部类解决。 本系列课程从Lambda表达式、方法的引用、Stream API三处着手分析Lambda表达式的使用。 通过大量的实战例子讲解如何使用Lambda表达式
Java8-Java16部分重要新特性汇总
ZkSky的博客
07-26 2453
本文主要记录了，Java8之后的每个版本的部分新特性，除了Java8，其他的基本都是简介。
JDK16 新特性详解
雨陆聪辰的博客
09-02 809
JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解，JDK16 新特性详解。
16_java8的其他新特性
海涛帅帅的博客
09-14 187
Java 8新特性简介 新特性简介 Java 8 (又称为 jdk 1.8) 是 Java 语言开发的一个主要版本。 Java 8 是oracle公司于2014年3月发布，可以看成是自Java 5 以 来最具革命性的版本。Java 8为Java语言、编译器、类库、开发 工具与JVM带来了大量新特性。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-itrO2xSg-1600041602719)(/Users/haitao/Pictures/TyporaPic/16_java
Java都到16了，为什么都还在用8，是越做越烂了么？
程序猿DD
03-19 2001
送一波超大福利！不仅有低价ECS，更有机械键盘、AirPods Pro等好礼！昨天转了小胖哥关于 Java 16发布的解读（没看过的小伙伴点过来：Java 16 正式发布！你还学得动吗？）...
Java 8实战指南：新特性和全面应用
书中分为多个章节，帮助读者逐步掌握Java 8的新特性和核心概念。第1章介绍了Java 8的入门知识，让初学者快速上手；第2章详细阐述了Java 8的新功能，包括lambda表达式和函数式编程的引入，这些特性极大地提高了代码的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值