Java8特性: Stream流

Java8特性: Stream

1.1介紹

Java8中的Stream 對於集合的處理十分方便，使用起來也像德芙般絲滑~
一.對於元素的匹配
使用Predicate （斷言，給一個參數T，返回boolean類型的結果）作爲參數
allMatch 所有元素匹配
anyMatch 任一元素匹配
二.循環遍歷，對每一個元素進行處理
使用了Consumer,重寫了其中的accept(T t)方法
三.filter
使用Predicate （斷言，給一個參數T，返回boolean類型的結果）作爲參數
將集合中不符合條件的元素過濾
四.map
每一個元素做指定操作，返回指定類型
使用Function 重寫了apply(T t)方法
五.sorted
使用Comparator，重寫compare(T o1, T o2)方法進行排序
這裏是使用Long的compareTo
六.統計，規約，字符串拼接
···

1.2使用案例

public class StreamTest {
    /**
     * 對於元素的匹配
     * 使用Predicate （斷言，給一個參數T，返回boolean類型的結果）作爲參數
     * allMatch 所有元素匹配
     * anyMatch 任一元素匹配
     */
    @Test
    public void match() {
        List list = getList();
        System.out.println(list.stream().allMatch(o -> (Long) o > 10));
        System.out.println(list.stream().anyMatch(o -> (Long) o > 10));
    }

    /**
     * 循環遍歷，對每一個元素進行處理
     * 使用了Consumer,重寫了其中的accept(T t)方法
     */
    @Test
    public void forEach() {
        List list = getList();
        Long a = 1L;
        list.stream().forEach(o -> {
            if (0 < (Long) o) {
                o = Long.valueOf((Long) o + a);
                System.out.println((Long) o);
            }
        });
    }
    
    /**
     * filter
     * 使用Predicate （斷言，給一個參數T，返回boolean類型的結果）作爲參數
     * 將集合中不符合條件的元素過濾
     */
    @Test
    public void filter() {
        List<Long> list = getList();
        List<Long> collect = list.stream().filter(o -> o > 10).collect(Collectors.toList());
        collect.forEach(a -> System.out.println(a));
    }

    /**
     * map
     * 每一個元素做指定操作，返回指定類型
     * 使用Function  重寫了apply(T t)方法
     */
    @Test
    public void map() {
        List<Long> list = getList();
        List<Long> collect = list.stream().map(a -> a * a).collect(Collectors.toList());
        collect.forEach(a -> System.out.println(a));
    }
    
    /**
     * sorted
     * 使用Comparator，重寫compare(T o1, T o2)方法進行排序
     * 這裏是使用Long的compareTo
     */
    @Test
    public void sorted() {
        List<Long> list = getList();
        List<Long> collectLong = list.stream().sorted(Long::compareTo)
                .collect(Collectors.toList());
        collectLong.forEach(a -> System.out.println(a));
    }

    /**
     * 排序，自定義排序方法
     */
    @Test
    public void sortedDesc() {
        List<Long> list = getList();
        list.stream().sorted(new Comparator<Long>() {
            @Override
            public int compare(Long o1, Long o2) {
                return 0;
            }
        });
        List<Long> collect = list.stream().sorted((x, y) -> (y < x) ? -1 : ((x == y) ? 0 : 1))
                .collect(Collectors.toList());
        collect.forEach(a -> System.out.println(a));
    }
    
    /**
     * 拼接字符串
     */
    @Test
    public void joining() {
        List<Long> list = getList();
        String collect = list.stream().sorted(Long::compareTo).map(a -> a.toString()).collect(Collectors.joining(","));
        System.out.println(collect);
    }

    /**
     * 統計
     * 最大值，最小值，平均值，數目等一些方法
     */
    @Test
    public void stats() {
        List<Long> list = getList();
        double average = list.stream().mapToLong(a -> a).summaryStatistics().getAverage();
        System.out.println(average);
        double max = list.stream().mapToLong(a -> a).summaryStatistics().getMax();
        System.out.println(max);
        double count = list.stream().mapToLong(a -> a).summaryStatistics().getCount();
        System.out.println(count);
    }
    
    /**
     * 規約
     */
    @Test
    public void reduce() {
        Stream<String> s = Stream.of("test", "t1", "t2", "t3", "t4");
        System.out.println(s.reduce("[value]", (s1, s2) -> s1.concat(s2)));
    }

    /**
     * 並行，規約
     */
    @Test
    public void parallelReduce() {
        /**
         *  必須是在並行的情況下
         * (1+4)*(2+4)*(3+4)
         */
        System.out.println(Stream.of(1, 2, 3).parallel().
                reduce(4, (integer, integer2) -> integer + integer2, (integer, integer2) -> integer * integer2));

    }

    public List getList() {
        ArrayList<Long> arrayList = new ArrayList<>();
        arrayList.add(5L);
        arrayList.add(3L);
        arrayList.add(88L);
        arrayList.add(46L);
        arrayList.add(99L);
        return arrayList;
    }