Lambda表达式

Lambda只留下参数和方法体！

Lambda只留下参数和方法体！

Lambda只留下参数和方法体！

案例一

package com.zsh.lambda;

/**
 * 案例一
 * 线程的内部类
 */
public class LambdaOne {
    public static void main(String[] args) {
        // Lambda简化前
        Thread oneThread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1的中run方法被执行了");
            }
        });
        // 启动线程
        oneThread.start();

        // Lambda简化后
        Thread twoThread = new Thread(() -> {
            System.out.println("线程2的中run方法被执行了");
        });
        // 启动线程
        twoThread.start();
    }


}

案例二

package com.zsh.lambda;

import java.util.function.IntBinaryOperator;

/**
 * 案例二
 * 求和
 * 求差
 */
public class LambdaTwo {
    public static void main(String[] args) {
        // 简化前
        int sumOne = sumNum(new IntBinaryOperator() {
            @Override
            public int applyAsInt(int left, int right) {
                return left + right;
            }
        });
        System.out.println("a + b = " + sumOne);

        // 简化后
        int sumTwo = sumNum((left, right) -> {
            return left - right;
        });
        System.out.println("a - b = " + sumTwo);
    }

    public static int sumNum(IntBinaryOperator operator){
        int a = 10;
        int b = 20;
        return operator.applyAsInt(a,b);
    }


}

案例三

package com.zsh.lambda;

import java.util.function.IntPredicate;

/**
 * 案例三
 * 求奇数偶数
 */
public class LambdaThree {

    public static void main(String[] args) {
        // 简化前
        printNum(new IntPredicate() {
            @Override
            public boolean test(int value) {
                return value % 2 == 0;
            }
        });

        // 简化后
        printNum(value -> {
            return value % 2 != 0;
        });
    }

    public static void printNum(IntPredicate predicate){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            if (predicate.test(i)){
                System.out.println(i);
            }
        }
    }


}

案例四

package com.zsh.lambda;

import java.util.function.Function;


/**
 * 案例四
 * 对泛型的操作
 */
public class LambdaFour {
    public static void main(String[] args) {
        // 简化前
        Integer resultOne = typeConver(new Function() {
            @Override
            public Integer apply(String s) {
                // 将String转换成Integer
                Integer strResult = Integer.valueOf(s);
                return strResult;
            }
        });
        System.out.println(resultOne);

        // 简化后
        Integer resultTwo = typeConver((String s) -> {
            // 将String转换成Integer
            Integer strResult = Integer.valueOf(s);
            return strResult;
        });
        System.out.println(resultTwo);

        // 再次简化
        String redisThree = typeConver((String s) -> {
            return s + "这是再一次的优化";
        });
        System.out.println(redisThree);
    }

    public static  R typeConver(Function function) {
        String str = "12345";
        R result = function.apply(str);
        return result;
    }


}

案例五

package com.zsh.lambda;

import java.util.function.IntConsumer;

/**
 * 第五个案例
 */
public class
LambdaFive {
    public static void main(String[] args) {
        // 简化前
        foreachArr(new IntConsumer() {
            @Override
            public void accept(int value) {
                System.out.println(value);
            }
        });

        System.out.println("--------------------");

        // 简化后
        foreachArr((int value) -> {
            System.out.println(value);
        });

        System.out.println("--------------------");

        // lambda省略写法

        // 参数类型可以推导出来，直接省略
        foreachArr((value) -> {
            System.out.println(value);
        });

        // 只有一个参数，小括号直接省略
        foreachArr(value -> {
            System.out.println(value);
        });

        // 只有一句代码时，大括号、return、分号都可以省略
        foreachArr(value -> System.out.println(value));

        // 记不住以上规则，可以不省略
        foreachArr((int value) -> {
            System.out.println(value);
        });

    }

    public static void foreachArr(IntConsumer consumer){
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        for (int i : arr) {
            consumer.accept(i);
        }
    }


}

最后：

1、参数类型可以推导出来，直接省略

2、只有一个参数，小括号直接省略

3、只有一句代码时，大括号、return、分号都可以省略

4、记不住以上规则，可以不省略！直接快捷键：ALT+Enter