# Giới thiệu về Generics và Stream trong Java Trong lập trình Java, **Generics** và **Stream** là hai tính năng quan trọng giúp nâng cao hiệu quả viết mã, tối ưu hóa quy trình xử lý dữ liệu và bảo đảm tính an toàn cho kiểu dữ liệu. Bài viết này sẽ hướng dẫn bạn cách sử dụng và những lợi ích mà chúng mang lại. ## 1. Generics Generics là một tính năng được giới thiệu từ Java 5, cho phép chúng ta viết mã tổng quát hơn, giảm thiểu lỗi trong quá trình thực thi, và cải thiện khả năng tái sử dụng mã. ### Tại sao cần sử dụng Generics? - **An toàn kiểu dữ liệu (Type Safety)**: Đảm bảo rằng chỉ các kiểu dữ liệu mong muốn được sử dụng. - **Giảm lỗi Runtime**: Các lỗi liên quan đến kiểu dữ liệu sẽ được phát hiện ngay từ khi biên dịch. - **Tái sử dụng mã (Code Reusability)**: Cho phép tạo các lớp, phương thức hoặc giao diện hoạt động với bất kỳ kiểu dữ liệu nào mà không cần viết lại mã. ### Cách sử dụng Generics #### 1. Ví dụ với Lớp ```java public class Box { private T value; public void setValue(T value) { this.value = value; } public T getValue() { return value; } } Box stringBox = new Box<>(); stringBox.setValue("Hello Generics"); System.out.println(stringBox.getValue()); // Output: Hello Generics Box integerBox = new Box<>(); integerBox.setValue(123); System.out.println(integerBox.getValue()); // Output: 123 ``` #### 2. Ví dụ với phương thức ```java public class Utility { public static void printArray(T[] array) { for (T element : array) { System.out.println(element); } } } String[] stringArray = {"A", "B", "C"}; Integer[] intArray = {1, 2, 3}; Utility.printArray(stringArray); // Output: A, B, C Utility.printArray(intArray); // Output: 1, 2, 3 ``` #### 3. Ví dụ với Interface ```java public interface Pair { K getKey(); V getValue(); } class KeyValuePair implements Pair { private K key; private V value; public KeyValuePair(K key, V value) { this.key = key; this.value = value; } public K getKey() { return key; } public V getValue() { return value; } } Pair pair = new KeyValuePair<>(1, "One"); System.out.println(pair.getKey()); // Output: 1 System.out.println(pair.getValue()); // Output: One ``` #### 4. Wildcards trong Generics Wildcards được sử dụng trong trường hợp bạn không chắc chắn về kiểu dữ liệu: - **Unbounded Wildcard (? ê)** - **Upper Bounded Wildcard ()**: Chấp nhận các kiểu là T hoặc subclass của T. - **Lower Bounded Wildcard ()**: Chấp nhận các kiểu là T hoặc superclass của T. #### 5. Generics và Erasure Generics chỉ tồn tại trong thời gian biên dịch. Tại thời điểm runtime, Java sử dụng type erasure để thay thế tất cả các tham chiếu kiểu bằng Object hoặc một kiểu biên dịch được xác định. **Lưu ý:** không thể sử dụng Primitive Types (int, double) trong Generics. ## 2. Stream trong Java Stream là một tính năng mới trong Java 8, thuộc gói `java.util.stream`. Nó hỗ trợ lập trình hàm và giúp xử lý các tập hợp dữ liệu với tính dễ dàng, gọn gàng và hiệu quả. ### Đặc điểm của Stream: 1. **Không lưu trữ dữ liệu**: Chỉ xử lý dữ liệu mà không giữ lại. 2. **Dựa trên pipeline**: Gồm ba giai đoạn chính: tạo Stream, thực hiện thao tác trung gian, và thao tác kết thúc. 3. **Lazy Evaluation**: Các thao tác được thực hiện chỉ khi cần thiết. 4. **Không thay đổi nguồn dữ liệu**: Stream không làm thay đổi Collection hoặc mảng ban đầu. ### Cách tạo Stream ```java // Từ Collection List names = List.of("Alice", "Bob", "Charlie"); Stream stream = names.stream(); // Từ Array String[] array = {"A", "B", "C"}; Stream stream = Arrays.stream(array); // Tạo Stream từ giá trị Stream stream = Stream.of("X", "Y", "Z"); // Tạo Stream vô hạn Stream infiniteStream = Stream.iterate(0, n -> n + 2); // 0, 2, 4, ... ``` ### Các thao tác trên Stream #### 1. Thao tác trung gian ```java // filter() List numbers = List.of(1, 2, 3, 4, 5); numbers.stream() .filter(n -> n % 2 == 0) .forEach(System.out::println); // Output: 2, 4 // map() List names = List.of("alice", "bob", "charlie"); names.stream() .map(String::toUpperCase) .forEach(System.out::println); // Output: ALICE, BOB, CHARLIE // sorted() List names = List.of("Charlie", "Bob", "Alice"); names.stream() .sorted() .forEach(System.out::println); // Output: Alice, Bob, Charlie // distinct() List numbers = List.of(1, 2, 2, 3, 3, 4); numbers.stream() .distinct() .forEach(System.out::println); // Output: 1, 2, 3, 4 // limit() Stream infiniteStream = Stream.iterate(0, n -> n + 1); infiniteStream.limit(5).forEach(System.out::println); // Output: 0, 1, 2, 3, 4 // skip() List numbers = List.of(1, 2, 3, 4, 5); numbers.stream() .skip(2) .forEach(System.out::println); // Output: 3, 4, 5 ``` #### 2. Thao tác kết thúc ```java // forEach() List names = List.of("Alice", "Bob", "Charlie"); names.stream().forEach(System.out::println); // collect() List result = names.stream() .filter(name -> name.startsWith("A")) .collect(Collectors.toList()); System.out.println(result); // Output: [Alice] // toArray() String[] array = names.stream().toArray(String[]::new); // reduce() int sum = numbers.stream() .reduce(0, Integer::sum); System.out.println(sum); // Output: 10 // count() long count = names.stream() .filter(name -> name.startsWith("A")) .count(); System.out.println(count); // Output: 1 // anyMatch(), allMatch(), noneMatch() boolean hasAlice = names.stream().anyMatch(name -> name.equals("Alice")); // true boolean allShort = names.stream().allMatch(name -> name.length() < 10); // true // findFirst() Optional first = names.stream().findFirst(); first.ifPresent(System.out::println); // Output: Alice ``` ### Lợi ích của Stream 1. **Mã sạch và dễ đọc hơn**: Việc xử lý dữ liệu trở nên trực quan hơn. 2. **Tối ưu hóa hiệu suất**: Các thao tác được thực hiện chỉ khi cần thiết. 3. **Hỗ trợ xử lý song song**: Dễ dàng áp dụng `parallelStream()` để xử lý dữ liệu song song. ### Kết luận Generics và Stream là hai công cụ mạnh mẽ trong Java giúp lập trình viên tăng cường hiệu suất, độ an toàn và khả năng tái sử dụng mã. Việc nắm vững cách sử dụng chúng sẽ giúp bạn trở thành một lập trình viên Java tốt hơn. source: viblo

Bài viết về chủ đềGeneric

Tổng hợp các bài viết về Generic

Hiểu biết về Generics và Stream trong Java: Cách sử dụng và lợi íchJavastreamGeneric

Chủ đề phổ biến

Hiểu biết về Generics và Stream trong Java: Cách sử dụng và lợi ích