Immutability và Functional Style — thiết kế Java không có surprise

public class OrderService {
    private List<Order> activeOrders = new ArrayList<>();

    public List<Order> getActiveOrders() {
        return activeOrders;   // tra truc tiep reference noi
    }

    public void processOrders(List<Order> orders) {
        orders.removeIf(o -> o.isExpired());   // modify input
        // process remaining...
    }
}

// Caller A:
List<Order> orders = service.getActiveOrders();

// Caller B (cung thread, sau Caller A):
service.processOrders(service.getActiveOrders());  // removeIf tren list noi!

// Caller A gio co it order hon -- bi modify boi Caller B ma khong biet
System.out.println(orders.size());  // khac voi luc lay ra -- SURPRISE!

// PURE -- chi phu thuoc input, khong modify gi
public static int add(int a, int b) {
    return a + b;   // output chi phu thuoc a, b
}

// PURE -- tra list moi, khong modify input
public static List<Order> filterActive(List<Order> orders) {
    return orders.stream()
        .filter(o -> !o.isExpired())
        .toList();   // list moi, orders goc khong doi
}

// IMPURE -- phu thuoc state ngoai (System.currentTimeMillis)
public static boolean isExpired(Order o) {
    return o.expiryTime() < System.currentTimeMillis();   // state ngoai: dong ho
}

// IMPURE -- side effect: modify input
public static void removeExpired(List<Order> orders) {
    orders.removeIf(Order::isExpired);   // modify tham so -- bieu hien impure
}

// add(2, 3) la referential transparent -- co the thay bang 5 bat cu dau
int x = add(2, 3) + add(2, 3);   // = 5 + 5 = 10
int y = 5 + 5;                   // tuong duong hoan toan

// System.currentTimeMillis() KHONG transparent -- 2 lan goi cho ket qua khac nhau
long t1 = System.currentTimeMillis();
long t2 = System.currentTimeMillis();   // t1 != t2

public class Config {
    private final String host;    // reference khong doi sau constructor
    private final int port;
    private final List<String> tags;   // reference final -- nhung tags.add() van duoc!

    public Config(String host, int port, List<String> tags) {
        this.host = host;
        this.port = port;
        this.tags = tags;   // chi copy reference, khong copy content
    }

    public List<String> getTags() { return tags; }
}

Config cfg = new Config("localhost", 8080, new ArrayList<>(List.of("web", "api")));
cfg.getTags().add("admin");   // THANH CONG -- tags van mutable du field la final!

public class Config {
    private final String host;
    private final int port;
    private final List<String> tags;

    public Config(String host, int port, List<String> tags) {
        this.host = host;
        this.port = port;
        // Defensive copy: copy noi dung, khong giu reference goc
        this.tags = List.copyOf(tags);   // Java 10+ -- unmodifiable deep copy
    }

    public List<String> getTags() {
        return tags;   // safe: tra ve unmodifiable list
    }
}

Config cfg = new Config("localhost", 8080, new ArrayList<>(List.of("web", "api")));
cfg.getTags().add("admin");   // throw UnsupportedOperationException -- PROTECTED

// Khai bao record
public record Point(double x, double y) {}

// Tuong duong viet tay:
public final class Point {
    private final double x;
    private final double y;

    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double x() { return x; }   // accessor, khong phai getX()
    public double y() { return y; }

    @Override public boolean equals(Object o) { ... }   // compare theo value
    @Override public int hashCode() { ... }
    @Override public String toString() { return "Point[x=" + x + ", y=" + y + "]"; }
}

public record Order(String id, int amount, List<String> tags) {
    // Compact canonical constructor -- validate + defensive copy
    public Order {
        if (amount < 0) throw new IllegalArgumentException("amount phai >= 0");
        tags = List.copyOf(tags);   // defensive copy component collection
    }
}

Order o = new Order("ORD-001", 500, List.of("web", "mobile"));
o.tags().add("admin");   // UnsupportedOperationException -- protected

List<String> immutable = List.of("a", "b", "c");
immutable.add("d");     // UnsupportedOperationException
immutable.set(0, "x");  // UnsupportedOperationException
immutable.get(0);       // "a" -- read OK

Map<String, Integer> map = Map.of("one", 1, "two", 2);
map.put("three", 3);    // UnsupportedOperationException

final List<String> list = new ArrayList<>(List.of("a", "b"));

// final ngan reassign reference:
// list = new ArrayList<>();  // compile error: cannot assign final variable

// Nhung KHONG ngan modify content:
list.add("c");          // OK -- list gio la [a, b, c]
list.remove(0);         // OK -- list gio la [b, c]
list.clear();           // OK -- list rong

final Map<String, Integer> map = new HashMap<>();
map.put("key", 1);      // OK -- final khong lien quan den map content
map.clear();            // OK

public record ServerConfig(
    String host,
    int port,
    int timeoutMs,
    boolean ssl,
    List<String> allowedOrigins
) {
    // Builder nested trong record
    public static class Builder {
        private String host = "localhost";
        private int port = 8080;
        private int timeoutMs = 5000;
        private boolean ssl = false;
        private List<String> allowedOrigins = new ArrayList<>();

        public Builder host(String host) { this.host = host; return this; }
        public Builder port(int port) { this.port = port; return this; }
        public Builder timeoutMs(int ms) { this.timeoutMs = ms; return this; }
        public Builder ssl(boolean ssl) { this.ssl = ssl; return this; }
        public Builder addOrigin(String origin) { allowedOrigins.add(origin); return this; }

        public ServerConfig build() {
            return new ServerConfig(host, port, timeoutMs, ssl,
                List.copyOf(allowedOrigins));   // defensive copy
        }
    }
}

// Su dung:
ServerConfig config = new ServerConfig.Builder()
    .host("api.example.com")
    .port(443)
    .ssl(true)
    .addOrigin("https://frontend.example.com")
    .build();
// config la immutable sau build()

// IMPURE -- manual loop modify shared state
List<String> result = new ArrayList<>();
for (Order o : orders) {
    if (o.amount() > 100) {
        result.add(o.customerId());   // side effect: add vao list ngoai
    }
}

// PURE -- stream pipeline, khong shared state
List<String> result = orders.stream()
    .filter(o -> o.amount() > 100)
    .map(Order::customerId)
    .toList();   // tao list moi, khong modify gi

// Intent khong ro -- caller co the modify result
Map<String, List<Order>> byCustomer = orders.stream()
    .collect(Collectors.groupingBy(Order::customerId));

// Intent ro rang -- caller biet result la immutable
Map<String, List<Order>> byCustomer = orders.stream()
    .collect(Collectors.groupingBy(
        Order::customerId,
        Collectors.toUnmodifiableList()
    ));

// IMPURE -- caller phai nho check null, de NullPointerException
public Order findById(String id) {
    return orderDb.get(id);   // co the tra null
}

// FUNCTIONAL -- explicit representation of "not found"
public Optional<Order> findById(String id) {
    return Optional.ofNullable(orderDb.get(id));
}

// Caller xu ly explicitly:
service.findById("ORD-001")
    .map(Order::amount)
    .orElse(0);

// SAI -- business logic lan sang side effect
public void processOrder(Order o) {
    if (o.amount() > 10000) {
        sendEmail(o.customerId(), "VIP order detected");   // side effect trong business
    }
    saveToDb(o);   // side effect trong business
}

// TOT HON -- tach pure logic khoi side effect
public boolean isVipOrder(Order o) {
    return o.amount() > 10000;   // pure function, testable khong mock
}

// Side effect chi o boundary (caller):
if (isVipOrder(order)) {
    emailService.send(order.customerId(), "VIP order");
}
orderRepository.save(order);

// IMPERATIVE -- mutable counter, side effect
int total = 0;
for (Order o : orders) {
    if (o.amount() > 100) {
        total += o.amount();   // modify shared state mutable
    }
}

// FUNCTIONAL -- pure reduction, khong shared state
int total = orders.stream()
    .filter(o -> o.amount() > 100)
    .mapToInt(Order::amount)
    .sum();   // sum() la reduce associative: (a, b) -> a + b, identity = 0

// Functional version neu can collect nhieu metric 1 lan:
record SalesStats(long count, int totalAmount) {}

SalesStats stats = orders.stream()
    .filter(o -> o.amount() > 100)
    .collect(Collector.of(
        () -> new int[2],              // [count, total]
        (arr, o) -> { arr[0]++; arr[1] += o.amount(); },
        (a, b) -> new int[]{a[0]+b[0], a[1]+b[1]},
        arr -> new SalesStats(arr[0], arr[1])
    ));

// Tao 1 trieu String moi -- memory pressure cao
String result = "";
for (int i = 0; i < 1_000_000; i++) {
    result = result + i;   // moi + tao String moi, cu bi GC
}

// DUNG StringBuilder -- mutable nhung local, khong shared
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1_000_000; i++) {
    sb.append(i);   // modify in-place, 1 object duy nhat
}
String result = sb.toString();