java8-9-Stream 的中間操作

 

 

Stream 的中間操作

 

filter 過濾 排除元素   

 filter(T -> boolean)

保留 boolean 為 true 的元素

 

limit 截斷 取得多少個結果

limit(long n)

返回前 n 個元素

 

 skip 跳過幾個結果  數量不足 返回空

skip(long n)

去除前 n 個元素

 

 

distinct 去重復

distinct()

去除重復元素，這個方法是通過類的 equals 方法來判斷兩個元素是否相等的

 

 

                    map 根據Lambda體中的操作 提取元素到 流中

                             若Lambdda體操作返回Stream()流

                             結果會是兩層流    需要遍歷兩次

 

flapMap  平鋪map  將元素提取到一個流中

 

 

sorted() / sorted((T, T) -> int)

如果流中的元素的類實現了 Comparable 接口，即有自己的排序規則，那么可以直接調用 sorted() 方法對元素進行排序，如 Stream

反之, 需要調用 sorted((T, T) -> int) 實現 Comparator 接口

1.自然排序  java.lang.Comparable

 

 

2.自然排序 java.util.Comparator

 

 

 

 

 

package com.wf.zhang.java8.stream;

import com.wf.zhang.java8.lamdba.Employee;
import org.junit.Test;

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

public class TestStream2 {

    //准備數據
    List<Employee> list = Arrays.asList(
            new Employee("張飛", 18, 5000.00),
            new Employee("趙雲", 28, 6666.66),
            new Employee("關羽", 38, 7777.77),
            new Employee("曹阿蠻", 29, 7777.77),
            new Employee("劉備", 48, 10000.88),
            new Employee("劉備", 48, 10000.88),
            new Employee("劉備", 48, 10000.88),
            new Employee("劉備", 48, 10000.88),
            new Employee("諸葛亮", 26, 10000.88)
    );


    /**
     * stream 中間操作  篩選
     * <p>
     * filter  過濾   排除元素
     * limit   截斷   取得幾個結果
     * skip    跳過幾個結果  若是數量不足 返回空
     * distinct  去重復 必須重寫 hashCode() 和 equals()
     */
    @Test
    public void test01() {
        list.stream().filter((t) -> t.getSalary() > 5000)
                .forEach(System.out::println);
    }

    @Test
    public void test02() {
        list.stream().filter((t) -> t.getAge() > 20)
                .limit(1)
                .forEach(System.out::println);
    }

    @Test
    public void test03() {
        list.stream().filter((t) -> t.getSalary() > 5000)
                .skip(2)
                .forEach(System.out::println);
    }

    @Test
    public void test04() {
        list.stream().filter((t) -> t.getSalary() > 5000)
                .skip(2)
                .distinct()
                .forEach(System.out::println);
    }

    /**
     * stream 中間操作  映射
     * <p>
     * map 根據Lambda體中的操作  提取元素  到流中
     * 若Lambda體操作中返回stream()流  會是兩層stream()流
     * 需要遍歷兩次
     * <p>
     * flatMap 將元素 添加到 新的一個流中
     */
    @Test
    public void test05() {

        List<String> stringList = Arrays.asList("aaa", "bbb", "ccc");
        stringList.stream()
                .map((s) -> s.toUpperCase())
                .forEach(System.out::println);

        System.out.println("----------------------------");

        //Employee的集合按照名字提取出來
        list.stream()
                .map(Employee::getName)
                .forEach(System.out::println);


        System.out.println("----------------------------");


        //將stringList 調用 filterchar方法
        Stream<Stream<Character>> stream = stringList.stream()
                .map(TestStream2::filterchar);
        //map
        // 兩層 stream 流遍歷
        stream.forEach((sm) -> {
            sm.forEach(System.out::println);
        });

        System.out.println("+++++++++++++++++++++++++++++++++++++");


        Stream<Character> characterStream = stringList.stream()
                .flatMap(TestStream2::filterchar);
        //flatMap 一層遍歷
        characterStream.forEach(System.out::println);
    }

    /**
     * 定義一個方法 將字符串轉成字符數組 提取一個個字符的 Stream流
     *
     * @param str
     * @return
     */
    public static Stream<Character> filterchar(String str) {
        List<Character> charlist = new ArrayList<>();
        for (Character ch : str.toCharArray()) {
            charlist.add(ch);
        }
        return charlist.stream();
    }

    /***
     * stream 中間操作   排序

     *                         1 自然排序：java.lang.Comparable  Comparable接口   compareTo()方法
     *
     *                        2 定制排序：java.util.Compartor   Comparator接口   compare()方法
     */
    @Test
    public void test0e6() {

        List<String> stringList = Arrays.asList("fff","aaa", "bbb", "ccc");
        //1 自然排序
                 stringList.stream()
                           .sorted()
                           .forEach(System.out::println);

        System.out.println("---------------------------------");

        //2 定制排序
                 list.stream()
                     .sorted((x, y) ->{
                         if (Objects.equals(x.getAge(),y.getAge())) {
                             return x.getName().compareTo(y.getName());
                         }else  {
                               return Integer.compare(x.getAge(),y.getAge());
                         }
                     }).forEach(System.out::println);
    }


}