static Integer[] unique(Integer[] arr) {
    List<Integer> result = new ArrayList<>();
    for (Integer item : arr) {
        // ArrayList.contains 是 O(n) 線性掃描，但每次掃描則是 O(n2)
        if (!result.contains(item)) {
            result.add(item);
        }
    }
    return result.toArray(new Integer[0]);
}

// 方法1：雙循環(huán)索引比較——當(dāng)前項(xiàng)跟左側(cè)逐個(gè)比較
static int[] unique1(int[] arr) {
    int[] newArr = new int[arr.length];
    int x = 0;
    // 當(dāng)前項(xiàng)跟左側(cè)全量比較，是否首次出現(xiàn)
    for (int i = 0; i < arr.length; i++) {
        for (int j = 0; j <= i; j++) {
          // i 與左側(cè)每個(gè) j 比對(duì)
            if (arr[i] == arr[j]) {
                // 值和位置均相同，表示前面沒(méi)有相同值，是首次出現(xiàn)
                if (i == j) {
                    newArr[x++] = arr[i];
                }
                break;
            }
        }
    }
    return Arrays.copyOf(newArr, x);
}

// 方法2：List.indexOf 索引法，跟第一種原理一致
// indexOf 返回首次出現(xiàn)的下標(biāo)，等于當(dāng)前下標(biāo)即首次出現(xiàn)
static Integer[] unique2(Integer[] arr) {
    List<Integer> list = new ArrayList<>(Arrays.asList(arr));
    List<Integer> result = new ArrayList<>();
    for (int i = 0; i < list.size(); i++) {
        // indexOf得到下標(biāo)，比較是否跟當(dāng)前下標(biāo)一致，如果一致則表示首次出現(xiàn)
        if (list.indexOf(list.get(i)) == i) {
            result.add(list.get(i));
        }
    }
    return result.toArray(new Integer[0]);
}

// 方法3：從后往前原地刪除
// 倒序遍歷，與左側(cè)任意相同則刪除自身
// 倒序刪除的好處：刪除點(diǎn)之后的元素都已處理，不會(huì)影響下標(biāo)
static Integer[] unique3(Integer[] arr) {
    List<Integer> list = new ArrayList<>(Arrays.asList(arr));
    int l = list.size();
    // 自后往前遍歷原數(shù)組
    while (l-- > 0) {
        int i = l;
        // 當(dāng)前項(xiàng)與左側(cè)逐個(gè)比較是否存在重復(fù)項(xiàng)，若存在則刪除自身
        while (i-- > 0) {
            if (list.get(l).equals(list.get(i))) {
                list.remove(l);
                break;
            }
        }
    }
    return list.toArray(new Integer[0]);
}

// 方法4：從前往后原地刪除（刪除后面相同項(xiàng)），與方法3相同
static Integer[] unique4(Integer[] arr) {
    List<Integer> list = new ArrayList<>(Arrays.asList(arr));
    int l = list.size();
    // 自前往后遍歷原數(shù)組
    for (int i = 0; i < l; i++) {
        // 當(dāng)前項(xiàng)與右側(cè)全部項(xiàng)逐個(gè)比較，若有相同則刪除相同項(xiàng)
        for (int j = i + 1; j < l; j++) {
            if (list.get(i).equals(list.get(j))) {
                list.remove(j);
                // 刪除后 j 位置的元素是原來(lái)的 j+1，j 不前進(jìn)
                // l 同步減一
                j--;
                l--;
            }
        }
    }
    return list.toArray(new Integer[0]);
}

// 方法5：Iterator 遍歷，原理與方法1同
// 用 Iterator 風(fēng)格遍歷，結(jié)果列表用 contains 判重
static Integer[] unique5(Integer[] arr) {
    List<Integer> source = Arrays.asList(arr);
    List<Integer> result = new ArrayList<>();
    Iterator<Integer> it = source.iterator();
    // 逐個(gè)迭代，判斷是否包含在新數(shù)組中
    while (it.hasNext()) {
        Integer item = it.next();
        // ArrayList.contains 是 O(n)，整體仍是 O(n2)
        if (!result.contains(item)) {
            result.add(item);
        }
    }
    return result.toArray(new Integer[0]);
}

// 方法6：從右往左跳過(guò)重復(fù)，不刪除（使用break跳出）
// 倒序掃描，若當(dāng)前元素在左側(cè)已存在則跳過(guò)，否則保留
static Integer[] unique6(Integer[] arr) {
    int len = arr.length;
    Integer[] result = new Integer[len];
    int x = len;
    // 自后往前遍歷數(shù)組
    for (int i = len - 1; i >= 0; i--) {
        boolean duplicate = false;
        // 檢查左側(cè)是否有相同元素
        for (int j = i - 1; j >= 0; j--) {
            if (arr[i].equals(arr[j])) {
                duplicate = true;
                break;   // 找到重復(fù)立即退出內(nèi)層循環(huán)
            }
        }
        // 沒(méi)有重復(fù)則保留當(dāng)前元素，倒序填入結(jié)果
        if (!duplicate) {
            result[--x] = arr[i];
        }
    }
    return Arrays.copyOfRange(result, x, len);
}

// 方法7：HashSet——最快，但結(jié)果無(wú)序
static Integer[] unique7(Integer[] arr) {
    // HashSet 自動(dòng)去重，但底層哈希散列后順序不可預(yù)測(cè)
    Set<Integer> set = new HashSet<>(Arrays.asList(arr));
    return set.toArray(new Integer[0]);
}

// 方法8：LinkedHashSet——保序，工程首選
static Integer[] unique8(Integer[] arr) {
    // LinkedHashSet 內(nèi)部用雙向鏈表維護(hù)插入順序
    Set<Integer> set = new LinkedHashSet<>(Arrays.asList(arr));
    return set.toArray(new Integer[0]);
}

// 方法9：TreeSet——自動(dòng)排序
static Integer[] unique9(Integer[] arr) {
    // TreeSet 基于紅黑樹(shù)，插入即有序（默認(rèn)升序）
    // 需要降序就用 .descendingSet() 或自定義 Comparator
    Set<Integer> set = new TreeSet<>(Arrays.asList(arr));
    return set.toArray(new Integer[0]);
}

// 方法10：HashMap 顯式判重
// 等價(jià)于方法7，但更便于擴(kuò)展（值可以放統(tǒng)計(jì)信息、首次位置等）
static Integer[] unique10(Integer[] arr) {
    Map<Integer, Integer> map = new HashMap<>();
    List<Integer> result = new ArrayList<>();
    for (Integer item : arr) {
        // putIfAbsent 內(nèi)部判 containsKey + put，等價(jià)但更緊湊
        if (map.putIfAbsent(item, item) == null) {
            result.add(item);
        }
    }
    return result.toArray(new Integer[0]);
}

// 方法11：LinkedHashMap——保序的 Map
// 適合"按某字段去重并攜帶其他信息"的場(chǎng)景
static Integer[] unique11(Integer[] arr) {
    // 用 LinkedHashMap 保留插入順序，鍵去重，值可攜帶統(tǒng)計(jì)
    Map<Integer, Integer> map = new LinkedHashMap<>();
    for (Integer item : arr) {
        // merge：鍵不存在則放 1，存在則累加（這里相當(dāng)于做了頻次統(tǒng)計(jì)）
        map.merge(item, 1, Integer::sum);
    }
    return map.keySet().toArray(new Integer[0]);
}

// 方法12：排序后從后往前刪
static Integer[] unique12(Integer[] arr) {
    List<Integer> list = new ArrayList<>(Arrays.asList(arr));
    Collections.sort(list); // 升序，相同元素聚到一起
    // 倒序掃描，自后往前：相鄰兩項(xiàng)相同就刪掉后一項(xiàng)
    for (int l = list.size() - 1; l > 0; l--) {
        if (list.get(l).equals(list.get(l - 1))) {
            list.remove(l);
        }
    }
    return list.toArray(new Integer[0]);
}

// 方法13：排序后從前往后刪
static Integer[] unique13(Integer[] arr) {
    List<Integer> list = new ArrayList<>(Arrays.asList(arr));
    Collections.sort(list, Collections.reverseOrder()); // 降序
    int l = list.size() - 1;
    int i = 0;
    while (i < l) {
        if (list.get(i).equals(list.get(i + 1))) {
            list.remove(i);
            // 刪完不前進(jìn)，長(zhǎng)度同步減一
            i--;
            l--;
        }
        i++;
    }
    return list.toArray(new Integer[0]);
}

// 方法14：排序 + 雙指針（類似LeetCode原題）
// 先排序，再原地去重（修改原數(shù)組），最后返回去重后的新數(shù)組
static int[] unique14(int[] arr) {
    if (arr.length == 0) return arr;
    Arrays.sort(arr);
    int slow = 0; // 慢指針：指向去重后區(qū)間的末尾（初始為第一個(gè)）
    for (int fast = 1; fast < arr.length; fast++) {
        // 當(dāng)前項(xiàng)與去重區(qū)間最后一個(gè)元素不同，說(shuō)明有新的值
        if (arr[fast] != arr[slow]) {
            // 將慢指針右移一步，并將新值寫(xiě)入到去重區(qū)間末尾
            arr[++slow] = arr[fast];
        }
    }
    // [0, slow] 是去重后的結(jié)果
    return Arrays.copyOf(arr, slow + 1);
}

// 方法15：基于 Stream.distinct() 一行去重
static Integer[] unique15(Integer[] arr) {
    // distinct 內(nèi)部基于 LinkedHashSet，保序、O(n)、寫(xiě)法最短
    return Arrays.stream(arr)
            .distinct()
            .toArray(Integer[]::new);
}

// 方法16：通過(guò) Stream.filter + 外部 Set
// 演示如何在函數(shù)式管道里攜帶"已出現(xiàn)"的狀態(tài)
static Integer[] unique16(Integer[] arr) {
    Set<Integer> seen = new HashSet<>();
    // filter 謂詞帶副作用：seen.add 返回 true 表示首次加入
    // 整個(gè)表達(dá)式語(yǔ)義：僅保留首次見(jiàn)到的元素
    return Arrays.stream(arr)
            .filter(seen::add)
            .toArray(Integer[]::new);
}

// 方法17：通過(guò) Collectors.toMap 按業(yè)務(wù)鍵去重
// 適合自定義對(duì)象按某字段去重的場(chǎng)景
static Integer[] unique17(Integer[] arr) {
    // 第三個(gè)參數(shù)是沖突合并函數(shù)：(existing, replacement) -> existing 保留首項(xiàng)
    // 用 LinkedHashMap::new 作為 Map 工廠，保留插入順序
    Map<Integer, Integer> map = Arrays.stream(arr).collect(
            Collectors.toMap(
                    item -> item,                  // keyMapper：用值本身做鍵
                    item -> item,                  // valueMapper
                    (existing, replacement) -> existing,
                    LinkedHashMap::new
            )
    );
    return map.values().toArray(new Integer[0]);
}

// 方法18：遞歸--從后往前構(gòu)建去重列表，跟方法1類似，也是新建數(shù)組獲得不重復(fù)項(xiàng)
// 遞歸檢查末尾元素是否在前面出現(xiàn)過(guò)，若不重復(fù)則插入到結(jié)果列表頭部，最終保持原順序
static Integer[] uniqueRecursive(Integer[] arr, int length, List<Integer> result) {
    // 遞歸終止：只剩一項(xiàng)，直接收尾
    if (length <= 1) {
        if (length == 1) result.add(0, arr[0]);
        return result.toArray(new Integer[0]);
    }

    int last = length - 1;
    Integer lastItem = arr[last];
    boolean isRepeat = false;
    // 在 [0, last) 區(qū)間找是否已出現(xiàn)過(guò) lastItem
    for (int i = last - 1; i >= 0; i--) {
        if (lastItem.equals(arr[i])) {
            isRepeat = true;
            break;
        }
    }
    // 不重復(fù)則把 lastItem 加入結(jié)果（往前插入以保持原順序）
    if (!isRepeat) {
        result.add(0, lastItem);
    }
    return uniqueRecursive(arr, length - 1, result);
}

// 方法19：遞歸--拼接返回（純函數(shù)式，不修改原數(shù)組和外部集合）
// 核心思路：先遞歸處理前 n-1 個(gè)元素得到去重結(jié)果，再判斷第 n 個(gè)元素是否在它前面出現(xiàn)過(guò)。
//         若未出現(xiàn)過(guò)，則追加到結(jié)果末尾；否則直接返回。最終保持原數(shù)組的首次出現(xiàn)順序。
static List<Integer> uniqueRecursiveConcat(List<Integer> list, int length) {
    if (length <= 1) {
        // 長(zhǎng)度≤1時(shí)，直接返回原列表的前 length 個(gè)元素（避免后續(xù)越界）
        return new ArrayList<>(list.subList(0, length));
    }

    int last = length - 1;
    Integer lastItem = list.get(last);
    boolean isRepeat = false;
    // 檢查當(dāng)前項(xiàng) lastItem 是否在它前面的子數(shù)組中出現(xiàn)過(guò)
    for (int i = last - 1; i >= 0; i--) {
        if (lastItem.equals(list.get(i))) {
            isRepeat = true;
            break;
        }
    }

    // 遞歸深入：此時(shí)尚未得到前 length-1 項(xiàng)的去重結(jié)果，暫停當(dāng)前層，進(jìn)入子問(wèn)題求解
    List<Integer> head = uniqueRecursiveConcat(list, length - 1);
    // 遞歸回溯：子問(wèn)題已返回結(jié)果（head 中已包含前 length-1 項(xiàng)的去重結(jié)果，且保序）
  
    // 當(dāng)前項(xiàng)不重復(fù)則追加到結(jié)果末尾（保持原順序）
    if (!isRepeat) {
        head.add(lastItem);
    }
    return head;
}

// 方法20：BitSet 位圖法（僅適用于非負(fù)整數(shù)）
// BitSet 是用一個(gè) long[] 數(shù)組來(lái)模擬一個(gè)無(wú)限長(zhǎng)的位序列。（0 表示 false/未出現(xiàn)，1 表示 true/已出現(xiàn)）
// 每個(gè) int 用一位標(biāo)記是否出現(xiàn)過(guò)，10 億規(guī)模也只要 ~128MB
static int[] uniqueBitSet(int[] arr) {
    BitSet bitSet = new BitSet();
    int[] result = new int[arr.length];
    int x = 0;
    for (int item : arr) {
        // 注意 BitSet 的下標(biāo)必須非負(fù)，負(fù)數(shù)需要先做偏移
        if (item < 0) {
            throw new IllegalArgumentException("BitSet 不支持負(fù)數(shù)，需要先偏移");
        }
        // 第 item 位為 0 表示首次出現(xiàn)
        if (!bitSet.get(item)) {
            bitSet.set(item); // 標(biāo)記為已出現(xiàn)
            result[x++] = item;
        }
    }
    return Arrays.copyOf(result, x);
}

// 保序、O(n)、寫(xiě)法最短，工程首選
List<Integer> result = list.stream().distinct().collect(Collectors.toList());

// 或顯式用 LinkedHashSet，語(yǔ)義更清晰
List<Integer> result = new ArrayList<>(new LinkedHashSet<>(list));

List<Integer> result = new ArrayList<>(new HashSet<>(list));

List<Integer> result = new ArrayList<>(new TreeSet<>(list));

BitSet bitSet = new BitSet();
for (int x : data) bitSet.set(x);
// bitSet.cardinality() 即不重復(fù)元素個(gè)數(shù)

/**
 * 帶業(yè)務(wù)規(guī)則的去重。
 *
 * @param data         原數(shù)據(jù)
 * @param keyFn        從元素提取去重鍵
 * @param onDuplicate  遇到重復(fù)時(shí)如何合并 (舊值, 新值) -> 新代表值
 */
static <T, K> List<T> uniqueBy(List<T> data,
                               Function<T, K> keyFn,
                               BinaryOperator<T> onDuplicate) {
    // LinkedHashMap 保證遍歷順序與首次出現(xiàn)順序一致
    Map<K, T> chosen = new LinkedHashMap<>();
    for (T item : data) {
        K key = keyFn.apply(item);
        // merge：鍵不存在則直接放入，存在則用 onDuplicate 決定保留誰(shuí)
        chosen.merge(key, item, onDuplicate);
    }
    return new ArrayList<>(chosen.values());
}

class Student {
    int id;
    String name;
    int score;
    // 構(gòu)造器、getter 略
}

List<Student> students = List.of(
        new Student(1, "張三", 90),
        new Student(1, "張三", 95),   // 同 id，分?jǐn)?shù)更高
        new Student(2, "李四", 85)
);

List<Student> result = uniqueBy(
        students,
        Student::getId,
        // 重復(fù)時(shí)保留分?jǐn)?shù)高的那條
        (old, news) -> news.getScore() > old.getScore() ? news : old
);
// 結(jié)果只剩 [{id:1,score:95}, {id:2,score:85}]

// groupingBy + counting 是 Java 里的"頻次統(tǒng)計(jì)"慣用法
Map<String, Long> counts = data.stream()
        .collect(Collectors.groupingBy(s -> s, LinkedHashMap::new, Collectors.counting()));
// counts.keySet() 即保序的去重結(jié)果

Set<Integer> seen = new HashSet<>();
List<Integer> result = new ArrayList<>();
for (int x : data) {
    if (x >= 0 && x <= 100) {
        // 區(qū)間內(nèi)才參與去重
        if (seen.add(x)) result.add(x);
    } else {
        // 區(qū)間外原樣保留
        result.add(x);
    }
}

class User {
    private final long id;
    private final String name;

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

    // equals：業(yè)務(wù)上認(rèn)為 id 相同就是同一個(gè)用戶
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        return id == ((User) o).id;
    }

    // hashCode：必須與 equals 一致——equals 相等的對(duì)象 hashCode 必須相等
    @Override
    public int hashCode() {
        return Long.hashCode(id);
    }
}

// 現(xiàn)在塞進(jìn) HashSet 就會(huì)按 id 去重
Set<User> uniqueUsers = new HashSet<>(users);