Java集合随笔

Collection部分：

1. Set部分：

• HashSet：底层数据结构是哈希表，线程不安全，无序，不可重复。
• LinkedHashSet：底层数据结构是哈希表和链表，线程不安全，有序，不可重复。
• SortedSet：底层数据结构可以是红黑树或跳表，线程不安全，有序，不可重复。
• TreeSet：底层数据结构是红黑树，线程不安全，有序，不可重复。

2. List部分：

• ArrayList：底层数据结构是数组，线程不安全，有序，可重复。
• LinkedList：底层数据结构是双向链表，线程不安全，有序，可重复。
• Vector：底层数据结构是数组，线程安全，有序，可重复。
• Stack：底层数据结构是数组，线程安全，有序，可重复。

3. Queue部分：

• PriorityQueue：底层数据结构是堆，线程不安全，无序，可重复。
• Deque：底层数据结构可以是数组或双向链表，线程不安全，有序，可重复。

Map部分：

• HashMap：底层数据结构是哈希表，线程不安全，无序，key不可重复。
• LinkedHashMap：底层数据结构是哈希表和链表，线程不安全，有序，key不可重复。
• HashTable：底层数据结构是哈希表，线程安全，无序，key不可重复。
• SortedMap：底层数据结构可以是红黑树或跳表，线程不安全，有序，key不可重复。
• TreeMap：底层数据结构是红黑树，线程不安全，有序，key不可重复。

好文链接

常见的方法

1. List接口的方法：

• add(E element)：将指定元素添加到列表的末尾。
• remove(int index)：移除指定位置的元素。
• get(int index)：返回指定位置的元素。
• size()：返回列表的大小。
• contains(Object o)：判断列表是否包含指定元素。
• indexOf(Object o)：返回指定元素在列表中的索引。

2. Set接口的方法：

• add(E element)：将指定元素添加到集合中。
• remove(Object o)：从集合中移除指定元素。
• contains(Object o)：判断集合是否包含指定元素。
• size()：返回集合的大小。

3. Map接口的方法：

• put(K key, V value)：将指定的键值对添加到映射中。
• remove(Object key)：从映射中移除指定键对应的键值对。
• get(Object key)：返回指定键对应的值。
• containsKey(Object key)：判断映射是否包含指定键。
• containsValue(Object value)：判断映射是否包含指定值。

4. Queue接口的方法：

• offer(E element)：将指定元素添加到队列的末尾。
• poll()：移除并返回队列的头部元素。
• peek()：返回队列的头部元素，但不移除。

5. Stack类的方法：

• push(E item)：将指定元素压入栈。
• pop()：移除并返回栈顶元素。
• peek()：返回栈顶元素，但不移除。

Collections类

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

public class CollectionExample {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(3);
        numbers.add(9);
        numbers.add(1);
        numbers.add(7);

        // 排序
        Collections.sort(numbers);
        System.out.println("升序排序后的列表：" + numbers);

        // 反转
        Collections.reverse(numbers);
        System.out.println("反转后的列表：" + numbers);

        // 随机打乱
        Collections.shuffle(numbers);
        System.out.println("随机打乱后的列表：" + numbers);

        // 查找元素
        int index = Collections.binarySearch(numbers, 7);
        System.out.println("元素7的位置索引：" + index);

        // 替换元素
        Collections.replaceAll(numbers, 3, 10);
        System.out.println("将元素3替换为10后的列表：" + numbers);
    }
}

输出结果：

升序排序后的列表：[1, 3, 5, 7, 9]
反转后的列表：[9, 7, 5, 3, 1]
随机打乱后的列表：[7, 1, 5, 9, 3]
元素7的位置索引：0
将元素3替换为10后的列表：[7, 1, 5, 9, 10]

Comparator接口

• 如果我们对一个类自带的自然排序不满意，又不能修改其源代码的情况下，可以使用Comparator来实现自定义排序。
• Comparator是一个接口，它定义了用于比较两个对象的方法。我们可以创建一个实现了Comparator接口的类，然后在该类中实现compare()方法来定义我们自己的比较规则。

下面是一个使用Comparator进行自定义排序的示例代码：

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CustomSortingExample {
    public static void main(String[] args) {
        List<Person> personList = new ArrayList<>();
        
        personList.add(new Person("Alice", 25));
        personList.add(new Person("Bob", 20));
        personList.add(new Person("Charlie", 30));
        
        // 使用Comparator进行自定义排序
        Collections.sort(personList, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                // 根据年龄升序排序
                return p1.getAge() - p2.getAge();
            }
        });
        
        // 输出排序后的结果
        for (Person person : personList) {
            System.out.println(person.getName() + " - " + person.getAge());
        }
    }
}

class Person {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public int getAge() {
        return age;
    }
}

HashMap 的长度为什么是 2 的幂次方？

讲解链接

• 设计一个算法来计算一个数除以2的幂次方的余数，可以使用位运算来实现。

具体步骤如下：

1. 将要计算的数转换为二进制表示。
2. 将2的幂次方减1转换为二进制表示。
3. 对这两个二进制数进行按位与操作。
4. 将结果转换为十进制表示，即为所求的余数。

例如，计算13除以8的余数：

1. 13的二进制表示为1101。
2. 8-1的二进制表示为111。
3. 进行按位与操作得到101。
4. 将101转换为十进制表示，结果为5。

这样就得到了13除以8的余数为5。