Java之Java基础二十（集合[上])

Violet永存

于 2024-07-31 15:36:56 发布

阅读量683

点赞数 25

分类专栏： Java 文章标签： java 开发语言 Java基础

本文链接：https://blog.csdn.net/AWSDN/article/details/140822782

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java 集合框架可以分为两条大的支线：

①、Collection，主要由 List、Set、Queue 组成：

List 代表有序、可重复的集合，典型代表就是封装了动态数组的 ArrayList 和封装了链表的 LinkedList；
Set 代表无序、不可重复的集合，典型代表就是 HashSet 和 TreeSet；
Queue 代表队列，典型代表就是双端队列 ArrayDeque，以及优先级队列 PriorityQueue。

②、Map，代表键值对的集合，典型代表就是HashMap

一、List

List 的特点是存取有序，可以存放重复的元素，可以用下标对元素进行操作。

（1）ArrayList

先来一段 ArrayList 的增删改查，学会用。

// 创建一个集合
ArrayList<String> list = new ArrayList<String>();
// 添加元素
list. Add("aa");
list. Add("bb");
list. Add("ccc");

// 遍历集合 for 循环
for (int i = 0; i < list.size(); i++) {
    String s = list. Get(i);
    System.out.println(s);
}
// 遍历集合 for each
for (String s : list) {
    System.out.println(s);
}

// 删除元素
list.remove(1);
// 遍历集合
for (String s : list) {
    System.out.println(s);
}

// 修改元素
list. Set(1, "aaa");
// 遍历集合
for (String s : list) {
    System.out.println(s);
}

简单介绍一下 ArrayList 的特征

ArrayList 是由数组实现的，支持随机存取，也就是可以通过下标直接存取元素；
从尾部插入和删除元素会比较快捷，从中间插入和删除元素会比较低效，因为涉及到数组元素的复制和移动；
如果内部数组的容量不足时会自动扩容，因此当元素非常庞大的时候，效率会比较低。

(2) LinkedList

同样先来一段 LinkedList 的增删改查，和 ArrayList 几乎没什么差别。

// 创建一个集合
LinkedList<String> list = new LinkedList<String>();
// 添加元素
list. Add("aa");
list. Add("bb");
list. Add("ccc");

// 遍历集合 for 循环
for (int i = 0; i < list.size(); i++) {
    String s = list.get(i);
    System.out.println(s);
}
// 遍历集合 for each
for (String s : list) {
    System.out.println(s);
}

// 删除元素
list.remove(1);
// 遍历集合
for (String s : list) {
    System.out.println(s);
}

// 修改元素
list. Set(1, "aaa");
// 遍历集合
for (String s : list) {
    System.out.println(s);
}

不过，LinkedList 和 ArrayList 仍然有较大的不同

LinkedList 是由双向链表实现的，不支持随机存取，只能从一端开始遍历，直到找到需要的元素后返回；
任意位置插入和删除元素都很方便，因为只需要改变前一个节点和后一个节点的引用即可，不像 ArrayList 那样需要复制和移动数组元素；
因为每个元素都存储了前一个和后一个节点的引用，所以相对来说，占用的内存空间会比 ArrayList 多一些。

(3) Vector 和 Stack

List 的实现类还有一个 Vector，是一个元老级的类，比 ArrayList 出现得更早。ArrayList 和 Vector 非常相似，只不过 Vector 是线程安全的，像 get、set、add 这些方法都加了 synchronized 关键字，就导致执行效率会比较低，所以现在已经很少用了。

看一下 add 方法的源码

public synchronized boolean add(E e) {
    elementData[elementCount++] = e;
    return true;
}

这种加了同步方法的类，注定会被淘汰掉，就像StringBuilder 取代 StringBuffer那样。JDK 源码也说了：

如果不需要线程安全，建议使用 ArrayList 代替 Vector。

Stack 是 Vector 的一个子类，本质上也是由动态数组实现的，只不过还实现了先进后出的功能（在 get、set、add 方法的基础上追加了 pop「返回并移除栈顶的元素」、peek「只返回栈顶元素」等方法），所以叫栈。

下面是这两个方法的源码，增删改查我就不写了，和 ArrayList 和 LinkedList 几乎一样。

public synchronized E pop() {
    E       obj;
    int     len = size();

    obj = peek();
    removeElementAt(len - 1);

    return obj;
}

public synchronized E peek() {
    int     len = size();

    if (len == 0)
        throw new EmptyStackException();
    return elementAt(len - 1);
}

不过，由于 Stack 执行效率比较低（方法上同样加了 synchronized 关键字），就被双端队列 ArrayDeque 取代了.

二、Set

Set 的特点是存取无序，不可以存放重复的元素，不可以用下标对元素进行操作，和 List 有很多不同。

（1）HashSet

HashSet 其实是由 HashMap 实现的，只不过值由一个固定的 Object 对象填充，而键用于操作。来简单看一下它的源码。

public class HashSet<E>
    extends AbstractSet<E>
    implements Set<E>, Cloneable, java.io.Serializable
{
    private transient HashMap<E,Object> map;

    // Dummy value to associate with an Object in the backing Map
    private static final Object PRESENT = new Object();

    public HashSet() {
        map = new HashMap<>();
    }

    public boolean add(E e) {
        return map.put(e, PRESENT)==null;
    }

    public boolean remove(Object o) {
        return map.remove(o)==PRESENT;
    }
}

实际开发中，HashSet 并不常用，比如，如果我们需要按照顺序存储一组元素，那么 ArrayList 和 LinkedList 可能更适合；如果我们需要存储键值对并根据键进行查找，那么 HashMap 可能更适合。

来一段增删改查体验一下：

// 创建一个新的HashSet
HashSet<String> set = new HashSet<>();

// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");

// 输出HashSet的元素个数
System.out.println("HashSet size: " + set.size()); // output: 3

// 判断元素是否存在于HashSet中
boolean containsWanger = set. Contains("bb");
System.out.println("Does set contain 'bb'? " + containsWanger); // output: true

// 删除元素
boolean removeWanger = set. Remove("bb");
System.out.println("Removed 'bb'? " + removeWanger); // output: true

// 修改元素，需要先删除后添加
Boolean removeChenmo = set. Remove("aa");
Boolean addBuChenmo = set. Add("aaa");
System.out.println("Modified set? " + (removeChenmo && addBuChenmo)); // output: true

// 输出修改后的HashSet
System.out.println("HashSet after modification: " + set); // output: [ccc, aaa]

HashSet 主要用于去重，比如，我们需要统计一篇文章中有多少个不重复的单词，就可以使用 HashSet 来实现。

// 创建一个 HashSet 对象
HashSet<String> set = new HashSet<>();

// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
set. Add("aa");

// 输出 HashSet 的元素个数
System.out.println("HashSet size: " + set.size()); // output: 3

// 遍历 HashSet
for (String s : set) {
    System.out.println(s);
}

从上面的例子可以看得出，HashSet 会自动去重，因为它是用 HashMap 实现的，HashMap 的键是唯一的（哈希值），相同键的值会覆盖掉原来的值，于是第二次 set.add("沉默") 的时候就覆盖了第一次的 set.add("aa")。

`(2)LinkedHashSet`

LinkedHashSet 虽然继承自 HashSet，其实是由 LinkedHashMap 实现的。

这是 LinkedHashSet 的无参构造方法：

public LinkedHashSet() {
    super(16, .75f, true);
}

super 的意思是它将调用父类的 HashSet 的一个有参构造方法：

HashSet(int initialCapacity, float loadFactor, boolean dummy) {
    map = new LinkedHashMap<>(initialCapacity, loadFactor);
}

LinkedHashSet 的增删改查

LinkedHashSet<String> set = new LinkedHashSet<>();

// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");

// 删除元素
set. Remove("bb");

// 修改元素
set. Remove("aa");
set. Add("aaaaa");

// 查找元素
Boolean hasChenQingYang = set. Contains("ccc");
System.out.println("set包含ccc吗？" + hasccc);

在以上代码中，我们首先创建了一个 LinkedHashSet 对象，然后使用 add 方法依次添加了三个元素：aa、bb和ccc。接着，我们使用 remove 方法删除了bb这个元素，并使用 remove 和 add 方法修改了aa这个元素。最后，我们使用 contains 方法查找了ccc这个元素是否存在于 set 中，并打印了结果。

LinkedHashSet 是一种基于哈希表实现的 Set 接口，它继承自 HashSet，并且使用链表维护了元素的插入顺序。因此，它既具有 HashSet 的快速查找、插入和删除操作的优点，又可以维护元素的插入顺序。

(3)TreeSet

与 TreeMap 相似，TreeSet 是一种基于红黑树实现的有序集合，它实现了 SortedSet 接口，可以自动对集合中的元素进行排序。按照键的自然顺序或指定的比较器顺序进行排序。

// 创建一个 TreeSet 对象
TreeSet<String> set = new TreeSet<>();

// 添加元素
set. Add("aa");
set. Add("bb");
set. Add("ccc");
System.out.println(set); // 输出 [aa, bb, ccc]

// 删除元素
set. Remove("bb");
System.out.println(set); // 输出 [aa, ccc]

// 修改元素：TreeSet 中的元素不支持直接修改，需要先删除再添加
set. Remove("ccc");
set. Add("cbc");
System.out.println(set); // 输出 [aa, cbc]

// 查找元素
System.out.println(set. Contains("aa")); // 输出 true
System.out.println(set. Contains("bb")); // 输出 false

需要注意的是，TreeSet 不允许插入 null 元素，否则会抛出 NullPointerException 异常。

总体上来说，Set 集合不是关注的重点，因为底层都是由 Map 实现的，为什么要用 Map 实现呢？

因为 Map 的键不允许重复、无序.

参考链接：https://javabetter.cn/collection/gailan.html