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);
    }


}