jdk新特性（一）接口和lambda表达式

柔光的暖阳◎ 2022-12-13 01:29 131阅读 0赞

## 引言 ##

*  伴随着编程技术的不断发展，oracle为了编程的便捷和提升项目的可维护性，对java做了许多的升级，比如新出现的lambda表达式的引入，在接口中增加静态方法和默认方法以及提取私有方法，下文首先复习一下lambda表达式。

## lambda表达式 ##

### 为什么采用lambda表达式？ ###

*  Lambda表达式是为了使得接口编程更加方便，这也可以与从lambda表达式的编程思想来考虑，函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”，所以这个可以使java编程变得更加优雅，代码更加简洁。

### 使用Lambda表达式需要注意的事项有哪些？ ###

1.  使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法。
2.  必须有上下文环境，才能推导出Lambda对应的接口。  
    以下是lambda表达式的具体实例理解。  
    根据局部变量的赋值得知Lambda对应的接口  
    Runnable r = () -> System.out.println(“Lambda表达式”);  
    根据调用方法的参数得知Lambda对应的接口  
    new Thread(() -> System.out.println(“Lambda表达式”)).start();  
    可以将lambda表达式理解为实现接口的一个对象（）

### lambda表达式与匿名内部类有什么区别？ ###

1)所需类型不同  
**匿名内部类：可以是接口，也可以是抽象类，还可以是具体类  
Lambda表达式：只能是接口**  
2)使用限制不同  
**如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类，如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式。**  
3)实现原理不同  
**匿名内部类：编译之后，产生一个单独的.class字节码文件  
Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成。**

### 案例 ###

采用lambda表达式和匿名内部类实现绵绵的接口，并体会两种方式的不同。  
接口类1

public interface Addable {
        int add(int x, int y);
    }

接口类2

public interface Eatable {
        void eatable(String s);
    }

接口类3

public interface Likable {
        void like(String s);
    }

测试类

public class LambdaDemo {
        public static void main(String[] args) {
    
            useAddable(new Addable() {
                @Override
                public int add(int x, int y) {
                    System.out.println("------------Add采用匿名内部类-------------");
                    return x+y;
                }
            });
    
            useEatable(new Eatable() {
                @Override
                public void eatable(String s) {
                    System.out.println("----------Eat采用匿名内部类------------");
                    System.out.println(s);
                }
            });
    
            useLikable(new Likable() {
                @Override
                public void like(String s) {
                    System.out.println(s);
                }
            });
    
            System.out.println("----------采用lambda表达式--------------");
    
            useAddable((int x,int y)->{
                System.out.println("-------------Eat采用lambda表达式---------------");
                return x+y;
            });
    
            useEatable((String str)->{
                System.out.println("----------Eat采用lambda表达式------------");
            });
            useLikable((String s)->{
                System.out.println(s);
            });
    
            System.out.println("----------采用省略lambda表达式----------");
            useEatable((s)-> System.out.println(s));
    
            useAddable((x,y)->x+y);
    
            useLikable((s)-> System.out.println(s));
        }
    
        public static void useEatable(Eatable eat){
            eat.eatable("我爱吃苹果");
        }
    
        public static void useAddable(Addable add){
            int sum = add.add(10, 20);
            System.out.println("sum:"+sum);
        }
    
        public static void useLikable(Likable like){
    
            //System.out.println("--------i love java---------");
            //System.out.println("---------i love python----------");
            like.like("--------i love java---------");
            like.like("---------i love python----------");
        }
    
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center]

## 接口新特性 ##

*  Jdk根据用户需求在接口中可以加入静态方法，默认方法，私有方法等等，这都是为了方便项目扩展，减少代码之间的耦合性，下面来看实际案例。

## 案例 ##

体验jdk中新增带有方法体的私有方法。  
接口类

public interface MyInterface {
    
        void show(String s);
    
        public static void show01(){
            System.out.println("---------this is static void show01----------");
            show03();
            //无法调用非静态方法
            //show04();
        }
    
        public default void show02(){
            System.out.println("-----------this is default void show03------------");
            show03();
            show04();
        }
    
        private static void show03(){
            System.out.println("---------this is private static void show03--------");
        }
    
        private void show04(){
            System.out.println("---------this is private normal void show04--------");
        }
    }

测试类

public class TestDemo {
        public static void main(String[] args) {
            useMyInterface((s)->{
                System.out.println("------这是通过lambda表达式实现MyInterface的show方法-------");
                System.out.println(s);
            });
            MyInterface.show01();
    
    
            MyInterface myInterface = new MyInterface() {
                @Override
                public void show(String s) {
                    System.out.println("------这是通过new的对象实现MyInterface的show方法-------");
                    System.out.println(s);
                }
            };
            myInterface.show("I LOVE PYTHON");
            myInterface.show02();
        }
    
        public static void useMyInterface(MyInterface myInterface){
            myInterface.show("i love java");
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 1]

### notes ###

**默认方法可以调用私有的静态方法和非静态方法  
静态方法只能调用私有的静态方法。**

## 方法引用 ##

### 为什么会出现方法引用？ ###

在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，所以就再也没有必要写重复逻辑。

### 什么是方法引用符？ ###

:: 该符号为引用运算符，而它所在的表达式被称为方法引用

### lambda表达式和方法引用是什么关系？ ###

方法引用是Lambda的孪生兄弟  
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导；如果使用方法引用，也是同样可以根据上下文进行推导。

### 案例一 ###

各类接口

public interface Converter {
        int convert(String s);
    }

public interface MyString {
        String mySubString(String str,int x, int y);
    }

public interface Printable {
        void printUpperCase(String s);
    }

Student build(String name,int age);
    }

学生类

public class Student {
        private String name;
        private int age;
        public Student() {
        }
        public Student(String name, int age) {
            this.name = name;
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

printStr类

public class PrintStr {
        public void printUpper(String s){
            String str = s.toUpperCase();
            System.out.println(str);
        }
    }

测试类

public class ReferenceDemo {
        public static void main(String[] args) {
           useConverter((s)->{
                int i = Integer.parseInt(s);
                //System.out.println(i);
                return i;
            });
            //采用静态方法
            useConverter(Integer::parseInt);
            System.out.println("-----------------------");
            //采用lambda接口来
            usePrintStr((s)->{
                System.out.println(s.toUpperCase());
            });
            //采用对象应用方法
            PrintStr printStr = new PrintStr();
            usePrintStr(printStr::printUpper);
            System.out.println("-----------------------");
            //引用类中成员方法
            useMyString((s,x,y)-> s.substring(x,y));
            useMyString(String::substring);
            System.out.println("------------------------");
            //采用构造方法
            useStudentBuilder((s,x)->new Student(s,x));
            useStudentBuilder(Student::new);
        }
        public static void useConverter(Converter converter){
            System.out.println("the result is:"+converter.convert("666"));
        }
        public static void usePrintStr(Printable printable){
            printable.printUpperCase("I Love Java I Love Python");
        }
        public static void useMyString(MyString myString){
            String str = myString.mySubString("HelloJava", 1, 6);
            System.out.println(str);
        }
        public static void useStudentBuilder(StudentBuilder studentBuilder){
            Student student = studentBuilder.build("赵丽颖", 34);
            System.out.println(student.getName()+":"+student.getAge());
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 2]

### 案例二 ###

采用

public class FunctionInterface {
        public static void main(String[] args) {
            String string = getString(() -> "巨量鹏");
            System.out.println(string);
            System.out.println("-------------------");
    
            int val = getInteger(() -> 30);
            System.out.println(val);
    
            System.out.println("------------------");
           int[] arr = {19, 97, 28, 37, 46,76};
    
            int maxVal=getMax(()->{
                int max =arr[0];
                for (int i = 1; i < arr.length; i++) {
                    if(arr[i]>max){
                        max=arr[i];
                    }
                }
                return max;
            });
            System.out.println(maxVal);
            System.out.println("------------------");
            /*operatorString("天量鹏",(String s)->{
                System.out.println(s);
            });*/
            //采用lambda表达式
            operatorString("天量鹏", s-> System.out.println(s));
            //采用函数式应用
           // operatorString("天量鹏",  System.out::println);
            //采用匿名内部类
            operatorString("若皮赞", new Consumer<String>() {
                @Override
                public void accept(String s) {
                    System.out.println(s);
                }
            });
            //反向输入
            operatorString("天量鹏",s-> System.out.println(new StringBuilder(s).reverse().toString()));
            System.out.println("---------------------------");
            operatorString("天量鹏",s-> System.out.println(s),
                    s-> System.out.println(new StringBuilder(s).reverse().toString()));
            System.out.println("---------------------------");
            String [] strArr={"杨颖,38","赵丽颖,34"};
            operatorString(strArr,s -> {
                String sName=s.split(",")[0];
                System.out.println("姓名："+sName);
            },s->{
                int sAge=Integer.parseInt(s.split(",")[1]);
                System.out.println("年龄："+sAge);
            });
            System.out.println("------------------------");
            boolean test = checkString("hello", s ->
                            s.length() > 4
                    ,s -> s.length() < 9);
            System.out.println(test);
            System.out.println("------------------------");
            String [] str= {"刘亦菲,40","刘岩,42","韩雪,44","文章,32","迪丽热巴,36","杨幂,37","我爱罗,34"};
            ArrayList<String> arrayList = condition(str, s -> {
                String s1 = s.split(",")[0];
                return s1.length() > 2;
            }, s -> {
                int i = Integer.parseInt(s.split(",")[1]);
                return i > 35;
            });
            for (String o : arrayList) {
                System.out.println(o);
            }
            System.out.println("--------------------------");
            String myConverter = converter("120", 6, (s) -> {
                return Integer.parseInt(s);
            }, (s) -> Integer.toString(s));
            System.out.println(myConverter);
    
        }
        //定义一个方法，返回一个整数数据
        private static Integer getInteger(Supplier<Integer> sup) {
            return sup.get();
        }
        //定义一个方法，返回一个字符串数据
        private static String getString(Supplier<String> sup) {
            return sup.get();
        }
        private static int getMax(Supplier<Integer> sup){
            return sup.get();
        }
        private static void operatorString(String str, Consumer<String> consumer){
            consumer.accept(str);
        }
        private static void operatorString(String str, Consumer<String> consumer1,Consumer<String > consumer2){
            //consumer1.accept(str);
            //consumer2.accept(str);
            consumer1.andThen(consumer2).accept(str);
        }
        private static void operatorString(String [] str,Consumer<String> consumer1,Consumer<String > consumer2){
            for (String s :
                    str) {
                consumer1.andThen(consumer2).accept(s);
            }
        }
        private static boolean checkString(String s, Predicate<String> s1,Predicate <String> s2){
            /*boolean test1 = s1.test(s);
            boolean test2=s2.test(s);
            return test1&&test2;*/
            //也可以使用or方法
            return s1.and(s2).test(s);
        }
        private static ArrayList condition(String [] str,Predicate<String> s1,Predicate<String> s2){
            ArrayList<String> arrayList = new ArrayList<>();
            for (String s : str) {
                boolean test = s1.and(s2).test(s);
                if(test){
                    arrayList.add(s);
                }
            }
            return arrayList;
        }
        //Function接口
        private  static String converter(String s, int startVal, Function<String ,Integer > fun1,Function<Integer ,String > fun2){
            Integer apply = fun1.apply(s)+startVal;
            String apply1 = fun2.apply(apply);
            return apply1;
            //不能满足要求
            //return  fun1.andThen(fun2).apply(s);
        }
    }

测试结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/c4e88ebf427c42c589d9236e7f918a56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/b3df60497830420381cb7fa0305d455c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/46cffd0abdf7481fbf73e6d856fdc0a9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3h1ZXNoYW5mZWl0aWFu_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/b891cf12413a45799b7854b5720c5c40.png