JDK1.8的一些新特性

冷不防 2022-10-12 01:16 164阅读 0赞

## 1. JDK8之前的接口 ##

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 1]  
**Lambda使用的要求：**  
1）只有一个抽象方法

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 2]

当方法是有返回值并且只有一条语句时候，可以省略大括号以及return：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 3]

## 3.Stream流： ##

**（注意：调用终止操作之后，是无法进行调用中间操作的）**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 4]

**创建流的两种方式：**  
串行流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));
    
    
    
    
        }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 5]

## 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);
    
    
    
        }
    
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70]: /images/20221005/49b9ebae0c354b4fafa93f8aceb75b32.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 1]: /images/20221005/7fa4986e04f4413aa185642b60719dc9.png
[---]: /images/20221005/0faac6e43c2d46fd9d626d0418e81231.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 2]: /images/20221005/ea66980e14d94ab3adf7a2911a8ddb3c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 3]: /images/20221005/08fb5f10efa04725a5669345bcceeab6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 4]: /images/20221005/b3ced7c630e04ddc854b8a791adcfd71.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjA2MzgyMA_size_16_color_FFFFFF_t_70 5]: /images/20221005/0b237e59f7824fc6bd5031a203c18f62.png