# Java vs Kotlin —— 同样需求两种写法

## 需求 1：定义一个 User 类（含 equals / hashCode / toString）

### Java（不用 Lombok）

```java
public class User {
    private final String id;
    private final String name;
    private final int age;

    public User(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        User user = (User) o;
        return age == user.age &&
               Objects.equals(id, user.id) &&
               Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() { return Objects.hash(id, name, age); }

    @Override
    public String toString() {
        return "User{id='" + id + "', name='" + name + "', age=" + age + '}';
    }
}
```

### Kotlin

```kotlin
data class User(val id: String, val name: String, val age: Int)
```

---

## 需求 2：从用户列表里筛出成年人，按年龄倒序

### Java

```java
List<User> adults = users.stream()
    .filter(u -> u.getAge() >= 18)
    .sorted((a, b) -> Integer.compare(b.getAge(), a.getAge()))
    .collect(Collectors.toList());
```

### Kotlin

```kotlin
val adults = users
    .filter { it.age >= 18 }
    .sortedByDescending { it.age }
```

---

## 需求 3：异步获取用户信息然后处理

### Java（CompletableFuture 链）

```java
fetchUser(userId)
    .thenCompose(user -> fetchOrders(user.getId()))
    .thenCompose(orders -> fetchPayments(orders.get(0).getId()))
    .thenAccept(payments -> System.out.println(payments))
    .exceptionally(ex -> {
        ex.printStackTrace();
        return null;
    });
```

### Kotlin（协程）

```kotlin
try {
    val user = fetchUser(userId)
    val orders = fetchOrders(user.id)
    val payments = fetchPayments(orders[0].id)
    println(payments)
} catch (e: Exception) {
    e.printStackTrace()
}
```

> 看起来像同步代码，**实际是非阻塞执行**，不会卡线程。