所有函数：
allMatch 和 anyMatch
/**
* allMatch 和 anyMatch
* 这个并不是过滤数据用的，而只是获取一个判断结果
*
* 注意：这个函数一个Stream只能调用一次，调用一次后，这个Stream就调用close，也就是流就会关闭了，
* 如果还要使用，那么需要再开辟一个
*/
@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居然还有建造者模式，数据是空的
*/
@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 数据流的唯一性
*/
@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
* 排序后的数据流，这个判断仅判断一次，一旦遇到不满足，则后面的就不再判断，和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 过滤对应的数据
*/
@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 主要用于过滤后查找某一个数据
*/
@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< >> 这种多重嵌套转换为一层，跟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 查询数据
* 与forEach 的区别在于在并行运行的时候，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 用于生成流数据
* 但是这个函数生成的数据是无限的，因此必须用limit进行限制，该函数主要用于生成自己的流
*/
@Test
public void generateTest(){
Random seed = new Random();
Supplier<Integer> random = seed::nextInt;
Stream.generate(random).limit(12).forEach(Out::show);
//函数会一直执行，直到limit限制，否则会一直阻塞
Stream.generate(()->23).limit(12).forEach(Out::show);
}
iterate
/**
* iterate 用于生成流数据
*/
@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 区别在于ofNullable是能够存放null
*/
@Test
public void ofNullableTest(){
Stream.ofNullable(12).forEach(Out::show);
Stream.ofNullable(null).forEach(Out::show);
}
peek
/**
* peek
* 这个是返回一个新的流，但是并没有对流中的数据进行操作，和map的区别在于map会生成一个新的数据流
* peek和foreach的区别在于peek是中间数据，而forEach是Stream终结流函数
*/
@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
* 该函数用于对排序后的数据进行过滤，从头排序，直到不满足条件，这个并不是过滤所有的，跟函数dropWhile
*/
@Test
public void takeWhileTest(){
Stream.of(12,3,4,65,4).sorted(Comparator.reverseOrder()).takeWhile(t->t>5).forEach(Out::show);
}
toArray
/**
* toArray
* 将数据流转换为数组
*/
@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函数和filter函数有什么区别
这个函数需要排序，排序后，这两个函数都是遇到一次不满足的，则不再向后过滤，所以性能稍微会高一点<br />
