Java8 Stream經常使用API整理（值得收藏）

點擊上方「Java專欄」，選擇「置頂或者星標」
web

第一時間閱讀精彩文章！sql

點擊這段文字獲取：5個能夠寫到簡歷的項目實戰視頻教程（含源碼）微信

題圖：pexelsapp

做者：程銘程銘你快成名編輯器

來源：https://blog.csdn.net/wangchengming1/article/details/89245402函數

Java8中有兩大最爲重要的改變，第一個是Lambda表達式，另一個則是Stream API。ui

流是 Java8 引入的全新概念，它用來處理集合中的數據。this
衆所周知，集合操做很是麻煩，若要對集合進行篩選、投影，須要寫大量的代碼，而流是以聲明的形式操做集合，它就像 SQL 語句，咱們只需告訴流須要對集合進行什麼操做，它就會自動進行操做，並將執行結果交給你，無需咱們本身手寫代碼。spa
在項目中使用 Stream API 能夠大大提升效率以及代碼的可讀性，使咱們對數據進行處理的時候事半功倍。.net

這篇博文以實戰角度出發，講解平時開發中經常使用 API 的用法以及一些注意的地方。

首先建立一個對象

public class Employee {

  private int id;
  private String name;
  private int age;
  private double salary;
  private Status status;

  public enum Status {
    FREE, BUSY, VOCATION;
  }

  public Employee() {
  }

  public Employee(String name) {
    this.name = name;
  }

  public Employee(String name, int age) {
    this.name = name;
    this.age = age;
  }
  
  public Employee(int id, String name, int age, double salary) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.salary = salary;
  }

  public Employee(int id, String name, int age, double salary, Status status) {
    this.id = id;
    this.name = name;
    this.age = age;
    this.salary = salary;
    this.status = status;
  }
  //省略get，set等。。。
}

隨便初始化一些數據

List<Employee> empList = Arrays.asList(new Employee(102, "李四", 59, 6666.66, Status.BUSY),
      new Employee(101, "張三", 18, 9999.99, Status.FREE), new Employee(103, "王五", 28, 3333.33, Status.VOCATION),
      new Employee(104, "趙六", 8, 7777.77, Status.BUSY), new Employee(104, "趙六", 8, 7777.77, Status.FREE),
      new Employee(104, "趙六", 8, 7777.77, Status.FREE), new Employee(105, "田七", 38, 5555.55, Status.BUSY));

中間操做

根據條件篩選 filter

/**
* 接收Lambda, 從流中排除某些元素。
*/
@Test
void testFilter() {
  empList.stream().filter((e) -> {
    return e.getSalary() >= 5000;
  }).forEach(System.out::println);
}

跳過流的前n個元素 skip

/**
* 跳過元素，返回一個扔掉了前n個元素的流。
*/
@Test
void testSkip() {
  empList.stream().filter((e) -> e.getSalary() >= 5000).skip(2).forEach(System.out::println);
}

去除重複元素 distinct

/**
* 篩選，經過流所生成元素的 hashCode() 和 equals() 去除重複元素
*/
@Test
void testDistinct() {
  empList.stream().distinct().forEach(System.out::println);
}

截取流的前n個元素 limit

/**
* 截斷流，使其元素不超過給定數量。
*/
@Test
void testLimit() {
  empList.stream().filter((e) -> {
    return e.getSalary() >= 5000;
  }).limit(3).forEach(System.out::println);
}

映射 map

/**
* 接收一個函數做爲參數，該函數會被應用到每一個元素上，並將其映射成一個新的元素
*/
@Test
void testMap() {
  empList.stream().map(e -> e.getName()).forEach(System.out::println);

  empList.stream().map(e -> {
    empList.forEach(i -> {
      i.setName(i.getName() + "111");
    });
    return e;
  }).collect(Collectors.toList());
}

天然排序 sorted

/**
* 產生一個新流，其中按天然順序排序
*/
@Test
void testSorted() {
  empList.stream().map(Employee::getName).sorted().forEach(System.out::println);
}

自定義排序 sorted(Comparator comp)

/**
* 產生一個新流，其中按天然順序排序
*/
@Test
void testSortedComparator() {
  empList.stream().sorted((x, y) -> {
   if (x.getAge() == y.getAge()) {
     return x.getName().compareTo(y.getName());
    } else {
     return Integer.compare(x.getAge(), y.getAge());
   }
  }).forEach(System.out::println);
}

最終操做

是否匹配任一元素 anyMatch

/**
 * 檢查是否至少匹配一個元素
 */
@Test
void testAnyMatch() {
  boolean b = empList.stream().anyMatch((e) -> e.getStatus().equals(Status.BUSY));
  System.out.println("boolean is : " + b);
}

是否匹配全部元素 allMatch

/**
 * 檢查是否匹配全部元素
 */
@Test
void testAllMatch() {
  boolean b = empList.stream().allMatch((e) -> e.getStatus().equals(Status.BUSY));
  System.out.println("boolean is : " + b);
}

是否未匹配全部元素 noneMatch

/**
 * 檢查是否沒有匹配的元素
 */
@Test
void testNoneMatch() {
  boolean b = empList.stream().noneMatch((e) -> e.getStatus().equals(Status.BUSY));
  System.out.println("boolean is : " + b);
}

返回第一個元素 findFirst

/**
 * 返回第一個元素
 */
@Test
void testFindFirst() {
  Optional<Employee> op = empList.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
      .findFirst();
  if (op.isPresent()) {
    System.out.println("first employee name is : " + op.get().getName().toString());
  }
}

返回流中任意元素 findAny

/**
 * 返回當前流中的任意元素
 */
@Test
void testFindAny() {
  Optional<Employee> op = empList.stream().sorted((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()))
      .findAny();
  if (op.isPresent()) {
    System.out.println("any employee name is : " + op.get().getName().toString());
  }
}

返回流的總數 count

/**
 * 返回流中元素的總個數
 */
@Test
void testCount() {
  long count = empList.stream().filter((e) -> e.getStatus().equals(Status.FREE)).count();
  System.out.println("Count is : " + count);
}

返回流中的最大值 max

/**
 * 返回流中最大值
 */
@Test
void testMax() {
  Optional<Double> op = empList.stream().map(Employee::getSalary).max(Double::compare);
  System.out.println(op.get());
}

返回流中的最小值 min

/**
 * 返回流中最小值
 */
@Test
void testMin() {
  Optional<Employee> op2 = empList.stream().min((e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
  System.out.println(op2.get());
}

歸約 reduce
歸約是將集合中的全部元素通過指定運算，摺疊成一個元素輸出

/**
 * 能夠將流中元素反覆結合起來，獲得一個值。返回T
 */
@Test
void testReduce() {
  Optional<Double> op = empList.stream().map(Employee::getSalary).reduce(Double::sum);

  System.out.println(op.get());
}

/**
 * 能夠將流中元素反覆結合起來，獲得一個值，返回Optional< T>
 */
@Test
void testReduce1() {
  Optional<Integer> sum = empList.stream().map(Employee::getName).flatMap(Java8Stream::filterCharacter)
      .map((ch) -> {
        if (ch.equals('六'))
          return 1;
        else
          return 0;
      }).reduce(Integer::sum);
  System.out.println(sum.get());
}

將元素收集到 list 裏 Collectors.toList()

/**
 * 把流中的元素收集到list裏。
 */
@Test
void testCollectorsToList() {
  List<String> list = empList.stream().map(Employee::getName).collect(Collectors.toList());
  list.forEach(System.out::println);
}

將元素收集到 set 裏 Collectors.toSet()

/**
 * 把流中的元素收集到set裏。
 */
@Test
void testCollectorsToSet() {
  Set<String> list = empList.stream().map(Employee::getName).collect(Collectors.toSet());
  list.forEach(System.out::println);
}

把流中的元素收集到新建立的集合裏 Collectors.toCollection(HashSet::new)

/**
 * 把流中的元素收集到新建立的集合裏。
 */
@Test
void testCollectorsToCollection() {
  HashSet<String> hs = empList.stream().map(Employee::getName).collect(Collectors.toCollection(HashSet::new));
  hs.forEach(System.out::println);
}

根據比較器選擇最大值 Collectors.maxBy()

/**
 * 根據比較器選擇最大值。
 */
@Test
void testCollectorsMaxBy() {
  Optional<Double> max = empList.stream().map(Employee::getSalary).collect(Collectors.maxBy(Double::compare));
  System.out.println(max.get());
}

根據比較器選擇最小值 Collectors.minBy()

/**
 * 根據比較器選擇最小值。
 */
@Test
void testCollectorsMinBy() {
  Optional<Double> max = empList.stream().map(Employee::getSalary).collect(Collectors.minBy(Double::compare));
  System.out.println(max.get());
}

對流中元素的某個字段求和 Collectors.summingDouble()

/**
 * 對流中元素的整數屬性求和。
 */
@Test
void testCollectorsSummingDouble() {
  Double sum = empList.stream().collect(Collectors.summingDouble(Employee::getSalary));
  System.out.println(sum);
}

對流中元素的某個字段求平均值 Collectors.averagingDouble()

/**
 * 計算流中元素Integer屬性的平均值。
 */
@Test
void testCollectorsAveragingDouble() {
  Double avg = empList.stream().collect(Collectors.averagingDouble(Employee::getSalary));
  System.out.println(avg);
}

分組，相似sql的 group by Collectors.groupingBy

/**
 * 分組
 */
@Test
void testCollectorsGroupingBy() {
  Map<Status, List<Employee>> map = empList.stream().collect(Collectors.groupingBy(Employee::getStatus));

  System.out.println(map);
}

多級分組

/**
 * 多級分組
 */
@Test
void testCollectorsGroupingBy1() {
  Map<Status, Map<String, List<Employee>>> map = empList.stream()
      .collect(Collectors.groupingBy(Employee::getStatus, Collectors.groupingBy((e) -> {
        if (e.getAge() >= 60)
          return "老年";
        else if (e.getAge() >= 35)
          return "中年";
        else
          return "成年";
      })));
  System.out.println(map);
}

字符串拼接 Collectors.joining()

/**
 * 字符串拼接
 */
@Test
void testCollectorsJoining() {
  String str = empList.stream().map(Employee::getName).collect(Collectors.joining(",", "----", "----"));
  System.out.println(str);
}

public static Stream<Character> filterCharacter(String str) {

  List<Character> list = new ArrayList<>();
  for (Character ch : str.toCharArray()) {
    list.add(ch);
  }
  return list.stream();
}

  
     
     
      
      
      
  
     
   
      
      
       
       
       
   
       
        
         
          
           
           以上，即是今天的分享，但願你們喜歡，以爲內容不錯的，歡迎點擊「在看」支持，謝謝各位

150頁，8W字的Java知識手冊

獲取方式：

一、公衆號後臺回覆「手冊」

二、掃描下方二維碼，回覆「手冊」

 
    
    
     
     
     
 
    
  
     
     
      
      
      
  
     👆
  
     
     
      
      
      
  
     長按上方二維碼 2 秒
 
    
    
     
     
     
 
    
 
    
    
     
     
     
 
    
  
     
     
      
      
      
  
     回覆「
  
     
     
      
      
      
  
     手冊
  
     
     
      
      
      
  
     」便可獲取資料

本文分享自微信公衆號 - Java專欄（finishbug）。
若有侵權，請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。