STREAM:

是資料渠道，用於操作資料來源（集合、陣列等）所生成的元素序列。 “集合講的是資料，流講的是計算！”

注意：
①Stream 自己不會儲存元素。
②Stream 不會改變源物件。相反，他們會返回一個持有結果的新Stream。

③Stream 操作是延遲執行的。這意味著他們會等到需要結果的時候才執行。

建立流：

//1. Collection 提供了兩個方法  stream() 與 parallelStream()
List<String> list = new ArrayList<>();
Stream<String> stream = list.stream(); //獲取一個順序流
Stream<String> parallelStream = list.parallelStream(); //獲取一個並行流

//2. 通過 Arrays 中的 stream() 獲取一個數組流
Integer[] nums = new Integer[10];
Stream<Integer> stream1 = Arrays.stream(nums);
		
//3. 通過 Stream 類中靜態方法 of()
Stream<Integer> stream2 = Stream.of(1,2,3,4,5,6);
		
//4. 建立無限流
//迭代
Stream<Integer> stream3 = Stream.iterate(0, (x) -> x + 2).limit(10);
		
//生成
Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
		

中間操作：

多箇中間操作可以連線起來形成一個流水線，除非流水 線上觸發終止操作，否則中間操作不會執行任何的處理！ 而在終止操作時一次性全部處理，稱為“惰性求值”。

filter——接收 Lambda ， 從流中排除某些元素。
limit——截斷流，使其元素不超過給定數量。
skip(n) —— 跳過元素，返回一個扔掉了前 n 個元素的流。若流中元素不足 n 個，則返回一個空流。與 limit(n) 互補
distinct——篩選，通過流所生成元素的 hashCode() 和 equals() 去除重複元素

//所有的中間操作不會做任何的處理
Stream<Employee> stream = emps.stream()
			.filter((e) -> {
				System.out.println("測試中間操作");
				return e.getAge() <= 35;
			});	

		emps.stream()
			.filter((e) -> {
				System.out.println("短路！"); // &&  ||
				return e.getSalary() >= 5000;
			}).limit(3)
		
	
		emps.parallelStream()
			.filter((e) -> e.getSalary() >= 5000)
			.skip(2)
		
	
	
		emps.stream()
			.distinct()
			.forEach(System.out::println);
	

對映
map——接收 Lambda ， 將元素轉換成其他形式或提取資訊。接收一個函式作為引數，該函式會被應用到每個元素上，並將其對映成一個新的元素。
flatMap——接收一個函式作為引數，將流中的每個值都換成另一個流，然後把所有流連線成一個流

Stream<String> str = emps.stream()
			.map((e) -> e.getName());
		
		
List<String> strList = Arrays.asList("aaa", "bbb", "ccc", "ddd", "eee");
		
Stream<String> stream = strList.stream()
			   .map(String::toUpperCase);
		
		
Stream<Stream<Character>> stream2 = strList.stream()
			   .map(TestStreamAPI1::filterCharacter);
		
==========================================

Stream<Character> stream3 = strList.stream()
			   .flatMap(TestStreamAPI1::filterCharacter);
		

public static Stream<Character> filterCharacter(String str){
		List<Character> list = new ArrayList<>();
		
		for (Character ch : str.toCharArray()) {
			list.add(ch);
		}
		
		return list.stream();
	}

終止操作：

終端操作會從流的流水線生成結果。其結果可以是任何不是流的 值，例如：List、Integer，甚至是 void 。

allMatch——檢查是否匹配所有元素
anyMatch——檢查是否至少匹配一個元素
noneMatch——檢查是否沒有匹配的元素
findFirst——返回第一個元素
findAny——返回當前流中的任意元素
count——返回流中元素的總個數
max——返回流中最大值
min——返回流中最小值

boolean bl = emps.stream()
			.allMatch((e) -> e.getStatus().equals(Status.BUSY));
			
			
boolean bl1 = emps.stream()
			.anyMatch((e) -> e.getStatus().equals(Status.BUSY));
						
			
boolean bl2 = emps.stream()
			.noneMatch((e) -> e.getStatus().equals(Status.BUSY));

Optional<Employee> op = emps.stream()
			.sorted((e1, e2) -> Double.compare(e1.getSalary(), 
                       e2.getSalary()))
			.findFirst();


Optional<Employee> op2 = emps.parallelStream()
			.filter((e) -> e.getStatus().equals(Status.FREE))
			.findAny();


long count = emps.stream()
			.filter((e) -> e.getStatus().equals(Status.FREE))
			 .count();

Optional<Double> op = emps.stream()
			.map(Employee::getSalary)
			.max(Double::compare);


Optional<Employee> op2 = emps.stream()
			.min((e1, e2) -> Double.compare(e1.getSalary(), 
                        e2.getSalary()));

歸約
reduce(T identity, BinaryOperator) / reduce(BinaryOperator) ——可以將流中元素反覆結合起來，得到一個值。

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10);
		
Integer sum = list.stream()
		.reduce(0, (x, y) -> x + y);
	
		
Optional<Double> op = emps.stream()
			.map(Employee::getSalary)
			.reduce(Double::sum);


//搜尋名字中 “六” 出現的次數
Optional<Integer> sum = emps.stream()
			.map(Employee::getName)
			.flatMap(TestStreamAPI1::filterCharacter)
			.map((ch) -> {
				if(ch.equals('六'))
					return 1;
				else 
					return 0;
			}).reduce(Integer::sum);

collect——將流轉換為其他形式。接收一個 Collector介面的實現，用於給Stream中元素做彙總的方法

//把流中元素收集到List
List<String> list = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toList());
//把流中元素收集到Set		
Set<String> set = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toSet());
		
HashSet<String> hs = emps.stream()
			.map(Employee::getName)
			.collect(Collectors.toCollection(HashSet::new));
		
Optional<Double> max = emps.stream()
			.map(Employee::getSalary)
			.collect(Collectors.maxBy(Double::compare));
		
		
Optional<Employee> op = emps.stream()
			.collect(Collectors.minBy((e1, e2) -> 
                       Double.compare(e1.getSalary(), e2.getSalary())));
					
Double sum = emps.stream()
			.collect(Collectors.summingDouble(Employee::getSalary));
				
Double avg = emps.stream()
			.collect(Collectors.averagingDouble(Employee::getSalary));
				
Long count = emps.stream()
			.collect(Collectors.counting());
		
//收集流中Double屬性的統計值 
DoubleSummaryStatistics dss = emps.stream() .collect(Collectors.summarizingDouble(Employee::getSalary));