巧用Java8中的Stream，讓集合操做飛起來！

時間  2019-11-11
標籤 巧用 java8 java stream 集合 飛起 欄目 Java 简体版
原文   原文鏈接

做者：堅持就是勝利javascript

juejin.im/post/5d5e2616f265da03b638b28ajava

簡介編程

java8也出來很久了，接口默認方法，lambda表達式，函數式接口，Date API等特性仍是有必要去了解一下。好比在項目中常常用到集合，遍歷集合能夠試下lambda表達式，常常還要對集合進行過濾和排序，Stream就派上用場了。用習慣了，不得不說真的很好用。app

Stream做爲java8的新特性，基於lambda表達式，是對集合對象功能的加強，它專一於對集合對象進行各類高效、便利的聚合操做或者大批量的數據操做，提升了編程效率和代碼可讀性。框架

Stream的原理：將要處理的元素看作一種流，流在管道中傳輸，而且能夠在管道的節點上處理，包括過濾篩選、去重、排序、聚合等。元素流在管道中通過中間操做的處理，最後由最終操做獲得前面處理的結果。分佈式

集合有兩種方式生成流：ide

  • stream() − 爲集合建立串行流函數

  • parallelStream() - 爲集合建立並行流post

640?wx_fmt=png

上圖中是Stream類的類結構圖，裏面包含了大部分的中間和終止操做。性能

中間操做主要有如下方法（此類型方法返回的都是Stream）：map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered

終止操做主要有如下方法：forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

舉例說明

首先爲了說明Stream對對象集合的操做，新建一個Student類（學生類）,覆寫了equals()和hashCode()方法

public class Student {

    private Long id;

    private String name;

    private int age;

    private String address;

    public Student() {}

    public Student(Long id, String name, int age, String address) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return age == student.age &&
                Objects.equals(id, student.id) &&
                Objects.equals(name, student.name) &&
                Objects.equals(address, student.address);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, age, address);
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

}

filter（篩選）

public static void main(String [] args) {

        Student s1 = new Student(1L, "肖戰", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        List<Student> streamStudents = testFilter(students);
        streamStudents.forEach(System.out::println);
    }
    /**
     * 集合的篩選
     * @param students
     * @return
     */
    private static List<Student> testFilter(List<Student> students) {
        //篩選年齡大於15歲的學生
//        return students.stream().filter(s -> s.getAge()>15).collect(Collectors.toList());
        //篩選住在浙江省的學生
        return students.stream().filter(s ->"浙江".equals(s.getAddress())).collect(Collectors.toList());
    }

運行結果：

640?wx_fmt=other

這裏咱們建立了四個學生，通過filter的篩選，篩選出地址是浙江的學生集合。

map(轉換)

    public static void main(String [] args) {

        Student s1 = new Student(1L, "肖戰", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);

        testMap(students);
    }

    /**
     * 集合轉換
     * @param students
     * @return
     */
    private static void testMap(List<Student> students) {
        //在地址前面加上部分信息，只獲取地址輸出
        List<String> addresses = students.stream().map(s ->"住址:"+s.getAddress()).collect(Collectors.toList());
        addresses.forEach(a ->System.out.println(a));
    }

運行結果

640?wx_fmt=other

map就是將對應的元素按照給定的方法進行轉換。

distinct(去重)

    public static void main(String [] args) {

      testDistinct1();
    }

    /**
     * 集合去重（基本類型）
     */
    private static void testDistinct1() {
        //簡單字符串的去重
        List<String> list = Arrays.asList("111","222","333","111","222");
        list.stream().distinct().forEach(System.out::println);
    }

運行結果：

640?wx_fmt=other

public static void main(String [] args) {

      testDistinct2();
    }

    /**
     * 集合去重（引用對象）
     */
    private static void testDistinct2() {
        //引用對象的去重，引用對象要實現hashCode和equal方法，不然去重無效
        Student s1 = new Student(1L, "肖戰", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        Student s5 = new Student(1L, "肖戰", 15, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.add(s5);
        students.stream().distinct().forEach(System.out::println);
    }

運行結果：

640?wx_fmt=png

能夠看出，兩個重複的「肖戰」同窗進行了去重，這不只由於使用了distinct()方法，並且由於Student對象重寫了equals和hashCode()方法，不然去重是無效的。

sorted(排序)

    public static void main(String [] args) {

        testSort1();
    }

    /**
     * 集合排序（默認排序）
     */
    private static void testSort1() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().sorted().forEach(System.out::println);
    }

運行結果：

640?wx_fmt=other

    public static void main(String [] args) {

        testSort2();
    }

    /**
     * 集合排序（指定排序規則）
     */
    private static void testSort2() {
        Student s1 = new Student(1L, "肖戰", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        students.stream()
                .sorted((stu1,stu2) ->Long.compare(stu2.getId(), stu1.getId()))
                .sorted((stu1,stu2) -> Integer.compare(stu2.getAge(),stu1.getAge()))
                .forEach(System.out::println);
    }

運行結果：

640?wx_fmt=png

上面指定排序規則，先按照學生的id進行降序排序，再按照年齡進行降序排序

limit（限制返回個數）

    public static void main(String [] args) {

        testLimit();
    }

    /**
     * 集合limit，返回前幾個元素
     */
    private static void testLimit() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().limit(2).forEach(System.out::println);
    }

運行結果：

640?wx_fmt=png

skip(刪除元素)

    public static void main(String [] args) {

        testSkip();
    }

    /**
     * 集合skip，刪除前n個元素
     */
    private static void testSkip() {
        List<String> list = Arrays.asList("333","222","111");
        list.stream().skip(2).forEach(System.out::println);
    }

運行結果：

640?wx_fmt=png

reduce(聚合)

    public static void main(String [] args) {
        testReduce();
    }
    /**
     * 集合reduce,將集合中每一個元素聚合成一條數據
     */
    private static void testReduce() {
        List<String> list = Arrays.asList("歡","迎","你");
        String appendStr = list.stream().reduce("北京",(a,b) -> a+b);
        System.out.println(appendStr);
    }

運行結果：

640?wx_fmt=png

min(求最小值)

    public static void main(String [] args) {
        testMin();
    }

    /**
     * 求集合中元素的最小值
     */
    private static void testMin() {
        Student s1 = new Student(1L, "肖戰", 14, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        Student minS = students.stream().min((stu1,stu2) ->Integer.compare(stu1.getAge(),stu2.getAge())).get();
        System.out.println(minS.toString());
    }

運行結果：

640?wx_fmt=png

上面是求全部學生中年齡最小的一個，max同理，求最大值。

anyMatch/allMatch/noneMatch（匹配）

    public static void main(String [] args) {
        testMatch();
    }

    private static void testMatch() {
        Student s1 = new Student(1L, "肖戰", 15, "浙江");
        Student s2 = new Student(2L, "王一博", 15, "湖北");
        Student s3 = new Student(3L, "楊紫", 17, "北京");
        Student s4 = new Student(4L, "李現", 17, "浙江");
        List<Student> students = new ArrayList<>();
        students.add(s1);
        students.add(s2);
        students.add(s3);
        students.add(s4);
        Boolean anyMatch = students.stream().anyMatch(s ->"湖北".equals(s.getAddress()));
        if (anyMatch) {
            System.out.println("有湖北人");
        }
        Boolean allMatch = students.stream().allMatch(s -> s.getAge()>=15);
        if (allMatch) {
            System.out.println("全部學生都滿15週歲");
        }
        Boolean noneMatch = students.stream().noneMatch(s -> "楊洋".equals(s.getName()));
        if (noneMatch) {
            System.out.println("沒有叫楊洋的同窗");
        }
    }

運行結果：

640?wx_fmt=png

anyMatch：Stream 中任意一個元素符合傳入的 predicate，返回 true

allMatch：Stream 中所有元素符合傳入的 predicate，返回 true

noneMatch：Stream 中沒有一個元素符合傳入的 predicate，返回 true

總結

上面介紹了Stream經常使用的一些方法，雖然對集合的遍歷和操做能夠用之前常規的方式，可是當業務邏輯複雜的時候，你會發現代碼量不少，可讀性不好，明明一行代碼解決的事情，你卻寫了好幾行。試試lambda表達式，試試Stream，你會有不同的體驗。

【推薦閱讀】

[技術]：分佈式 RPC 框架性能大比拼

[技術]：咱們公司使用了 6 年的分佈式鎖，非常牛逼啊！

[技術]：提高10倍生產力：IDEA遠程一鍵部署SpringBoot到Docker

[職場]：大公司病(太現實了！)

[技術]：用了這麼久 IDEA ，你居然不知道有個功能叫自動補全！

[技術]：細思極恐 - 你真的會寫Java嗎

640?wx_fmt=jpeg

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程