關於Streamd使用

引言

　　Stream 是 Java8 中處理集合的關鍵抽象概念，它能夠指定你但願對集合進行的操做，能夠執行很是複雜的查找、過濾和映射數據等操做。使用Stream API 對集合數據進行操做，就相似於使用 SQL 執行的數據庫查詢。也可使用 Stream API 來並行執行操做。簡而言之，Stream API 提供了一種高效且易於使用的處理數據的方式。

轉自：http://www.javashuo.com/article/p-mcrdtoif-mu.html

特色：

        1 . 不是數據結構，不會保存數據。

        2. 不會修改原來的數據源，它會將操做後的數據保存到另一個對象中。（保留意見：畢竟peek方法能夠修改流中元素）

        3. 惰性求值，流在中間處理過程當中，只是對操做進行了記錄，並不會當即執行，須要等到執行終止操做的時候纔會進行實際的計算。

建立流

// 獲取順序流
Stream stream = new ArrayList().stream(); 
// 獲取並行流
Stream parallelStream = new ArrayList().parallelStream(); 
// 數組轉成流
Integer[] nums = {1,2,3};
Stream<Integer> streamArray = Arrays.stream(nums);

 

賦值

// of方法直接賦值
Stream<Integer> stream1 = Stream.of(1,2,3,4,5);
stream1.forEach(System.out::println); // 1 2 3 4 5
​
// iterate生成生成無限順序有序流，主要做用是抽象迭代邏輯
Stream<Integer> stream2 = Stream.iterate(2, x -> x * 2).limit(5);
stream2.forEach(System.out::println); // 2 4 8 16 32
​
// generate生成無限順序無序流，其中每一個元素由提供的供應商生成。這適用於生成恆定流，隨機元素流等。
Stream<Integer> stream3 = Stream.generate(new Random()::nextInt).limit(2);
stream3.forEach(System.out::println); //15356208 -2042159

 

篩選與切片

filter：過濾流中的某些元素 limit(n)：獲取n個元素 skip(n)：跳過n元素 distinct：經過流中元素的 hashCode() 和 equals() 去除重複元素

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10};
Stream<Integer> streamArray = Arrays.stream(nums);
Stream<Integer> result = streamArray
        .distinct()  // 去重 1 2 3 4 5 6 7 8 9 10
        .filter(i -> (i > 2)) // 篩選出值>2的元素 3 4 5 6 7 8 9 10
        .skip(2) // 跳過前2個元素 5 6 7 8 9 10
        .limit(4); // 獲取前4個元素 5 6 7 8

 

映射

map：接收一個函數做爲參數，該函數會被應用到每一個元素上，並將其映射成一個新的元素

Integer[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10};
Stream<Integer> streamArray = Arrays.stream(nums);
List<String> strings = streamArray
        .map(String::valueOf) // 經過String.valueOf()方法將各個元素轉爲字符串
        .collect(Collectors.toList()); // 將流轉爲List集合

flatMap：接收一個函數做爲參數，將流中的每一個值都換成另外一個流，而後把全部流鏈接成一個流

Stream<String> streamArray2 = Stream.of("1.2.3", "4.5.6", "7.8.9");
List<String> result = streamArray2
        .flatMap(s -> Arrays.stream(s.split("\\."))) //將流中的每一個值都換成另外一個流，而後分割
        .collect(Collectors.toList());
// 1 2 3 4 5 6 7 8 9

 

排序

sorted()：天然排序，流中元素需實現Comparable接口

List<String> list = Arrays.asList("a", "d", "c", "b", "x");
List<String> result = list.stream()
  .sorted()
  .collect(Collectors.toList());
// a b c d x

sorted(Comparator com)：定製排序，自定義Comparator排序器

Person s1 = new Person("aa", 10);
Person s2 = new Person("bb", 20);
Person s3 = new Person("aa", 30);
Person s4 = new Person("dd", 40);
List<Person> personList = Arrays.asList(s1, s2, s3, s4);

//自定義排序：先按姓名升序，姓名相同則按年齡升序
personList.stream().sorted(
       (o1, o2) -> {
            if (o1.getName().equals(o2.getName())) {
                return o1.getAge() - o2.getAge();
           } else {
                return o1.getName().compareTo(o2.getName());
           }
       }
).forEach(person -> System.out.println(person.getName()));

消費

peek：如同於map，能獲得流中的每個元素。但map接收的是一個Function表達式，有返回值；而peek接收的是Consumer表達式，沒有返回值

Person s1 = new Person("aa", 10);
Person s2 = new Person("bb", 20);
Person s3 = new Person("aa", 30);
Person s4 = new Person("dd", 40);
List<Person> personList = Arrays.asList(s1, s2, s3, s4);
​
personList.stream()
        .peek(person -> person.setAge(100))
        .forEach(person -> System.out.println(person.getName()+":"+person.getAge()));

 

匹配

allMatch：接收一個 Predicate 函數，當流中每一個元素都符合該斷言時才返回true，不然返回false

List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
// 裏面的元素是否都知足>10這個條件
boolean result = integers.stream().allMatch(i -> i > 10); // false

noneMatch：接收一個 Predicate 函數，當流中每一個元素都不符合該斷言時才返回true，不然返回false

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
// 裏面的元素是否都 不 知足>10這個條件
boolean result = list.stream().noneMatch(i -> i > 10); // true

anyMatch：接收一個 Predicate 函數，只要流中存在元素知足該斷言則返回true，不然返回false

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 11);
// 裏面的元素是否存在知足>10這個條件
boolean result = list.stream().anyMatch(i -> i > 10); // true

findFirst：返回流中第一個元素

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 11);
// Optional對象經常使用於解決空指針問題
Optional<Integer> optional = list.stream().findFirst();
System.out.println(optional.get()); // 1

count：返回流中元素的總個數

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 11);
Long result = list.stream().count();
System.out.println(result); // 6

max：返回流中元素最大值

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 11);
Integer max = list.stream().max(Integer::compareTo).get(); // 11

min：返回流中元素最小值

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 11);
Integer min = list.stream().min(Integer::compareTo).get(); // 1