Java集合：理解HashSet与TreeSet中复杂对象的时间复杂度

import java.util.Objects;

public class CustomObject {
    private final String name;
    private final int id;

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

    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

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

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

    // 注意：如果CustomObject是可变的，并且在添加到HashSet后改变了name或id，
    // 那么HashSet可能无法正确找到或删除该对象。
}

// 使用HashSet
import java.util.HashSet;

public class HashSetExample {
    public static void main(String[] args) {
        HashSet<CustomObject> mySet = new HashSet<>();
        CustomObject obj1 = new CustomObject("Alice", 1);
        CustomObject obj2 = new CustomObject("Bob", 2);
        CustomObject obj3 = new CustomObject("Alice", 1); // 与obj1相等

        mySet.add(obj1);
        mySet.add(obj2);
        mySet.add(obj3); // 不会被添加，因为与obj1相等

        System.out.println("Set size: " + mySet.size()); // 输出 2
        System.out.println("Contains obj1: " + mySet.contains(obj1)); // 输出 true
        System.out.println("Contains new Alice(1): " + mySet.contains(new CustomObject("Alice", 1))); // 输出 true
    }
}

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.TreeSet;
import java.util.Vector;

public class TreeSetExample {
    public static void main(String[] args) {
        // 创建一个比较器，基于列表的长度进行比较
        Comparator<List<Integer>> listComparator = new Comparator<List<Integer>>() {
            @Override
            public int compare(List<Integer> list1, List<Integer> list2) {
                // 首先比较列表大小
                int sizeComparison = Integer.compare(list1.size(), list2.size());
                if (sizeComparison != 0) {
                    return sizeComparison;
                }
                // 如果大小相同，则按元素逐个比较（这里仅作示例，实际可能更复杂）
                for (int i = 0; i < list1.size(); i++) {
                    int elementComparison = Integer.compare(list1.get(i), list2.get(i));
                    if (elementComparison != 0) {
                        return elementComparison;
                    }
                }
                return 0; // 列表内容完全相同
            }
        };

        // 使用ArrayList作为示例，因为Vector是ArrayList的同步版本，行为类似
        TreeSet<List<Integer>> myTreeSet = new TreeSet<>(listComparator);

        List<Integer> listA = new ArrayList<>();
        listA.add(1);
        listA.add(2);

        List<Integer> listB = new ArrayList<>();
        listB.add(1);
        listB.add(2);
        listB.add(3);

        List<Integer> listC = new ArrayList<>();
        listC.add(1);
        listC.add(3); // 长度与listA相同，但内容不同

        myTreeSet.add(listA);
        myTreeSet.add(listB);
        myTreeSet.add(listC);

        System.out.println("TreeSet elements (sorted by length then content):");
        for (List<Integer> list : myTreeSet) {
            System.out.println(list);
        }
        // 预期输出可能为：
        // [1, 2]
        // [1, 3]
        // [1, 2, 3]
    }
}