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<T> {
private T value;
public void setValue(T value) {
this.value = value;
}
public T getValue() {
return value;
}
}
Box<String> stringBox = new Box<>();
stringBox.setValue("Hello Generics");
System.out.println(stringBox.getValue()); // Output: Hello Generics
Box<Integer> integerBox = new Box<>();
integerBox.setValue(123);
System.out.println(integerBox.getValue()); // Output: 1232. Ví dụ với phương thức
java
public class Utility {
public static <T> 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, 33. Ví dụ với Interface
java
public interface Pair<K, V> {
K getKey();
V getValue();
}
class KeyValuePair<K, V> implements Pair<K, V> {
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<Integer, String> pair = new KeyValuePair<>(1, "One");
System.out.println(pair.getKey()); // Output: 1
System.out.println(pair.getValue()); // Output: One4. 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 (<? extends T>): Chấp nhận các kiểu là T hoặc subclass của T.
- Lower Bounded Wildcard (<? super T>): 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:
- Không lưu trữ dữ liệu: Chỉ xử lý dữ liệu mà không giữ lại.
- 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.
- Lazy Evaluation: Các thao tác được thực hiện chỉ khi cần thiết.
- 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<String> names = List.of("Alice", "Bob", "Charlie");
Stream<String> stream = names.stream();
// Từ Array
String[] array = {"A", "B", "C"};
Stream<String> stream = Arrays.stream(array);
// Tạo Stream từ giá trị
Stream<String> stream = Stream.of("X", "Y", "Z");
// Tạo Stream vô hạn
Stream<Integer> 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<Integer> numbers = List.of(1, 2, 3, 4, 5);
numbers.stream()
.filter(n -> n % 2 == 0)
.forEach(System.out::println); // Output: 2, 4
// map()
List<String> names = List.of("alice", "bob", "charlie");
names.stream()
.map(String::toUpperCase)
.forEach(System.out::println); // Output: ALICE, BOB, CHARLIE
// sorted()
List<String> names = List.of("Charlie", "Bob", "Alice");
names.stream()
.sorted()
.forEach(System.out::println); // Output: Alice, Bob, Charlie
// distinct()
List<Integer> numbers = List.of(1, 2, 2, 3, 3, 4);
numbers.stream()
.distinct()
.forEach(System.out::println); // Output: 1, 2, 3, 4
// limit()
Stream<Integer> infiniteStream = Stream.iterate(0, n -> n + 1);
infiniteStream.limit(5).forEach(System.out::println); // Output: 0, 1, 2, 3, 4
// skip()
List<Integer> numbers = List.of(1, 2, 3, 4, 5);
numbers.stream()
.skip(2)
.forEach(System.out::println); // Output: 3, 4, 52. Thao tác kết thúc
java
// forEach()
List<String> names = List.of("Alice", "Bob", "Charlie");
names.stream().forEach(System.out::println);
// collect()
List<String> 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<String> first = names.stream().findFirst();
first.ifPresent(System.out::println); // Output: AliceLợi ích của Stream
- Mã sạch và dễ đọc hơn: Việc xử lý dữ liệu trở nên trực quan hơn.
- 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.
- 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
