Java hàm — lambda, Stream API và Optional

@FunctionalInterface              // tuỳ chọn, nhưng NÊN có
interface PhepTinh {
    double tinh(double a, double b);      // ← đúng MỘT method trừu tượng

    // default và static method KHÔNG tính — bao nhiêu cũng được
    default PhepTinh roiThi(DoubleUnaryOperator sau) {
        return (a, b) -> sau.applyAsDouble(tinh(a, b));
    }
    static PhepTinh cong() { return (a, b) -> a + b; }
}

// ❌ Không phải functional interface — hai method trừu tượng
// @FunctionalInterface
// interface Hai { void a(); void b(); }
//   error: Hai is not a functional interface

// --- Ba cách cài đặt, từ cũ tới mới ---

// ① Class riêng (Java 1.0) — 5 dòng cho một phép cộng
class Cong implements PhepTinh {
    @Override public double tinh(double a, double b) { return a + b; }
}
PhepTinh p1 = new Cong();

// ② Anonymous class (Java 1.1) — 3 dòng
PhepTinh p2 = new PhepTinh() {
    @Override public double tinh(double a, double b) { return a + b; }
};

// ③ Lambda (Java 8) — MỘT dòng ⭐
PhepTinh p3 = (a, b) -> a + b;

// Cú pháp đầy đủ: (kiểu tên, kiểu tên) -> { câu lệnh; return giaTri; }
PhepTinh a = (double x, double y) -> { return x + y; };

// Bỏ kiểu — trình biên dịch tự suy ra
PhepTinh b = (x, y) -> { return x + y; };

// Một biểu thức → bỏ luôn ngoặc nhọn và return
PhepTinh c = (x, y) -> x + y;

// MỘT tham số → bỏ được cả ngoặc tròn
Predicate<String> d = s -> s.isEmpty();

// KHÔNG tham số → ngoặc tròn rỗng là bắt buộc
Supplier<String> e = () -> "xin chào";

// Nhiều dòng → cần ngoặc nhọn và return tường minh
PhepTinh f = (x, y) -> {
    if (y == 0) throw new ArithmeticException("Chia cho 0");
    return x / y;
};

// var trong tham số (Java 11+) — chỉ hữu ích khi cần thêm annotation
PhepTinh g = (var x, var y) -> x + y;

// ① Phương thức STATIC:  Class::method
Function<String, Integer> f1 = s -> Integer.parseInt(s);
Function<String, Integer> f2 = Integer::parseInt;          // ✅

// ② Phương thức của MỘT INSTANCE cụ thể:  bien::method
String tienTo = "Java";
Predicate<String> p1 = s -> tienTo.startsWith(s);
Predicate<String> p2 = tienTo::startsWith;                 // ✅

// ③ Phương thức của instance TUỲ Ý thuộc một class:  Class::method
Function<String, Integer> f3 = s -> s.length();
Function<String, Integer> f4 = String::length;             // ✅ tham số đầu thành receiver

Comparator<String> c1 = (a, b) -> a.compareTo(b);
Comparator<String> c2 = String::compareTo;                // ✅

// ④ CONSTRUCTOR:  Class::new
Supplier<List<String>> s1 = () -> new ArrayList<>();
Supplier<List<String>> s2 = ArrayList::new;              // ✅

Function<String, SinhVien> s3 = SinhVien::new;           // constructor 1 tham số
IntFunction<String[]> s4 = String[]::new;                 // constructor MẢNG

// --- Ứng dụng thực tế ---
danhSach.forEach(System.out::println);
danhSach.sort(Comparator.comparing(SinhVien::getTen));
List<Integer> doDai = ten.stream().map(String::length).toList();

// --- Kết hợp Function ---
Function<String, Integer> doDai = String::length;
Function<Integer, String> moTa  = n -> "dài " + n;

doDai.andThen(moTa).apply("Java");   // "dài 4"  — doDai TRƯỚC
moTa.compose(doDai).apply("Java");  // "dài 4"  — doDai cũng trước
Function.<String>identity();               // x -> x

// --- Kết hợp Predicate ---
Predicate<String> rong   = String::isEmpty;
Predicate<String> ngan   = s -> s.length() < 5;

rong.negate();                          // không rỗng
rong.or(ngan);                          // rỗng HOẶC ngắn
rong.negate().and(ngan);                // không rỗng VÀ ngắn
Predicate.not(rong);                     // Java 11+, dùng được với method reference

// --- Consumer nối tiếp ---
Consumer<String> in    = System.out::println;
Consumer<String> ghiLog = s -> log.info(s);
in.andThen(ghiLog).accept("xin chào");   // làm cả hai

// --- Supplier: hoãn tính toán tới khi thực sự cần ---
Supplier<String> tonKem = () -> tinhToanRatLau();
Optional.ofNullable(x).orElseGet(tonKem);   // chỉ chạy khi x là null ⭐

// --- Phiên bản NGUYÊN THỦY: tránh autoboxing ---
IntPredicate       chan  = n -> n % 2 == 0;   // thay Predicate<Integer>
IntFunction<String> doi   = n -> "số " + n;
ToIntFunction<String> dai = String::length;
IntUnaryOperator   binh  = n -> n * n;
// Với hàng triệu phần tử, các phiên bản này nhanh hơn 4-6 lần

// ① LƯỜI — không có thao tác kết thúc thì KHÔNG CHẠY GÌ
Stream<String> s = List.of("a", "b").stream()
    .filter(x -> { System.out.println("lọc " + x); return true; });
// KHÔNG in gì cả! filter chưa hề chạy.
s.count();     // bây giờ mới in "lọc a", "lọc b"


// ② MỘT LẦN DÙNG
Stream<String> s2 = List.of("a", "b").stream();
s2.count();   // ✅
s2.count();   // 💥 IllegalStateException: stream has already been
             //    operated upon or closed


// ③ KHÔNG SỬA NGUỒN
List<String> goc = new ArrayList<>(List.of("b", "a"));
List<String> moi = goc.stream().sorted().toList();
System.out.println(goc);   // [b, a] — không đổi
System.out.println(moi);   // [a, b]


// ⭐ HỆ QUẢ CỦA TÍNH LƯỜI: xử lý theo CHIỀU DỌC, không phải chiều ngang
List.of("a", "bb", "ccc").stream()
    .filter(x -> { System.out.println("lọc " + x);  return x.length() > 1; })
    .map(x    -> { System.out.println("  ánh xạ " + x); return x.toUpperCase(); })
    .findFirst();
// lọc a
// lọc bb
//   ánh xạ bb        ← DỪNG LUÔN! "ccc" không hề được chạm tới

// Từ collection
danhSach.stream();
danhSach.parallelStream();

// Từ mảng
Arrays.stream(mang);
Arrays.stream(mang, 1, 4);          // một phần

// Từ giá trị rời
Stream.of("a", "b", "c");
Stream.empty();
Stream.ofNullable(coTheNull);        // Java 9+: rỗng nếu null

// Stream số nguyên thủy — tránh autoboxing
IntStream.range(0, 5);              // 0 1 2 3 4
IntStream.rangeClosed(1, 5);        // 1 2 3 4 5
IntStream.of(1, 2, 3).sum();

// Vô hạn — BẮT BUỘC có limit() hoặc thao tác ngắn mạch
Stream.iterate(1, n -> n * 2).limit(10);        // 1 2 4 8 ...
Stream.iterate(1, n -> n < 100, n -> n * 2);   // Java 9+: có điều kiện dừng
Stream.generate(Math::random).limit(5);

// Từ chuỗi
"a,b,c".chars();                     // IntStream các mã ký tự
Pattern.compile(",").splitAsStream("a,b,c");

// Từ tệp — nhớ đóng! (chương 11)
try (Stream<String> dong = Files.lines(Path.of("data.txt"))) {
    dong.filter(l -> l.contains("ERROR")).forEach(System.out::println);
}

// Từ Map
map.entrySet().stream();
map.keySet().stream();
map.values().stream();

List<String> ds = List.of("java", "python", "go", "java", "rust");

// filter — giữ phần tử thoả điều kiện
ds.stream().filter(s -> s.length() > 2)

// map — biến đổi từng phần tử
   .map(String::toUpperCase)

// distinct — loại trùng (dùng equals)
   .distinct()

// sorted — sắp xếp
   .sorted()
   .sorted(Comparator.comparingInt(String::length))

// limit / skip — phân trang
   .skip(1).limit(3)

// peek — xem giữa chừng, CHỈ để gỡ lỗi
   .peek(System.out::println)
   .toList();


// ⭐ flatMap — LÀM PHẲNG cấu trúc lồng nhau
List<List<String>> long2 = List.of(
    List.of("a", "b"),
    List.of("c", "d")
);
long2.stream().flatMap(List::stream).toList();   // [a, b, c, d]

// Tách câu thành từ
List.of("xin chào", "thế giới").stream()
    .flatMap(c -> Arrays.stream(c.split(" ")))
    .toList();                          // [xin, chào, thế, giới]

// Lấy mọi đơn hàng của mọi khách
khachHang.stream()
    .flatMap(k -> k.getDonHang().stream())
    .toList();


// mapToInt/Long/Double — chuyển sang stream nguyên thủy
ds.stream().mapToInt(String::length).sum();
ds.stream().mapToInt(String::length).average().orElse(0);

// takeWhile / dropWhile (Java 9+) — dừng/bỏ theo điều kiện
Stream.of(1, 2, 3, 10, 4, 5).takeWhile(n -> n < 5).toList();  // [1,2,3]
Stream.of(1, 2, 3, 10, 4, 5).dropWhile(n -> n < 5).toList();  // [10,4,5]
// ⚠️ Khác filter: chúng DỪNG ở phần tử đầu tiên không thoả

List<String> ds = List.of("java", "python", "go");

// --- Thu thập ---
ds.stream().toList();                       // Java 16+, BẤT BIẾN ⭐
ds.stream().collect(Collectors.toList());   // cách cũ, sửa được
ds.stream().toArray(String[]::new);

// --- Duyệt ---
ds.forEach(System.out::println);
ds.stream().forEachOrdered(System.out::println);   // giữ thứ tự cả khi song song

// --- Đếm và thống kê ---
ds.stream().count();
ds.stream().mapToInt(String::length).summaryStatistics();
// IntSummaryStatistics{count=3, sum=12, min=2, average=4.0, max=6}

// --- Tìm kiếm (NGẮN MẠCH — dừng ngay khi có kết quả) ---
ds.stream().findFirst();                    // Optional
ds.stream().findAny();                      // Optional (hợp với song song)
ds.stream().anyMatch(s -> s.startsWith("j"));   // true
ds.stream().allMatch(s -> s.length() > 1);      // true
ds.stream().noneMatch(String::isEmpty);        // true

// --- Min / max ---
ds.stream().max(Comparator.comparingInt(String::length));

// --- reduce: gộp về một giá trị ---
Optional<String> noi = ds.stream().reduce((a, b) -> a + ", " + b);
String noi2 = ds.stream().reduce("", (a, b) -> a + b);   // có giá trị khởi đầu
int tongDoDai = ds.stream().reduce(0, (t, s) -> t + s.length(), Integer::sum);

// ⚠️ Nhưng thường có cách gọn hơn reduce:
int tot = ds.stream().mapToInt(String::length).sum();   // ✅ rõ hơn

record SinhVien(String ten, String lop, double diem, int tuoi) { }
List<SinhVien> ds = ...;

// --- Thu thập cơ bản ---
ds.stream().collect(Collectors.toList());
ds.stream().collect(Collectors.toSet());
ds.stream().collect(Collectors.toCollection(TreeSet::new));

// --- toMap ---
Map<String, Double> tenDiem = ds.stream()
    .collect(Collectors.toMap(SinhVien::ten, SinhVien::diem));
// ⚠️ Khoá TRÙNG → IllegalStateException: Duplicate key

// ✅ Xử lý trùng bằng hàm gộp
Map<String, Double> anToan = ds.stream()
    .collect(Collectors.toMap(SinhVien::ten, SinhVien::diem, Double::max));

// --- joining: nối chuỗi ---
String tenAll = ds.stream().map(SinhVien::ten)
    .collect(Collectors.joining(", ", "[", "]"));   // [An, Bình, Chi]

// --- Thống kê ---
Collectors.counting();
Collectors.summingDouble(SinhVien::diem);
Collectors.averagingDouble(SinhVien::diem);
Collectors.summarizingDouble(SinhVien::diem);   // count/sum/min/avg/max
Collectors.maxBy(Comparator.comparingDouble(SinhVien::diem));


// ⭐⭐ groupingBy — thao tác mạnh nhất của Stream API

// Nhóm đơn giản
Map<String, List<SinhVien>> theoLop = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop));

// Nhóm + đếm
Map<String, Long> siSo = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop, Collectors.counting()));

// Nhóm + tính trung bình
Map<String, Double> diemTb = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop,
                          Collectors.averagingDouble(SinhVien::diem)));

// Nhóm + lấy danh sách tên
Map<String, List<String>> tenTheoLop = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop,
                          Collectors.mapping(SinhVien::ten, Collectors.toList())));

// Nhóm HAI TẦNG
Map<String, Map<Boolean, List<SinhVien>>> hai = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop,
                          Collectors.groupingBy(s -> s.diem() >= 8)));

// Chỉ định kiểu Map cụ thể
TreeMap<String, Long> sapXep = ds.stream()
    .collect(Collectors.groupingBy(SinhVien::lop,
                          TreeMap::new, Collectors.counting()));


// --- partitioningBy: chia ĐÔI theo điều kiện (nhanh hơn groupingBy) ---
Map<Boolean, List<SinhVien>> dat = ds.stream()
    .collect(Collectors.partitioningBy(s -> s.diem() >= 5));
dat.get(true);    // đạt
dat.get(false);   // không đạt — LUÔN có cả hai khoá, kể cả khi rỗng

// --- teeing (Java 12+): hai collector cùng lúc ---
record ThongKe(double min, double max) { }
ThongKe tk = ds.stream().collect(Collectors.teeing(
    Collectors.minBy(Comparator.comparingDouble(SinhVien::diem)),
    Collectors.maxBy(Comparator.comparingDouble(SinhVien::diem)),
    (a, b) -> new ThongKe(a.map(SinhVien::diem).orElse(0.0),
                            b.map(SinhVien::diem).orElse(0.0))
));

// --- Tạo ---
Optional<String> a = Optional.of("giá trị");       // NPE nếu null
Optional<String> b = Optional.ofNullable(coTheNull);
Optional<String> c = Optional.empty();

// --- ❌ CÁCH DÙNG SAI: chỉ thay if-null bằng if-isPresent ---
if (b.isPresent()) {
    String s = b.get();
    System.out.println(s.toUpperCase());
}
// Không tốt hơn `if (x != null)` chút nào — chỉ dài hơn

// --- ✅ CÁCH DÙNG ĐÚNG: nối chuỗi thao tác ---
b.map(String::toUpperCase).ifPresent(System.out::println);

// --- Lấy giá trị ---
b.orElse("mặc định");                   // giá trị đã tính sẵn
b.orElseGet(() -> tinhToanTonKem());     // ⭐ CHỈ chạy khi rỗng
b.orElseThrow();                          // NoSuchElementException
b.orElseThrow(() -> new MyException("không thấy"));

// --- Biến đổi ---
b.map(String::length);                  // Optional<Integer>
b.filter(s -> s.length() > 3);          // rỗng nếu không thoả
b.flatMap(s -> timTrongDb(s));          // khi hàm đã trả Optional
b.or(() -> Optional.of("dự phòng"));    // Java 9+

// --- Thực hiện hành động ---
b.ifPresent(System.out::println);
b.ifPresentOrElse(System.out::println,
                 () -> System.out.println("trống"));   // Java 9+
b.stream();                               // Java 9+: Stream 0 hoặc 1 phần tử


// --- Ví dụ thực tế: chuỗi tra cứu an toàn ---
String thanhPho = timNguoiDung(id)          // Optional<NguoiDung>
    .flatMap(NguoiDung::getDiaChi)        // Optional<DiaChi>
    .map(DiaChi::getThanhPho)             // Optional<String>
    .filter(t -> !t.isBlank())
    .orElse("Không rõ");
// Thay cho bốn tầng kiểm tra null lồng nhau

// Chuyển sang song song chỉ cần một từ
long tong = ds.parallelStream().mapToLong(SinhVien::diem).sum();
long tong2 = ds.stream().parallel().count();

// ⚠️ Mặc định dùng ForkJoinPool.commonPool() — CHUNG cho toàn ứng dụng!
System.out.println(ForkJoinPool.commonPool().getParallelism());
// = số nhân CPU - 1

// ❌ SAI: tác dụng phụ lên collection không an toàn luồng
List<String> kq = new ArrayList<>();
ds.parallelStream().forEach(kq::add);
// → mất phần tử, hoặc ArrayIndexOutOfBoundsException, hoặc null xen kẽ
//   Kết quả KHÁC NHAU mỗi lần chạy — loại bug khó tái hiện nhất

// ✅ ĐÚNG: để collect() lo việc gộp
List<String> kq2 = ds.parallelStream().map(...).toList();


// ❌ SAI: I/O trong parallel stream
duongDan.parallelStream().forEach(p -> Files.readString(p));
// → chiếm hết pool CHUNG, mọi parallel stream khác trong ứng dụng bị treo


// ❌ SAI: dữ liệu quá nhỏ
List.of(1, 2, 3).parallelStream().map(n -> n * 2).toList();
// → chậm hơn tuần tự HÀNG CHỤC lần vì chi phí khởi tạo pool

// ❌ Stream cho việc quá đơn giản — dài hơn và chậm hơn
IntStream.range(0, 10).forEach(System.out::println);
for (int i = 0; i < 10; i++) System.out.println(i);   // ✅ rõ hơn

// ❌ Cần cả CHỈ SỐ lẫn giá trị — Stream làm rất vụng
IntStream.range(0, ds.size())
    .forEach(i -> System.out.println(i + ": " + ds.get(i)));
for (int i = 0; i < ds.size(); i++)                       // ✅
    System.out.println(i + ": " + ds.get(i));

// ❌ Cần break/continue giữa chừng với logic phức tạp
// Stream chỉ có findFirst/anyMatch/takeWhile — không linh hoạt bằng vòng lặp

// ❌ Cần sửa biến bên ngoài
// Vướng ràng buộc effectively final; ép dùng AtomicInteger là dấu hiệu
// bạn đang dùng sai công cụ

// ❌ Ném checked exception bên trong lambda
duongDan.forEach(p -> Files.readString(p));   // ❌ không biên dịch được
for (Path p : duongDan) Files.readString(p);  // ✅ với method có throws

// ✅ Stream toả sáng khi: LỌC → BIẾN ĐỔI → NHÓM/TỔNG HỢP
Map<String, Double> diemTbTheoLop = ds.stream()
    .filter(s -> s.tuoi() >= 18)
    .collect(Collectors.groupingBy(SinhVien::lop,
                          Collectors.averagingDouble(SinhVien::diem)));
// Viết bằng vòng lặp: khoảng 15 dòng với Map lồng nhau và kiểm tra null