import java.util.List;
import java.util.ArrayList;

// 1. 存儲基本類型包裝類（如 Long、String）
List<Long> idList = new ArrayList<>(); // 存儲用戶 ID 列表

// 2. 存儲自定義對象（如 User）
List<User> userList = new ArrayList<>(); // 存儲用戶對象列表

// 3. 初始化時添加元素（Java 9+）
List<String> nameList = List.of("張三", "李四"); // 不可修改的 List

public class ListDemo {
    public static void main(String[] args) {
        // 1. 創(chuàng)建并初始化 List
        List<User> userList = new ArrayList<>();
        User zhangsan = new User(1L, "張三", 25);
        User lisi = new User(2L, "李四", 30);
        User wangwu = new User(3L, "王五", 28);

        // 2. 添加元素（add）
        userList.add(zhangsan); // 末尾添加：[張三]
        userList.add(1, lisi);  // 插入到索引 1：[張三, 李四]
        userList.add(wangwu);   // 末尾添加：[張三, 李四, 王五]

        // 3. 獲取元素（get）：通過索引訪問（0 開始）
        User firstUser = userList.get(0); // 獲取第一個元素：張三
        System.out.println(firstUser.getName()); // 輸出：張三

        // 4. 修改元素（set）：替換指定索引的元素
        userList.set(2, new User(3L, "王五（修改后）", 29)); // 索引 2 替換為新對象

        // 5. 刪除元素（remove）：按索引或?qū)ο髣h除
        userList.remove(1); // 刪除索引 1 的元素（李四）：[張三, 王五（修改后）]
        userList.remove(zhangsan); // 刪除指定對象（張三）：[王五（修改后）]

        // 6. 遍歷 List（3 種常用方式）
        // 方式 1：普通 for 循環(huán)（適合需要索引的場景）
        for (int i = 0; i < userList.size(); i++) {
            User user = userList.get(i);
            System.out.println("索引 " + i + "：" + user.getName());
        }

        // 方式 2：增強 for 循環(huán)（簡潔，無需索引）
        for (User user : userList) {
            System.out.println("用戶：" + user);
        }

        // 方式 3：Java 8+ 流式遍歷（函數(shù)式編程，簡潔靈活）
        userList.forEach(user -> System.out.println("流式遍歷：" + user.getName()));

        // 7. 其他常用操作
        int size = userList.size(); // 元素個數(shù)：1
        boolean contains = userList.contains(wangwu); // 是否包含王五對象？false（已修改）
        userList.clear(); // 清空所有元素：size=0
        boolean isEmpty = userList.isEmpty(); // 是否為空？true
    }
}

import java.util.Map;
import java.util.HashMap;

// 1. Key=基本類型包裝類，Value=基本類型/包裝類（如統(tǒng)計用戶年齡分布）
Map<Integer, Integer> ageCountMap = new HashMap<>(); // Key=年齡，Value=人數(shù)

// 2. Key=用戶 ID（Long），Value=User 對象（緩存用戶）
Map<Long, User> userMap = new HashMap<>();

// 3. Key=String，Value=List（如按性別分組用戶）
Map<String, List<User>> genderGroupMap = new HashMap<>();

public class MapDemo {
    public static void main(String[] args) {
        // 1. 創(chuàng)建并初始化 Map
        Map<Long, User> userMap = new HashMap<>();
        User zhangsan = new User(1L, "張三", 25);
        User lisi = new User(2L, "李四", 30);

        // 2. 添加/修改元素（put）：Key 不存在則添加，存在則覆蓋
        userMap.put(zhangsan.getId(), zhangsan); // Key=1L → Value=張三
        userMap.put(lisi.getId(), lisi);         // Key=2L → Value=李四
        userMap.put(1L, new User(1L, "張三（更新）", 26)); // 覆蓋 Key=1L 的值

        // 3. 獲取元素（get）：通過 Key 查找，找不到返回 null
        User findUser = userMap.get(2L);
        System.out.println(findUser.getName()); // 輸出：李四

        // 4. 安全獲取（getOrDefault）：Key 不存在時返回默認(rèn)值
        User defaultUser = userMap.getOrDefault(3L, new User(0L, "默認(rèn)用戶", 0));
        System.out.println(defaultUser.getName()); // 輸出：默認(rèn)用戶

        // 5. 刪除元素（remove）：通過 Key 刪除
        userMap.remove(2L); // 刪除 Key=2L 的鍵值對：僅剩 Key=1L

        // 6. 遍歷 Map（3 種常用方式）
        // 方式 1：遍歷 Key 集合（keySet）→ 適合只需要 Key 或 Value
        for (Long userId : userMap.keySet()) {
            User user = userMap.get(userId);
            System.out.println("ID：" + userId + "，姓名：" + user.getName());
        }

        // 方式 2：遍歷鍵值對（entrySet）→ 推薦（效率高，同時獲 Key/Value）
        for (Map.Entry<Long, User> entry : userMap.entrySet()) {
            Long id = entry.getKey();
            User user = entry.getValue();
            System.out.println("ID：" + id + "，年齡：" + user.getAge());
        }

        // 方式 3：Java 8+ 流式遍歷（forEach）→ 簡潔
        userMap.forEach((id, user) -> 
            System.out.println("流式遍歷：ID=" + id + "，用戶=" + user)
        );

        // 7. 其他常用操作
        int size = userMap.size(); // 鍵值對個數(shù)：1
        boolean hasKey = userMap.containsKey(1L); // 是否存在 Key=1L？true
        boolean hasValue = userMap.containsValue(zhangsan); // 是否存在張三對象？false（已更新）
        userMap.clear(); // 清空所有鍵值對
        boolean isEmpty = userMap.isEmpty(); // 是否為空？true
    }
}

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class UserService {
    // Map：緩存用戶（Key=用戶 ID，快速查詢）
    private Map<Long, User> userCache = new HashMap<>();

    // 1. 添加用戶：存入 Map（自動去重，ID 重復(fù)則覆蓋）
    public boolean addUser(User user) {
        if (user == null || user.getId() == null) {
            return false;
        }
        userCache.put(user.getId(), user);
        return true;
    }

    // 2. 按 ID 查詢：Map.get(Key) 快速獲?。∣(1)）
    public User getUserById(Long id) {
        return userCache.get(id);
    }

    // 3. 查詢所有用戶：Map.values() 轉(zhuǎn)成 List 返回（順序無關(guān)，如需順序用 LinkedHashMap）
    public List<User> listAllUsers() {
        return new ArrayList<>(userCache.values());
    }

    // 拓展：按性別分組用戶（Map<String, List<User>>）
    public Map<String, List<User>> groupByGender() {
        Map<String, List<User>> genderMap = new HashMap<>();
        for (User user : userCache.values()) {
            String gender = user.getGender(); // 假設(shè) User 有 gender 字段
            // 不存在該性別分組，則創(chuàng)建新 List
            genderMap.computeIfAbsent(gender, k -> new ArrayList<>());
            // 加入該性別分組
            genderMap.get(gender).add(user);
        }
        return genderMap;
    }

    // 測試
    public static void main(String[] args) {
        UserService service = new UserService();
        service.addUser(new User(1L, "張三", 25, "男"));
        service.addUser(new User(2L, "李四", 30, "男"));
        service.addUser(new User(3L, "王五", 28, "女"));

        System.out.println(service.getUserById(1L).getName()); // 張三
        System.out.println(service.listAllUsers().size()); // 3

        // 按性別分組
        Map<String, List<User>> genderMap = service.groupByGender();
        System.out.println("男性用戶：" + genderMap.get("男").size()); // 2
        System.out.println("女性用戶：" + genderMap.get("女").size()); // 1
    }
}

// 補充完整的 User 類
class User {
    private Long id;
    private String name;
    private int age;
    private String gender;

    // 構(gòu)造器、getter、toString
    public User(Long id, String name, int age, String gender) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // getter 方法
    public Long getId() { return id; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getGender() { return gender; }

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