Java Stream的基本概念以及創(chuàng)建方法

Random random = new Random(29);
random.ints()
   .filter(v -> v > 5 && v < 31)
   .limit(3)
   .forEach(System.out::println);

// output:
//  21
//  22
//  28

IntStream stream = new Random(29).ints();
stream.filter(v -> v > 5 && v < 31)
   .limit(3)
   .forEach(System.out::println);
// 當執(zhí)行了終端操作后再使用，就會出現(xiàn)一下異常提示信息
// java.lang.IllegalStateException: stream has already been operated upon or closed
stream.forEach(System.out::println);

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
// 創(chuàng)建一個普通的流
Stream<Integer> stream = list.stream();
// 創(chuàng)建一個并行流
Stream<Integer> parallelStream = list.parallelStream();

IntStream stream = Arrays.stream(new int[]{1, 2, 3});
// 生成流對應的并行流
IntStream parallelStream = stream.parallel();

// 產(chǎn)生一個不包含任何元素的流
Stream<Object> stream1 = Stream.empty();

// 由給定元素所生成的流
Stream<Integer> stream2 = Stream.of(1, 2, 3);

// 合并兩個流產(chǎn)生一個新的流
Stream<Object> stream3 = Stream.concat(stream1, stream2);

// 創(chuàng)建一個<無限流>，流中的數(shù)據(jù)是通過調(diào)用所傳函數(shù)產(chǎn)生的
Stream<Double> stream4 = Stream.generate(Math::random);

// 創(chuàng)建一個<無限流>，流中的數(shù)據(jù)由第一個參數(shù)、將
// 第一個參數(shù)作為函數(shù)參數(shù)調(diào)用產(chǎn)生的值以及不斷將
// 函數(shù)調(diào)用得到的值作為參數(shù)繼續(xù)調(diào)用所組成，
// 例如下面會生成1,2,3....的整數(shù)流
Stream<Integer> stream5 = Stream.iterate(1, v -> v + 1);

// 創(chuàng)建范圍為[1, 5)組成的整數(shù)流
IntStream stream6 = IntStream.range(1, 5);

// 創(chuàng)建范圍為[1, 5]組成的整數(shù)流
IntStream stream7 = IntStream.rangeClosed(1, 5);

// 通過流的建造者模式創(chuàng)建流
Stream.Builder<Integer> builder = Stream.builder();
for (int i = 0; i < 10; i++) {
  // add 與 accept 方法均可將元素添加到流中
  // 區(qū)別是 add 無返回值, accept 會返回當前 builder 的 this 對象
  // 底層 add 方法也是調(diào)用了 accept 然后返回 this
  // 因此對于 add 方法可以進行鏈式調(diào)用
  builder.add(i);
  builder.accept(i);
}
Stream<Integer> stream8 = builder.build();

try {
  String dir = System.getProperty("user.dir");
  // 以下兩種方法均是獲取文件中行數(shù)據(jù)組成的流
  Stream<String> stream1 = new BufferedReader(new FileReader(dir + "\\demo.txt")).lines();
  Stream<String> stream2 = Files.lines(Paths.get(dir + "\\demo.txt"));
  // 獲取指定路徑下所有文件/文件夾的路徑組成的流
  Stream<Path> stream3 = Files.list(Paths.get("d:\\temp"));
  // 獲取指定路徑下以及指定最深文件層級內(nèi)(在這里為2)且滿足函數(shù)條件的所有文件/文件夾的路徑組成的流
  Stream<Path> stream4 = Files.find(
    Paths.get("d:\\temp"), 1, (path, basicFileAttributes) -> path.isAbsolute());
  // 獲取指定路徑下以及指定最深文件層級內(nèi)(在這里為2)所有文件/文件夾的路徑組成的流
  Stream<Path> stream5 = Files.walk(Paths.get("d:\\temp"), 2);
} catch (IOException e) {
  e.printStackTrace();
}

Random random = new Random();
// 以下三種方式得到的均是隨機數(shù)組成的<無限流>
IntStream stream1 = random.ints();
DoubleStream stream2 = random.doubles();
LongStream stream3 = random.longs();
Stream<Integer> boxedStream = stream1.boxed();

// 對數(shù)組元素進行倒序排序
// 如果不進行裝箱(boxed)處理，則只能使用默認的升序排序方法
// 通過裝箱，則可以通過自定義比較器，實現(xiàn)更加多樣的排序
int[] arr = {1, 5, 4, 6, 3, 9, 4, 5, 6, 4};
int[] reverseArr = Arrays.stream(arr)
             .boxed()
             .sorted(Comparator.reverseOrder())
             .mapToInt(Integer::valueOf)
             .toArray();
// output: [9, 6, 6, 5, 5, 4, 4, 4, 3, 1]
System.out.println(Arrays.toString(reverseArr));

String s = "1,2,3,4,5,6,7";
// 由分割后的字符串組成的流
// 在這里就是"1", "2", "3", "4", "5", "6", "7"組成的流
Stream<String> stream1 = Pattern.compile(",").splitAsStream(s);
BitSet bitSet = new BitSet();
for (int i = 0; i < 10; i++) {
  if (i % 2 == 0) {
    bitSet.set(i);
  }
}
// 由 bitset 中被設置為 true 的位下標所組成的流
// 在這里就是0, 2, 4, 6, 8
IntStream stream2 = bitSet.stream();
try {
  String dir = System.getProperty("user.dir");
  JarFile jarFile = new JarFile(dir + "\\demo.jar");
  // 由指定 jar 包中所有文件及文件夾的 JarEntry 對象所組形成的流
  Stream<JarEntry> stream3 = jarFile.stream();
} catch (IOException e) {
  e.printStackTrace();
}