Java 8 流庫學習筆記（一）
【core Java學習筆記】Java SE8 流庫 Stream Library
從叠代到流
如果要計算一個文本中有多少長單詞(字母>12)。
叠代式:
words = getlist();//虛構方法，獲得一個List<String> long count = 0; for(String w:words) { if(w.length()>12) count++; }流式:
words = getlist();//虛構方法，獲得一個List<String> long count = words.stream() .filter(w->w.length() > 12) .count();- 流式表達式相對於叠代式的好處:
- 易於閱讀。
- 易於優化，例如將
steam()方法換為parallelStream()方法就可以進行並行計算。 - 遵循"what, not how"原則，抽象層次更高。
- 流的特征：
- 流不存儲元素，元素可能存儲在按需生成的匿名集合中。
- 流操作絕不會改變源數據。例如
filter()方法不會移除數據，而是產生新的流。 - 流操作是lazy的，意味著直到流操作的結果被需要時才會進行運算。
- 流操作的範式:
- 建立流。例如上例的
stream() - 應用
intermediate operations使用原流去產生其他需要的流，可以進行多步。例如上例的filter() - 應用
terminal operation去產生結果。之後流將不可用。例如count()
- 建立流。例如上例的
建立流
- 如果有
Collection類，調用其stream()或其他流方法。 - 如果有數組，使用
Stream.of(Array array)方法。 - 創建空流，調用
Stream.empty()方法。 創建無限長流，調用
Stream.generate(Supplier supplier<T> s)方法。Stream<String> echos = Stream.generate(()->"Echo"); //上方lambda表達式可寫為如下完整表達式 Stream<String> echos = Stream.generate(new Supplier<String>() { @Override public String get() { return "echo"; } });Stream<Double> randoms = Stream.generate(Math::random); //產生隨機數,雙冒號是lambda表達式中的方法引用創建叠代的無限長流，使用
Stream.iterate(T seed,UnaryOperator f)Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO,n->n.addd(BigInteger.ONE)) //流的第一個元素為seed，後續元素為f(seed),f(f(seed))...字符串創建流，調用
Pattern類中的spliteAsStream(CharSequence input)方法Pattern pattern = Pattern.compile(" "); Stream<String> s = pattern.splitAsStream("A B C");
filter,map和flatmap方法
最常用的三種intermediate operations
Stream<T> filter方法：選擇源流中符合一定條件的元素組成新流。List<String> wordList = ...; //省略初始化 Stream<String> longWords = wordList.Stream().filter(w -> w.length() > 12);<R> Stream<R> map方法：對源流中所有元素執行同一操作後組成新流。List<String> words = ...; //省略初始化 Stream<String> lowercaseWords = words.stream().map(String::toLowerCase);<R> Stream<R> flatmap方法：和map方法的效果大致相同，但對多個流組成的流操作會得到合並的一個流。即對Stream提取子流以及合並流
調用
Stream<T> limit(n)來提取前n個元素的子流。Stream<Double> randoms = Stream.generate(Math::random).limit(100);調用
Stream<T> skip(n)來獲得跳過前n個元素的子流Stream<String> words = Stream.of(contents.split("\\PL+")).skip(1);調用
Stream<T> concate(Stream a,Stream b)來創建a,b流合並後的流，b在a後。其他流轉換操作
Stream<T> distinct()獲得相同順序，但是只保留一個相同項的流。Stream<String> uniqueWords = Stream.of("a","a","b","c","a").distinct();使用
Stream<T> sorted()對comparable排序，或使用Stream<T> sorted(Comparator<? super T> comparator)對普通對象元素排序。Stream<String> longestFirst = words .stream() .sorted(Comparator.comparing(String::length)) .reversed();使用
Stream<T> peek(Consumer<? super T> action)在每次元素實際被訪問時觸發動作(action)，利於debug。Object[] powers = Stream.iterate(1.0,p -> p * 2) .peek(e - > System.out.println("Peeking"+e)) .limit(20).toArrays();簡單的還原(reduction)操作
- 還原操作是將流對象轉換為非流對象的操作。
- 還原操作是終止操作(terminal operations)，操作之後流不可用。
count()計算流中元素個數。(上例有)max(Comparator<? super T> comparator)和min(Comparator<? super T> comparator)獲得最大/最小元素。他們返回一個Optional<? super T>類。Optional<String> largest = words.max(String::compareToIgnoreCase); System.out.println("largest:" + largest.orElse(""));findFirst()和findAny()獲得過濾器過濾到的第一個/所有元素。他們返回一個Optional<? super T>類。Optional<String> startsWithQ = words.filter(s -> s.startWith("Q")).findFirst();anyMatch(Predicate<? super T> p),allMatch(Predicate<? super T> p),noneMatch(Predicate<? super T> p)返回匹配結果(boolean)。boolean aWordStartsWithQ = words.parallel().anyMatch(s -> s.startWith("Q"));
Optional類
Optional類是流還原操作的常用返回值。Optional<T>持有(wrap)T類型對象或null的對象。這樣的設計思路是為了安全，避免空引用。
簡單地處理Optional對象中持有的對象。
T orElse(T other)如果該Optional對象非空，就返回持有的對象，否則返回other。String result = optionalString.orElse(""); //return wrapped string, or "" if nullT orElseGet(Supplier<? extends T> other)如果該Optional對象非空，就返回持有對象，否則返回other.get()T orElseThrow(Supplier<? extends X> exceptionSupplier)，如果該Optional對象非空，就返回持有的對象，否則拋出一個exceptionSupplier.get()異常。ifPresent接受一個函數，如果option持有對象，則用該函數處理；否則無事發生。
optionValue.ifPresent(v -> Process v);。該方法無返回值。map方法和ifPresent類似，但是有一個Optional<T>的返回值，原Optional<T>對象不變。
正確地使用Optional類
隨時警惕
Optional對象可能不持有對象。這種特性可能造成NoSuchElementException錯誤的拋出。Optional<T> optionValue = ...; optionValue.get().someMethod(); //not safe, cause get() may produce nullOptional<T> optionValue = ...; if(optionValue.isPresent()) optionValue.get().someMethod(); //safe, cause isPresent() reports whether an Optional object has a value創建
Optional類的對象創建
Optional對象的主要方法是調用Optional類的靜態工廠方法。static <T> Optional<T> of(T value) 產生一個Optional對象，如果value是null，則拋出異常 static <T> Optional<T> ofNullable(T value) 產生一個Optional對象。 static<T> Optional通過
flatMap方法調用Optional<T>對象持有的T對象的方法。
//f() yields an Optional<T>
//T has a method g() yields an Optional<U>
Optional<U> result = s.f().flatMap(T::g)收集流到集合中
展示流
stream.forEach(System.out::println);獲得數組
String[] result = stream.toArray(String::new); //toArray get Object[], pass it to constructor to get the right type.使用
collect方法和Collectors類中眾多的工廠方法來獲得不同容器中的對象集合。
List<String> result = stream.collect(Collectors.toList());
Set<String> result = stream.collect(Collectors.toSet());
TreeSet<String> result = stream.collect(Collectors.toCollection(TreeSet::new));
//control which type of implementation of Collection
String result = stream.collect(Collectors.joining());
String result = stream.collect(Collectors.joining(", "));
//joing to one String
Iterator<T> iterator = stream.iterator();
IntSummaryStatistics summary = stream.collect(
Collectors.summarizingInt(String::length));
double averageWordLength = summary.getAverage();
double maxWordLength = summary.getMax();
//summarizing(Int|Long|double) -> (Int|Long|Double)SummaryStatistisc收集流到字典中
例如有一個Person類
Person{
private int id;
private String name;
public getId(){
return id;
}
public getName(){
return name;
}
public Person(int id,String name){
this.id = id;
this.name = name;
}
}- 一般情況
Map<Integer, String> keyToValue = stream.collect(
Collectors.toMap(Person::getID,Person::getName));
//(Function keyMapper, Function valueMapper)- 將對象整個作為鍵/值
Map<Integer, Person> idToPerson = stream.collect(
Collectors.toMap(Person::getID,Function.identity()));Java 8 流庫學習筆記（一）