JAVA8你只需要知道這些（4）

     

    java8的Stream寫法，讓你告別For循環，快點學習起來吧！讓你的代碼更加的簡潔！非常喜歡啊！！！

package Stream;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestStream {
    private List<String> stringList = new ArrayList<String>();
    /**
     * 初始化字符串列表
     */
    private void initStringList() {
        stringList.add("zzz1");
        stringList.add("aaa2");
        stringList.add("bbb2");
        stringList.add("fff1");
        stringList.add("fff2");
        stringList.add("aaa1");
        stringList.add("bbb1");
        stringList.add("zzz2");
    }

    /**
     * Filter接受一個predicate接口類型的變量，並將所有流對象中的元素進行過濾。該操作是一箇中間操作，
     * 因此它允許我們在返回結果的基礎上再進行其他的流操作
     * （forEach）。ForEach接受一個function接口類型的變量，用來執行對每一個元素的操作
     * 。ForEach是一箇中止操作。它不返回流，所以我們不能再調用其他的流操作
     */
    public void useStreamFilter() {
        // stream()方法是Collection接口的一個默認方法
        // Stream<T> filter(Predicate<? super T>
        // predicate);filter方法參數是一個Predicate函數式接口並繼續返回Stream接口
        // void forEach(Consumer<? super T> action);foreach方法參數是一個Consumer函數式接口

        // 解釋:從字符串序列中過濾出以字符a開頭的字符串並迭代打印輸出
        stringList.stream().filter((s) -> s.startsWith("a")).forEach(System.out::println);
    }
    /**
     * Sorted是一箇中間操作，能夠返回一個排過序的流對象的視圖。流對象中的元素會默認按照自然順序進行排序，
     * 除非你自己指定一個Comparator接口來改變排序規則.
     *
     * <p>
     * 一定要記住，sorted只是創建一個流對象排序的視圖，而不會改變原來集合中元素的順序。原來string集合中的元素順序是沒有改變的
     */
    public void useStreamSort() {
        // Stream<T> sorted();返回Stream接口
        // 另外還有一個 Stream<T> sorted(Comparator<? super T>
        // comparator);帶Comparator接口的參數
        stringList.stream().sorted().filter((s) -> s.startsWith("a")).forEach(System.out::println);

        // 輸出原始集合元素，sorted只是創建排序視圖，不影響原來集合順序
        stringList.stream().forEach(System.out::println);
    }
    /**
     * map是一個對於流對象的中間操作，通過給定的方法，它能夠把流對象中的每一個元素對應到另外一個對象上。
     * 下面的例子就演示瞭如何把每個string都轉換成大寫的string.
     * 不但如此，你還可以把每一種對象映射成爲其他類型。對於帶泛型結果的流對象，具體的類型還要由傳遞給map的泛型方法來決定。
     */
    public void useStreamMap() {
        // <R> Stream<R> map(Function<? super T, ? extends R> mapper);
        // map方法參數爲Function函數式接口(R_String,T_String).

        // 解釋:將集合元素轉爲大寫(每個元素映射到大寫)->降序排序->迭代輸出
        // 不影響原來集合
        stringList.stream().map(String::toUpperCase).sorted((a, b) -> b.compareTo(a)).forEach(System.out::println);
    }
    /**
     * 匹配操作有多種不同的類型，都是用來判斷某一種規則是否與流對象相互吻合的。所有的匹配操作都是終結操作，只返回一個boolean類型的結果
     */
    public void useStreamMatch() {
        // boolean anyMatch(Predicate<? super T> predicate);參數爲Predicate函數式接口
        // 解釋:集合中是否有任一元素匹配以'a'開頭
        boolean anyStartsWithA = stringList.stream().anyMatch((s) -> s.startsWith("a"));
        System.out.println(anyStartsWithA);

        // boolean allMatch(Predicate<? super T> predicate);
        // 解釋:集合中是否所有元素匹配以'a'開頭
        boolean allStartsWithA = stringList.stream().allMatch((s) -> s.startsWith("a"));
        System.out.println(allStartsWithA);

        // boolean noneMatch(Predicate<? super T> predicate);
        // 解釋:集合中是否沒有元素匹配以'd'開頭
        boolean nonStartsWithD = stringList.stream().noneMatch((s) -> s.startsWith("d"));
        System.out.println(nonStartsWithD);
    }

    /**
     * Count是一個終結操作，它的作用是返回一個數值，用來標識當前流對象中包含的元素數量
     */
    public void useStreamCount() {
        // long count();
        // 解釋:返回集合中以'a'開頭元素的數目
        long startsWithACount = stringList.stream().filter((s) -> s.startsWith("a")).count();
        System.out.println(startsWithACount);

        System.out.println(stringList.stream().count());
    }
    /**
     * 該操作是一個終結操作，它能夠通過某一個方法，對元素進行削減操作。該操作的結果會放在一個Optional變量裏返回。
     */
    public void useStreamReduce() {
        // Optional<T> reduce(BinaryOperator<T> accumulator);
        // @FunctionalInterface public interface BinaryOperator<T> extends
        // BiFunction<T,T,T> {

        // @FunctionalInterface public interface BiFunction<T, U, R> { R apply(T
        // t, U u);
        Optional<String> reduced = stringList.stream().sorted().reduce((s1, s2) -> s1 + "#" + s2);

        // 解釋:集合元素排序後->reduce(削減 )->將元素以#連接->生成Optional對象(其get方法返回#拼接後的值)
        reduced.ifPresent(System.out::println);
        System.out.println(reduced.get());
    }
    /**
     * 使用並行流
     * <p>
     * 流操作可以是順序的，也可以是並行的。順序操作通過單線程執行，而並行操作則通過多線程執行. 可使用並行流進行操作來提高運行效率
     */
    public void useParallelStreams() {
        // 初始化一個字符串集合
        int max = 1000000;
        List<String> values = new ArrayList<>();

        for (int i = 0; i < max; i++) {
            UUID uuid = UUID.randomUUID();
            values.add(uuid.toString());
        }

        // 使用順序流排序

        long sequenceT0 = System.nanoTime();
        values.stream().sorted();
        long sequenceT1 = System.nanoTime();

        // 輸出:sequential sort took: 51921 ms.
        System.out.format("sequential sort took: %d ms.", sequenceT1 - sequenceT0).println();

        // 使用並行流排序
        long parallelT0 = System.nanoTime();
        // default Stream<E> parallelStream() {
        // parallelStream爲Collection接口的一個默認方法
        values.parallelStream().sorted();
        long parallelT1 = System.nanoTime();

        // 輸出:parallel sort took: 21432 ms.
        System.out.format("parallel sort took: %d ms.", parallelT1 - parallelT0).println();

        // 從輸出可以看出：並行排序快了一倍多
    }

    public void userCollectStream(){
        //將
        Stream<String> stream=Stream.of("a","b","c","d");
        List<String> list=stream.collect(Collectors.toList());
        list.forEach(str->System.out.println(str));
    }
    public static void main(String[] args) {
        TestStream example = new TestStream();

//        example.useStreamFilter();
//        example.useStreamMap();
//        example.useStreamMatch();
//        example.useStreamCount();
//        example.useStreamReduce();
//        example.useParallelStreams();
        example.userCollectStream();
    }
}