集合

List<String> list = new ArrayList<>(Arrays.asList("A", "B", "C"));     Arrays.asList() 将数组转化为 List
String[] strings = {"1", "2", "3"};

集合转数组
String[] ListToArray = new String[list.size()];
list.toArray(ListToArray);

增
----
list.add("A");     A B C A     加入集合
list.add(0, "A");     A A B C     插入集合
list.addAll(1, Arrays.asList(strings));     A 1 2 3 B C     插入集合

删
----
list.remove(0);     B C     删除集合中的对象
list.remove(string);     B C     删除集合中的对象     String string = list.get(0) 获得对象的引用
list.removeAll(Arrays.asList(strings));     C     删除集合中的对象     String[] strings = {list.get(0), list.get(1)} 获得对象的引用并转换为 List

改
----
list.set(1, "A");     A A C     修改集合中的对象

查
----
list.get(0);     获得对象 A
list.size();     获得集合容量
list.indexOf("A")     0     索引对象，没有匹配对象则返回 -1     实现原理同 contains 方法
list.contains("A")     true     是否包含该对象     该方法调用对象的 equals 方法进行比较；通过重写 equals 方法使其比较数据本身，而不是对象内存地址，以获得更好的扩展。
list.containsAll(Arrays.asList("A", "C"))     true     是否包含该对象            ⇳
                                                                                                                HashSet 先比较 hashCode，再调用 equals 方法，所以还需要重写 hashCode 方法。
遍历集合
1     foreach
for (String i : list) {
    System.out.println(i);
}

2     迭代器
Iterator iterator = list.iterator();     接收集合的迭代器
for (; iterator.hasNext(); ) {
    System.out.println(iterator.next());
}

-------------------------------------------------------
Set<String> list = new HashSet<>(Arrays.asList("A", "B", "A"));     A B
Set 是无序且不可重复的，所以不会有重复对象的引用，也不会含有具体位置的方法。

Map<Integer, String> map = new HashMap<>();

增
----
map.put(1, "A");     添加映射关系

删
----
map.remove(1);     移除指定键的映射关系，同时返回映射值 (栈的 pop)
map.clear();     清空映射关系

改
----
map.put(1, "B");     覆盖已有的映射关系

查
----
map.get(1);     获得指定键所映射的值
map.size();     获得映射关系数
map.containsKey(1);     true     是否包含该 Key     实现原理同 contains 方法
map.containsValue("A");     true     是否包含该 Value     实现原理同 contains 方法

遍历 Map
1     entrySet     键 值
Set<Map.Entry<Integer, String>> entrySet = map.entrySet();     接收包含 Entry 对象的 Set 集合
for (Map.Entry<Integer, String> entry : entrySet) {
    System.out.println(entry.getKey() + " " + entry.getValue());
}

2     keySet     键
Set<Integer> keyset = map.keySet();     接收包含 Key 的 Set 集合
for (int i : keyset) {
    System.out.println(i + " " + map.get(i));
}

3     values     值
Collection list = map.values();     接收包含 Value 的 Collection 集合
for (Object i : list) {
    System.out.println(i);
}

生成 10 个不重复的 10 位以内的随机字符串并排序输出
----
public class A {
    private static List<String> list = new ArrayList<>();

    public static void main(String[] args) {
        generateList();
        Collections.sort(list);     排序集合
        getList();
    }

    private static void generateList() {     生成集合
        String strings = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
        String string = "";
        Random random = new Random();     实例化 Random
        for (int j = 0; j < 10; j++) {
            do {
                string = "";     重置字符串
                for (int i = 0, k = random.nextInt(10); i < k; i++) {     random.nextInt(10) 返回 [0,10) 以内的随机整数
                    string += strings.charAt(random.nextInt(62));
                }
            } while (list.contains(string));     确保字符串不重复
            list.add(string);
        }
    }

    private static void getList() {     遍历集合
        int j = 0;
        for (String i : list) {
            System.out.println("元素" + j + "：" + i);
            j++;
        }
    }
}
----
输出：
元素0：0CcjLX
元素1：DsJ9tF
元素2：ErW5sK59k
元素3：JuD
元素4：Q54tooYP
元素5：VVZ
元素6：dQStqTlKn
元素7：fwVv
元素8：pnY3c
元素9：ri6NDi

Tips：
字符串比较规则：
数字：0-9
大写字母：A-Z
小写字母：a-z

-------------------------------------------------------

对自定义类进行排序
----
public class A {
    private static List<Student> list = new ArrayList<>(Arrays.asList(new Student(1, "CC"), new Student(2, "AA"), new Student(3, "BB")));

    public static void main(String[] args) {
        Collections.sort(list);     使用默认比较规则，调用 compareTo，等同于 list.sort(null)
        getlist();
        System.out.println("---------");
        Collections.sort(list, new Student());     使用临时比较规则，调用 compare，等同于 list.sort(new Student())
        getlist();
    }

    private static void getlist() {
        for (Student i : list) {
            System.out.println(i.id + ":" + i.name);
        }
    }
}

class Student implements Comparable<Student>, Comparator<Student> {     实现接口
    int id;
    String name;

    Student() {
    }

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

    @Override
    public int compareTo(Student o) {     默认比较规则
        return ((Integer) this.id).compareTo(o.id);     比较 id
    }

    @Override
    public int compare(Student o1, Student o2) {     临时比较规则
        return o1.name.compareTo(o2.name);     比较 name
    }
}
----
输出：
1:CC
2:AA
3:BB
---------
2:AA
3:BB
1:CC

Tips：
实现以下接口代表该类是可以比较大小的，可以进行自然排序：
java.lang.Comparable     默认比较规则     compareTo(Object o)
java.util.Comparator       临时比较规则     compare(Object o1, Object o2)
返回值：
0      相等     o1=o2
1      大于     o1>o2
-1     小于     o1<o2