技術標籤：javajava

Java SE 8 的流庫

• • 1.迭代與流的操作
  • 2.流的建立

1.迭代與流的操作

對列表中的長單詞計數
1.迭代操作

long count = 0;
for(String w : words){
    if.(w.length() > 12)
        count++;
}

2.使用流操作實現相同功能

long count = words.stream().filter(w -> w.length() > 12),count();

使用流代替迴圈的好處： 流操作遵循“做什麼而非怎麼做原則”。
1.流版本比迴圈的版本更易於閱讀，因為我們不必掃描整個程式碼去查詢過濾和計數操作，方法名就可以直接告訴我們其程式碼意欲何為。

流與集合的差異：
1.流並不儲存其元素。（流使用的元素可能儲存在底層的集合中，也可能是按照需求生成的）
2.流的操作不會修改資料來源。（例如，filter（）方法不會從新的流中移除元素，而是會生成一個新的流，其中不包括被過濾的掉的元素）
3.流的操作是儘可能惰性執行的。（意思是隻有需要結果時，操作才會執行）

流的典型操作流程：
1.建立一個流。
2.指定將初始化流轉化為其他流的中間操作，可能包含多個步驟。
3.應用終止操作，產生執行結果。

import java.io.IOException;
 

import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;

public class oneone {
    public static void main(String[] args) throws IOException {
        //讀檔案將檔案讀到集合中
        String contents = new String(Files.readAllBytes
 
(Paths.get("alice30.txt")), StandardCharsets.UTF_8);
        List<String> words = Arrays.asList(contents.split("//PL+"));

        long count = 0;
        //迴圈查詢集合words中單詞長度大於12的單詞的數量。
        for(String w : words){
            if (w.length() > 12){
                count++;
            }
        }
        System.out.println(count);
        //單執行緒的流操作
        count = words.stream().filter(w -> w.length() > 12).count();
        System.out.println(count);
        //併發執行流的操作
        count = words.parallelStream().filter(w -> w.length() > 12).count();
        System.out.println(count);
    }
}

• Stream filter(Predicate<? super T> p):產生一個流，其中包含當前流中滿足P的所有元素。
• long count（）：產生當前流中元素的數量。是流的一個終止操作。
• default Stream stream()：產生當前集合中所有元素的順序流
• default Stream parallelStream()：產生當前集合中所有元素的並行流。

2.流的建立

 使用Collection介面的stream（）方法將任何集合轉化為一個流。
 使用靜態的Stream.of（）方法將陣列轉化為一個流。
 使用Array.stream(array, from, to)方法可以從陣列中位於from(包括)和to(不包括)的元素中建立一個流。
 使用Stream.empty（）方法建立一個不包含任何元素的流。
 使用Stream.generate(Supplier<T> P)方法或Stream.iterate(UnaryOperation<T> P)方法建立無限流。
 Pattern類有一個splitAsStream方法，它將按照某個正則表示式來分割一個CharSequence物件。
 靜態的Files.lines方法返回一個包含了檔案中所有行的Stream。

Stream<String> words = Stream.of(contents.split("\\PL+"));
Stream<String> words = Stream.of("gently", "down", "the");
Stream<String> words = Array.stream(contents, 1, 5);
Stream<String> slience = Stream.empty();
Stream<String> echos = Stream.generate(()-> "Echos");
Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
Stream<Stream> words = Pattern.compile("\\PL+").splitAsStream(contents);
try(Stream<String> lines = Files.lines(path))
{
     Process lines;
}

import java.io.IOException;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.List;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class onetwo {
    public static <T> void show(String title, Stream<T> stream){
        final int SIZE = 10;
        List<T> firstElements = stream.limit(SIZE + 1).collect(Collectors.toList());
        System.out.println(title + ": ");
        for(int i = 0; i < firstElements.size(); i++){
            if (i > 0) System.out.println(", ");
            if (i < SIZE)
                System.out.println(firstElements.get(i));
            else
                System.out.println("...");
        }
        System.out.println();
    }

    public static void main(String[] args) throws IOException {
        Path path = Paths.get("alice30.txt");
        String contents = new String(Files.readAllBytes(path), StandardCharsets.UTF_8);
        //將陣列轉化為一個流
        Stream<String> words = Stream.of(contents.split("\\PL+"));
        show("words", words);
        Stream<String> songs = Stream.of("gently", "down", "the", "stream");
        show("song", songs);
        //建立一個沒有元素的流
        Stream<String> empty = Stream.empty();
        show("empty", empty);

        //建立一個某個字串的無限流
        Stream<String> echos = Stream.generate(() ->"Echos");
        show("echos", echos);
        
        //建立一個隨機數的無限流
        Stream<Double> randoms = Stream.generate(Math::random);
        show("randoms", randoms);
        
        //建立一個自增的無限流
        Stream<BigInteger> integerStream = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));
        show("intergers", integerStream);
        
        //使用Pattern將檔案轉為一個流
        Stream<String> wordsAnotherWay = Pattern.compile("\\PL+").splitAsStream(contents);
        show("wprdsAnotherWay", wordsAnotherWay);
        
        //讀檔案將讀到的每行轉化為一個流
        try(Stream<String> lines = Files.lines(path, StandardCharsets.UTF_8)){
            show("lines", lines);
        }
    }
}

1. static Stream of (T…values)：產生一個元素為給定值的流。
2. static Stream empty()：產生一個空的流。
3. static Stream generate(Suppliers)：產生一個無限流，它的值是反覆呼叫函式s而構建的。
4. static Stream iterate(T seed, UnaryOperator f)：產生一個無限流，它的元素包含種子、在種子上呼叫f產生的值、在前一個元素上呼叫f產生的值。
5. static Stream stream(T[] array, int startInclusive, int endExclusive)：產生一個流，它的元素是由陣列中指定範圍內的元素構成的。
6. static splitAsStream(CharSequence input) ：產生一個流，它的元素是輸入中由該模式界定的部分。
   7.static Stream lines(Path path)
   8.static Stream lines(Path path, Charset cs)：產生一個流，它的元素是指定檔案中的行，該檔案的字符集為UTF_8或者指定的字符集。