带你彻底掌握 Lambda 表达式（上）

/**
 * @author: sss
 */
public class TaskAThread implements Runnable {
    @Override
    public void run() {
        // process taskA
        ...
    }
}

public class Main {
    public static void main(String[] args) {
        // new 一个新线程，执行任务A
        Runnable taskA = new TaskAThread();
        new Thread(taskA).start();

        // 主线程继续做其他事情
        System.out.println("do other things...");
    }
}

public class Main {
    public static void main(String[] args) {
        // 通过匿名类来创建一个新线程，执行任务A
        Runnable taskA = new Runnable() {
            @Override
            public void run() {
                // process taskA
                ...
            }
        };
        new Thread(taskA).start();

        // 主线程继续做其他事情
        System.out.println("do other things...");
    }
}

public static void main(String[] args) {
    // 通过匿名类来创建一个新线程，执行任务A
    new Thread(() -> {
        System.out.println("正在异步处理 taskA 中...");
        // do things
        ...
    }).start();

    // 主线程继续做其他事情
    System.out.println("do other things...");
}

// 错误示例 1
@FunctionalInterface
interface InvalidInterfaceA {
}

// 错误示例 2
@FunctionalInterface
interface InvalidInterfaceB {
    void testA();
    void testB();
}

@FunctionalInterface
interface InvalidInterfaceC {
    void testC();
}

@FunctionalInterface
interface InvalidInterfaceD {
    void testD();
    default void testE() {
        System.out.println("this is a default method.");
    }
}

interface MathOperation {
    int operation(int a, int b);
}

public static void main(String args[]) {
    MathOperation addition = (int a, int b) -> a + b;
}

public static void main(String[] args) {
    // 使用匿名内部类
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("正在异步处理 taskA 中...");
        }
    }).start();

    // 使用 Lambda 表达式
    new Thread(() -> System.out.println("正在异步处理 taskA 中...")).start();
}

public static void main(String[] args) {
    List<String> strList = Arrays.asList("a", "b", "c", "d");
    // 方式1
    for (int i = 0; i < strList.size(); i++) {
        System.out.println(strList.get(i));
    }
    // 方式2，语法糖，本质还是下面的方式3
    for (String str : strList) {
        System.out.println(str);
    }
    // 方法3
    Iterator<String> iterator = strList.iterator();
    while (iterator.hasNext()) {
        System.out.println(iterator.next());
    }
}

strList.forEach(str -> System.out.println(str));

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

/**
 * Represents an operation that accepts a single input argument and returns no
 * result. Unlike most other functional interfaces, {@code Consumer} is expected
 * to operate via side-effects.
 *
 * <p>This is a <a href="package-summary.html">functional interface</a>
 * whose functional method is {@link #accept(Object)}.
 *
 * @param <T> the type of the input to the operation
 *
 * @since 1.8
 */
@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);

    default Consumer<T> andThen(Consumer<? super T> after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

strList.forEach(new Consumer<String>() {
    @Override
    public void accept(String str) {
        System.out.println(str);
    }
});

strList.forEach(str -> System.out.println(str));

() -> {...}
或
(xxx) -> {...}

() -> {System.out.println("test expression!");};
() -> 123;

(x) -> {System.out.println(x);};
x => x + 2;

(x, y, z) -> {
    System.out.println(x);
    System.out.println(y);
    System.out.println(z);
};

List<String> strList = Arrays.asList("a", "b", "c", "d");
strList.forEach(str -> {
	System.out.println(str);
});

strList.forEach(str -> System.out.println(str));

## 找出所有学生的数学成绩
select name,
       age,
       course,
       score
  from student
 where course= "math";

def sum(x):
    def add(y):
        return x + y;
    return add;

sum2 = sum(2);
elementB = sum(7);
a = sum2(3); # 2 + 3 = 5
b = elementB(1); # 7 + 1 = 8
print a; # 输出5
print b; # 输出8

public int sum(int x, int y) {
	return x + y;
}

new Thread(() -> System.out.println("this is a Lambda expression!")).start();

List<String> nameList = Arrays.asList("tom", "kate", "jim", "david");
List<String> newNameList = nameList
    .stream()
    .filter(name -> name.length() > 3)
    .map(name -> name.toUpperCase())
    .sorted()
    .collect(Collectors.toList());

// 给定一个整数集合
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

// 求所有元素的和
private Integer sumAll(List<Integer> list) {
    int sum = 0;
    for (Integer ele : list) {
        sum += ele;
    }
    return sum;
}

// 求所有偶数元素的和
private Integer sumEven(List<Integer> list) {
    int sum = 0;
    for (Integer ele : list) {
        if (ele % 2 == 0) {
            sum += ele;
        }
    }
    return sum;
}

// 求所有奇数元素的和
private Integer sumOdd(List<Integer> list) {
    int sum = 0;
    for (Integer ele : list) {
        if (ele % 2 == 1) {
            sum += ele;
        }
    }
    return sum;
}
// 求所有大于3的元素的和
private Integer sumLargerThan3(List<Integer> list) {
    int sum = 0;
    for (Integer ele : list) {
        if (ele > 3) {
            sum += ele;
        }
    }
    return sum;
}

public interface sumStrategy {
	Integer sum(List<Integer> list);
}

public class SumAllStrategy implements sumStrategy {
	@Override
    public Integer sum(List<Integer> list) {
        int sum;
        for (Integer ele : list) {
            sum += ele;
        }
        return sum;
    }
}

public class SumEvenStrategy implements sumStrategy {
	@Override
    public Integer sum(List<Integer> list) {
    	...
    }
}

// 实际调用
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// 示例1：当想求所有元素的和时，使用 SumAllStrategy 类
Strategy strategy1 = new SumAllStrategy();
strategy1.sum(list);

// 示例2：当想求所有偶数元素的和时，使用 SumEvenStrategy 类
Strategy strategy2 = new SumEvenStrategy();
strategy2.sum(list);

// @since 1.8
@FunctionalInterface
public interface Predicate<T> {
    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);

    ...
 }

private Integer sum(List<Integer> list, Predicate condition) {
    int sum = 0;
    for (Integer ele : list) {
        if (condition.test(ele)) {
            sum += ele;
        }
    }
    return sum;
}

// 实际使用
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// 示例1：求所有元素的和
int sum = sum(list, x -> true);
// 示例2：求所有偶数元素的和
sum = tester.sum(list, x -> (int)x % 2 == 0);
// 示例3：求所有大于5的元素的和
sum = tester.sum(list, x -> (int)x > 5);

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);
// 串行
Integer reduce = list.stream().reduce((a, b) -> a + b).get();
// 并行，相比串行多了 parallel() 函数
Integer reduce = list.stream().parallel().reduce((a, b) -> a + b).get();