Lambda8 表达式

阅读原文时间：2022年04月01日阅读：1

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。

JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

可以对某些匿名内部类的写法进行简化，它是函数式编程思想的一个重要体现，不用关注是什么对象，而是更关注对数据进行了什么操作。

基本格式

(参数列表)->{代码}

范例

范例一：

在创建线程并启动时可以使用匿名内部类的写法；

匿名内部类方式：

new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread());
}
}).start();
Lambda方式：

new Thread(() -> {
System.out.println(Thread.currentThread());
}).start();

范例二：

IntBinaryOperator是一个接口，使用匿名内部类的写法调用该方法；

匿名内部类方式：

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

@Test
public void testLambda2() {
int i = calculateNum(new IntBinaryOperator() {
@Override
public int applyAsInt(int left, int right) {
return left + right;
}
});
```
System.out.println(i);
```
}
Lambda方式：

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

@Test
public void testLambda2() {
int i = calculateNum((int left, int right) -> {
return left + right;
});
```
System.out.println(i);
```
}

范例三：

IntPredicate是一个接口。先使用匿名内部类的写法调用该方法；

匿名内部类方式：

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);
}
}
}

@Test
public void testLambda3() {
printNum(new IntPredicate() {
@Override
public boolean test(int value) {
return value % 3 == 0;
}
});
}
Lambda方式：

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);
}
}
}

@Test
public void testLambda3() {
printNum((int value) -> {
return value % 3 == 0;
});
}

范例四：

Function是一个接口，先使用匿名内部类的写法调用该方法；

匿名内部类方式：

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

@Test
public void testLambda4() {
Integer result = typeConver(new Function() {
@Override
public Integer apply(String s) {
return Integer.valueOf(s);
}
});
System.out.println(result);
}
Lambda方式：

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

@Test
public void testLambda4() {
Integer result = typeConver((String s) -> {
return Integer.valueOf(s);
});
System.out.println(result);
}

范例五：

IntConsumer是一个接口，先使用匿名内部类的写法调用该方法；

匿名内部类方式：

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);
}
}

@Test
public void testLambda5() {
foreachArr(new IntConsumer() {
@Override
public void accept(int value) {
System.out.println(value);
}
});
Lambda方式：

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);
}
}

@Test
public void testLambda5() {
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);
}
}

@Test
public void testLambda5() {
foreachArr((value) -> {
System.out.println(value);
});
}
方法体只有一句代码时大括号return和唯一一句代码的分号可以省略；

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);
}
}

@Test
public void testLambda5() {
foreachArr((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);
}
}

@Test
public void testLambda5() {
foreachArr(value -> System.out.println(value));
}
以上这些规则都记不住也可以省略不记，可通过idea的replaceLambda表达式快速生成lambda表达式；

Stream将要处理的元素集合看作一种流，在流的过程中，借助Stream API对流中的元素进行操作。

Stream - 特性

Stream可以由数组或集合创建，对流的操作分为两种：

中间操作，每次返回一个新的流，可以有多个；
终端操作，每个流只能进行一次终端操作，终端操作结束后流无法再次使用。终端操作会产生一个新的集合或值。

Stream特性：

stream不存储数据，而是按照特定的规则对数据进行计算，一般会输出结果；
stream不会改变数据源，通常情况下会产生一个新的集合或一个值；
stream具有延迟执行特性，只有调用终端操作时，中间操作才会执行。

Stream - 创建方式

Stream创建方式有三种：

通过 java.util.Collection.stream() 方法用集合创建流；
使用java.util.Arrays.stream(T[] array)方法用数组创建流；

使用Stream的静态方法：of()、iterate()、generate()。

import java.util.Arrays;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**

@author hos

@Createdate 2022/3/21 14:40
*/
public class StreamCreateType {

public static void main(String[] args) {

/**
 * Stream 流的创建有3种方式
 *  1. Collection.stream（）方法用集合创建
 *  2. Arrays.stream(T[] array) 方法用数组创建
 *  3. 使用Stream的静态方法：of()、iterate()、generate()
 */
//方式一: Collection.stream（）方法用集合创建
List<String> list = Arrays.asList("1", "2", "3", "4", "5", "6", "7", "8", "9");
// 创建一个顺序流
Stream<String> stream = list.stream();
// 创建一个并行流
Stream<String> stringStream = list.parallelStream();
List<String> collect = stringStream.collect(Collectors.toList());

//方式二: Arrays.stream(T[] array) 方法用数组创建
int[] array = {1, 2, 3, 4, 5};
IntStream stream1 = Arrays.stream(array);
System.out.println(stream1.max().getAsInt());

//方式三: 使用Stream的静态方法：of()、iterate()、generate()
Stream<Integer> intStream = Stream.of(1, 2, 3, 4, 5, 6);
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 3).limit(4);
// 0 3 6 9
stream2.forEach(System.out::println);

AtomicInteger m = new AtomicInteger(10);
Stream<Integer> stream3 = Stream.generate(()-> m.getAndIncrement()).limit(3);
//10 11 12
stream3.forEach(System.out::println);

}
}