import java.io.

BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

public class Main {

public static void main(String[] args) {

// Bài 1: Đọc dữ liệu từ file

System.out.println("=====================Bài 1=====================");

// a. Tạo một Supplier<List<Integer>> để đọc các số nguyên từ file

numbers.txt
Supplier<List<Integer>> integerListSupplier = () -> {
List<Integer> integers = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new
FileReader("numbers.txt"))) {
String line;
while ((line = br.readLine()) != null) {
String[] tokens = line.split(", ");
for (String token : tokens) {
integers.add(Integer.parseInt(token));
}
}
} catch (IOException e) {
e.printStackTrace();
}
return integers;
};

// b. Tạo một Supplier<List<String>> để đọc các chuỗi từ file

strings.txt
Supplier<List<String>> stringListSupplier = () -> {
List<String> strings = new ArrayList<>();
try (BufferedReader br = new BufferedReader(new
FileReader("strings.txt"))) {
String line;
while ((line = br.readLine()) != null) {
strings.add(line);
}
} catch (IOException e) {
e.printStackTrace();
}
return strings;
};

// Bài 2: Hiển thị dữ liệu

System.out.println("=====================Bài 2=====================");

// a. Tạo một Consumer để in ra số nguyên và in ra 3 số đầu tiên trong

stream
Consumer<Integer> integerConsumer = number -> System.out.println("Số
nguyên: " + number);
List<Integer> integerList = integerListSupplier.get();
System.out.println("In ra 3 số nguyên đầu tiên:");
integerList.stream().limit(3).forEach(integerConsumer);

// b. Tạo một Consumer để in ra chuỗi và in ra 3 chuỗi đầu tiên trong

stream
Consumer<String> stringConsumer = str -> System.out.println("Chuỗi: "
+ str);
List<String> stringList = stringListSupplier.get();
System.out.println("In ra 3 chuỗi đầu tiên:");
stringList.stream().limit(3).forEach(stringConsumer);

// c. Tạo một Consumer để in ra thông tin sinh viên

// Giả sử có một lớp Student định nghĩa thông tin sinh viên
// Consumer<Student> studentConsumer = student ->
System.out.println("Thông tin sinh viên: " + student);
// List<Student> studentList = ... // Lấy thông tin sinh viên từ đâu
đó
// System.out.println("In ra 3 sinh viên đầu tiên:");
// studentList.stream().limit(3).forEach(studentConsumer);

// Bài 3: Biến đổi dữ liệu

System.out.println("=====================Bài 3=====================");

// a. Tạo một Function<Integer, Double> để chuyển đổi mỗi số nguyên

thành căn bậc hai của nó
Function<Integer, Double> sqrtFunction = Math::sqrt;
System.out.println("Căn bậc hai của 3 số nguyên đầu tiên:");

integerList.stream().limit(3).map(sqrtFunction).forEach(System.out::println);

// b. Tạo một Function<String, String> để đảo ngược mỗi chuỗi và in ra

3 chuỗi đầu tiên sau khi biến đổi
Function<String, String> reverseFunction = str -> new
StringBuilder(str).reverse().toString();
System.out.println("Chuỗi đảo ngược của 3 chuỗi đầu tiên:");

stringList.stream().limit(3).map(reverseFunction).forEach(System.out::println)
;

// Bài 4: Lọc dữ liệu trong List

System.out.println("=====================Bài 4=====================");

// a. Tạo một Predicate<Integer> để lọc ra các số chẵn

Predicate<Integer> evenPredicate = number -> number % 2 == 0;
// Lọc và in ra 3 số chẵn đầu tiên
System.out.println("3 số chẵn đầu tiên:");

integerList.stream().filter(evenPredicate).limit(3).forEach(System.out::printl
n);

// b. Tạo một Predicate<String> để lọc ra các chuỗi có độ dài lớn hơn

30 ký tự
Predicate<String> longStringPredicate = str -> str.length() > 30;
// Lọc và in ra 3 chuỗi có độ dài lớn hơn 30 ký tự đầu tiên
System.out.println("3 chuỗi có độ dài lớn hơn 30 ký tự:");
stringList.stream().filter(longStringPredicate).limit(3).forEach(System.out::p
rintln);

// c. Tạo một Predicate<Student> để lọc ra các Sinh viên có điểm số

cao hơn hoặc bằng 9
// Predicate<Student> highScorePredicate = student ->
student.getScore() >= 9;
// Lọc và in ra 3 sinh viên có điểm số cao nhất
// System.out.println("3 sinh viên có điểm số cao nhất:");
//
studentList.stream().filter(highScorePredicate).limit(3).forEach(System.out::p
rintln);

// Bài 5: Ghép nối và sắp xếp dữ liệu

System.out.println("=====================Bài 5=====================");

// a. Tạo một BinaryOperator<Integer> để cộng 2 số nguyên.

// Hãy sử dụng Operator này để tính tổng các phần tử trong stream chứa
các chữ số.
// BinaryOperator<Integer> sumOperator = (a, b) -> a + b;
// int totalSum = digitList.stream().reduce(0, sumOperator);
// System.out.println("Tổng các chữ số trong danh sách là: " +
totalSum);

// b. Tạo một UnaryOperator<String> lấy ra chữ cái đầu tiên trong mỗi
chuỗi.
// Hãy sử dụng Operator này cho các chuỗi dữ liệu trong stream để lấy
ra các ký tự đầu tiên trong mỗi chuỗi và in 10 ký tự đầu tiên ra trên một dòng
// UnaryOperator<String> firstCharOperator = str -> str.substring(0,
1);
// System.out.println("10 ký tự đầu tiên trong mỗi chuỗi:");
//
stringList.stream().map(firstCharOperator).limit(10).forEach(System.out::print
ln);
}
}

Giải thích code:

Bài 1: Đọc dữ liệu từ file
Supplier cho số nguyên từ file:
- Supplier<List<Integer>> integerListSupplier = () -> { ... }: Tạo một supplier để đọc dữ liệu từ file
numbers.txt và trả về một danh sách các số nguyên. Sử dụng cú pháp lambda để triển --khai
supplier.
- Supplier cho chuỗi từ file: Supplier<List<String>> stringListSupplier = () -> { ... }: Tạo một
supplier để đọc dữ liệu từ file strings.txt và trả về một danh sách các chuỗi
Bài 2: Hiển thị dữ liệu
Consumer in ra số nguyên:
- Consumer<Integer> integerConsumer = number -> System.out.println("Số nguyên: " +
number);: Tạo một consumer để in ra số nguyên.
- integerList.stream().limit(3).forEach(integerConsumer);: Sử dụng consumer để in ra 3 số nguyên
đầu tiên từ danh sách.
Consumer in ra chuỗi:
- Consumer<String> stringConsumer = str -> System.out.println("Chuỗi: " + str);: Tạo một
consumer để in ra chuỗi.
- stringList.stream().limit(3).forEach(stringConsumer);: Sử dụng consumer để in ra 3 chuỗi đầu
tiên từ danh sách..
Bài 3: Biến đổi dữ liệu
Function chuyển đổi số nguyên thành căn bậc hai:
- Function<Integer, Double> sqrtFunction = Math::sqrt;: Tạo một function để chuyển đổi mỗi số
nguyên thành căn bậc hai của nó.
- integerList.stream().limit(3).map(sqrtFunction).forEach(System.out::println);: Sử dụng function
để tính căn bậc hai của 3 số nguyên đầu tiên và in ra kết quả.
Function đảo ngược chuỗi:
- Function<String, String> reverseFunction = str -> new StringBuilder(str).reverse().toString();:
Tạo một function để đảo ngược mỗi chuỗi.
- stringList.stream().limit(3).map(reverseFunction).forEach(System.out::println);: Sử dụng
function để đảo ngược 3 chuỗi đầu tiên và in ra kết quả.
Bài 4: Lọc dữ liệu trong List Predicate lọc số chẵn:
- Predicate<Integer> evenPredicate = number -> number % 2 == 0;: Tạo một predicate để lọc ra
các số chẵn.
- integerList.stream().filter(evenPredicate).limit(3).forEach(System.out::println);: Sử dụng
predicate để lọc và in ra 3 số chẵn đầu tiên.
Predicate lọc chuỗi dài:
- Predicate<String> longStringPredicate = str -> str.length() > 30;: Tạo một predicate để lọc ra các
chuỗi có độ dài lớn hơn 30 ký tự.
- stringList.stream().filter(longStringPredicate).limit(3).forEach(System.out::println);: Sử dụng
predicate để lọc và in ra 3 chuỗi có độ dài lớn hơn 30 ký tự đầu tiên
Bài 5: Ghép nối và sắp xếp dữ liệu Ghép nối số nguyên:
- Phần này đã được comment do không có đủ thông tin về danh sách số nguyên và phép tính cộng.
-
Lấy ký tự đầu tiên của mỗi chuỗi: Phần này cũng đã được comment do không có đủ thông tin về
danh sách chuỗi và cách lấy ký tự đầu tiên của mỗi chuỗi.

Kết quả chạy: