Java高級特性1_流庫_初體驗

Java高級特性流庫_初體驗

面對結果編程

在編程裏, 有兩種編程方式, 一種是面對過程編程, 一種是面對結果編程. 二者區別以下

面向過程編程

面向過程編程須要編程程序讓程序依次執行獲得本身想要的結構

面向結果編程

流庫帶給咱們的好處就是咱們不須要知道過程, 只須要提供咱們的須要, 具體怎麼作由流庫內部實現

1. 迭代到流代碼演示

流庫正如其名所示, 它處理的是大量元素.

這裏能夠將流庫比做一個水管, 流庫中的許多函數比做水龍頭, 函數成立, 水龍頭便打開讓水流動, 函數不成立, 水龍頭關閉, 鎖住水.

public class FlowDemo2 {
    public static void main(String[] args) throws IOException {
        int count = 0;
//        讀取文本文件, 其中是一段文章
        String s = new String(Files.readAllBytes(Paths.get("src","a.txt")));
        String[] split = s.split("\\n");
//        面向過程編程 統計段落長度大於90的數量
        for (String s1 : split){
            if(s1.length() > 90) count++;
        }
        
//        面向結果編程 統計段落長度大於90的數量
        List<String> list = Arrays.asList(split);
        System.out.println(list.stream().filter(w -> w.length() > 90).count());
        
//        另外一種數組轉流的方式
//        Stream<String> stream = Arrays.stream(split);
//        System.out.println(stream);
//        System.out.println(stream.filter(w -> w.length() > 90)
//                .count());
//        System.out.println(count);
    }
}

結果一致, 都爲6.

2. 流的優勢

1. 更加簡潔明瞭
2. 可以鏈式操做( 每次返回的數據類型都是流 )
3. 流不會存儲元素, 節約內存
4. 流的操做不會修改數據源
5. 個人理解: 流是單向的, 只會單方向流動改變, 不會改變以前的狀態, 流動過了就過了, 不會再回來

3. 建立流的方式

根據流的長度能夠分爲無限流和有限長度的流

Java中有大量API能夠產生流, 假若有方法能夠返回大量數據, 那麼就能夠查查文檔看, 是否有轉換爲流的方法.

Stream接口生成有限長度的流的方式

//        第一種
//        Stream.of(可變長參數數組)
        int[] arr1 = {2, 34, 6, 8, 9, 19};
        int[] arr2 = {2, 4, 5};
        Stream<int[]> stream1 = Stream.of(arr1, arr2);
        System.out.println(stream1.getClass());

//        第二種
        int[] arr3 = {2, 34, 6, 8, 9, 19};
//        截取數組部分, 從1到2, 不包括結束
        IntStream stream = Arrays.stream(arr3, 1, 3);
        System.out.println(stream.sum());

//		  建立空流
		Stream.empty()

Stream接口生成無限流的方法

//        第三種, 建立無限流之generate
        Stream<Integer> generate = Stream.generate(() -> 1);
        generate.filter(w -> {
            System.out.println(w);
            return w>0;
        });

//        Stream.generate(參數爲一個函數, 返回值必須是一個數, 
//        該方法被不停調用並將返回值賦予流成爲水流中的一員)
        Stream<Double> generate1 = Stream.generate(Math::random);
//        必須有count, 不然在filter中的sout失效
        generate1.filter((w) -> {
            System.out.println(w);
            return w>0.5;
        }).count();

//        建立無限流之iterate
//		  Stream.iterate(種子參數, 迭代函數), 種子參數表示迭代時的初始值, 迭代函數表示每次
//		  執行函數修改上一次迭代函數返回的值, 再做爲本次函數的返回值返回,用下面的例子
//		  種子爲0, 每次基於上次的結果值加1, 流中存儲的數據爲0, 1, 2, 3, 4 ...
//        問題: 每次中止運行後,再次運行的迭代函數是基於上次結束的返回值, 難道是有緩存, 
// 		  	中止時打印6002, 再次運行時從6003開始
        Stream<Integer> iterate = Stream.iterate(0, n -> n += 1);
        iterate.filter((w) -> {
            System.out.println(w);
            return w>0.5;
        }).count();
        iterate.forEach(w -> System.out.println(w));

熱烈歡迎你們看下, 一塊兒解決上述程序最後提出的問題

總結

對流的操做加上 Lambda 表達式可以使程序更加簡潔易懂, 也正是因爲簡潔, 不易將這種類型的程序內容書寫太多, 不然過了一段時間, 本身都看不懂這段代碼.

在後續對大量元素的處理, 能夠優先考慮流, 而非集合