GP Coder

Trang chia sẻ kiến thức lập trình Java

  • Java Core
    • Basic Java
    • OOP
    • Exception Handling
    • Multi-Thread
    • Java I/O
    • Networking
    • Reflection
    • Collection
    • Java 8
  • Design pattern
    • Creational Pattern
    • Structuaral Pattern
    • Behavior Pattern
  • Web Service
    • SOAP
    • REST
  • JPA
  • Java library
    • Report
    • Json
    • Unit Test
  • Message Queue
    • ActiveMQ
    • RabbitMQ
  • All
Trang chủ Java Core Java 8 Tìm hiểu cơ chế Lazy Evaluation của Stream trong Java 8

Tìm hiểu cơ chế Lazy Evaluation của Stream trong Java 8

Đăng vào 15/09/2019 Được đăng bởi GP Coder 4052 Lượt xem

Trong bài viết “Giới thiệu về Stream API trong Java 8” , chúng ta đã tìm hiểu về các đặc điểm, các làm việc của Stream trong Java 8. Ở bài viết này, tôi muốn giải thích kỹ hơn về cơ chế Lazy Evaluation của Stream trong Java 8.

Như chúng ta đã biết, Stream có một đặc điểm rất quan trọng là cho phép tối ưu hóa hiệu xuất của chương trình thông qua cơ chế lazy evaluation, nghĩa là chúng không được thực hiện cho đến khi cần thiết. Các hoạt động tính toán trên source data chỉ được thực hiện khi một terminal operation được khởi tạo và các source element chỉ được sử dụng khi cần.

Hãy xem ví dụ sau:


import java.util.HashMap;
import java.util.Map;
import java.util.function.Predicate;
import java.util.stream.Stream;

import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
class Employee {
	String name;
	String department;
	int salary;
}

class EmployeeRepository {
	private static final Map<Integer, Employee> employees = new HashMap<>();
	static {
		employees.put(1, new Employee("gpcoder 1", "A", 50));
		employees.put(2, new Employee("gpcoder 2", "B", 100));
		employees.put(3, new Employee("gpcoder 3", "A", 150));
		employees.put(4, new Employee("gpcoder 4", "B", 200));
	}
	
	public Employee findById(Integer id) {
		System.out.println("findById: " + id);
		return employees.get(id);
	}
}

class EmployeeFilter {
	
	public static Predicate<Employee> filterDepartmentEqualsWith(String department) {
		return e -> {
			System.out.println("filterDepartmentEqualsWith: " + e);
			return e.getDepartment().equals(department);
		};
	}
	
	public static Predicate<Employee> filterSalaryGreaterThan(int salary) {
		return e -> {
			System.out.println("filterSalaryGreaterThan: " + e);
			return e.getSalary() >= salary;
		};
	}
}

public class Java8StreamDeeply {
	
	public static void main(String[] args) {
		EmployeeRepository employeeRepository = new EmployeeRepository();
		
		Integer[] empIds = { 1, 2, 3, 4 };
	    
	    Stream.of(empIds)
	      .map(employeeRepository::findById)
	      .filter(EmployeeFilter.filterSalaryGreaterThan(100))
	      .filter(EmployeeFilter.filterDepartmentEqualsWith("A"))
	      .findFirst();
	}
}

Chạy chương trình trên, chúng ta có kết quả như sau:


findById: 1
filterSalaryGreaterThan: Employee(name=gpcoder 1, department=A, salary=50)
findById: 2
filterSalaryGreaterThan: Employee(name=gpcoder 2, department=B, salary=100)
filterDepartmentEqualsWith: Employee(name=gpcoder 2, department=B, salary=100)
findById: 3
filterSalaryGreaterThan: Employee(name=gpcoder 3, department=A, salary=150)
filterDepartmentEqualsWith: Employee(name=gpcoder 3, department=A, salary=150)

Như bạn thấy, chương trình của chúng ta có 4 phần tử nhưng chỉ 3 phần tử được thực thi. Tại sao vậy?

Trong ví dụ trên, tôi sử dụng 3 Intermediate operations: 1 map() và 2 filter() operations. Chúng ta có 4 phần tử ở Stream source, mỗi phần tử có thể sẽ được thực thi 1 lần qua tất cả intermediate operation.

Đầu tiên, nó sẽ kiểm tra tất cả các operation trên phần tử có id là 1. Vì salary của nó không thõa filter salary, nên xử lý sẽ chuyển sang phần tử kế tiếp – id là 2. Không thực hiện trên filter deparment.

Tiếp theo, id 2 chỉ thõa mãn điều kiện salary, không thõa mãn điều kiện department, nên xử lý chuyển sang phần tử kế tiếp – id là 3.

Tại id 3, thõa mãn tất cả điều kiện ở trên và Stream evaluate yêu cầu Terminal Operations findFirst() và trả về kết quả.

Các operation trên các phần tử còn lại sẽ không được thực thi – id 4.

Có thể thấy rằng, Stream hoạt động tuần tự trên từng phần tử của source, duyệt qua tất cả các immediate operations, rồi đến terminal operation, cuối cùng mới chuyển sang phần tử kế tiếp (có thể không chuyển sang phần tử kế tiếp nếu đã thõa mãn mong muốn của terminal operation).

Tóm lại, quá trình xử lý các Stream một cách lười biếng (lazy) cho phép tránh việc kiểm tra tất cả dữ liệu khi không cần thiết. Cách làm này giúp cho Stream hoạt động rất hiệu quả khi có nhiều intermediate operation và nguồn dữ liệu là lớn.

Bài viết đến đây là hết, sau bài này hy vọng các bạn hiểu rõ hơn về Stream trong Java 8 và vận dụng nó thích hợp để đạt được hiệu quả tốt hơn.

4.8
18
Nếu bạn thấy hay thì hãy chia sẻ bài viết cho mọi người nhé!

Shares

Chuyên mục: Java 8 Được gắn thẻ: Java 8

Tổng hợp các bài viết về web services
Tạo số và chuỗi ngẫu nhiên trong Java

Có thể bạn muốn xem:

  • Giới thiệu Java 8 (23/04/2018)
  • Functional Interface trong Java 8 (30/04/2018)
  • Consumer trong Java 8 (28/05/2018)
  • Annotation trong Java 8 (09/07/2018)
  • Function trong Java 8 (11/06/2018)

Bình luận

bình luận

Tìm kiếm

Bài viết mới

  • Giới thiệu CloudAMQP – Một RabbitMQ server trên Cloud 02/10/2020
  • Kết nối RabbitMQ sử dụng Web STOMP Plugin 19/06/2020
  • Sử dụng publisher confirm trong RabbitMQ 16/06/2020
  • Sử dụng Dead Letter Exchange trong RabbitMQ 13/06/2020
  • Sử dụng Alternate Exchange trong RabbitMQ 10/06/2020

Xem nhiều

  • Hướng dẫn Java Design Pattern – Factory Method (54264 lượt xem)
  • Lập trình đa luồng trong Java (Java Multi-threading) (53062 lượt xem)
  • Hướng dẫn Java Design Pattern – Singleton (52704 lượt xem)
  • Xây dựng ứng dụng Client-Server với Socket trong Java (48765 lượt xem)
  • Giới thiệu Design Patterns (47929 lượt xem)

Lưu trữ

Thẻ đánh dấu

Annotation Authentication Basic Java Behavior Pattern Collection Creational Design Pattern Cấu trúc điều khiển Database Dependency Injection Design pattern Eclipse Exception Executor Service Google Guice Gson Hibernate How to Interceptor IO Jackson Java 8 Java Core JDBC JDK Jersey JMS JPA json JUnit JWT Message Queue Mockito Multithreading OOP Performance PowerMockito RabbitMQ Reflection Report REST SOAP Structuaral Pattern Thread Pool Unit Test Webservice

Liên kết website

Design Pattern

  • Refactoring Guru
  • Source Making

Lập trình Java

  • JavaTpoint
  • JavaWorld
  • Journaldev
  • TutorialsPoint
  • W3Schools Online Web Tutorials

Giới thiệu

GP Coder là trang web cá nhân, được thành lập với mục đích lưu trữ, chia sẽ kiến thức đã học và làm việc của tôi. Các bài viết trên trang này chủ yếu về ngôn ngữ Java và các công nghệ có liên quan đến Java như: Spring, JSF, Web Services, Unit Test, Hibernate, SQL, ...
Hi vọng góp được chút ít công sức cho sự phát triển cộng đồng Coder Việt.

Tìm kiếm các bài viết của GP Coder với Google Search

Liên hệ

Các bạn có thể liên hệ với tôi thông qua:
  • Trang liên hệ
  • Linkedin: gpcoder
  • Email: contact@gpcoder.com
  • Skype: ptgiang56it

Follow me

Copyright 2022 © GP Coder · All Rights Reserved · Giới thiệu · Chính sách · Điều khoản · Liên hệ ·

sponsored

Share

Blogger
Delicious
Digg
Email
Facebook
Facebook messenger
Google
Hacker News
Line
LinkedIn
Mix
Odnoklassniki
PDF
Pinterest
Pocket
Print
Reddit
Renren
Short link
SMS
Skype
Telegram
Tumblr
Twitter
VKontakte
wechat
Weibo
WhatsApp
Xing
Yahoo! Mail
Powered by WP Socializer

Copy short link

Copy link
Powered by WP Socializer