JAVA 8 新特性 Lamdba表达式

水深无声 2023-10-08 18:11 46阅读 0赞

**Java8 新特性：**

> 1、Lamdba表达式  
> 2、函数式接口  
> 3、方法引用和构造引用  
> 4、Stream API  
> 5、接口中的默认方法和静态方法  
> 6、新时间日期API  
> 7、Optional
> 
> 8、其他特性

**Java8 优势：**速度快、代码更少（增加了新的语法 Lambda 表达式）、强大的 Stream API、便于并行、最大化减少空指针异常 Optional；

### 一、Lambda表达式 ###

Lambda 是一个**匿名函数**，它是一段可以传递的代码（将代码像数据一样进行传递）。可以取代大部分的匿名内部类，可以写出更简洁、更灵活的代码。**尤其在集合的遍历和其他集合操作**中，可以极大地优化代码结构。作为一种**更紧凑的代码风格**，使 Java 的语言表达能力得到提升。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。 **从匿名类到 Lambda 的转换：**虽然使用 Lambda 表达式可以对某些**接口**进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法。

### 二、为何使用Lambda表达式 ###

> 1.  提供Functional接口的实现。
> 2.  编码少

### 三、Lambda表达式的语法 ###

> (parameters) -> expression
> 
> 或
> 
> (parameters) ->\{ statements; \}

### 四、 Lambda表达式重要特征 ###

> 1.  可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
> 2.  可选的参数圆括号：**一个参数无需定义圆括号**，但多个参数需要定义圆括号。
> 3.  可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
> 4.  可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

### 五、Lambda表达式由三个组件组成 ###

> **1)参数列表:** 也可以为空或非空。
> 
> **2)箭头令牌:** 用于链接参数列表和表达式主体。
> 
> **3)主体**: 它包含表达式和语句

**（1）无参数语法**

() -> {
    //Body of no parameter lambda
    }

public class MyLamdba {
        public static void main(String[] args) {
           Person p=()->{
               return "Hello!";
            };
           //输出
            System.out.println(p.say());
        }
    }
    
    //@FunctionalInterface   //It is optional
    interface Person{
        public String say();
    }

（2）**一个参数语法**

(a) -> {
    //Body of single parameter lambda
    }

public class MyLamdba {
        public static void main(String[] args) {
            //一个参数可以使用（）
           Person p=(name)->{
               return "Hello!"+name;
            };
           //输出
            System.out.println(p.say("mike"));
    
           //一个参数也可以不使用（）
            Person p2=name -> {
                return "Who are you? "+name;
            };
    
            System.out.println(p2.say("pop"));
        }
    }
    
    interface Person{
        public String say(String name);
    }

(3) **两个参数的语法**

(p1,p2) -> {
    //Body of multiple parameter lambda
    }

public class MyLamdba {
        public static void main(String[] args) {
            //多个参数必须使用（）
           Person p=(name,age)->{
               return "Hello!"+name+",Are you "+age+" years old?";
            };
           //输出
            System.out.println(p.say("mike",18));
        }
    }
    
    interface Person{
        public String say(String name,int age);
    }

**（4）返回值带有或不带有return关键字**

public class MyLamdba {
        public static void main(String[] args) {
    //        one();
    
            //(1) (parameter)->(expression)
            Addable a1=(a,b)->(a+b);
            System.out.println(a1.add(100,50));
    
            //(2) (parameter)->{statements}
            Addable a2=(a,b)->{
                return  a+b;
            };
            System.out.println(a2.add(1,5));
    
        }
    
    }
    
    interface Addable{
        public int add(int a,int b);
    }

**（5）Foreach循环**

List<String> list= Arrays.asList("sunny","windy","cloudy","rainy");
     list.forEach(m-> System.out.println(m));

### 六、Lamdba函数接口 ###

> 方法引用通过一对双冒号**::** 来表示，方法引用是一种函数式接口的另一种书写方式
> 
> 1.  **静态方法**引用，通过类名::静态方法名， 如 Integer::parseInt
> 2.  **实例方法**引用，通过实例对象::实例方法，如 str::substring
> 3.  类名::实例方法名, 如 String::substring
> 4.  **构造方法**引用，通过类名::new， 如 User::new

java.util.function 它包含了很多类，用来支持 Java的 函数式编程，该包中的函数式接口有：

![c24c0c91d3f24d0bad4fe99cd886777c.png][]

public class MyLamdba2 {
        public static void main(String[] args) {
            //接受一个输入参数 String
            Consumer<String> cc=Pet::show;
            cc.accept("宠物！");
    
            //接受一个输入参数 Pet
            Consumer<Pet> pet=Pet::eat;
            pet.accept(new Pet());
    
            //接受两个输入参数 Pet, String
            BiConsumer<Pet,String> p1=Pet::say;
            p1.accept(new Pet(),"你好啊！");
    
            //接受两个输入参数 Pet, String,并返回一个值Integer
            BiFunction<Pet,String,Integer> p2=Pet::play;
            int num=p2.apply(new Pet(),"好球");
            System.out.println(num);
    
        }
    
    }
    
    class Pet{
        //静态方法 -有参无返回
        public static void show(String str){
            System.out.println("show方法："+str);
        }
    
        //实例方法 -无参无返回
        public void eat(){
            System.out.println("eat方法："+this.toString());
        }
    
        //实例方法 -有参无返回
        public void say(String str){
            System.out.println("say方法："+str);
        }
    
        //实例方法 -有参有返回
        public int play(String str){
            System.out.println("play方法："+str);
            return 10;
        }
    }

![ddaaa0a603ab4b74b16af78f1699ca2c.png][]

> 用::提取的函数，最主要的区别在于静态与非静态方法，非静态方法比静态方法多一个参数，就是被**调用的实例**。

**构造方法的引用**  
一般我们需要声明接口，该接口作为对象的生成器，通过 类名::new 的方式来实例化对象，然后调用方法返回对象。

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

public class MyLamdba3 {
        public static void main(String[] args) {
            IBlackConstruct ibc = () -> new Student();
            Student stu = ibc.getStudent();
            System.out.println(stu);
    
            IBlackConstruct ibc2 = Student::new;
            Student stu2 = ibc.getStudent();
            System.out.println(stu2);
    
            IParameterConstruct ibc3 = Student::new;
            Student stu3 = ibc3.getStudent("zhangsan", 18);
            System.out.println(stu3);
    
        }
    }
    
    interface IBlackConstruct {
        // 对象定义 -无参数
        Student getStudent();
    }
    
    interface IParameterConstruct {
        // 对象定义 -有参数
        Student getStudent(String name, int age);
    }

![25b958003e944bb8948cb25509a8a2ab.png][]

[c24c0c91d3f24d0bad4fe99cd886777c.png]: https://img-blog.csdnimg.cn/c24c0c91d3f24d0bad4fe99cd886777c.png
[ddaaa0a603ab4b74b16af78f1699ca2c.png]: https://img-blog.csdnimg.cn/ddaaa0a603ab4b74b16af78f1699ca2c.png
[25b958003e944bb8948cb25509a8a2ab.png]: https://img-blog.csdnimg.cn/25b958003e944bb8948cb25509a8a2ab.png