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

Java之Java基础二十(集合[上])_第1张图片

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

①、Collection,主要由 List、Set、Queue 组成:

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

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

一、List

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

(1)ArrayList

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

// 创建一个集合
ArrayList list = new ArrayList();
// 添加元素
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 list = new LinkedList();
// 添加元素
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
    extends AbstractSet
    implements Set, Cloneable, java.io.Serializable
{
    private transient HashMap 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 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 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 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 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

你可能感兴趣的:(Java,java,开发语言,Java基础)