List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //獲取一個順序流
Stream<String> parallelStream = list.parallelStream(); //獲取一個并行流

Integer[] nums = new Integer[10];
Stream<Integer> stream = Arrays.stream(nums);

// 1. of()
Stream<Integer> stream = Stream.of(1,2,3,4,5,6);
// 2. iterate()
Stream<Integer> stream2 = Stream.iterate(0, (x) -> x + 2).limit(6);
stream2.forEach(System.out::println); // 0 2 4 6 8 10
// 3. generate()
Stream<Double> stream3 = Stream.generate(Math::random).limit(2);
stream3.forEach(System.out::println);

BufferedReader reader = new BufferedReader(new FileReader("F:\\test_stream.txt"));
Stream<String> lineStream = reader.lines();
lineStream.forEach(System.out::println);

Pattern pattern = Pattern.compile(",");
Stream<String> stringStream = pattern.splitAsStream("a,b,c,d");
stringStream.forEach(System.out::println);

// 1. 篩選與切片
filter：過濾流中的某些元素
limit skip distinct sorted 都是有狀態(tài)操作，這些操作只有拿到前面處理后的所有元素之后才能繼續(xù)下去。
limit(n)：獲取前n個元素
skip(n)：跳過前n元素，配合limit(n)可實現(xiàn)分頁
distinct：通過流中元素的 hashCode() 和 equals() 去除重復(fù)元素
// 2. 映射
map：接收一個函數(shù)作為參數(shù)，該函數(shù)會被應(yīng)用到每個元素上，并將其映射成一個新的元素。
flatMap：接收一個函數(shù)作為參數(shù)，將流中的每個值都換成另一個流，然后把所有流連接成一個流。
// 3. 消費 peek , 類似map，    
//        map接收的是一個Function表達(dá)式，有返回值；
//        而peek接收的是Consumer表達(dá)式，沒有返回值。
// 4. 排序
sorted()：自然排序，流中元素需實現(xiàn)Comparable接口
sorted(Comparator com)：定制排序，自定義Comparator排序器
// 5. 

// 實例：集合內(nèi)元素>5,去重，跳過前兩位，取剩下元素的兩個返回為新集合
Stream<Integer> stream = Stream.of(6, 4, 6, 7, 3, 9, 8, 10, 12, 14, 14);
Stream<Integer> newStream = stream.filter(s -> s > 5) //6 6 7 9 8 10 12 14 14
 .distinct() //6 7 9 8 10 12 14
 .skip(2) //9 8 10 12 14
 .limit(2); //9 8
newStream.forEach(System.out::println);

// 1. Map可以看成一個轉(zhuǎn)換器，傳入一個對象，返回新的對象
// map的使用實例 ? stream.map(x->x.getId());
List<String> list = Arrays.asList("a,b,c", "1,2,3");
// 去掉字符串中所有的,
List<String> collect = list.stream().map(s -> s.replaceAll(",", "")).collect(Collectors.toList());
// collect集合內(nèi)容為：{abc,123}
System.out.println(collect);

// 2. flatMap ? 效果：結(jié)果展平 ，即把嵌套集合，按照子集合的形式，統(tǒng)一放入到新的一個集合中?? ?
//?? ??? ??? ??? ?接收一個函數(shù)作為參數(shù)，將流中的每個值都換成另一個流，
//?? ??? ??? ??? ?然后把所有流連接成一個流。
Stream<String> stringStream = list.stream().flatMap(s -> {
?? ?// 將字符串以,分割后得到一個字符串?dāng)?shù)組
?? ?String[] split = s.split(",");
?? ?// 然后將每個字符串?dāng)?shù)組對應(yīng)流返回，flatMap會自動把返回的所有流連接成一個流
?? ?Stream<String> stream = Arrays.stream(split);
?? ?return stream;
});
// stringStream.collect(Collectors.toList())的集合內(nèi)容為：{a,b,c,1,2,3}
System.out.println(stringStream.collect(Collectors.toList()));

//?? ?說明：reduce看似效果和map相似，
//?? ??? ??? ?但reduce返回的是函數(shù)經(jīng)過執(zhí)行運算后的結(jié)果,
//?? ??? ??? ?而map返回的是處理后新的集合
List<String> memberNames = new ArrayList<>();
memberNames.add("Amitabh");
memberNames.add("Shekhar");
memberNames.add("Aman");
memberNames.add("Rahul");
memberNames.add("Shahrukh");
memberNames.add("Salman");
memberNames.add("Yana");
memberNames.add("Lokesh");

// 將集合中的元素按照#連接成字符串，并返回放置在Optional<String>中
Optional<String> reduced = memberNames.stream()
? ? ? ? .reduce((s1,s2) -> s1 + "#" + s2);
// 有值則取出打印顯示 ? ? ? ?
reduced.ifPresent(System.out::println); ?
// 輸出內(nèi)容： ? Amitabh#Shekhar#Aman#Rahul#Shahrukh#Salman#Yana#Lokesh

// 計算統(tǒng)計實例：
? ? /**
? ? ?* T reduce(T identity, BinaryOperator<T> accumulator);
? ? ?* identity：它允許用戶提供一個循環(huán)計算的初始值。
? ? ?* accumulator：計算的累加器，
? ? ?*/
? ? private static void testReduce() {
? ? ? ? //T reduce(T identity, BinaryOperator<T> accumulator);
? ? ? ? System.out.println("給定個初始值，求和");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (sum, item) -> sum + item));
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::sum));
?? ??? ?// 輸出：110

? ? ? ? System.out.println("給定個初始值，求min");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (min, item) -> Math.min(min, item)));
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::min));
? ? ? ? // 輸出：1

? ? ? ? System.out.println("給定個初始值，求max");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, (max, item) -> Math.max(max, item)));
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(100, Integer::max));
? ? ? ? // 輸出：100
?
? ? ? ? //Optional<T> reduce(BinaryOperator<T> accumulator);
? ? ? ? // 注意返回值，上面的返回是T,泛型，傳進(jìn)去啥類型，返回就是啥類型。
? ? ? ? // 下面的返回的則是Optional類型
? ? ? ? System.out.println("無初始值，求和");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::sum).orElse(0));?
? ? ? ? // 輸出：10
? ? ? ? Integer sum=Stream.of(1, 2, 3, 4).reduce((x,y)->x+y).get();
? ? ? ? System.out.println(sum); ?// 輸出：10
? ? ? ??
? ? ? ? System.out.println("無初始值，求max");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::max).orElse(0));
? ? ? ? // 輸出：4?
? ? ? ??
? ? ? ? System.out.println("無初始值，求min");
? ? ? ? System.out.println(Stream.of(1, 2, 3, 4).reduce(Integer::min).orElse(0));
? ? ? ? // 輸出：1
?
? ? }

// 按照默認(rèn)字典順序排序
stream.sorted();?
// 按照sortNo排序
stream.sorted((x,y)->Integer.compare(x.getSortNo(),y.getSortNo()));
?
2-4-1 函數(shù)式接口排序
// 正向排序（默認(rèn)）
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId));
// 逆向排序
pendingPeriod.stream().sorted(Comparator.comparingInt(ReservoirPeriodResult::getId).reversed());
?
2-4-2 LocalDate 和 LocalDateTime 排序
// 準(zhǔn)備測試數(shù)據(jù)
Stream<DateModel> stream = Stream.of(new DateModel(LocalDate.of(2020, 1, 1))
, new DateModel(LocalDate.of(2021, 1, 1)), new DateModel(LocalDate.of(2022, 1, 1)));

// 正向排序（默認(rèn)）
stream.sorted(Comparator.comparing(DateModel::getLocalDate))
.forEach(System.out::println);
// 逆向排序
stream.sorted(Comparator.comparing(DateModel::getLocalDate).reversed())
.forEach(System.out::println);

// 匹配和聚合
allmatch，noneMatch，anyMatch用于對集合中對象的某一個屬性值是否存在判斷。
?? ?allMatch全部符合該條件返回true，
?? ?noneMatch全部不符合該斷言返回true
?? ?anyMatch 任意一個元素符合該斷言返回true
// 實例：
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
boolean allMatch = list.stream().allMatch(e -> e > 10); //false
boolean noneMatch = list.stream().noneMatch(e -> e > 10); //true
boolean anyMatch = list.stream().anyMatch(e -> e > 4); //true

// 其他一些方法
findFirst：返回流中第一個元素
?? ??? ?String firstMatchedName = memberNames.stream()
?? ? ? ? ? ? ? ?.filter((s) -> s.startsWith("L"))
?? ? ? ? ? ? ? ?.findFirst().get();
findAny：返回流中的任意元素
count：返回流中元素的總個數(shù)
?? ?long totalMatched = memberNames.stream()
?? ? ? ?.filter((s) -> s.startsWith("A"))
?? ? ? ?.count();
max：返回流中元素最大值
min：返回流中元素最小值

// 默認(rèn)返回的類型為ArrayList，可通過Collectors.toCollection(LinkedList::new)
//?? ??? ?顯示指明使用其它數(shù)據(jù)結(jié)構(gòu)作為返回值容器。
List<String> collect = stream.collect(Collectors.toList());

// 由集合創(chuàng)建流的收集需注意：僅僅修改流字段中的內(nèi)容，沒有返回新類型，
//?? ??? ?如下操作直接修改原始集合，無需處理返回值。
userVos.stream().map(e -> e.setDeptName(hashMap.get(e.getDeptId())))
.collect(Collectors.toList());

// 收集偶數(shù)集合的實例：
List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
? ? list.add(i);
}
Stream<Integer> stream = list.stream();
List<Integer> evenNumbersList = stream.filter(i -> i%2 == 0)
? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?.collect(Collectors.toList());
System.out.print(evenNumbersList);

// list 為 {1,2,3,.....100}
Stream<Integer> stream = list.stream();
Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);

// 默認(rèn)返回類型為HashSet，可通過Collectors.toCollection(TreeSet::new)
//        顯示指明使用其它數(shù)據(jù)結(jié)構(gòu)作為返回值容器。
Set<String> collect = stream.collect(Collectors.toSet());

//?? ?默認(rèn)返回類型為HashMap，可通過Collectors.toCollection(LinkedHashMap::new)
//?? ??? ?顯示指明使用其它數(shù)據(jù)結(jié)構(gòu)作為返回值容器

// 測試實體類
@Data
public class Entity {
? ? private Integer id;
? ? private String name;
}

// 模擬從數(shù)據(jù)庫中查詢批量的數(shù)據(jù)
List<Entity> entityList = Stream.of(new Entity(1,"A"),?
new Entity(2,"B"), new Entity(3,"C")).collect(Collectors.toList());

// 將集合數(shù)據(jù)轉(zhuǎn)化成id與name的Map
Map<Integer, String> hashMap = entityList.stream()
.collect(Collectors.toMap(Entity::getId, Entity::getName));

// 默認(rèn)使用List作為分組后承載容器
Map<Integer, List<XUser>> hashMap =?
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId));
?
// 顯示指明使用List作為分組后承載容器
Map<Integer, List<XUser>> hashMap =?
xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId, Collectors.toList()));

// 映射后再分組
Map<Integer, List<String>> hashMap = xUsers.stream().collect(Collectors.groupingBy(XUser::getDeptId,Collectors.mapping(XUser::getUserName,Collectors.toList())));

/**
?* 將單個對象轉(zhuǎn)化為集合
?*
?* @param t ? 對象實例
?* @param <T> 對象類型
?* @param <C> 集合類型
?* @return 包含對象的集合實例
?*/
public static <T, C extends Collection<T>> Collection<T> toCollection(T t) {
? ? return toCollection(t, ArrayList::new);
}

/**
?* 用戶自定義返回的集合實例類型: ?將單個對象轉(zhuǎn)化為集合
?*
?* @param t ? ? ? ?對象實例
?* @param supplier 集合工廠
?* @param <T> ? ? ?對象類型
?* @param <C> ? ? ?集合類型
?* @return 包含對象的集合實例
?*/
public static <T, C extends Collection<T>> Collection<T> toCollection(T t, Supplier<C> supplier) {
? ? return Stream.of(t).collect(Collectors.toCollection(supplier));
}

/**
?* 取出集合中第一個元素
?*
?* @param collection 集合實例
?* @param <E> ? ? ? ?集合中元素類型
?* @return 泛型類型
?*/
public static <E> E toObject(Collection<E> collection) {
? ? // 處理集合空指針異常
? ? Collection<E> coll = Optional.ofNullable(collection).orElseGet(ArrayList::new);
? ? // 此處可以對流進(jìn)行排序，然后取出第一個元素
? ? return coll.stream().findFirst().orElse(null);
}

List<Integer> list = new ArrayList<Integer>();
for(int i = 1; i< 10; i++){
? ? list.add(i);
}
Stream<Integer> stream = list.parallelStream(); ? ?// 創(chuàng)建并發(fā)流

Integer[] evenNumbersArr = stream.filter(i -> i%2 == 0).toArray(Integer[]::new);
System.out.print(evenNumbersArr); ? // 打印出的偶數(shù)為無規(guī)則排序的