Java8新特性：Lambda表达式和函数式接口

一. lambda表达式

当一个接口中，只有一个抽象方法时，我们可以使用lambda表达式

语法：

接口  变量 = (参数列表) -> {方法的实现};

• 参数列表就是接口中那个唯一的抽象方法的参数列表

• 后面的大括号就是这唯一的一个抽象方法的实现

• 参数列表可以定义数据类型，默认的数据类型和那个唯一抽象方法的参数列表对应的参数数据类型一致

• 如果方法的实现只有一行代码，那么大括号也可以省略

• 如果方法的实现只有一行代码，且是该方法的返回值，那么大括号省略，return也省略

public class Demo01 {
​
    public static void main(String[] args) {
        //接口的引用指向实现类的对象
        A a = new B();
        a.aa();
        
        //使用内部类
        A a2= new A() {
​
            @Override
            public void aa() {
                System.out.println("使用匿名内部类实现aa方法");
            }
        };
        a2.aa();
        
        //使用lambda表达式实现
        A a3 = () -> System.out.println("使用lambda表达式实现aa方法");
        a3.aa();
        
        
    }
}
​
interface A {
    void aa();
}
​
class B implements A {
​
    @Override
    public void aa() {
        System.out.println("B实现了A中aa方法");
    }
    
}


package com.qfedu;
​
public class Demo02 {
    
    public static void main(String[] args) {
        //可以定义参数类型
        C c = (int a,double b, String e) -> {
            
        };
        
        //参数类型可以忽略
        C c2 = (a,b,e) -> {
            System.out.println(a+b+e);
        };
        
        //当实现方法体中只有一行代码，可以省略掉大括号
        C c3 = (a,b,e) -> System.out.println(a+b+e);
            
        
        
        D d = (a,b) -> {
            return a+b;
        };
        
        //当实现方法体中只有一行代码，且包含return关键字，那么大括号可以不要，但return也必须省略
        D d2 = (a,b) -> a+b;
        
        int r = d2.add(1, 3);
        System.out.println(r);
        
    }
    
}
​
interface C {
    void m(int a,double b, String e);
}
​
interface D {
    int add(int a,int b);
}

二. 函数式编程

1. 供给型接口

        不需要传入参数，调用get方法返回一个值

public interface Supplier<T> {
​
    T get();
}

2. 消费型接口

        需要使用accept方法传入参数，但不返回值

public interface Consumer<T> {
    
    void accept(T t);
}

3. 函数式接口

        有传参，有返回值

public interface Function<T, R> {
    R apply(T t);
}

4. 断言式接口

        返回一个boolean类型的值

@FunctionalInterface
public interface Predicate<T> {
    boolean test(T t);
}

练习：

1. 得到一个1-100内的整数

2.打印字符串的长度

3.得到字符串第二个字符

4.判断是否包含a

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
​
public class Demo04 {
    
    public static void main(String[] args) {
        
        //Integer表示的返回数据的类型
        Supplier<Integer> s = () -> (int)(Math.random()*100+1);
        
        System.out.println(s.get());
        System.out.println(s.get());
        
​
        //参数的数据类型
        Consumer<String> c = (str) -> {
            System.out.println(str.length());
        };
        c.accept("abcde");
        
        
        //函数式接口  有参数，有返回值
        Function<String, Character> f = (str) -> str.charAt(1);
        Function<Integer, Integer> f2 = (i) -> i/10%10;
        char ch = f.apply("jackma");
        
        //断言式接口 String表示的数据类型
        Predicate<String> p = (str)-> str.contains("a");
        boolean r = p.test("abc");
        System.out.println(r);
        
        
        /*
         * 1. 使用断言式接口实现 判断一个整数是够大于100
         * 2. 使用函数式接口实现，传递一个整数数组，返回第二小的数
         * 3. 使用消费型接口实现，传递一个整数，打印该整数减100
         * 4. 使用供给型接口实现，随机返回一个A B C D 中的一个字符
         */
    }
​
}

​