Java8 Stream流式操作接口详解

接口就是stream支持的所有方法了。
我们挨个看用法

    Stream filter(Predicate predicate);

传入predict接口，泛型要求 Predicate是当前流中类型，或者是其父类

public interface Predicate {


    boolean test(T t);

    default Predicate and(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) && other.test(t);
    }

   
    default Predicate negate() {
        return (t) -> !test(t);
    }

    default Predicate or(Predicate other) {
        Objects.requireNonNull(other);
        return (t) -> test(t) || other.test(t);
    }


    static  Predicate isEqual(Object targetRef) {
        return (null == targetRef)
                ? Objects::isNull
                : object -> targetRef.equals(object);
    }
}

看到这个接口就可以使用花样用法了。

  List names = Arrays.asList("Adam", "Alexander", "John", "Tom");
   List result = names.stream()
     .filter(name -> name.startsWith("A"))
     .collect(Collectors.toList());

相当于实现了test方法，根据lamda条件返回true或者false

两个条件都要满足

@Test
public void whenFilterListWithCombinedPredicatesUsingAnd_thenSuccess(){
    Predicate predicate1 =  str -> str.startsWith("A");
    Predicate predicate2 =  str -> str.length() < 5;
   
    List result = names.stream()
      .filter(predicate1.and(predicate2))
      .collect(Collectors.toList());
         
    assertEquals(1, result.size());
    assertThat(result, contains("Adam"));
}

满足其中一个即可

@Test
public void whenFilterListWithCombinedPredicatesUsingOr_thenSuccess(){
    Predicate predicate1 =  str -> str.startsWith("J");
    Predicate predicate2 =  str -> str.length() < 4;
     
    List result = names.stream()
      .filter(predicate1.or(predicate2))
      .collect(Collectors.toList());
     
    assertEquals(2, result.size());
    assertThat(result, contains("John","Tom"));
}

将此条件取反

@Test
public void whenFilterListWithCombinedPredicatesUsingOrAndNegate_thenSuccess(){
    Predicate predicate1 =  str -> str.startsWith("J");
    Predicate predicate2 =  str -> str.length() < 4;
     
    List result = names.stream()
      .filter(predicate1.or(predicate2.negate()))
      .collect(Collectors.toList());
     
    assertEquals(3, result.size());
    assertThat(result, contains("Adam","Alexander","John"));
}

   Stream map(Function mapper);

可以看出来
可以看出来 map是将当前类型的流转换成另一种类型

@FunctionalInterface
public interface Function {


    R apply(T t);


    default  Function compose(Function before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }


    default  Function andThen(Function after) {
        Objects.requireNonNull(after);
        return (T t) -> after.apply(apply(t));
    }

    static  Function identity() {
        return t -> t;
    }
}

也就是直接实现lamda方法

 list.stream().map(it-> Arrays.stream(it.split(""))).forEach(
                it->it.forEach(
                        s-> System.out.println(s)
                )
        );

  Function function = ErpDecorationCostClassification::getSecondClassificationNo;
                Function function1 = Integer::parseInt;

                List list = costClassificationList.stream().map(function.andThen(function1)).collect(Collectors.toList());

一个function作为另一个funcion的执行入参，
该方法同样用于“先做什么，再做什么”的场景
compose：入参处理当前返回值
andThen： 入参作为返回的类型
这里讲下双冒号::的用法
把上面两个lamda等同改写下

  Function function2 = it->it.getThirdClassificationNo();
                Function function1 = it->Integer.valueOf(it);

如果是非静态方法使用::形式。相当于lamda it->getThirdClassificationNo
如果是静态方法使用::形式。相当于lamda it->Integer.valueOf(it);

     Stream flatMap(Function> mapper);

与mao不同，
Function返回值R要求是Stream类型的

Streamzhe

这里有一个有意思的现象，入参要求为指定类型的父类，反参要求为为指定类型的子类
所以一般用于，将集合中的元素的集合返回

将字符串分割成字符

        List list = Arrays.asList("tom", "jame", "jerry", "hello");
        list.stream().flatMap(it-> Arrays.stream(it.split(""))).forEach(it-> System.out.println(it));
        list.stream().map(it-> Arrays.stream(it.split(""))).forEach(
                it->it.forEach(
                        s-> System.out.println(s)
                )
        );

获取Map 中的list整合成一个list

Map> collect = dictionaryList.stream().collect(Collectors.groupingBy(ErpDictionary::getDataKey));
                List dictionaries = collect.values().stream().flatMap(it->it.stream()).collect(Collectors.toList());
                

  * Returns a stream consisting of the distinct elements (according to
     * {@link Object#equals(Object)}) of this stream.

看注释就是用equals判断，去除相同的，很简单

    Stream sorted(Comparator comparator);

    int compare(T o1, T o2);

int compare(T o1, T o2) 是“比较o1和o2的大小”，其中o1指的就是第一个要比较的对象， o2指的就是第二要比的对象。 比较之后会根据大小返回值。 返回“负数”， 意味着“o1比o2小”；返回“零”，意味着“o1等于o2”；返回“正数”，意味着“o1大于o2。
最终的结果按照"从小到大"

顺序反转

  List list = Arrays.asList("tom", "jame", "jerry", "hello");
        Comparator stringComparator = (o1,o2)->o1.compareTo(o2);
        list.stream().sorted(stringComparator.reversed()).collect(Collectors.toList());

public static  Comparator reverseOrder(Comparator cmp) {
        if (cmp == null)
            return reverseOrder();

        if (cmp instanceof ReverseComparator2)
            return ((ReverseComparator2)cmp).cmp;

        return new ReverseComparator2<>(cmp);
    }

private static class ReverseComparator2 implements Comparator,
        Serializable
    {
        private static final long serialVersionUID = 4374092139857L;

        
        final Comparator cmp;

        ReverseComparator2(Comparator cmp) {
            assert cmp != null;
            this.cmp = cmp;
        }

        public int compare(T t1, T t2) {
            return cmp.compare(t2, t1);
        }

        public boolean equals(Object o) {
            return (o == this) ||
                (o instanceof ReverseComparator2 &&
                 cmp.equals(((ReverseComparator2)o).cmp));
        }

        public int hashCode() {
            return cmp.hashCode() ^ Integer.MIN_VALUE;
        }

        @Override
        public Comparator reversed() {
            return cmp;
        }
    }

在之前定的cmp上再包一层，调换入参位置，实现反转

 default Comparator thenComparing(Comparator other) {
        Objects.requireNonNull(other);
        return (Comparator & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }

 List list = Arrays.asList("tom", "jame", "jerry", "hello");
        Comparator stringComparator = (o1,o2)->o1.compareTo(o2);
        stringComparator.thenComparing((o1, o2) -> o1.hashCode() - o2.hashCode());

也很简单，就是创建一个Comparator
如果当前比较器比较结果为0.就再thenComparing中的比较器进行比较

default  Comparator thenComparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }

 List list = Arrays.asList("tom", "jame", "jerry", "hello");
        Comparator stringComparator = (o1,o2)->o1.compareTo(o2);
        stringComparator.thenComparing(it->it.length(),(o1,o2)->o1-o2);

 public static  Comparator comparing(
            Function keyExtractor,
            Comparator keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }

 final static class NullComparator implements Comparator, Serializable {
        private static final long serialVersionUID = -7569533591570686392L;
        private final boolean nullFirst;
        // if null, non-null Ts are considered equal
        private final Comparator real;

        @SuppressWarnings("unchecked")
        NullComparator(boolean nullFirst, Comparator real) {
            this.nullFirst = nullFirst;
            this.real = (Comparator) real;
        }

        @Override
        public int compare(T a, T b) {
            if (a == null) {
                return (b == null) ? 0 : (nullFirst ? -1 : 1);
            } else if (b == null) {
                return nullFirst ? 1: -1;
            } else {
                return (real == null) ? 0 : real.compare(a, b);
            }
        }

        @Override
        public Comparator thenComparing(Comparator other) {
            Objects.requireNonNull(other);
            return new NullComparator<>(nullFirst, real == null ? other : real.thenComparing(other));
        }

        @Override
        public Comparator reversed() {
            return new NullComparator<>(!nullFirst, real == null ? null : real.reversed());
        }
    }
}

    Stream peek(Consumer action);
    void forEach(Consumer action);

@FunctionalInterface
public interface Consumer {

  
    void accept(T t);

   
    default Consumer andThen(Consumer after) {
        Objects.requireNonNull(after);
        return (T t) -> { accept(t); after.accept(t); };
    }
}

 List list = Arrays.asList("tom", "jame", "jerry", "hello");
        list.stream().forEach(it-> System.out.println(it));

        List list = Arrays.asList("tom", "jame", "jerry", "hello");
        Consumer consumer1 = it -> System.out.println(it+"Y");
        Consumer consumer2 = it -> System.out.println(it);
        list.stream().forEach(consumer1.andThen(consumer2));

tomY
tom
jameY
jame
jerryY
jerry
helloY
hello