JDK8新特性学习

最新推荐文章于 2022-12-26 20:10:42 发布
最新推荐文章于 2022-12-26 20:10:42 发布
阅读量242 收藏
点赞数
文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/y843667014/article/details/128390867
版权

一：Lambda表达式学习

  一：初次接触Lambda表达式，通过实现接口来创建线程

        

 public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过匿名类部类实现线程："+Thread.currentThread().getName());
            }
        }).start();

        new Thread(()-> System.out.println("这是通过Lambda表达式创建的线程："+Thread.currentThread().getName()))
                .start();
    }

        代码分析：

                1、上面通过两种方式来通过实现接口来创建的线程

                     ①通过匿名内部类来创建的线程，Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法使用来指定线程任务的核心。我们为了指定run方法体，不得不需要Runnable的实现类。必须覆盖重新抽象方法run方法，所有的方法名称，方法的参数以及方法的返回值不得不重写一遍，而且都不能出错。

                     ②第二种方式是通过Lambda表达式创建的线程，我们可以明显看出代码的量量减少，并且语法更加简单。

二：Lambda表达式的语法

        Lambda表达式主要有3个部分组成

        （参数类型   参数名称）->{

                代码块；

}

格式说明：

        1、（参数类型   参数名称）：参数列表

        2、{代码体；}：方法体

        3、->：箭头，分割参数列表和方法体

三：Lambda表达式的练习

        1、无参无返的Lambda表达式

        定义一个用户接口

public interface User {
    void show();
}

       通过一个主方法来调用

   public static void main(String[] args) {
        //形式一：
        getShow(()->{
            System.out.println("这是用户接口的无参无返的方法");
        });
        //形式二：
        getShow(()-> System.out.println("这是用户接口的无参无返的方法11111"));
    }

    public static void getShow(User user){
        user.show();
    }

        输出结果：

        这是用户接口的无参无返的方法
        这是用户接口的无参无返的方法11111

2、无参有返的Lambda表达式

定义一个接口

public interface Person {
    String getName();
}

   通过主方法来调用

public static void main(String[] args) {
        //无参无返的表达式形式一：
        getShow(()->{
            System.out.println("这是用户接口的无参无返的方法");
        });
        //无参无返的表达式形式二：
        getShow(()-> System.out.println("这是用户接口的无参无返的方法11111"));

        //无参有返的表达式形式一：
        getShow1(()->{
            return "这是无参有返的Lambda表达式";
        });
        //无参有返的表达式形式二：
        getShow1(()->"这是无参有返的Lambda表达式111");

    }

    public static void getShow(User user){
        user.show();
    }

    public static  void getShow1(Person person){
        String name = person.getName();
        System.out.println(name);
    }

输出结果：

这是用户接口的无参无返的方法
这是用户接口的无参无返的方法11111
这是无参有返的Lambda表达式
这是无参有返的Lambda表达式111

3、有参无返的Lambda表达式

本身Consumer就是一个函数式接口，里面有有一个accept方法，这个方法就是一个有参数无返的方法

public static void main(String[] args) {
       /* //无参无返的表达式形式一：
        getShow(()->{
            System.out.println("这是用户接口的无参无返的方法");
        });
        //无参无返的表达式形式二：
        getShow(()-> System.out.println("这是用户接口的无参无返的方法11111"));

        //无参有返的表达式形式一：
        getShow1(()->{
            return "这是无参有返的Lambda表达式";
        });
        //无参有返的表达式形式二：
        getShow1(()->"这是无参有返的Lambda表达式111");*/

        //有参无返的表达式
        getConsumer(s-> System.out.println(s));

    }

    /*public static void getShow(User user){
        user.show();
    }

    public static  void getShow1(Person person){
        String name = person.getName();
        System.out.println(name);
    }*/

    public static  void getConsumer(Consumer consumer){
        consumer.accept("这是一个有参无返的方法");
    }

输出结果：

这是一个有参无返的方法

4、有参有返的Lambda表达式

定义一个实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Integer sex;
}

通过主方法调用Collections.sort方法来实现对实体类中的年龄进行排序

public static void main(String[] args) {
        ArrayList<Person> people = new ArrayList<>();
        people.add(new Person("张三",23,1));
        people.add(new Person("李四",21,0));
        people.add(new Person("王五",22,1));

        //通过Collections.sort方法，对Person对象种的年龄进行排序
        Collections.sort(people,((o1, o2) -> {
            return o1.getAge()-o2.getAge();
        }));

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

输出：

Person(name=李四, age=21, sex=0)
Person(name=王五, age=22, sex=1)
Person(name=张三, age=23, sex=1)

5、Lambda表达式的注意事项：

        ①如果参数列表中的参数只有一个，我们就可以省略参数的类型，并且可以去掉小括号不写。

        ②如果参数列表中没有参数，则必须要加上小括号

        ③如果参数列表中的参数不止一个并且参数的类型不一致则必须要加上参数的类型

        ④方体里面如果只有一条语句的话可以省略掉大括号

        ⑤如果方法体里面只有一条return语句的话return可以省略不写

四：@FunctionalInterface注解

      

@FunctionalInterface
public interface User {
    void show();
}

如果在接口上面加了@FunctionalInterface这个注解，那么这个接口就被申明为是函数式接口，并且这个接口里面只能有一个抽象方法

五：Lambda表达式使用的前提

Lambda表达式的语法式非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件需要注意：

1、方法的参数或者局部变量的类型必须为接口才能使用Lambda表达式

2、接口中有且只能有一个抽线方法（@FunctionalInterface）

六：Lambada表达式和匿名内部类的区别

1、所需要的类型不一样

        匿名内部类的类型可以是类、抽象类、接口

        Lambda表达式需要的类型必须是接口

2、抽象方法的数量不一样

        匿名内部类所需要的接口中的抽象方法数量是随意的

        Lambda表达式所需要的接口中只能有一个抽象方法

3、实现的原理不同

        匿名内部类是在编译后形成的一个class

        Lambda表达式时在程序运行的时候动态生成的class

三：JDK8后的接口中的新增的方法

一：在JDK8中针对接口做了一些增强，在JDK8之前

interface 接口名{
    静态常量；
    抽象方法；
}

在JDK8之后对接口增加了，默认方法和静态方法

interface 接口名{
    静态常量；
    抽象方法；
    默认方法；
    静态方法；
}

二：接口中的默认方法

interface 接口名{
    修饰符 default 返回值类型 方法名{
        方法体；
    }
}

代码示例：

public static void main(String[] args) {
        A b = new B();
        b.test3();
        A c = new C();
        c.test3();
    }
    //定义一个接口A
    interface A{
        //普通抽线方法
        void test1();
        void test2();
        public default void test3(){
            System.out.println("这是接口中的默认方法");
        }
    }

    //定义一个类B去实现A
   static class B implements A{

        @Override
        public void test1() {
        }

        @Override
        public void test2() {
        }

        @Override
        public void test3(){
            System.out.println("这是B方法里面的接口中的默认方法");
        }

    }

    //定义一个类C去实现A
   static class C implements A{

        @Override
        public void test1() {
        }
        @Override
        public void test2() {
        }
    }

执行结果

这是B方法里面的接口中的默认方法
这是接口中的默认方法

默认方法有两种使用方法：

1、实现类直接调用接口的默认方法

2、实现类可以重写接口中的默认方法

三：接口中的静态方法

语法格式：

interface 接口名{
    修饰符 static 返回值类型 方法名{
        方法体；
    }
}

示例代码：

package InterfceDeom;

public class Interface01 {

    public static void main(String[] args) {
        A b = new B();
        b.test3();
        A c = new C();
        c.test3();
        A.test4();
    }
    //定义一个接口A
    interface A{
        //普通抽象方法
        void test1();
        void test2();
        //默认方法
        public default void test3(){
            System.out.println("这是接口中的默认方法");
        }
        //静态方法
        public static void test4(){
            System.out.println("这是接口中的静态方法");
        }
    }

    //定义一个类B去实现A
   static class B implements A{

        @Override
        public void test1() {
        }

        @Override
        public void test2() {
        }

        @Override
        public void test3(){
            System.out.println("这是B方法里面的接口中的默认方法");
        }
        

    }

    //定义一个类C去实现A
   static class C implements A{

        @Override
        public void test1() {
        }
        @Override
        public void test2() {
        }
    }
}

输出结果：

这是B方法里面的接口中的默认方法
这是接口中的默认方法
这是接口中的静态方法

静态方法的使用：

接口中的静态方法在实习类中不是能被重写的，调用的话只能通过接口名来实现：接口名.静态方法名（）；

四：默认方法和静态方法的区别

1、默认方法通过实例调用，静态方法是通过接口名进行调用

2、默认方法可以被继承，实现类可以直接调用接口的默认方法，也可以重写接口的默认方法

3、静态方法不能被继承，实现类不能重写接口的静态方法，只能使用接口名进行调用

五：函数式接口

一：函数式接口的介绍

在我们使用Lambda表达式的前提就是需要有函数式接口，在使用Lambda表达式时不关心接口名、抽象方法名。只关心抽象方法的参数列表和返回值。所以为了让我们能更方便的使用Lambda表达式，JDK提供了大量常用的函数式接口

主要存在于java.util.function包中

二：主要的函数接口

1、Supplier

该函数式接口是一个无参有返回值的接口，对于的Lambda表达式需要提供一个返回数据的类型

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

使用案例：

public class SupplierTest {
    public static void main(String[] args) {
        Supplier01(()->{
            List<Integer> integers = Arrays.asList(1, 3, 2, 5, 4);
            Optional<Integer> reduce = integers.stream().reduce(Integer::max);
            return reduce.get();
        });
    }

    public static void Supplier01(Supplier<Integer> supplier){
        System.out.println(supplier.get());
    }
}

返回值：

5

代码解释：定义一个方法里面传入Supplier函数接口，然后在主方法中进行调用，通过Lambda表达式，在里面定义一个集合然后再通过Stream流的reduce方法里面使用Integer里面的max方法获取到集合中的最大值，并将其结果返回

2、Consumer

该函数式接口是一个有参无返回值的一个接口，就像我们的消费者一样是用来消费数据的，使用的时候需要指定一个泛型来定义参数的类型

2.1、accept方法

public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);

使用案例：

public class ConsumerTest {
    public static void main(String[] args) {
        Consumer01(s-> System.out.println(s));
    }

    public static void Consumer01(Consumer<String> consumer){
        consumer.accept("这是Consumer接口返回的参数");
    }
}

输出结果：

这是Consumer接口返回的参数

2.2、默认方法：andThen

        方法描述：如果一个方法的参数和返回值全是Consumer类型，那就可以实现效果，消费一个数据的时候，首先做一个操作，然后再做另外一个操作，实现组合，这个方法就是Consumer接口中的默认的方法andThen方法

default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }

使用案例：

public class ConsumerTest {
    public static void main(String[] args) {
        //Consumer01(s-> System.out.println(s));

        Consumer02(s1 -> {
            System.out.println("转为小写："+s1.toLowerCase());
        },s2 -> System.out.println("转为全大写："+s2.toUpperCase()) );
    }

    public static void Consumer01(Consumer<String> consumer){
        consumer.accept("这是Consumer接口返回的参数");
    }

    public static void Consumer02(Consumer<String> con1,Consumer<String> con2){
        con1.andThen(con2).accept("Hello");
    }
}

输出结果

转为小写：hello
转为全大写：HELLO

3、Function

该函数式接口是一个有参有返的接口，function接口是根据一个类型的数据得到另外一个类型的数据，前者是前置条件，后者是后置添加。

3.1 apply方法

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);

实例代码：

public class FunctionTest {
    public static void main(String[] args) {
        functionTest(s-> "这是function接口返回的结果"+s);
    }
    public static void functionTest(Function<Integer,String> function){
        System.out.println(function.apply(666));
    }
}

输出结果：

这是function接口返回的结果666

3.2 默认方法：andThen方法

default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

实例代码

public class FunctionTest02 {
    public static void main(String[] args) {
        function02(s1->{
            return Integer.parseInt(s1);
        },s2->{
            return s2*5;
        });
    }

    public static void function02(Function<String,Integer> fun1,Function<Integer,Integer> fun2){
        System.out.println(fun1.andThen(fun2).apply("6"));
    }
}

输出结果：

30

其中还有两个方法：

1、默认方法：compose方法的作用顺序和andThen方法刚好是相反的

2、静态方法identity则是，传入什么参数就返回什么参数

4、Predicate

该函数式接口是一个有参有返的接口，并且返回值时Boolean类型的

4.1  Predicate方法：

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

实例代码：

public class PredicateTest {
    public static void main(String[] args) {
        Predicate01(s->{
            return s.contains("o");
        });
    }

    public static void Predicate01(Predicate<String> pre){
        boolean hello = pre.test("Hello");
        System.out.println(hello);
    }
}

返回结果：

true

4.2 默认方法：and、or、negate、isEquals方法

实例代码：

public class PredicateTest02 {
    public static void main(String[] args) {
        Predicate01(s->{
            return s.contains("o");
        },s1->{
            return s1.contains("w");
        });
    }

    public static void Predicate01(Predicate<String> pre1,Predicate<String> pre2){
        //两个都满足
        System.out.println(pre1.and(pre2).test("Hello"));
        //两个满足其中的一个
        System.out.println(pre1.or(pre2).test("Hello"));
        //不满足
        System.out.println(pre1.negate().test("Hello"));
    }
}

输出结果：

false

true

false

五：方法引用

一、为什么要用方法引用

当我们在使用Lambda表达式的时候也会出现代码冗余的情况，比如以下代码：

public class funRef01 {
    public static void main(String[] args) {
        arrSum(arr->{
            int sum = 0;
            for (int i : arr) {
                sum+= i;
            }
            return sum;
        });
    }

    public static void arrSum(Function<int[],Integer> function){
        int[] arr = {1,2,3,4};
        Integer apply = function.apply(arr);
        System.out.println(apply);
    }
}

上述代码是通过Lambda表达式对数组中的元素进行求和操作

简化代码：

public class funRef01 {
    public static void main(String[] args) {
        /*arrSum(arr->{
            int sum = 0;
            for (int i : arr) {
                sum+= i;
            }
            return sum;
        });*/
       arrSum(funRef01::arrSum1);
    }

    public static Integer arrSum1(int[] arr){
        int sum = 0;
        for (int i : arr) {
            sum+=i;
        }
        return sum;
    }

    public static void arrSum(Function<int[],Integer> function){
        int[] arr = {1,2,3,4};
        Integer apply = function.apply(arr);
        System.out.println(apply);
    }
}

二：方法引用的格式

符号表示：::（英文格式下的双冒号）

符号说明：双冒号为方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda表达式所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用

常见的引用方法：

instanceName::methodName 对象::方法名

ClassName::staticMethodName 类名::静态方法名

ClassName::methodName 类名::普通方法

ClassName::new 类名::new调用构造器

TypeName[]::new String[]::new 调用数组的构造器

2.1 对象名::方法民

        这是最常见的一种用法。如果一个类中的已经存在了一个成员方法，可以直接通过对象名引用成员方法

public static void main(String[] args) {
        //正常的Lambda表达式写法
        Date date = new Date();
        Supplier<Long> supplier = () -> {
            return date.getTime();
        };
        System.out.println(supplier);

        //使用方法引用的写法
        Supplier<Long> getTime = date::getTime;
        System.out.println(getTime);
    }

注意事项：

1、被引用的方法，参数要和接口中的抽象方法的参数一样

2、当接口抽象方法有返回值式，被引用的方法也必须有返回值

2.2 类名::静态方法名

public static void main(String[] args) {
        Supplier<Instant> instantCallable = () -> {
            return Instant.now();
        };
        System.out.println(instantCallable);

        Supplier<Instant> user = Instant::now;
        System.out.println(user);
    }

2.3 类名::引用实例方法

public static void main(String[] args) {
        Function<String,Boolean> app = s -> {
            return s.contains("s");
        };
        System.out.println(app.apply("asd"));


        BiFunction<String, CharSequence, Boolean> contains = String::contains;
        Function<String, Integer> stringIntegerFunction = String::length;
        System.out.println(contains.apply("asd", "s"));
        System.out.println(stringIntegerFunction.apply("asds"));
    }

2.4 类名::构造器

 public static void main(String[] args) {
        Supplier<Person> personCallable = () -> {
            return new Person();
        };
        Person person1 = personCallable.get();

        Supplier<Person> user = Person::new;
        Person person = user.get();
    }

2.5 数组::构造器

public static void main(String[] args) {
        Function<Integer,String[]> arr =  s->{
            return new String[s];
        };
        String[] apply1 = arr.apply(6);
        System.out.println(apply1.length);

        Function<Integer,String[]> arr1 = String[]::new;
        String[] apply = arr1.apply(5);
        System.out.println(apply.length);
    }

总结：方法引用是对于Lambda表达式符号特定情况下的一种写法方式，使得Lambda表达式更加精简，注意方法引用只能引用已经存在的方法。

吃蛋不吃蛋清
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
最全java8 讲解【建议收藏，反复研读】
08-18 7660
在这里，被包起来的收集器就是用 maxBy 建立的那个，而转换函数 Optional::get 则把返回的 Optional 中的值提取出来。可以看到，行为参数化是一个很有用的模式，它能够轻松地使用不断变化的需求，这种模式可以把一个行为封装起来，并通过传递和使用创建的行为将方法的行为参数化。的抽象方法，它没有传入参数，会返回一个泛型 T 的对象，如果你需要定义一个 Lambda，输出自定义的对象，就可以使用这个接口。来定义一个默认值，遭遇到空的Optional值的时候，默认值会作为该方法的调用返回值。
JDK8新特性的学习总结
冷血之心的博客
02-24 2846
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/87903464冷血之心的博客） 目录 背景： 正文： Lambda表达式 定义  语法 示例 总结： 默认方法 总结： Stream API 什么是 Stream？ 生成流 总结： 总结： 背景：        JDK8发布于2...
JDK8新特性详解
weixin_47072986的博客
12-26 1932
JDK8新特性详解
JDK8 超详细，肝
Java.慈祥
12-07 1216
Java8 新特性 2021/11/22 学习来源于 B站 尚硅谷yyds Java学习源码 距离，过年还有 57 天，想家~???? JDK1.8已经发布很久了，在很多企业中都已经在使用 虽然，JDK是向下兼容的不会新特性也一样可以正常开发，但是作为程序员还是要不断更新新的技术. 不要求啥都会,但要求能看懂!???? Java 8 是oracle公司于2014年3月发布 是自Java 5 以 来最具革命性的版本 Java 8为Java语言： 编译器、类库、开发 工具与JVM带来了大量新特性. La
java8 函数编程Consumer使用详解
qq_43842093的博客
06-20 3921
从源码来看，Consumer函数主要有两个方法，accept和andThen。建立演示方法： 执行结果： 演示二 创建一个car汽车类 创建演示方法： 执行结果： 演示三 执行结果： consumer从字面上面来理解就是消费的意思，用过mq的，应该大概可以了解到意思。我们先来看看Java8定义的这个consumer的接口： 该接口被@FunctionalInterface注解修饰，这个注解的意思代表的是这个接口只有一个抽象接口方法，如果超过一个，只不能不用该接口，会编译不通过。该接口有一个抽象方法acc
JDK8 新特性学习.rar
01-19
以下是对JDK8新特性的详细解析： 1. **Lambda表达式**：这是JDK8最显著的新特性之一，它提供了一种简洁的函数式编程风格。Lambda表达式可以作为参数传递，也可以作为返回值。通过这种方式，你可以创建匿名函数，...
jdk8新特性学习代码
08-09
在这个"jdk8新特性学习代码"压缩包中，我们可以深入探索Java 8的核心新特性。以下是对这些特性的详细解析： 1. **Lambda表达式**： Lambda表达式是Java 8最重要的特性之一，它提供了一种简洁的方式来表示匿名函数...
jdk8新特性对应代码
最新发布
07-14
Java开发工具包（JDK）是Java编程语言的核心组件，用于构建和运行Java应用程序。JDK8是一个重要的版本，引入了许多创新特性和改进，极...通过深入学习和实践，你可以更好地掌握JDK8的这些新特性，提升自己的编程技能。
JDK8核心新特性
06-20
JDK8已经发行有几年了，在该版本中推出了不少新特性，其中比较有代表的新特性有：Lambda表达式，Stream流，方法引用。在网上也有很多关于这些新特性的介绍，但个人觉得网上的很多文字对新特性的介绍是不够全面的，...
JDK8的部分新特性
11-15
本文档介绍了jdk8的部分新特性，主要针对自己想学习的可以看看
Java高级--JDK8新特性
Dumpling_skin的博客
07-19 497
lambda表达式特殊的匿名内部类，语法更简洁；lambda表达式允许把函数作为一个方法的函数（函数作为方法的参数传递），将代码像数据一样传递；注函数式接口接口中只有一个抽象方法(参数1,参数2)抽象方法的参数->分隔符{}表示抽象方法的实现我们创建线程任务时，之前使用的有两种方式，从上面两种方式可以发现我们真正需要的只是run方法中的方法体从JDK8之后加入了lambda表达式，我们创建线程任务的方式也有了第三种方式；.........
jdk 8 学习
菜鸟阿达
09-09 387
lamdba表达式 1. lamdba 包含参数列表,-&gt;,lamdba主体. 2. 特点 1. 匿名: 没有一个明确的名字.写的少而想的多 2. 函数: 不像方法一样属于某个类,但是像方法一样,包含参数列表,函数主体,返回类型,还可能有抛出的异常列表. # 语法 ()-&gt; 32; // 返回一个int类型数据 ()-&gt;{return 32;} // 返回...
JDK8 之线程Thread小记
灵小帝的博客
03-03 9922
本文主要对常用的jdk中Thread做了一个简单的阅读。主要对线程的属性、状态、常用的方法做了一个简单的阅读分析。很多初学者其实都没对join、wait等方法的细节有一个很好的掌握，例如：调用thread.join()时，程序具体干了什么、为什么线程的执行达到了同步效果、主线程什么时候被释放的。
jdk8新特性(详解)
weixin_34362875的博客
02-25 784
最近在复习外加看点面试题，jdk8的新特性虽然在项目用用到过一两个，准备系统的了解一下jdk8的常用新特性 一：Lambd表达式也可称为闭包 引入函数式编程到Java中 　　为了使现有函数更好的支持Lambda表达式，Java 8引入了函数式接口的概念。 　　函数式接口就是只有一个方法的普通接口加一个@FunctionalInterface注解即可 　　基本语法：(...
Java8新特性教程
JessenPan
03-30 6707
欢迎阅读我的java8新特性介绍教程。本教程将一步一步的引领你浏览所有新的语言特性。伴随着一些简单且简短的代码示例，你将学习如何使用默认接口方法，lambda表示式，方法引用和可重复的annotation。 在阅读完本篇文章，你将对新加入的和更新的API有着更详细的了解。这些API包括流、功能接口、扩展的map以及新的Date API。
Java高级----＞JDK8新特性学习笔记
weixin_44720982的博客
07-20 416
JDK8新特性
【Java】JDK8 学习 第一章
huifer
05-29 421
package com.read.JDK8; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.function.Predicate; import java.util.stream.Collectors; public class Demo1_2_2_tes...
Java8 新特性学习
innerpeacez成长之路
06-05 5211
1、接口中的默认方法 Java8中允许接口中包含具有具体实现的方法，这种方法被称为“默认方法”，使用default关键字修饰。 如： public interface MyInterface { String notDefault(); default String testDefault() { return "Hello Default Metho...
《jdk8u源码分析》16.2.ContinueInNewThread
johnjoe's blog
03-20 399
src/share/bin/java.c::ContinueInNewThread int ContinueInNewThread(InvocationFunctions* ifn, jlong threadStackSize, int argc, char **argv, int mode, char *what, ...
JDK8新特性.pdf
03-09
"JDK8新特性" 在Java的开发历程中，JDK8是一个重要的里程碑，它引入了许多创新性特性和改进，极大地提升了开发效率和代码的可读性。本教程主要关注JDK8的几个核心新特性，包括Lambda表达式、集合的Stream流式操作、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值