J2SE 8的流库 --- 生成流 1. 产生流方式一 List.stream() List->流 2. 产生流方式二 List.parallelStream() 并行流,可以在多线程中执行操作 List->流 3. 产生流方式三 Pattern方式 字符串切割->流 4. 产生流方式四 Files方式 文件->流 5. 产生流方式五 Arrays.stream() 数组->流 6. 产生流方式六 Stream.of() 任意对象->流 7. 产生流方式七 Stream.empty() 创建空流 8. 产生流方式八 Stream.generate() 产生无限流 无限长度的Stream，其元素的生成是通过给定的Supplier 9. 产生流方式九 iterate() 接受种子+函数 10. 产生流方式十 IntStream 11. 产生流方式十一 LongStream 12. 产生流方式十二 DoubleStream 13. 对应的，创建short
本文介绍了如何产生J2SE 8的流, 包括基本类型的流IntStream, LongStream, DoubleStream 。
展现流的方法
public static <T> void show(String title, Stream<T> stream){
System.out.println("title:"+title);
List<T> collect = stream.limit(10).collect(Collectors.toList());
collect.forEach(n->System.out.println(n));
System.out.println();
}创建公共的list
ArrayList<String> arrayList = new ArrayList<>();
arrayList.add("aa");
arrayList.add("bb");
arrayList.add("cc");Stream<String> listStream = arrayList.stream();
show("listStream", listStream);2. 产生流方式二 List.parallelStream() 并行流,可以在多线程中执行操作 List->流
Stream<String> parallelListStream = arrayList.parallelStream();
show("parallelListStream", parallelListStream);不想出现流被关的错误,用Supplier<T> 包装流,直接get(),多次使用不会错
Supplier<Stream<String>> arrayListSupplier = () -> arrayList.stream();
show("arrayListSupplier", arrayListSupplier.get());
show("arrayListSupplier", arrayListSupplier.get());
show("arrayListSupplier", arrayListSupplier.get());3. 产生流方式三 Pattern方式 字符串切割->流
Stream<String> patternStream = Pattern.compile("
").splitAsStream("11111
22222
33333
6666666666666");
show("patternStream", patternStream);4. 产生流方式四 Files方式 文件->流
Stream<String> fileStream = Files.lines(Paths.get("E:\111.txt"),StandardCharsets.UTF_8); //StandardCharsets.UTF_8
show("fileStream", fileStream);5. 产生流方式五 Arrays.stream() 数组->流
Stream<String> arrayStream = Arrays.stream(new String[]{"AA","BB","CC"});
Arrays.stream(new String[]{"AA","BB","CC"},0,2); //T[] array, int startInclusive, int endExclusive 切割数组
show("arrayStream", arrayStream);6. 产生流方式六 Stream.of() 任意对象->流
Stream.of(arrayList);
Stream<String> ofStream = Stream.of("aa","bb","cc");
show("ofStream", ofStream);7. 产生流方式七 Stream.empty() 创建空流
Stream<Object> emptyStream = Stream.empty();
show("emptyStream", emptyStream);8. 产生流方式八 Stream.generate() 产生无限流 无限长度的Stream，其元素的生成是通过给定的Supplier
Stream<String> generateStream1 = Stream.generate(()->"AABBCC");
show("generateStream1", generateStream1);
Stream<Double> generateStream2 = Stream.generate(new Supplier<Double>() {
@Override
public Double get() {
return Math.random();
}
});
generateStream2 = Stream.generate(()->Math.random());
generateStream2 = Stream.generate(Math::random);
show("generateStream2", generateStream2);9. 产生流方式九 iterate() 接受种子+函数
Stream<BigInteger> iterateStream = Stream.iterate(BigInteger.ZERO, n->n.add(BigInteger.ONE));
show("iterateStream", iterateStream);10. 产生流方式十 IntStream
IntStream intStream = IntStream.of(1,1,2,3,4);
show("intStream", intStream.boxed()); //boxed() 基本类型流->对象流
intStream = IntStream.range(0, 5); //[int startInclusive, int endExclusive),不包括5
show("intStream", intStream.boxed());
intStream = IntStream.rangeClosed(0, 5); //[int startInclusive, int endExclusive],包括5
show("intStream", intStream.boxed());
intStream = IntStream.generate(()->new Random().nextInt());
show("intStream", intStream.boxed());
intStream = IntStream.iterate(0, n->n+8);
show("intStream", intStream.boxed());
IntStream mapToIntStream = arrayList.stream().mapToInt(String::length); //mapToInt 将对象流->基本类型流
show("mapToIntStream", mapToIntStream.boxed()); 11. 产生流方式十一 LongStream
LongStream longStream = LongStream.of(1,1,2,3,4);
show("longStream", longStream.boxed()); //boxed() 基本类型流->对象流
longStream = LongStream.range(0, 5); //[int startInclusive, int endExclusive),不包括5
show("longStream", longStream.boxed());
longStream = LongStream.rangeClosed(0, 5); //[int startInclusive, int endExclusive],包括5
show("longStream", longStream.boxed());
longStream = LongStream.generate(()->new Random().nextLong());
show("longStream", longStream.boxed());
longStream = LongStream.iterate(0, n->n+8);
show("longStream", longStream.boxed());
LongStream mapToLongStream = arrayList.stream().mapToLong(x->(long)x.length()); //mapToLong 将对象流->基本类型流
show("mapToLongStream", mapToLongStream.boxed()); 12. 产生流方式十二 DoubleStream
DoubleStream doubleStream = DoubleStream.of(1.1,1.2,1.3,2.1,2.2);
show("doubleStream", doubleStream.boxed());
doubleStream = DoubleStream.generate(Math::random);
show("doubleStream", doubleStream.boxed());
doubleStream = DoubleStream.iterate(1.1, n->n+1.1);
show("doubleStream", doubleStream.boxed());
DoubleStream mapToDoubleStream = arrayList.stream().mapToDouble(x->(double)x.length()); //mapToDouble 将对象流->基本类型流
show("mapToDoubleStream", mapToDoubleStream.boxed()); 13. 对应的，创建short,char,byte,boolean,float流
Stream<Boolean> booleanStream = Arrays.stream(new Boolean[]{true,false,false,true});
show("booleanStream", booleanStream);14. 流操作, 不要修改流操作中间引出的集合的值
//不在流中修改arrayList，不要紧
Stream<String> stream = arrayList.stream();
arrayList.add("added stream");
System.out.println(stream.count());
//在流中修改arrayList，会 java.util.ConcurrentModificationException
//arrayList.stream().forEach(s->arrayList.remove(s));15. 并行流
使用并行流的条件:
1).操作可以以任意顺序执行， 顺序执行结果和不顺序执行的结果相同
2).操作可以分开执行，并行执行
//生成并行流的两种方式
Stream<String> parallelStream = arrayList.parallelStream();
parallelStream = arrayList.stream().parallel();
Map<Integer, Long> parallelStreamResult = parallelStream.filter(w->w.length()>1).collect(Collectors.groupingBy(String::length, Collectors.counting()));
parallelStreamResult.entrySet().forEach((n)->System.out.println(n.getKey()+" , counting:"+n.getValue()));
//unordered表示对排序不感兴趣, 打乱顺序
arrayList.parallelStream().limit(2).forEach((n)->System.out.println(n));
System.out.println();
arrayList.parallelStream().unordered().limit(2).forEach((n)->System.out.println(n));