package com.paic.stream;
import org.junit.Test;
import java.text.Collator;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* 创建流
* 串行流
* strings.stream();
* 并行流
* strings.parallelStream();
* 中间操作符:filter、distinct、limit、skip、map、flatMap、sorted
* 终止操作符:anyMatch、allMatch、noneMatch、findAny、findFirst、forEach、collect、reduce.
*/
public class StreamTest {
// ****************************中间操作符**************************************
/**
* filter:过滤集合中不符合条件的元素
*/
@Test
public void filter() {
List<String> strings = Arrays.asList("aaa", "bbb", "ccc", "ddd");
/**
* 将集合转为流,在进行过滤,最后转成集合,不对之前的集合进行操作,产生的集合为新的集合
*/
List<String> c = strings.stream().filter(str -> str.contains("c")).collect(Collectors.toList());
System.out.println("c = " + c); // c = [ccc]
System.out.println("strings = " + strings); // strings = [aaa, bbb, ccc, ddd]
}
/**
* distinct:去重(比较的事元素的hashCode和equals方法实现)
*/
@Test
public void distinct() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
List<String> collect = strings.stream().distinct().collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [aaa, bbb, ccc, ddd]
System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
//-----------------------------------------------------------
ArrayList<User> list = new ArrayList<>();
list.add(new User(1, "z"));
list.add(new User(1, "z"));
list.add(new User(2, "s"));
List<User> users = list.stream().distinct().collect(Collectors.toList());
System.out.println("users = " + users);
System.out.println("list = " + list);
}
/**
* limit: 获取流中的指定元素前n个
*/
@Test
public void limit() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
List<String> collect = strings.stream().limit(3).collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [aaa, bbb, bbb]
System.out.println("strings = " + strings); //strings = [aaa, bbb, bbb, ccc, ddd]
}
/**
* skip: 获取流中除去前n个元素的其他所有元素
*/
@Test
public void skip() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
List<String> collect = strings.stream().skip(3).collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [ccc, ddd]
System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
}
/**
* map: 对流中所有元素做统一处理
*/
@Test
public void map() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
List<Object> collect = strings.stream().map(str ->
str.concat("_map")
).collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [aaa_map, bbb_map, bbb_map, ccc_map, ddd_map]
System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
}
/**
* flatMap: 扁平化,把返回的流数组中的内容整合成一个流
*/
@Test
public void flatMap() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
List<Character> collect = strings.stream().flatMap(str -> StreamTest.getCharacterByString(str)).collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [a, a, a, b, b, b, b, b, b, c, c, c, d, d, d]
System.out.println("strings = " + strings); // strings = [aaa, bbb, bbb, ccc, ddd]
}
/**
* map与flatMap 对比
* 以下解析:
* flatMap
* (1) [a,a,a],[b,b,b],[b,b,b],[c,c,c],[d,d,d]
* (2) [a,a,a,b,b,b,b,b,b,c,c,c,d,d,d]
* <p>
* <p>
* map
* (1) [a,a,a],[b,b,b],[b,b,b],[c,c,c],[d,d,d]
*/
@Test
public void flatMap___map() {
List<String> strings = Arrays.asList("aaa", "bbb", "bbb", "ccc", "ddd");
Stream<Stream<Character>> streamMap = strings.stream().map(StreamTest::getCharacterByString);
streamMap.forEach(s -> s.forEach(System.out::println)); // 遍历层级-2
System.out.println("------------------------------");
Stream<Character> streamFlatMap = strings.stream().flatMap(StreamTest::getCharacterByString);
streamFlatMap.forEach(System.out::println); // 遍历层级-1
}
/**
* sorted: 排序
*/
@Test
public void sorted() {
// ***************************字母排序*************************************************
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
List<String> collect = strings.stream().sorted().collect(Collectors.toList());
System.out.println("collect = " + collect); // collect = [aaa, bbb, ccc, dbb, ddd]
System.out.println("strings = " + strings); // strings = [aaa, dbb, bbb, ccc, ddd]
// ****************************数字排序***********************************************
List<Integer> integers = Arrays.asList(1, 2, 3, 5, 6, 4, 5, 6, 7, 8, 9, 05, 534543, 664);
List<Integer> integerList = integers.stream().sorted().collect(Collectors.toList());
System.out.println("integers = " + integers); // integers = [1, 2, 3, 5, 6, 4, 5, 6, 7, 8, 9, 5, 534543, 664]
System.out.println("integerList = " + integerList); // integerList = [1, 2, 3, 4, 5, 5, 5, 6, 6, 7, 8, 9, 664, 534543]
// ****************************汉字排序***********************************************
List<String> stringList = Arrays.asList("张三", "李四", "王五", "赵柳", "王小二");
List<String> collect1 = stringList.stream().sorted().collect(Collectors.toList());
System.out.println("collect1 = " + collect1); // collect1 = [张三, 李四, 王五, 王小二, 赵柳]
// 汉字按字母顺序排序
List<String> collect2 = stringList.stream().sorted(Collator.getInstance(Locale.CHINA)).collect(Collectors.toList());
System.out.println("collect2 = " + collect2); // collect2 = [李四, 王五, 王小二, 张三, 赵柳]
}
// 字符串转换成字符流
public static Stream<Character> getCharacterByString(String str) {
ArrayList<Character> list = new ArrayList<>();
for (Character character : str.toCharArray()) {
list.add(character);
}
return list.stream();
}
// *******************************终止操作符********************************************
/**
* anyMatch: 检查是否至少匹配一个元素,返回Boolean
*/
@Test
public void anyMatch() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
boolean b = strings.stream().anyMatch(s -> s.contains("b/"));
boolean b1 = strings.stream().anyMatch(s -> s.contains("b"));
System.out.println("b = " + b); // b = false
System.out.println("b1 = " + b1); // b1 = true
}
/**
* allMatch: 集合中元素是否都满足条件
*/
@Test
public void allMatch() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
boolean b = strings.stream().allMatch(s -> s.length() > 0);
boolean b1 = strings.stream().allMatch(s -> s.contains("a"));
System.out.println("b = " + b); // b = true
System.out.println("b1 = " + b1); // b1 = false
}
/**
* allMatch: 集合中元素是否都不满足条件
*/
@Test
public void noneMatch() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
boolean b = strings.stream().noneMatch(s -> s.length() > 0);
boolean b1 = strings.stream().noneMatch(s -> s.contains("f"));
System.out.println("b = " + b); // b = false
System.out.println("b1 = " + b1); // b1 = true
}
/**
* findAny: 返回集合中任意元素
*/
@Test
public void findAny() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
Optional<String> any = strings.stream().findAny();
if (any.isPresent()) // 判断是否存在
System.out.println(any.get()); // aaa
}
/**
* findFirst: 返回集合中第一个元素
*/
@Test
public void findFirst() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
Optional<String> any = strings.stream().findFirst();
if (any.isPresent()) // 判断是否存在
System.out.println(any.get()); // aaa
}
/**
* forEach: 循环/遍历流
*/
@Test
public void forEach() {
List<String> strings = Arrays.asList("aaa", "dbb", "bbb", "ccc", "ddd");
strings.stream().forEach(System.out::println);
strings.stream().forEach(s -> System.out.println(s));
}
/**
* collect: 收集器,将流转换成其他形式
*/
@Test
public void collect() {
List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
strings.stream().collect(Collectors.toSet()); // 转换成set集合
strings.stream().collect(Collectors.toList()); // 转换成List集合
// // ***************************************************
// Map<String, String> collect = strings.stream().collect(Collectors.toMap(v -> v, v -> v));// 转换成map集合,将list中的每一个元素当做key和value,但是当key重复是会报错 java.lang.IllegalStateException: Duplicate key aaa
// System.out.println("collect = " + collect);
Map<String, String> collect1 = strings.stream().collect(Collectors.toMap(v -> v, v -> v, (oldValue, newValue) -> newValue));// 转换成map集合,将list中的每一个元素当做key和value,但是当key重复是取newValue(调用了 return (a, b) -> comparator.compare(a, b) >= 0 ? a : b;)
System.out.println("collect1 = " + collect1);
}
/**
* reduce: 可以将元素反复结合起来,得到一个值
*/
@Test
public void reduce(){
List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
/**
* acc : 计算结果
* item : 每一个元素
* -> 计算规则
*/
Optional<String> reduce = strings.stream().reduce((acc, item) -> acc + item);
// 此时给定一个初始结果,结果会与初始结果共同进行规则计算
String reduce1 = strings.stream().reduce("aaa",(acc, item) -> (acc + item).replace("a",""));
if (reduce.isPresent())
System.out.println(reduce.get()); // aaadbbaaacccddd
System.out.println("reduce1 = " + reduce1); // reduce1 = dbbcccddd
}
/**
* count: 返回流中的元素总数
*/
@Test
public void count(){
List<String> strings = Arrays.asList("aaa", "dbb", "aaa", "ccc", "ddd");
long count = strings.stream().count();
System.out.println("count = " + count);
}
}
stream流基本用法
最新推荐文章于 2024-05-26 11:11:51 发布