什麼是Stream流式計算

儲存+計算

• 集合框架,mysql 本質是儲存東西的
• 計算應該交給流來操作

//一行程式碼實現五個要求
/* 篩選出
* 1.id必須是偶數
* 2.年齡大於15歲
* 3.使用者名稱轉為大寫字母
* 4.使用者名稱字母倒著排序
* 5.只輸出一個使用者*/
public class Test {
    public static void main(String[] args) {
        User u1=new User(1,"a",13);
        User u2=new User(2,"b",14);
        User u3=new User(3,"c",15);
        User u4=new User(4,"d",16);
        User u5=new User(5,"e",17);
        //集合就是儲存
        List<User> list = Arrays.asList(u1, u2, u3, u4, u5);
        //計算交給Stream流
        list.stream()  //lambda表示式，鏈式程式設計，函式式介面，Stream流計算
                .filter(u->{return u.getId()%2!=0;})
                .filter(user -> {return user.getAge()>=15;})
                .map(user -> {return user.getName().toUpperCase();})
                .sorted((uu1,uu2)->{return uu2.compareTo(uu1);})
                .limit(1)
                .forEach(System.out::println);
    }
}
 

使用Stream流式計算的優點

• 使用Stream流式計算效率更高
• 程式更加簡潔

方法

boolean allMatch(Predicate<? super T> predicate) 
返回此流的所有元素是否與提供的謂詞匹配。  
boolean anyMatch(Predicate<? super T> predicate) 
返回此流的任何元素是否與提供的謂詞匹配。  
static <T> Stream.Builder<T> builder() 
返回一個 Stream的構建器。  
<R,A> R collect(Collector<? super T,A,R> collector) 
使用 Collector對此流的元素執行 mutable reduction Collector 。  
<R> R collect(Supplier<R> supplier, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner) 
對此流的元素執行 mutable reduction操作。  
static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b) 
建立一個懶惰連線的流，其元素是第一個流的所有元素，後跟第二個流的所有元素。  
long count() 
返回此流中的元素數。  
Stream<T> distinct() 
返回由該流的不同元素（根據 Object.equals(Object) ）組成的流。  
static <T> Stream<T> empty() 
返回一個空的順序 Stream 。  
Stream<T> filter(Predicate<? super T> predicate) 
返回由與此給定謂詞匹配的此流的元素組成的流。  
Optional<T> findAny() 
返回描述流的一些元素的Optional如果流為空，則返回一個空的Optional 。  
Optional<T> findFirst() 
返回描述此流的第一個元素的Optional如果流為空，則返回一個空的Optional 。  
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper) 
返回由通過將提供的對映函式應用於每個元素而產生的對映流的內容來替換該流的每個元素的結果的流。  
DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper) 
返回一個 DoubleStream ，其中包含將該流的每個元素替換為通過將提供的對映函式應用於每個元素而產生的對映流的內容的結果。  
IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper) 
返回一個 IntStream ，其中包含將該流的每個元素替換為通過將提供的對映函式應用於每個元素而產生的對映流的內容的結果。  
LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper) 
返回一個 LongStream ，其中包含將該流的每個元素替換為通過將提供的對映函式應用於每個元素而產生的對映流的內容的結果。  
void forEach(Consumer<? super T> action) 
對此流的每個元素執行操作。  
void forEachOrdered(Consumer<? super T> action) 
如果流具有定義的遇到順序，則以流的遇到順序對該流的每個元素執行操作。  
static <T> Stream<T> generate(Supplier<T> s) 
返回無限順序無序流，其中每個元素由提供的 Supplier 。  
static <T> Stream<T> iterate(T seed, UnaryOperator<T> f) 
返回有序無限連續 Stream由函式的迭代應用產生 f至初始元素 seed ，產生 Stream包括 seed ， f(seed) ， f(f(seed)) ，等  
Stream<T> limit(long maxSize) 
返回由此流的元素組成的流，截短長度不能超過 maxSize 。  
<R> Stream<R> map(Function<? super T,? extends R> mapper) 
返回由給定函式應用於此流的元素的結果組成的流。  
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) 
返回一個 DoubleStream ，其中包含將給定函式應用於此流的元素的結果。  
IntStream mapToInt(ToIntFunction<? super T> mapper) 
返回一個 IntStream ，其中包含將給定函式應用於此流的元素的結果。  
LongStream mapToLong(ToLongFunction<? super T> mapper) 
返回一個 LongStream ，其中包含將給定函式應用於此流的元素的結果。  
Optional<T> max(Comparator<? super T> comparator) 
根據提供的 Comparator返回此流的最大元素。  
Optional<T> min(Comparator<? super T> comparator) 
根據提供的 Comparator返回此流的最小元素。  
boolean noneMatch(Predicate<? super T> predicate) 
返回此流的元素是否與提供的謂詞匹配。  
static <T> Stream<T> of(T... values) 
返回其元素是指定值的順序排序流。  
static <T> Stream<T> of(T t) 
返回包含單個元素的順序 Stream 。  
Stream<T> peek(Consumer<? super T> action) 
返回由該流的元素組成的流，另外在從生成的流中消耗元素時對每個元素執行提供的操作。  
Optional<T> reduce(BinaryOperator<T> accumulator) 
使用 associative累積函式對此流的元素執行 reduction ，並返回描述減小值的 Optional （如果有）。  
T reduce(T identity, BinaryOperator<T> accumulator) 
使用提供的身份值和 associative累積功能對此流的元素執行 reduction ，並返回減小的值。  
<U> U reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner) 
執行 reduction在此流中的元素，使用所提供的身份，積累和組合功能。  
Stream<T> skip(long n) 
在丟棄流的第一個 n元素後，返回由該流的 n元素組成的流。  
Stream<T> sorted() 
返回由此流的元素組成的流，根據自然順序排序。  
Stream<T> sorted(Comparator<? super T> comparator) 
返回由該流的元素組成的流，根據提供的 Comparator進行排序。  
Object[] toArray() 
返回一個包含此流的元素的陣列。  
<A> A[] toArray(IntFunction<A[]> generator) 
使用提供的 generator函式返回一個包含此流的元素的陣列，以分配返回的陣列，以及分割槽執行或調整大小可能需要的任何其他陣列。