Stream簡介
Stream流不存儲數據，它的作用是檢索和邏輯處理集合數據、包括篩選、排序、統計、計數等?？梢韵胂蟪墒?Sql 語句。
它的源數據可以是Collection、Array等。由于它的方法參數都是函數式接口類型，所以一般和 Lambda 配合使用。
Stream流類型
1.stream 串行流
2.parallelStream 并行流，可以多線程執行,基于 ForkJoin 框架實現
常用方法
接下來我們看java.util.stream.Stream常用方法
/**
* 返回一個串行流
*/
default Stream<E> stream()
/**
* 返回一個并行流
*/
default Stream<E> parallelStream()
/**
* 返回T的流
*/
public static<T> Stream<T> of(T t)
/**
* 返回其元素是指定值的順序流。
*/
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
/**
* 過濾，返回由與給定predicate匹配的該流的元素組成的流
*/
Stream<T> filter(Predicate<? super T> predicate);
/**
* 此流的所有元素是否與提供的predicate匹配。
*/
boolean allMatch(Predicate<? super T> predicate)
/**
* 此流任意元素是否有與提供的predicate匹配。
*/
boolean anyMatch(Predicate<? super T> predicate);
/**
* 返回一個 Stream的構建器。
*/
public static<T> Builder<T> builder();
/**
* 使用 Collector對此流的元素進行歸納
*/
<R, A> R collect(Collector<? super T, A, R> collector);
/**
* 返回此流中的元素數。
*/
long count();
/**
* 返回由該流的不同元素（根據 Object.equals(Object) ）組成的流。
*/
Stream<T> distinct();
/**
* 遍歷
*/
void forEach(Consumer<? super T> action);
/**
* 用于獲取指定數量的流，截短長度不能超過 maxSize 。
*/
Stream<T> limit(long maxSize);
/**
* 用于映射每個元素到對應的結果
*/
<R> Stream<R> map(Function<? super T, ? extends R> mapper);
/**
* 根據提供的 Comparator進行排序。
*/
Stream<T> sorted(Comparator<? super T> comparator);
/**
* 在丟棄流的第一個 n元素后，返回由該流的 n元素組成的流。
*/
Stream<T> skip(long n);
/**
* 返回一個包含此流的元素的數組。
*/
Object[] toArray();
/**
* 使用提供的 generator函數返回一個包含此流的元素的數組，以分配返回的數組，以及分區執行或調整大小可能需要的任何其他數組。
*/
<A> A[] toArray(IntFunction<A[]> generator);
/**
* 合并流
*/
public static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)
具體使用示例
List<String> strings = Arrays.asList("abc", "def", "gkh", "abc");
//返回符合條件的stream
Stream<String> stringStream = strings.stream().filter(s -> "abc".equals(s));
//計算流符合條件的流的數量
long count = stringStream.count();
//forEach遍歷->打印元素
strings.stream().forEach(System.out::println);
//limit 獲取到1個元素的stream
Stream<String> limit = strings.stream().limit(1);
//toArray 比如我們想看這個limitStream里面是什么，比如轉換成String[],比如循環
String[] array = limit.toArray(String[]::new);
//map 對每個元素進行操作返回新流
Stream<String> map = strings.stream().map(s -> s + "22");
//sorted 排序并打印
strings.stream().sorted().forEach(System.out::println);
//Collectors collect 把abc放入容器中
List<String> collect = strings.stream().filter(string -> "abc".equals(string)).collect(Collectors.toList());
//把list轉為string，各元素用，號隔開
String mergedString = strings.stream().filter(string -> !string.isEmpty()).collect(Collectors.joining(","));
//對數組的統計，比如用
List<Integer> number = Arrays.asList(1, 2, 5, 4);
IntSummaryStatistics statistics = number.stream().mapToInt((x) -> x).summaryStatistics();
System.out.println("列表中最大的數 : "+statistics.getMax());
System.out.println("列表中最小的數 : "+statistics.getMin());
System.out.println("平均數 : "+statistics.getAverage());
System.out.println("所有數之和 : "+statistics.getSum());
//concat 合并流
List<String> strings2 = Arrays.asList("xyz", "jqx");
Stream.concat(strings2.stream(),strings.stream()).count();
//注意 一個Stream只能操作一次，不能斷開，否則會報錯。
Stream stream = strings.stream();
//第一次使用
stream.limit(2);
//第二次使用
stream.forEach(System.out::println);
//報錯 java.lang.IllegalStateException: stream has already been operated upon or closed
//但是可以這樣, 連續使用
stream.limit(2).forEach(System.out::println);
Optional簡介
Optional 是 Java8 提供的為了解決 null 安全問題的一個 API。善用 Optional 可以使我們代碼中很多繁瑣、丑陋的設計變得十分優雅
Stream 中的 findAny、max/min、reduce 等方法等返回 Optional 值。還有例如 IntStream.average() 返回 OptionalDouble 等等
假設有一個 Zoo 類，里面有個屬性 Dog，需求要獲取 Dog 的 age
class Zoo {
private Dog dog;
}
class Dog {
private int age;
}
傳統解決NPE的方法
Zoo zoo = getZoo();
if(zoo != null){
Dog dog = zoo.getDog();
if(dog != null){
int age = dog.getAge();
System.out.println(age);
}
}
使用Optional后的代碼
Optional.ofNullable(zoo).map(o -> o.getDog()).map(d -> d.getAge()).ifPresent(age ->
System.out.println(age)
);
Optional類中的方法
上例中Optional.ofNullable是其中一種創建 Optional 的方式。我們先看一下它的含義和其他創建 Optional 的源碼方法。
創建Optional
/**
* Common instance for {@code empty()}. 全局EMPTY對象
*/
private static final Optional<?> EMPTY = new Optional<>();
/**
* Optional維護的值
*/
private final T value;
/**
* 如果value是null就返回EMPTY，否則就返回of(T)
*/
public static <T> Optional<T> ofNullable(T value) {
return value == null ? empty() : of(value);
}
/**
* 返回 EMPTY 對象
*/
public static<T> Optional<T> empty() {
Optional<T> t = (Optional<T>) EMPTY;
return t;
}
/**
* 返回Optional對象
*/
public static <T> Optional<T> of(T value) {
return new Optional<>(value);
}
/**
* 私有構造方法，給value賦值
*/
private Optional(T value) {
this.value = Objects.requireNonNull(value);
}
/**
* 所以如果of(T value) 的value是null，會拋出NullPointerException異常，這樣貌似就沒處理NPE問題
*/
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}
ofNullable方法和of方法唯一區別就是當 value 為 null 時，ofNullable 返回的是EMPTY，of 會拋出 NullPointerException 異常。如果需要把 NullPointerException 暴漏出來就用 of，否則就用 ofNullable。
map()相關方法
/**
* 如果value為null，返回EMPTY，否則返回Optional封裝的參數值
*/
public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Optional.ofNullable(mapper.apply(value));
}
}
/**
* 如果value為null，返回EMPTY，否則返回Optional封裝的參數值，如果參數值返回null會拋 NullPointerException
*/
public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
Objects.requireNonNull(mapper);
if (!isPresent())
return empty();
else {
return Objects.requireNonNull(mapper.apply(value));
}
}
兩個方法區別：
flatMap()參數返回值如果是 null 會拋 NullPointerException，而 map()返回EMPTY
判斷 value 是否為 null
/**
* value是否為null
*/
public boolean isPresent() {
return value != null;
}
/**
* 如果value不為null執行consumer.accept
*/
public void ifPresent(Consumer<? super T> consumer) {
if (value != null)
consumer.accept(value);
}
獲取value
/**
* Return the value if present, otherwise invoke {@code other} and return
* the result of that invocation.
* 如果value != null 返回value，否則返回other的執行結果
*/
public T orElseGet(Supplier<? extends T> other) {
return value != null ? value : other.get();
}
/**
* 如果value != null 返回value，否則返回T
*/
public T orElse(T other) {
return value != null ? value : other;
}
/**
* 如果value != null 返回value，否則拋出參數返回的異常
*/
public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
if (value != null) {
return value;
} else {
throw exceptionSupplier.get();
}
}
/**
* value為null拋出NoSuchElementException，不為空返回value。
*/
public T get() {
if (value == null) {
throw new NoSuchElementException("No value present");
}
return value;
}
filter()
/**
* 1. 如果是empty返回empty
* 2. predicate.test(value)==true 返回this，否則返回empty
*/
public Optional<T> filter(Predicate<? super T> predicate) {
Objects.requireNonNull(predicate);
if (!isPresent())
return this;
else
return predicate.test(value) ? this : empty();
}
Optional常見使用
Optional.ofNullable(zoo).map(o -> o.getDog()).map(d -> d.getAge()).filter(v->v==1).orElse(3);
