JDK1.8的一些新特性

Posted scanner小霸王

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了JDK1.8的一些新特性相关的知识,希望对你有一定的参考价值。

1. JDK8之前的接口

1.8之前方法默认的修饰词是public astract,并且接口里面不能写方法体,但是1.8的可以定义static和default的方法,并且其实现的子类没有强制写static和default的方法
在这里插入图片描述

2.Lambda表达式:简化匿名内部类的调用

在这里插入图片描述
Lambda使用的要求:
1)只有一个抽象方法

使用规则:
1)参数的数据类型可以省略;多参数时,省略时需全部省略,不能只省略部分
2)参数的小括号,当只有一个参数时,可以省略小括号
3)方法体的大括号,方法体中只有一句代码的时候,可以省略大括号
4)如果方法体中唯一的语句为返回语句,则省略大括号同时需要再省略return
语法:
()---参数列表

在这里插入图片描述

当方法是有返回值并且只有一条语句时候,可以省略大括号以及return:
在这里插入图片描述

3.Stream流:

(注意:调用终止操作之后,是无法进行调用中间操作的)
在这里插入图片描述

创建流的两种方式:
串行流Stream() 单线程
并行流parallelstream()多线程
1)转为list

//list转为set
        Stream<Dog> stream = objects.stream();
        Set<Dog> collect = stream.collect(Collectors.toSet());
        System.out.println(collect.toString());

2)转为map

//list转为Map
        //第一个匿名方法是为了得到key,第二个匿名方法是为了得到value
        Map<String, Dog> collect1 = stream.collect(Collectors.toMap(new Function<Dog, String>() {

            //代表key
            @Override
            public String apply(Dog o) {
                return o.getName();
            }

        }, new Function<Dog, Dog>() {

            //代表value
            @Override
            public Dog apply(Dog o) {
                return o;
            }

        }));

        //lambda写法
        Map<String, Dog> collect1Lambda = stream.collect(Collectors.toMap(o -> o.getName(), o -> o));

3)过滤器filter用法:

Stream<Dog> stream = objects.stream();

        //过滤器
        //以前写法
        stream.filter(new Predicate<Dog>() {
            @Override
            public boolean test(Dog dog) {
                return dog.getName().equals("A");
            }
        }).forEach(new Consumer<Dog>() {
            @Override
            public void accept(Dog dog) {
                System.out.println(dog);
            }
        });

        //lambda写法
        stream.filter(dog -> dog.getName().equals("A")).forEach(dog -> System.out.println(dog));

4)skip,limit分页用法

//取前两条
     stream.limit(2).forEach(dog -> System.out.println(dog));
    //跳过前两条取一条数据
     stream2.skip(2).limit(1).forEach(dog -> System.out.println(dog));

5)sorted排序

  //排序
        //原始做法
        stream.sorted(new Comparator<Dog>() {
            @Override
            public int compare(Dog o1, Dog o2) {
                return o1.age-o2.age;
            }
        }).forEach(new Consumer<Dog>() {
            @Override
            public void accept(Dog dog) {
                System.out.println(dog);
            }
        });

        //lambda写法
        stream2.sorted((o1, o2) -> o1.age-o2.age).forEach(dog -> System.out.println(dog));

4.方法引入:

(结合lambda,能让代码更加的精简)
lambda:是让匿名内部类更加精简;
方法引入:是让lambda更加精简
(注意:使用方法引入必须保证,方法签名以及类型,返回值和重写的方法保持一致)

1)静态方法引入;类名::(静态)方法名称

package MyCode.JDK18;

public class lambdaTest {
    public static void main(String[] args) {
        //1原生方法
        JDK8Interface jDK8Interface =new JDK8Interface(){

            @Override
            public int add(int i, int j) {
                System.out.println("main方法:"+(i+j));
                test(i,j);
                return i+j;
            }
        };
        jDK8Interface.add(1,2);

        //2.lambda方法
        JDK8Interface jDK8Interface2= (i, j) -> {
            System.out.println("main方法:"+(i+j));
            test(i,j);
            return i+j;

        };
        jDK8Interface2.add(1,2);
        //3方法引入
        JDK8Interface jDK8Interface3= lambdaTest::test;
        jDK8Interface3.add(1,2);

    }
    public static int test(int i,int j){
        System.out.println("test方法:"+(i-j));
        return i-j;
    }
}

2)对象方法引入;类名::实例方法名称

package MyCode.JDK18;

public class lambdaTest2 {
    public static void main(String[] args) {

        lambdaTest2 lambdaTest = new lambdaTest2();
        //1lambda引入
        JDK8Interface jDK8Interface11= (i,j)->lambdaTest.test11(i,j);
        jDK8Interface11.add(1,2);

        //2方法引入
        JDK8Interface jDK8Interface22= lambdaTest::test11;
        jDK8Interface22.add(1,2);



    }

    public void test11(int i,int j){
        System.out.println("test方法:"+(i-j));
//        return i-j;
    }
}

3)实例方法引入;new 对象 对象实例::方法引入

package MyCode.JDK18;

public class lambdaTest4 {
    public static void main(String[] args) {

        lambdaTest4 lambdaTest = new lambdaTest4();
        //1.原生
        JDK8Interface4 JDK8Interface1 = new JDK8Interface4(){

            @Override
            public String returnDog(Dog dog) {
                return dog.toString();
            }
        };

        //2.lambda
        JDK8Interface4 JDK8Interface2 = dog -> dog.toString();

        //3.方法引入
        JDK8Interface4 JDK8Interface3 = Dog::toString;





    }

}

4)构造方法引入;类名::new

package MyCode.JDK18;

public class lambdaTest3 {
    public static void main(String[] args) {

        lambdaTest3 lambdaTest = new lambdaTest3();
        //1.原生
        JDK8Interface2 jDK8Interface1 = new JDK8Interface2(){

            @Override
            public Dog returnDog(String name, int age) {
                return new Dog(name,age);
            }
        };
        System.out.println(jDK8Interface1.returnDog("A",10));

        //2.lambda
        JDK8Interface2 jDK8Interface2 = (name, age) -> new Dog(name,age);
        System.out.println(jDK8Interface1.returnDog("B",20));
        //3方法引入
        JDK8Interface2 jDK8Interface3 = Dog::new;
        System.out.println(jDK8Interface1.returnDog("C",30));




    }

}

在这里插入图片描述

5.Optional的用法:

1)空值的判断:
ofNullable可以传递空值,但是get()不能拿到空值
of()不允许空值

package MyCode.JDK18;

import java.util.Optional;

public class optionalTest {
    public static void main(String[] args) {

        optionalTest lambdaTest = new optionalTest();
        /**
         * ofNullable可以传递空值,但是get()不能拿到空值
         * of()不允许空值
         */
        Optional<Object> o = Optional.ofNullable(null);
        System.out.println(o.get());
        //判断是否为空,false为空
        o.isPresent();


    }

}

2)为空则使用默认值

//为空则使用默认值
        String test = (String)Optional.ofNullable(null).orElse("为空了");
        System.out.println(test);

3)判断是否为空,不空的话就调用accept方法

package MyCode.JDK18;

import java.util.Optional;
import java.util.function.Consumer;

public class optionalTest {
    public static void main(String[] args) {

        optionalTest lambdaTest = new optionalTest();
        /**
         * ofNullable可以传递空值,但是get()不能拿到空值
         * of()不允许空值
         */
       /* Optional<Object> o = Optional.ofNullable(null);
        System.out.println(o.get());*/
        //判断是否为空,false为空
//        o.isPresent();


       /* String test = (String)Optional.ofNullable(null).orElse("为空了");
        System.out.println(test);*/

//       判断是否为空,不空的话就调用accept方法
        Optional<String> o = Optional.ofNullable(null);
        //原始
          o.ifPresent(new Consumer<String>() {

            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });
        //lambda
        o.ifPresent(s -> System.out.println(s));
        //放入引入
        o.ifPresent(System.out::println);



    }

}

以上是关于JDK1.8的一些新特性的主要内容,如果未能解决你的问题,请参考以下文章

jdk1.8新特性Stream流式处理

JDK1.8 新特性(全)

JDK1.8新特性

jdk1.8新特性——主要内容

JDK1.8的一些新特性

JDK1.8的一些新特性