Java 8 中使用 Lambda 表达式简化代码

 1// @FunctionalInterface 注解说明： 
 2// 使用该注解来定义接口，编译器会强制检查接口是否符合函数式接口规则（有且仅有一个抽象方法），如果不符合则会报错。
 3@FunctionalInterface
 4public interface MyInterface{
 5    /**
 6     * 抽象方法（Jdk 8 以后接口类中方法可以省去 public abstract）
 7     */
 8    public abstract [返回值类型] [方法名称](参数列表);
 9    
10    /**
11     * 其它方法（Jdk 8 以后允许接口类中添加"默认方法"与"静态方法" ）
12     */
13    ...(略)
14}

1@FunctionalInterface
2public interface MyCollection {
3    
4    void push(List list);
5    
6}

 1@FunctionalInterface
 2public interface Predicate<T> {
 3    /** abstract 方法，接收一个参数, 判断这个参数是否匹配某种规则, 然后返回布尔值结果 */
 4    boolean test(T t);
 5    
 6    /** default 方法，接收另外一个 Predicate<T> 类型参数进行"逻辑与"操作，返回一个新的 Predicate */
 7    default Predicate<T> and(Predicate<? super T> other) {
 8        Objects.requireNonNull(other);
 9        return (t) -> test(t) && other.test(t);
10    }
11    
12    /** default 方法，接收另外一个 Predicate<T> 类型参数进行"逻辑或"操作，返回一个新的 Predicate */
13    default Predicate<T> negate() {
14        return (t) -> !test(t);
15    }
16    
17    /** default 方法，返回当前 Predicate 取反操作之后的 Predicate */
18    default Predicate<T> or(Predicate<? super T> other) {
19        Objects.requireNonNull(other);
20        return (t) -> test(t) || other.test(t);
21    }
22
23    static <T> Predicate<T> isEqual(Object targetRef) {
24        return (null == targetRef)
25                ? Objects::isNull
26                : object -> targetRef.equals(object);
27    }
28}

 1public class PredicateExample {
 2
 3    /** 这里创建一个 Prodicate，设置验证秘钥的一个逻辑，然后返回并输出验证结果 */
 4    public static void main(String[] args) {
 5        // 创建 Predicate 及 Lambda 表达式与待实现的逻辑
 6        Predicate<String> validation = (String secret) -> {
 7            return "123456".equals(secret);
 8        };
 9        // 调用 Predicate 提供的 test 方法并输出结果
10        System.out.println(validation.test("123"));
11        System.out.println(validation.test("123456"));
12    }   
13    
14}

 1@FunctionalInterface
 2public interface Consumer<T> {
 3
 4    /** abstract 方法，接收一个参数，执行消费逻辑 */
 5    void accept(T t);
 6     
 7     /** default 方法，将两个 Consumer 连接到一起，再进行消费 */
 8    default Consumer<T> andThen(Consumer<? super T> after) {
 9        Objects.requireNonNull(after);
10        return (T t) -> { accept(t); after.accept(t); };
11    }
12    
13}

 1/** 这里创建一个 Consumer，模拟发送消息并打印内容 */
 2public class ConsumerExample {
 3
 4    public static void main(String[] args) {
 5        // 创建 Consumer 及 Lambda 表达式与待实现的逻辑
 6        Consumer<String> consumer = (String message) -> {
 7            System.out.println("发送消息内容：" + message);
 8        };
 9        // 调用 Consumer 提供的 accept 方法
10        consumer.accept("测试消息");
11    } 
12    
13}

 1@FunctionalInterface
 2public interface Function<T, R> {
 3    /**abstract 方法，接收一个参数进行处理，然后返回处理结果 R */
 4    R apply(T t);
 5
 6    /** default 方法，先执行参数(Function)的，再执行调用者(Function) */
 7    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
 8        Objects.requireNonNull(before);
 9        return (V v) -> apply(before.apply(v));
10    }
11    
12    /** default 方法，先执行调用者，再执行参数，和compose相反 */
13    default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
14        Objects.requireNonNull(after);
15        return (T t) -> after.apply(apply(t));
16    }
17    
18    /** 返回当前正在执行的方法 */
19    static <T> Function<T, T> identity() {
20        return t -> t;
21    }
22}

 1/** 这里创建一个 Function，对传入的参数进行验证，如果包含 a 字符就返回1，否则返回0 */
 2public class FunctionExample {
 3
 4    public static void main(String[] args) {
 5        // 创建 Function 及 Lambda 表达式与待实现的逻辑
 6        Function<String, Integer> function = (String str) -> {
 7            return str.contains("a") ? 1 : 0;
 8        };
 9        // 调用 Function 提供的 apply 方法
10        System.out.println(function.apply("abcd"));
11        System.out.println(function.apply("efgh"));
12    }
13    
14}

1@FunctionalInterface
2public interface Supplier<T> {
3    /** abstract 方法，设置业务逻辑，获取逻辑中创建的对象 */
4    T get();
5}

 1/** 这里创建一个 Supplier，用于生成随机ID，通过 get 方法获取生成的随机ID值 */
 2public class SupplierExample {
 3
 4    public static void main(String[] args) {
 5        // 创建 Supplier 及 Lambda 表达式与待实现的逻辑
 6        Supplier<String> supplier = () -> {
 7            return UUID.randomUUID().toString();
 8        };
 9        // 调用 Supplier 提供的 get 方法
10        System.out.println(supplier.get());
11    }
12
13}

1// 可以看到 UnaryOperator 继承了 Function 接口
2@FunctionalInterface
3public interface UnaryOperator<T> extends Function<T, T> {
4    /** static 方法，接收一个参数，然后对其处理后再返回 */
5    static <T> UnaryOperator<T> identity() {
6        return t -> t;
7    }
8}

 1/** 这里创建一个 UnaryOperator，接收一个字符串进行加工处理后返回新字符串 */
 2public class UnaryOperatorExample {
 3    
 4    public static void main(String[] args) {
 5        // 创建 UnaryOperator 及 Lambda 表达式与待实现的逻辑
 6        UnaryOperator<String> unaryOperator = (String str) -> {
 7            return "[" + str + "]";
 8        };
 9        // 调用 UnaryOperator 继承的 Function 提供的 apply 方法
10        System.out.println(unaryOperator.apply("hello"));
11    }
12
13}

 1@FunctionalInterface
 2public interface BinaryOperator<T> extends BiFunction<T,T,T> {
 3    /** abstract 方法，通过比较器Comparator来比较两个元素中较小的一个作为返回值返回 */
 4    public static <T> BinaryOperator<T> minBy(Comparator<? super T> comparator) {
 5        Objects.requireNonNull(comparator);
 6        return (a, b) -> comparator.compare(a, b) <= 0 ? a : b;
 7    }
 8    
 9    /** 通过比较器Comparator来比较两个元素中较大的一个作为返回值返回 */
10    public static <T> BinaryOperator<T> maxBy(Comparator<? super T> comparator) {
11        Objects.requireNonNull(comparator);
12        return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;
13    }
14}

 1/** 这里创建一个 BinaryOperator，比较传入的两个参数哪个值最大，返回最大值 */
 2public class BinaryOperatorExample {
 3
 4    public static void main(String[] args) {
 5        // 创建 BinaryOperator 及 Lambda 表达式与待实现的逻辑
 6        BinaryOperator<Integer> binaryOperator = (Integer t1, Integer t2) -> {
 7            return t1 > t2 ? t1 : t2;
 8        };
 9        // 调用 BinaryOperator 继承的 BiFunction 提供的 apply 方法
10        System.out.println(binaryOperator.apply(1, 2));
11    }
12
13}

1() -> System.out.println("测试");

1(x) -> System.out.println(x);

1x -> System.out.println(x);

1Comparator<Integer> comparator = (x, y) -> {
2    System.out.println("测试");
3    return Integer.compare(x,y);
4};

1Comparator<Integer> Comparator = (x, y) -> Integer.compare(x, y);

1(Integer x, Integer y) -> Integer.compare();

 1public class VariableExample {
 2    /** 成员变量 */
 3    String str1 = "成员变量";
 4
 5    public void innerClass() {
 6        // 方法内部变量
 7        String str2 = "方法内部变量";
 8        // 使用匿名内部类创建线程
 9        new Thread(new Runnable() {
10            // 匿名内部类内部变量
11            String str3 = "匿名内部类内部变量";
12            @Override
13            public void run() {
14                /* 访问变量 */
15                System.out.println("匿名内部类输出：" + str1);
16                System.out.println("匿名内部类输出：" + str2);
17                System.out.println("匿名内部类输出：" + str3);
18                /* 修改变量 */
19                str1 = "修改访问成员变量";
20                // str2 = "修改访问方法内部变量"; // 不能进行修改，默认推导变量的修饰符 final
21                str3 = "修改访问匿名内部类内部变量";
22                /* 在匿名内部类中定义和类外部变量一样名称的变量 */
23                String str1 = "重新命名成员变量";
24                String str2 = "重新命名方法内部变量";
25            }
26        }).start();
27    }
28    
29    /** Main 方法 */
30    public static void main(String[] args) {
31        VariableExample variableExample = new VariableExample();
32        // 匿名内部类
33        variableExample.innerClass();
34    }
35
36}

 1public class VariableExample {
 2    /** 成员变量 */
 3    String str1 = "成员变量";
 4    
 5    public void lambdaExpression() {
 6        // 方法内部变量
 7        String str2 = "方法内部变量";
 8        new Thread(()->{
 9            // Lambda 内部变量
10            String str3 = "Lambda 内部变量";
11            /* 访问变量 */
12            // 访问成员变量
13            System.out.println("Lambda 表达式输出：" + str1);
14            // 访问方法内部变量
15            System.out.println("Lambda 表达式输出：" + str2);
16            // 访问匿名内部类内部变量
17            System.out.println("Lambda 表达式输出：" + str3);
18            /* 修改变量 */
19            str1 = "修改访问成员变量";
20            // str2 = "修改访问方法内部变量"; // 不能进行修改，默认推导变量的修饰符 final
21            str3 = "修改访问匿名内部类内部变量";
22            /* 在 Lambda 中定义和类外部变量一样名称的变量 */
23            String str1 = "重新命名成员变量";
24            // String str2 = "重新命名方法内部变量"; // 不能命名，lambda 不支持变量隐藏
25        }).start();
26    }
27
28    /** Main 方法 */
29    public static void main(String[] args) {
30        VariableExample variableExample = new VariableExample();
31        // 匿名内部类
32        variableExample.innerClass();
33        // Lambda 表达式
34        variableExample.lambdaExpression();
35    }
36
37}

1@FunctionalInterface
2interface MyInterfaceA {
3    void push(String param);
4}

1@FunctionalInterface
2interface MyInterfaceB {
3    void pull(String param);
4}

 1public class LambdaOverloadExample {
 2    
 3    // 重载方法A
 4    public static void method(MyInterfaceA myInterfaceA) {
 5        myInterfaceA.push("hello 1");
 6    }
 7    // 重载方法B
 8    public static void method(MyInterfaceB myInterfaceB) {
 9        myInterfaceB.pull("Hello 2");
10    }
11
12    /** Main 方法*/
13    public static void main(String[] args) {
14        // 使用匿名内部类
15        method(new MyInterfaceA() {
16            @Override
17            public void push(String param) {
18                System.out.println(param);
19            }
20        });
21        method(new MyInterfaceB() {
22            @Override
23            public void pull(String param) {
24                System.out.println(param);
25            }
26        });
27        // 使用 Lambda 表达式
28        //method(param -> System.out.println(param)); // 编译器提示错误，表示无法推断使用哪个参数
29    }
30
31}

1// 转换参数为 MyInterfaceA
2method((MyInterfaceA)param -> System.out.println(param));
3// 转换参数为 MyInterfaceB
4method((MyInterfaceB)param -> System.out.println(param));

 1public class Person {
 2    /** 姓名 */
 3    private String name;
 4    /** 岁数 */
 5    private int age;
 6
 7    public Person() {
 8    }
 9    public Person(String name, int age) {
10        this.name = name;
11        this.age = age;
12    }
13
14    public String getName() {
15        return name;
16    }
17    public void setName(String name) {
18        this.name = name;
19    }
20    public int getAge() {
21        return age;
22    }
23    public void setAge(int age) {
24        this.age = age;
25    }
26    
27    @Override
28    public String toString() {
29        return "Person{name=" + name + ",age=" + age + "}";
30    }
31}

 1public class StaticMethodExample {
 2
 3    /** 测试的静态方法 */
 4    public static int compareAge(Person p1, Person p2) {
 5        return p1.getAge() - p2.getAge();
 6    }
 7
 8    public static void main(String[] args) {
 9        // 创建 Person 集合
10        List<Person> personList = new ArrayList<>();
11        personList.add(new Person("Wangqin",26));
12        personList.add(new Person("Liming",22));
13        personList.add(new Person("Alisi",18));
14        personList.add(new Person("Jerry",31));
15        
16        // 按岁数进行排序，使用静态方法引用
17        personList.sort(StaticMethodExample::compareAge);
18    }
19
20}

1public class PersonUtil{
2    /** 测试的实例方法 */
3    public int compareAge(Person p1, Person p2) {
4        return p1.getAge() - p2.getAge();
5    }
6}

 1public class InstanceMethodExample {
 2
 3    public static void main(String[] args) {
 4        // 创建 Person 集合
 5        List<Person> personList = new ArrayList<>();
 6        personList.add(new Person("Wangqin",26));
 7        personList.add(new Person("Liming",22));
 8        personList.add(new Person("Alisi",18));
 9        personList.add(new Person("Jerry",31));
10        
11        // 按岁数进行排序，
12        PersonUtil personUtil = new PersonUtil();
13        // 引用实例方法
14        personList.sort(personUtil::compareAge);
15    }
16
17}

1@FunctionalInterface
2public interface PersonConstructor{
3    Person initInstance(String name, int age);
4}

 1public class LambdaConstructorMethodExample {
 2
 3    public static void main(String[] args) {
 4        // 创建 Person 集合
 5        List<Person> personList = new ArrayList<>();
 6        personList.add(new Person("Wangqin", 26));
 7        personList.add(new Person("Liming", 22));
 8        personList.add(new Person("Alisi", 18));
 9        personList.add(new Person("Jerry", 31));
10
11        // 构造方法引用
12        PersonConstructor personConstructor = Person::new;
13        Person person = personConstructor.initInstance("linda", 18);
14        System.out.println(person);
15    }
16    
17}

 1public class LambdaExample {
 2
 3    public static void main(String[] args) {
 4        // 创建字符串集合
 5        List<String> strList = new ArrayList<>();
 6        strList.add("Jerry");
 7        strList.add("Mini");
 8        strList.add("Kary");
 9        strList.add("walls");
10        
11        // 使用集合的sort方法，按照String的compareToIgnoreCase进行排序（比较字符串hash值）
12        strList.sort(String::compareToIgnoreCase);
13        System.out.println(strList);
14    }
15
16}