Stream流的常用方法

1、forEach

// forEach接收消費類型的函數式接口，為Stream流的最終方法，調用后不能再調用Stream流的其它方法了

// 若只有一個參數則可以省略()

// 參數的類型也可省略，java編譯器會自動推斷參數類型

// 若方法體只有一行代碼則可以省略{}

@Test
public void test1() {
    Stream<String> st = Stream.of("張三","李四","王五","趙六","田七");
    st.forEach((String name) -> {
        System.out.println(name);
    });
}

@Test
public void test2() {
    Stream<String> st = Stream.of("張三","李四","王五","趙六","田七");
    st.forEach(name -> System.out.println(name));
}

2、filter

// 過濾，延遲方法，接收判斷類型的函數式接口，產生新的子集流，調用后還可以繼續調用其它的Stream流方法

// 若寫了{}則必須用return返回結果

// 若省略了{}則不需要return返回結果

@Test
public void test1() {
    // 原始Stream流
    Stream<String> st1 = Stream.of("張三","張無忌","趙敏","張三豐","周芷若");
    // 過濾后會產生一個新的子集流
    Stream<String> st2 = st1.filter((String name) -> {
        return name.startsWith("張") && name.length() == 3;
    });
    st2.forEach(name -> System.out.println(name));
}

@Test
public void test2() {
    // 原始Stream流
    Stream<String> st1 = Stream.of("張三","張無忌","趙敏","張三豐","周芷若");
    // 過濾后會產生一個新的子集流
    Stream<String> st2 = st1.filter(name -> name.startsWith("張") && name.length() == 3);
    st2.forEach(name -> System.out.println(name));
}

3、map

// 延遲方法，操作Stream流數據中的每個元素，將Stream流映射到一個新的Stream流上

// 操作數據中的每個元素，改變該元素的值或者類型等等

@Test
public void test1() {
    Stream<String> st1 = Stream.of("a","b","c","d","e");
    // 操作數據中的每個元素，返回新的元素
    // 方法體只有一行時，可省略{}和return
    st1.map(str -> str += str.toUpperCase())
            .forEach(str -> System.out.println(str));
}

@Test
public void test2() {
    Stream<String> st1 = Stream.of("a","b","c","d","e");
    // 操作數據中的每個元素，返回新的元素
    // 方法體有{}時必須加上return
    st1.map(str -> {
        return str += str.toUpperCase();
    }).forEach(str -> System.out.println(str));
}

@Test
public void test3() {
    Stream<String> st1 = Stream.of("1","2","3","4","5");
    // 操作數據中的每個元素，將每個元素轉為Integer類型
    Stream<Integer> st2 = st1.map(str -> Integer.parseInt(str));
    st2.forEach(num -> System.out.println(num.getClass()));
}

4、count

// 最終方法，沒有參數，沒有方法體，屬於Stream流的最終方法，用於統計Stream流中的數據長度，返回long類型

@Test
public void test4() {
    // count方法屬於Stream流的最終方法，統計數據的長度，返回long類型
    Stream<String> st1 = Stream.of("1","2","3","4","5");
    long ct = st1.map(str -> Integer.parseInt(str))
            .filter(num -> num > 3)
            .count();
    System.out.println(ct);
}

5、limit

// 延遲方法，截取Stream流中的前幾個元素返回新的Stream流，入參為long類型，沒有方法體

// 若入參的值大於Stream流中的數據的長度則返回由原數據組成的新Stream流

@Test
public void test1() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    st1.limit(3).forEach(str -> System.out.println(str));
}

6、skip

// 延遲方法，入參為long類型，沒有方法體，跳過前一個Stream流的前幾個元素，得到由后面的元素組成的新Stream流

@Test
public void test2() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    st1.skip(2).forEach(str -> System.out.println(str));
}

// 若跳過的元素個數>=Stream流數據的長度則會得到一個元素個數為0的空流

@Test
public void test2() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    long ct = st1.skip(6).count();
    System.out.println(ct);
}

7、concat

// Stream的靜態方法，將多個Stream流的數據按入參順序合並為一個新的Stream流

@Test
public void test3() {
    Stream<String> st1 = Stream.of("aa","bb","cc","dd","ee");
    Stream<String> st2 = Stream.of("AA","BB","CC","DD","EE");
    Stream<String> st3 = Stream.concat(st1,st2);
    st3.forEach(s -> System.out.println(s));
}