openplanning

Hướng dẫn sử dụng Java Stream

Xem thêm các chuyên mục:

1- Stream

Java 8 đưa vào một khái niệm mới đó là Stream (dòng chẩy), lần đầu tiên đọc về Stream API có thể bạn sẽ bối rối vì cái tên của nó giống với InputStreamOutputStream, nhưng Java 8 Stream là thứ hoàn toàn khác. Stream là đơn nguyên (monad), do đó nó đóng một vai trò quan trọng trong việc đưa lập trình chức năng (functional programming) vào Java.
Trước khi bắt đầu với bài viết này tôi khuyến nghị bạn tìm hiểu trước về khái niệm functional interface và một vài functional interface thông dụng như Supplier, Consumer, Predicate. Dưới đây là các bài viết của tôi:
Trong lập trình chức năng (functional programming), một đơn nguyên (monad) là một cấu trúc đại diện cho một phép tính (computation) đòi hỏi một dẫy các bước liên kết với nhau. Để đơn giản hãy xem ví dụ đơn nguyên dưới đây:
List<String> myList = Arrays.asList("a1", "a2", "b1", "c2", "c1");

myList
      .stream() // (1)  return a Stream
      .filter(s -> s.startsWith("c")) // (2)  return a new Stream
      .map(String::toUpperCase)  // (3)  return a new Stream
      .sorted()   // (4)  return a new Stream
      .forEach(System.out::println); // (5)
Output:
C1
C2
  1. Tạo ra một Stream từ một đối tượng List.
  2. Tạo ra một Stream mới từ Stream trước và chỉ bao gồm các phần tử bắt đầu bởi chữ "c".
  3. Tạo ra một Stream mới từ Stream trước với tất cả các phần tử được chuyển thành chữ hoa (upercase).
  4. Tạo ra một Stream mới từ Stream trước bằng cách xắp xếp lại các phần tử.
  5. In ra các phần tử của Stream cuối cùng.
Trong ví dụ trên, các bước từ (2) đến (4) là các hoạt động trung gian (intermediate operation) vì chúng trả về một đối tượng Stream, vì vậy bạn có thể gọi tiếp một phương thức khác của Stream mà không phải kết thúc nó bởi một dấu chấm phẩy.
Hoạt động đầu cuối (terminal operation) là một phương thức trả về void hoặc trả về một kiểu khác với Stream. Trong ví dụ trên, bước 5 là một hoạt động đầu cuối vì phương thức Stream.forEach trả về void.
Sau đây là các đặc điểm và ưu điểm của Java 8 Stream:
  • Không lưu trữ. Stream không phải là một cấu trúc dữ liệu, mà chỉ là một khung nhìn của nguồn dữ liệu (Có thể là một mảng, danh sách hoặc một I/O Channel,..).
  • Một Stream là chức năng tự nhiên. Mọi sửa đổi đối với Stream sẽ không thay đổi nguồn dữ liệu. Ví dụ: lọc một Stream sẽ không xóa bất kỳ một phần tử nào, nhưng tạo ra một Stream mới bao gồm các phần tử được lọc.
  • Thực thi lười biếng. Các hoạt động trên Stream sẽ không được thực hiện ngay lập tức. Chúng sẽ chỉ được thực thi khi người dùng thực sự cần kết quả.
  • Có thể tiêu thụ (Consumable). Các phần tử của Stream chỉ được truy cập một lần trong suốt vòng đời của Stream. Sau khi được duyệt, Stream sẽ bị vô hiệu, giống như một Iterator. Bạn phải tạo lại Stream mới nếu bạn muốn xem lại Stream.
Hãy xem hình minh hoạ dưới đây để hiểu hơn về cách mà Stream hoạt động.
  1. Tạo một stream từ một tập hợp (collection).
  2. Lọc các mầu khác mầu đỏ.
  3. Sơn mầu hồng cho các hình tam giác.
  4. Lọc các hình khác hình vuông.
  5. Tính tổng diện tích.
Lớp Employee sẽ tham gia vào một vài ví dụ trong bài viết này:
Employee.java
package org.o7planning.stream.ex;

public class Employee {

    private String name;
    private float salary;
    private String gender; // "M", "F"

    public Employee(String name, float salary, String gender) {
        this.name = name;
        this.salary = salary;
        this.gender = gender;
    }

    public String getName() {
        return name;
    }

    public float getSalary() {
        return salary;
    }

    public String getGender() {
        return gender;
    }

    public boolean isFemale() {
        return "F".equals(this.getGender());
    }
}

2- Stream.filter(Predicate)

Trả về một Stream bao gồm các phần tử của Stream này phù hợp với Predicate đã cho.
Stream<T> filter(Predicate<? super T> predicate)
Ví dụ: Từ một danh sách các nhân viên (Employee), in ra danh sách các nhân viên nữ có lương lớn hơn 2500.
Stream_filter_ex1.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;

public class Stream_filter_ex1 {

    public static void main(String[] args) {

        Employee john = new Employee("John P.", 1500, "M");
        Employee sarah = new Employee("Sarah M.", 2000, "F");
        Employee charles = new Employee("Charles B.", 1700, "M");
        Employee mary = new Employee("Mary T.", 5000, "F");
        Employee sophia = new Employee("Sophia B.", 7000, "F");

        List<Employee> employees = Arrays.asList(john, sarah, charles, mary, sophia);
        
        // Employee is Female and salary > 2500
        Predicate<Employee> predicate = e -> e.isFemale() && e.getSalary() > 2500;

        employees //
             .stream() //
             .filter(predicate) //
             .forEach(e -> System.out.println(e.getName()+ " : " + e.getSalary()));
    }
}
Output:
Mary T. : 5000.0
Sophia B. : 7000.0
Nếu một phương thức không tĩnh (non-static method), không tham số, và trả về giá trị boolean thì tham chiếu của nó được coi là một Predicate. (Xem thêm giải thích trong bài viết của tôi về Java Predicate).
Ví dụ: Tạo một Predicate từ tham chiếu của phương thức (method reference):
Predicate<Employee> p = Employee::isFemale;
 
// Same as:
 
Predicate<Employee> p = employee -> employee.isFemale();
Stream_filter_ex2.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;

public class Stream_filter_ex2 {

    public static void main(String[] args) {
        Employee john = new Employee("John P.", 1500, "M");
        Employee sarah = new Employee("Sarah M.", 2000, "F");
        Employee charles = new Employee("Charles B.", 1700, "M");
        Employee mary = new Employee("Mary T.", 5000, "F");
        Employee sophia = new Employee("Sophia B.", 7000, "F");

        List<Employee> employees = Arrays.asList(john, sarah, charles, mary, sophia);

        employees //
             .stream() //
             .filter(Employee::isFemale) //
             .forEach(e -> System.out.println(e.getName()+ " : " + e.getSalary()));
    }
}
Output:
Sarah M. : 2000.0
Mary T. : 5000.0
Sophia B. : 7000.0

3- Stream.sorted(Comparator)

Trả về một Stream bao gồm các phần tử của luồng này, được sắp xếp theo Comparator được cung cấp.
Stream<T> sorted(Comparator<? super T> comparator)
  • TODO Link?
Ví dụ: Sắp xếp các nhân viên theo thứ tự lương tăng dần:
Stream_sort_ex1.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;

public class Stream_sort_ex1 {

    public static void main(String[] args) {
        Employee john = new Employee("John P.", 1500, "M");
        Employee sarah = new Employee("Sarah M.", 2000, "F");
        Employee charles = new Employee("Charles B.", 1700, "M");
        Employee mary = new Employee("Mary T.", 5000, "F");
        Employee sophia = new Employee("Sophia B.", 7000, "F");

        List<Employee> employees = Arrays.asList(john, sarah, charles, mary, sophia);

        employees //
             .stream() //
             .sorted (
                 (e1,e2) -> (int) (e1.getSalary() - e2.getSalary())
              ) //
             .forEach(e -> System.out.println(e.getSalary() + " : " + e.getName()));
    }
}
Output:
1500.0 : John P.
1700.0 : Charles B.
2000.0 : Sarah M.
5000.0 : Mary T.
7000.0 : Sophia B.
Ví dụ: Sắp xếp các nhân viên theo giới tính (Gender) và lương:
Stream_sort_ex2.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;

public class Stream_sort_ex2 {

    public static void main(String[] args) {
        Employee john = new Employee("John P.", 1500, "M");
        Employee sarah = new Employee("Sarah M.", 2000, "F");
        Employee charles = new Employee("Charles B.", 1700, "M");
        Employee mary = new Employee("Mary T.", 5000, "F");
        Employee sophia = new Employee("Sophia B.", 7000, "F");

        List<Employee> employees = Arrays.asList(john, sarah, charles, mary, sophia);

        employees //
             .stream() //
             .sorted (
                 (e1,e2) -> {
                     int v = e1.getGender().compareTo(e2.getGender());
                     if(v == 0) {
                         v = (int) (e1.getSalary() - e2.getSalary());
                     }
                     return v;
                 }
              ) //
             .forEach(e -> System.out.println(e.getGender()+ " : "+ e.getSalary() + " : " + e.getName()));
    }
}
Output:
F : 2000.0 : Sarah M.
F : 5000.0 : Mary T.
F : 7000.0 : Sophia B.
M : 1500.0 : John P.
M : 1700.0 : Charles B.

4- Stream.map(Function)

Trả về một Stream mới bao gồm các kết quả của việc áp dụng Function đã cho cho các phần tử của Stream này.
<R> Stream<R> map(Function<? super T,? extends R> mapper)
Ví dụ: Chuyển đổi một danh sách các String thành chữ hoa (uppercase).
Stream_map_ex1.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Stream_map_ex1 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");
        
        List<String> newList = list //
                    .stream() // a Stream
                    .map(s -> s.toUpperCase()) // a new Stream
                    .collect(Collectors.toList()); // Stream => List

        System.out.println(list); // [a, b, c, d, e]
        System.out.println(newList); // [A, B, C, D, E]
    }
}
Nếu một phương thức không tĩnh (non-static method), không tham số, và trả về một giá trị thì tham chiếu của nó được coi là một Function. (Xem thêm giải thích trong bài viết của tôi về Java Function).
// Create a Function from a method reference:
Function<String, String> f1 = String::toUpperCase;
// Same as:
Function<String, String> f2 = s -> s.toUpperCase();
Stream_map_ex2.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class Stream_map_ex2 {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c", "d", "e");
        
        List<String> newList = list //
                    .stream() // a Stream
                    .map(String::toUpperCase) // a new Stream
                    .collect(Collectors.toList()); // Stream => List  

        System.out.println(list); // [a, b, c, d, e]
        System.out.println(newList); // [A, B, C, D, E]
    }
}
Ví dụ: Tăng lương gấp 2 cho mỗi nhân viên trong một danh sách:
Stream_map_ex3.java
package org.o7planning.stream.ex;

import java.util.Arrays;
import java.util.List;

public class Stream_map_ex3 {

    public static void main(String[] args) {

        Employee john = new Employee("John P.", 1500, "M");
        Employee sarah = new Employee("Sarah M.", 2000, "F");
        Employee charles = new Employee("Charles B.", 1700, "M");
        Employee mary = new Employee("Mary T.", 5000, "F");
        Employee sophia = new Employee("Sophia B.", 7000, "F");

        List<Employee> employees = Arrays.asList(john, sarah, charles, mary, sophia);
        
        employees //
             .stream() // a Stream.
             .map((e) -> new Employee(e.getName(), e.getSalary()* 2, e.getGender())) // a new Stream.
             .forEach(c -> System.out.println(c.getName()+ " : " + c.getSalary()));
    }  
}
Output:
John P. : 3000.0
Sarah M. : 4000.0
Charles B. : 3400.0
Mary T. : 10000.0
Sophia B. : 14000.0

5- Stream.flatMap(Function)

public class Stream<T> {

    <R> Stream<R> flatMap​(Function<? super T,​? extends Stream<? extends R>> mapper);
    
    // .....
}
Phương thức Stream.flatMap là một phương thức khá hữu ích và có nhiều điều để nói vì vậy tôi đã tách nó ra trong một bài viết riêng:
  • TODO Link?

Xem thêm các chuyên mục:

Có thể bạn quan tâm

Đây là các khóa học trực tuyến bên ngoài website o7planning mà chúng tôi giới thiệu, nó có thể bao gồm các khóa học miễn phí hoặc giảm giá.