package com.zs.lamda;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;
import org.junit.Test;
/**
* @author zhaoshuai06 <zhaoshuai06@kuaishou.com>
* Created on 2021-06-09
*/
public class TestLamda {
private static ArrayList<Apple> arrayList = new ArrayList<>();
private static ArrayList<String> stringArrayList = new ArrayList<>();
static {
arrayList.add(new Apple(1, "red", 500, "湖南"));
arrayList.add(new Apple(1, "red", 500, "湖南"));
arrayList.add(new Apple(2, "red", 400, "湖南"));
arrayList.add(new Apple(3, "green", 300, "湖南"));
arrayList.add(new Apple(4, "green", 200, "天津"));
arrayList.add(new Apple(5, "green", 100, "天津"));
}
static {
stringArrayList.add("aaa bbb ccc");
stringArrayList.add("ddd eee fff");
stringArrayList.add("ggg hhh iii");
}
@Test
//filter: 是一种过滤的方法 == 相当于 if()
public void test_filter() {
List<Apple> redList = arrayList.stream()
.filter(item -> item.getColor().equals("red"))
.collect(Collectors.toList());
System.out.println(redList);
}
@Test
//distinct: 去除重复元素
public void test_distinct() {
List<Apple> redList = arrayList.stream()
.filter(item -> item.getColor().equals("red"))
.distinct()
.collect(Collectors.toList());
System.out.println(redList);
}
@Test
//sorted: 按id逆序排列输出
public void test_sorted() {
List<Apple> redList = arrayList.stream()
.distinct()
.sorted((p1, p2) -> p2.getId() - p1.getId())
.collect(Collectors.toList());
System.out.println(redList);
}
@Test
//limit(2): 返回前两个元素
public void test_limit() {
List<Apple> redList = arrayList.stream()
.distinct()
.sorted((p1, p2) -> p2.getId() - p1.getId())
.limit(2)
.collect(Collectors.toList());
System.out.println(redList);
}
@Test
//skip(2): 跳过前两个元素
public void test_skip() {
List<Apple> redList = arrayList.stream()
.distinct()
.sorted((p1, p2) -> p2.getId() - p1.getId())
.skip(2)
.collect(Collectors.toList());
System.out.println(redList);
}
// map(Apple::getOrigin) == .map(item -> item.getOrigin()): 将流中的每一个元素 T 映射为 R(类似类型转换)
@Test
public void testMap() {
List<String> newList = arrayList.stream()
.map(Apple::getOrigin) //.map(item -> item.getOrigin())
.collect(Collectors.toList());
System.out.println(newList);
}
@Test
// 我们的目的是把 List 中每个字符串元素以" "分割开,变成一个新的 List
// flatMap(Arrays::stream)
//首先 map 方法分割每个字符串元素,但此时流的类型为 Stream<String[ ]>,因为 split 方法返回的是 String[ ] 类型;
// 所以我们需要使用 flatMap 方法,先使用Arrays::stream将每个 String[ ] 元素变成一个 Stream 流,
// 然后 flatMap 会将每一个流连接成为一个流,最终返回我们需要的 Stream;
public void testFlatMap() {
List<String> result = stringArrayList.stream()
.map(item -> item.split(" "))
.flatMap(Arrays::stream)
.collect(Collectors.toList());
System.out.println(result);
}
@Test
//anyMatch(T -> boolean) :流中是否有一个元素匹配给定的 T -> boolean 条件
public void testAnyMatch() {
boolean result = arrayList.stream()
.anyMatch(item -> item.getOrigin().equals("天津"));
System.out.println(result);
}
@Test
// allMatch(T -> boolean):流中是否所有元素都匹配给定的 T -> boolean 条件
public void testAllMatch() {
boolean result = arrayList.stream()
.allMatch(item -> item.getOrigin().equals("天津"));
System.out.println(result);
}
@Test
// noneMatch(T -> boolean):流中是否没有元素匹配给定的 T -> boolean 条件
public void testNoneMatch() {
boolean result = arrayList.stream()
.noneMatch(item -> item.getOrigin().equals("北京"));
System.out.println(result);
}
@Test
public void testFindAnyOrAll() {
Optional<Apple> any = arrayList.stream()
.findAny();
System.out.println(any.get());
Optional<Apple> first = arrayList.stream()
.findFirst();
System.out.println(first.get());
}
@Test
// reduce(0, Integer::sum):
//reduce 第一个参数 0 代表起始值为 0, 将两值相加产生一个新值
public void testReduce() {
Integer result = arrayList.stream()
.map(Apple::getWeight)
.reduce(0, Integer::sum);
System.out.println(result);
Optional<Integer> result_multi = arrayList.stream()
.map(Apple::getId)
.distinct()
.reduce((a, b) -> a * b); //1 2 3 4 5
System.out.println(result_multi.get());
}
@Test
public void test() {
long result_count = arrayList.stream()
.distinct()
.count();
System.out.println(result_count);
}
@Test
public void testCollect() {
List<Apple> res_collect = arrayList.stream()
.distinct()
.collect(Collectors.toList());
System.out.println("res_collect = " + res_collect);
Map<Integer, Apple> res_map = arrayList.stream()
.distinct()
.collect(Collectors.toMap(Apple::getId, Function.identity())); //1=Apple(id=1, color=red, weight=500, origin=湖南)
System.out.println(res_map);
}
@Test
public void testForEach() {
List<Integer> int_list = new ArrayList<>();
arrayList.stream()
.distinct()
.forEach(item -> int_list.add(item.getId()));
System.out.println(int_list);
}
@Test
public void testGroup() {
Map<String, List<Apple>> res_map = arrayList.stream()
.distinct()
.collect(Collectors.groupingBy(Apple::getOrigin));
System.out.println(res_map);
Map<String, Double> res_map = arrayList.stream()
.collect(Collectors.groupingBy(Apple::getOrigin, Collectors.averagingInt(Apple::getId)));
System.out.println(res_map);
Map<String, Integer> res_map = arrayList.stream()
.distinct()
.collect(Collectors.groupingBy(Apple::getOrigin, Collectors.summingInt(Apple::getWeight)));
System.out.println(res_map);
}
@Test
public void testPartitioningBy() {
Map<Boolean, List<Apple>> res_map = arrayList.stream()
.collect(Collectors.partitioningBy(item -> item.getColor().equals("red")));
System.out.println(res_map);
}
@Test
// find red apple and weight > 400
public void findRedAndWeightApple() {
List<Apple> redList = arrayList.stream()
.filter(item -> item.getColor().equals("red") && item.getWeight() > 400)
.collect(Collectors.toList());
System.out.println(redList);
}
@Test
// find red apple and groupByRed
public void findRedAndWeightApple1() {
arrayList.stream()
.filter(item -> item.getColor().equals("red"))
.collect(Collectors.groupingBy(
item -> item.getColor(),
Collectors.averagingInt(item -> item.getWeight())
)
)
.forEach((k, v) -> System.out.println(k + ":" + v));
}
}
@Test
public void test_inner_class() {
new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}).start();
}
改变成lamda的形式:
@Test
public void test_inner_class() {
new Thread(() -> System.out.println(Thread.currentThread().getName())).start();
}
@Test
public void test_inner_class_1() {
List<Integer> integers = new ArrayList<>();
integers.add(1);
integers.add(2);
integers.add(3);
integers.add(4);
Collections.sort(integers, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
System.out.println(integers);
}
@Test
public void test_inner_class_1() {
List<Integer> integers = new ArrayList<>();
integers.add(1);
integers.add(2);
integers.add(3);
integers.add(4);
Collections.sort(integers, (o1, o2) -> o2 - o1);
System.out.println(integers);
}
省去了new 接口名;简化为() ->{…} 实际也是实现且创建一个接口对象。
一个方法的参数,括号中是否可以使用Lambda表达式,取决于这个方法的参数类型:
----是否是一个函数式接口(只有一个抽象方法可以有多个default方法的接口),构造方法也同理。
抽象方法中Object类下的方法除外。