所有函數(shù)：
allMatch 和 anyMatch
/**
* allMatch 和 anyMatch
* 這個并不是過濾數(shù)據(jù)用的凫碌，而只是獲取一個判斷結(jié)果
*
* 注意：這個函數(shù)一個Stream只能調(diào)用一次，調(diào)用一次后勋又，這個Stream就調(diào)用close，也就是流就會關(guān)閉了换帜，
* 如果還要使用赐写，那么需要再開辟一個
*/
@Test
public void allMatchAndAnyMatchTest(){
List<Integer> integerList = Arrays.asList(1,2,3,123,12,41);
Stream<Integer> stream = integerList.stream();
//true
show(stream.allMatch(t->t>0));
Stream<Integer> stream1 = integerList.stream();
//false
show(stream1.allMatch(t->t>8));
Stream<Integer> stream3 = integerList.stream();
//true
show(stream3.anyMatch(t->t>8));
Stream<Integer> stream4 = integerList.stream();
//false
show(stream4.anyMatch(t->t>400));
}
builder
/**
* Stream居然還有建造者模式，數(shù)據(jù)是空的
*/
@Test
public void builderTest(){
Stream<Object> stringStream = Stream.builder().build();
stringStream.forEach(Out::show);
}
collect
/**
* collect 這個算是流的終止操作符
*/
@Test
public void collectTest(){
List<Integer> integerList = Arrays.asList(1,2,3,123,12,41);
integerList.stream().collect(Collectors.toList()).forEach(Out::show);
}
contact
/**
* static contact 連接兩個流的操作
*/
@Test
public void contactTest(){
List<Integer> list = Arrays.asList(1,2,3);
List<Integer> list2 = Arrays.asList(3,123,12,41);
Stream.concat(list.stream(), list2.stream()).forEach(Out::show);
}
count
/**
* count
*/
@Test
public void CountTest(){
List<Integer> list = Arrays.asList(1,2,3);
show(list.stream().count());
}
distinct
/**
* distinct 數(shù)據(jù)流的唯一性
*/
@Test
public void distinctTest(){
List<Integer> list = Arrays.asList(1,2,3);
List<Integer> list2 = Arrays.asList(3,123,12,41);
Stream.concat(list.stream(), list2.stream()).distinct().forEach(Out::show);
}
dropWhile
/**
* dropWhile
* 排序后的數(shù)據(jù)流膜赃，這個判斷僅判斷一次，一旦遇到不滿足揉忘，則后面的就不再判斷跳座，和takeWhile相似
*/
@Test
public void dropWhileTest(){
Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).dropWhile(t->t>5).forEach(Out::show);
}
skip
/**
* skip 跳過前面多少個元素
*/
@Test
public void skipTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
list.stream().skip(3).forEach(Out::show);
}
limit
/**
* limit 保留流中的從前往后的多少個元素
*/
@Test
public void limitTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
list.stream().limit(4).forEach(Out::show);
}
empty
/**
* static empty 返回一個空的集合
*/
@Test
public void emptyTest(){
Stream.empty().forEach(Out::show);
}
filter
/**
* filter 過濾對應(yīng)的數(shù)據(jù)
*/
@Test
public void filterTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
list.stream().filter(t->t>10).forEach(Out::show);
}
findAny
/**
* findAny 主要用于過濾后查找某一個數(shù)據(jù)
*/
@Test
public void findAnyTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
show(list.stream().filter(t->t==14).findAny().orElse(0));
}
findFirst
/**
* findFirst
*/
@Test
public void findFirstTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
show(list.stream().filter(t->t>14).findFirst().orElse(0));
}
flatMap
/**
* flatMap 主要用于將List< List< >> 這種多重嵌套轉(zhuǎn)換為一層，跟CompletableFuture.thenCompose比較像
*/
@Test
public void flatMapTest(){
List<Integer> list1 = Arrays.asList(1,2);
List<Integer> list2 = Arrays.asList(1,2);
List<Integer> list3 = Arrays.asList(1,2);
List<List<Integer>> lists = List.of(list1, list2, list3);
List<Integer> result = lists.stream().flatMap(Collection::stream).collect(Collectors.toList());
}
forEachOrdered
/**
* forEachOrdered 查詢數(shù)據(jù)
* 與forEach 的區(qū)別在于在并行運行的時候泣矛，forEach是并行亂序的疲眷，而forEachOrdered還是有順序的
*/
@Test
public void forEachOrderedTest(){
List<Integer> list = Arrays.asList(1,2,3,123,12,41);
list.stream().parallel().forEach(Out::show);
tab();
list.stream().parallel().forEachOrdered(Out::show);
}
generate
/**
* generate 用于生成流數(shù)據(jù)
* 但是這個函數(shù)生成的數(shù)據(jù)是無限的，因此必須用limit進行限制您朽，該函數(shù)主要用于生成自己的流
*/
@Test
public void generateTest(){
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(12).forEach(Out::show);
//函數(shù)會一直執(zhí)行狂丝，直到limit限制，否則會一直阻塞
Stream.generate(()->23).limit(12).forEach(Out::show);
}
iterate
/**
* iterate 用于生成流數(shù)據(jù)
*/
@Test
public void iterateTest(){
//方法1
Stream.iterate(0, a->a+2).limit(3).forEach(Out::show);
//方法2
Stream.iterate(0, r->r<8, a->a+2).limit(7).forEach(Out::show);
}
max
/**
* max
*/
@Test
public void maxTest(){
show(Stream.iterate(0, a->a+1).limit(12).max(Comparator.comparingInt(a -> a)).get());
}
noneMatch
/**
* noneMatch 測試
*/
@Test
public void noneMatchTest(){
show(Stream.iterate(0, a->a+1).limit(12).noneMatch(a->a>3));
show(Stream.iterate(0, a->a+1).limit(12).noneMatch(a->a>30));
}
of
/**
* of 測試
*/
@Test
public void ofTest(){
Stream.of(12).forEach(Out::show);
tab();
Stream.of(12,3,4,65,4).forEach(Out::show);
}
ofNullable
/**
* ofNullable
* 與of 區(qū)別在于ofNullable是能夠存放null
*/
@Test
public void ofNullableTest(){
Stream.ofNullable(12).forEach(Out::show);
Stream.ofNullable(null).forEach(Out::show);
}
peek
/**
* peek
* 這個是返回一個新的流哗总，但是并沒有對流中的數(shù)據(jù)進行操作几颜，和map的區(qū)別在于map會生成一個新的數(shù)據(jù)流
* peek和foreach的區(qū)別在于peek是中間數(shù)據(jù)，而forEach是Stream終結(jié)流函數(shù)
*/
@Test
public void peekTest(){
Stream.of(12,3,4,65,4)
.peek(t->{
show(" - "+t+" - ");
})
.filter(t->t>6)
.peek(t->{
show(" * "+t+" * ");
})
.forEach(Out::show);
}
reduce
/**
* reduce 用法
* reduce 這個其實是相當于將那些流全部進行匯總之后進行操作
*/
@Test
public void reduceTest(){
show(Stream.of(12,3,4,65,4).reduce(1, (a, b)->a+b));
show(Stream.of(12,3,4,65,4).reduce((a, b)->a+b));
}
sorted
/**
* sorted
* 默認升序
*/
@Test
public void sortedTest(){
Stream.of(12,3,4,65,4).sorted().forEach(Out::show);
Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).forEach(Out::show);
}
takeWhile
/**
* takeWhile java9
* 該函數(shù)用于對排序后的數(shù)據(jù)進行過濾讯屈，從頭排序蛋哭，直到不滿足條件，這個并不是過濾所有的涮母，跟函數(shù)dropWhile
*/
@Test
public void takeWhileTest(){
Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).takeWhile(t->t>5).forEach(Out::show);
}
toArray
/**
* toArray
* 將數(shù)據(jù)流轉(zhuǎn)換為數(shù)組
*/
@Test
public void toArrayTest(){
//方法1
Object[] objects = Stream.of(12,3,4,65,4).toArray();
Arrays.stream(objects).forEach(Out::show);
//方法2
Integer[] integers = Stream.of(12,3,4,65,4).toArray(Integer[]::new);
Arrays.stream(integers).forEach(Out::show);
}
<br />
注意：
1.java9的這個dropWhite函數(shù)和filter函數(shù)有什么區(qū)別
這個函數(shù)需要排序谆趾，排序后，這兩個函數(shù)都是遇到一次不滿足的叛本，則不再向后過濾沪蓬，所以性能稍微會高一點<br />
