java8 - 5

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Stream;

import org.junit.Test;

/*
 * 1、Stream API 的操做步驟：
 * 
 * 1. 建立 Stream
 * 
 * 2. 中間操做
 * 
 * 3. 終止操做(終端操做)
 */
public class TestStreamaAPI {
    
    //1. 建立 Stream
    @Test
    public void test1(){
        //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);
        stream3.forEach(System.out::println);
        
        //生成
        Stream<Double> stream4 = Stream.generate(Math::random).limit(2);
        stream4.forEach(System.out::println);
        
    }
    
    //2. 中間操做
    List<Employee> emps = Arrays.asList(
            new Employee(102, "李四", 59, 6666.66),
            new Employee(101, "張三", 18, 9999.99),
            new Employee(103, "王五", 28, 3333.33),
            new Employee(104, "趙六", 8, 7777.77),
            new Employee(104, "趙六", 8, 7777.77),
            new Employee(104, "趙六", 8, 7777.77),
            new Employee(105, "田七", 38, 5555.55)
    );
    
    /*
      篩選與切片
        filter——接收 Lambda ， 從流中排除某些元素。
        limit——截斷流，使其元素不超過給定數量。
        skip(n) —— 跳過元素，返回一個扔掉了前 n 個元素的流。若流中元素不足 n 個，則返回一個空流。與 limit(n) 互補
        distinct——篩選，經過流所生成元素的 hashCode() 和 equals() 去除重複元素
     */
    
    //內部迭代：迭代操做 Stream API 內部完成
    @Test
    public void test2(){
        //全部的中間操做不會作任何的處理
        Stream<Employee> stream = emps.stream()
            .filter((e) -> {
                System.out.println("測試中間操做");
                return e.getAge() <= 35;
            });
        
        //只有當作終止操做時，全部的中間操做會一次性的所有執行，稱爲「惰性求值」
        stream.forEach(System.out::println);
    }
    
    //外部迭代
    @Test
    public void test3(){
        Iterator<Employee> it = emps.iterator();
        
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
    
    @Test
    public void test4(){
        emps.stream()
            .filter((e) -> {
                System.out.println("短路！"); // &&  ||
                return e.getSalary() >= 5000;
            }).limit(3)
            .forEach(System.out::println);
    }
    
    @Test
    public void test5(){
        emps.parallelStream()
            .filter((e) -> e.getSalary() >= 5000)
            .skip(2)
            .forEach(System.out::println);
    }
    
    @Test
    public void test6(){
        emps.stream()
            .distinct()
            .forEach(System.out::println);
    }
}