JavaSE-Lambda表达式&Stream流-CSDN博客

public class _04_JdkOwn_02 {
private static void consumeResult(Consumer<String> function, String message) {
function.accept(message);
}
public static void main(String[] args) {
// 传递的参数
String message = "消费一些内容!!!";
// 调用方法
consumeResult(result -> {
System.out.println(result);
}, message);
}
}

演示示例:_04_JdkOwn_02.java

2.5.3 Function<T,R>接口

Function<T,R>接口表示接收一个参数并产生结果的函数

顾名思义,是函数操作的

有一个R apply(T)方法,Function中没有具体的操作，具体的操作需要我们去为它指定，因此apply具体返回的结果取决于传入的lambda表达式

public class _05_JdkOwn_03 {
// Function<参数, 返回值>
public static void convertType(Function<String, Integer> function,
String str) {
int num = function.apply(str);
System.out.println(num);
}
public static void main(String[] args) {
// 传递的参数
String str = "123";
// s是说明需要传递参数, 也可以写 (s)
convertType(s -> {
int sInt = Integer.parseInt(s);
return sInt;
}, str);
}
}

演示示例:_05_JdkOwn_03.java

2.5.4 Predicate<T>接口

Predicate<T>接口断言接口

就是做一些判断,返回值为boolean

有一个boolean test(T)方法,用于校验传入数据是否符合判断条件,返回boolean类型

public class _06_JdkOwn_04 {
// 自定义方法,并且 Predicate 接收String字符串类型
public static void call(Predicate<String> predicate, String isOKMessage) {
boolean isOK = predicate.test(isOKMessage);
System.out.println("isOK吗：" + isOK);
}
public static void main(String[] args) {
// 传入的参数
String input = "ok";
call((String message) -> {
// 不区分大小写比较,是ok就返回true,否则返回false
if (message.equalsIgnoreCase("ok")) {
return true;
}
return false;
}, input);
}
}

演示示例:_06_JdkOwn_04.java

3.方法引用和构造器调用

3.1概念说明

Lambda表达式的另外一种表现形式，提高方法复用率和灵活性。

3.2 特点

更简单、代码量更少、复用性、扩展性更高。

3.3 应用场景

若Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用。

不需要再复写已有API的Lambda的实现。

3.4 代码实现

3.4.1 方法引用

方法引用-3种形式

3.4.1.1 对象的引用 :: 实例方法名

public static void main(String[] args) {
Integer intObj = new Integer(123456);
// 常规lambda写法
Supplier<String> su = () -> intObj.toString();
System.out.println(su.get());
// 方法引用写法
Supplier<String> su1 = intObj::toString;
System.out.println(su1.get());
}

演示示例:_01_FunCall.java

3.4.1.2 类名 :: 静态方法名

public static void main(String[] args) {
// 常规lambda写法
// 前两个泛型是参数类型,第三个是返回值类型
BiFunction<Integer, Integer, Integer> bi = (x, y) -> Integer.max(x, y);
int apply = bi.apply(10, 11);
System.out.println(apply);

// 方法引用写法
BiFunction<Integer, Integer, Integer> bif = Integer::max;
int apply2 = bif.apply(10, 11);
System.out.println(apply2);
}

演示示例:_02_FunCall.java

3.4.1.3 类名 :: 实例方法名

public static void main(String[] args) {
// 常规lambda写法
// 两个泛型都是参数类型
BiPredicate<String, String> predicate = (x, y) -> x.equals(y);
System.out.println(predicate.test("a", "a"));
// 方法引用写法
// 使用第一个参数调用成员方法把第二个参数传入
// ::前面的类型要和第一个参数的类型一致
BiPredicate<String, String> predicate2 = String::equals;
System.out.println(predicate2.test("a", "b"));
}

演示示例:_03_FunCall.java

3.4.3 构造器调用

public static void main(String[] args) {
// 无参构造器
// 常规lambda写法
Supplier<Object> objSup = () -> new Object();
System.out.println(objSup.get());

// 方法引用写法
Supplier<Object> s1 = Object::new;
System.out.println(s1.get());
// 有参构造器
// 常规lambda写法
Function<String, Integer> func = (x) -> new Integer(x);
System.out.println(func.apply("123456"));

// 方法引用写法
Function<String, Integer> func2 = Integer::new;
System.out.println(func2.apply("123456"));
}

演示示例:_04_ConstructorCall.java

3.4.4 数组调用

public static void main(String[] args) {
// lambda传统写法
Function<Integer, Integer[]> fun = (n) -> new Integer[n];
Integer[] intArray1 = fun.apply(5);
intArray1[0] = 100;
System.out.println(intArray1[0]);

// 数组引用新写法
Function<Integer, Integer[]> fun1 = Integer[]::new;
Integer[] intArray = fun1.apply(5);
intArray[0] = 100;
System.out.println(intArray[0]);
}

演示示例:_05_ArrayCall.java

4.Stream API

4.1 概念说明

数据渠道、管道，用于操作数据源（集合、数组等）所生成的元素序列。

集合讲的是数据，流讲的是计算

即一组用来处理数组，集合的API。

4.2 特点

Stream 不是数据结构，没有内部存储，自己不会存储元素。

Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。

Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

很容易生成数据或集合

支持过滤，查找，转换，汇总，聚合等操作。

4.3 应用场景

流式计算处理，需要延迟计算、更方便的并行计算

更灵活、简洁的集合处理方式场景

4.4 代码实现

4.4.1 运行机制说明

Stream分为源source，中间操作，终止操作。

流的源可以是一个数组，集合，生成器方法，I/O通道等等。

一个流可以有零个或多个中间操作，每一个中间操作都会返回一个新的流，供下一个操作使用，一个流只会有一个终止操作。

中间操作也称为转换算子-transformation

Stream只有遇到终止操作，它的数据源会开始执行遍历操作。

终止操作也称为动作算子-action

因为动作算子的返回值不再是 stream,所以这个计算就终止了

只有碰到动作算子的时候,才会真正的计算

4.4.2 代码实现

4.4.2.1 生成stream流的5种方式说明

public static void main(String[] args) {
// 1 通过数组,Stream.of()
String[] str = { "a", "b", "c" };
Stream<String> str1 = Stream.of(str);
// System.out.println(str1);
// 2 通过集合
List<String> strings = Arrays.asList("a", "b", "c");
Stream<String> stream = strings.stream();
System.out.println(stream);
// 3 通过Stream.generate方法来创建
// 这是一个无限流，通过这种方法创建在操作的时候最好加上limit进行限制
Stream<Integer> generate = Stream.generate(() -> 1);
generate.limit(10).forEach(x -> System.out.println(x));
// 4 通过Stream iterate
Stream<Integer> iterate = Stream.iterate(1, x -> x + 2);
iterate.limit(100).forEach(x -> System.out.println(x));
// 5 已有类的stream源生成API
String str2 = "123456";
IntStream chars = str2.chars();
chars.forEach(x -> System.out.println(x));
}

演示示例:_01_Stream.java

4.4.2.2 常用转换算子

常用转换算子 filter,distinct,map,limit,skip,flatMap等

filter : 对元素进行过滤筛选,不符合的就不要了

distinct : 去掉重复的元素

skip : 跳过多少元素

limit : 取一个集合的前几条数据

map : 可以理解是在遍历集合的过程中,对元素进行操作,比如判断集合元素是否是a 返回boolean

因为map的返回值,就是新集合中的元素,所以也可以在遍历的时候对集合的数据进行更改,比如都加 –

sorted :排序

注意只用此算子是不会真正进行计算的，只有后边调用动作算子才会真正计算。

public static void main(String[] args) {
List<String> strings = Arrays.asList("a", "b", "c", "a");
Stream<String> stream = strings.stream();
/**
* 对元素进行过滤筛选,不符合的就不要了
*/
// collect 把符合条件的转换为集合strings,属于动作算子,因为不用动作算子这些转换算子不会执行,所以看不到结果
// 只要 a
List<String> value = stream.filter(x -> x.equals("a")).collect(Collectors.toList());
// 集合中只有 a 了
System.out.println(value);

// 使用过之后,需要重新生成stream
stream = strings.stream();
/**
* 跳过1个元素原来是 abca 现在就是 bca
*/
value = stream.skip(1).collect(Collectors.toList());
// bca
System.out.println(value);

/**
* map : 可以理解是在遍历集合的过程中,对元素进行操作,比如判断集合元素是否是a 返回boolean
* 或者对集合元素进行更改数据,比如都加--
*/
stream = strings.stream();
// 判断集合元素,这样就是booelean 是a 就是true 否则就是false
List<Boolean> value1=stream.map(x -> x.equals("a")).collect(Collectors.toList());
// true,false,false,true
System.out.println(value1);

stream = strings.stream();
// 更改集合元素
value =stream.map(x -> x+"--").collect(Collectors.toList());
// a--, b--, c--, a--
System.out.println(value);
/**
* 去掉重复元素
*/
stream = strings.stream();
value = stream.distinct().collect(Collectors.toList());
// 去除一个a 只有a,b,c
System.out.println(value);
/**
* 取一个集合的前几条数据
*/
stream = strings.stream();
value = stream.limit(2).collect(Collectors.toList());
// ab
System.out.println(value);

/**
* 解决一个字符串数组返回单一的字符串使用flatMap
*/
strings = Arrays.asList("1,2,3", "a,b,c");
stream = strings.stream();
// 本来集合中有两个数据 "1,2,3" 和 "a,b,c"
// 会把每一个元素以 , 分割,得到字符串数组
// 然后把数组中每一个元素,都单独拿出来
// 最终就会得到 1,2,3,a,b,c 6个元素
// 通过 collect 把这6个元素放到集合中
value =stream.map(x -> x.split(",")).flatMap(arr -> Arrays.stream(arr)).collect(Collectors.toList());
// 1, 2, 3, a, b, c
System.out.println(value);
}

演示示例:_02_Stream.java

4.4.2.3 常用动作算子

循环 forEach

计算 min、max、count、average

匹配 anyMatch、allMatch、noneMatch、findFirst、findAny

汇聚 reduce

收集器 collect

public static void main(String[] args) {
List<String> strings = Arrays.asList("a", "b", "c");
Stream<String> stream = strings.stream();
// 测试forEach
stream.filter(x -> x.equals("a")).forEach(x -> System.out.println(x));
// 测试count
stream = strings.stream();
long cnt = stream.count();
System.out.println(cnt);
// 测试collect
stream = strings.stream();
List<String> list = stream.map(x -> x + "--").collect(
Collectors.toList());
System.out.println(list);
}