Java集合-Collection

过山车gsc

已于 2022-10-07 00:18:06 修改

阅读量165

点赞数

分类专栏： # 集合文章标签： java 开发语言算法

于 2022-10-06 19:19:28 首次发布

本文链接：https://blog.csdn.net/AxAxx/article/details/127185999

版权

集合专栏收录该内容

4 篇文章 0 订阅

订阅专栏

本文详细介绍了Java集合框架中的Collection接口及其子接口List和Set的实现类，如ArrayList、Vector和LinkedList的特点和操作。ArrayList在JDK1.7和1.8中的扩容策略对比，Vector的线程安全性，以及LinkedList的高效插入删除操作。同时，还探讨了Set接口的HashSet和TreeSet，强调了它们在存储和排序上的特性。

摘要由CSDN通过智能技术生成

类图

Collection类图

图解

Collection

特点

单据数的存储
继承Iterable接口，其实现类均可使用迭代器循环

api

增加：add(E e); addAll(Collection<? extends E> c);
删除：clear(); remove(Object o);
查看：iterator(); size();
判断：contains(Object o); equals(Object o); isEmpty() ;

List

特点

Collection的子接口
元素有序（索引），可重复

api

修改：set(int index, E e);
查看：get(int index);

ArrayList

特点

List的实现类
物理结构：紧密结构；逻辑结构：数组
查询效率高，删除、增加元素的效率低
线程不安全

属性

private transient Object[] elementData;
private int size;

JDK1.7

构造函数

// 无参构造
public ArrayList() {
    // 默认创建长度为10的数组
    this(10);
}
public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    // 根据指定长度初始化数组
    this.elementData = new Object[initialCapacity];
}

在使用无参构造时，默认初始化长度为10的数组
可以使用有参构造，指定底层数组的长度

add()

public boolean add(E e) {
    // 判断是否需要扩容
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}

首先判断是否需要扩容
在数组的尾部插入元素
size++
返回true

扩容

判断是否需要扩容

private void ensureCapacityInternal(int minCapacity) {
    modCount++;
    // 如果需要的容量大于当前数组的长度，则进行扩容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容

private void grow(int minCapacity) {

    int oldCapacity = elementData.length;
    // 扩容至原来的1.5倍
    int newCapacity = oldCapacity + (oldCapacity >> 1);    
    // 如果1.5倍的容量仍小于需要的容量，则扩容至需要的容量
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    // 以新容量作为长度创建新的数组，将旧数组元素复制到新的数组
    elementData = Arrays.copyOf(elementData, newCapacity);
}

扩容至原数组长度的1.5倍
判断新容量是否满足要求
以新容量作为长度创建新的数组，将旧数组元素复制到新的数组

JDK1.8

默认属性

// 默认空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 默认容量
private static final int DEFAULT_CAPACITY = 10;

构造函数

// 无参构造
public ArrayList() {
    // 默认创建空数组
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

使用无参构造时，默认创建一个空数组，在调用add() 方法之后，再重新赋值新数组，数组长度为 Max(10, minCapacity)

add()

public boolean add(E e) {
    // 判断是否需要扩容
    ensureCapacityInternal(size + 1);  
    elementData[size++] = e;
    return true;
}

首先判断是否需要扩容
在数组的尾部插入元素
size++
返回true

扩容

计算至少需要的容量

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 如果当前数组是默认空数组，
    // 则比较默认容量（10）和需要的容量，
    // 返回较大的容量
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

判断是否需要扩容

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    // 需要的容量 > 原数组的长度
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容

同JDK1.7-扩容

Vector

特点

List的实现类
物理结构：紧密结构；逻辑结构：数组
查询效率高，删除、增加元素的效率低
线程安全

成员属性

protected Object[] elementData;
protected int elementCount;

构造函数

// 无参构造，默认数组长度为10
public Vector() {
    this(10);
}

add()

// 线程安全
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}

使用synchronized保证线程安全
判断是否需要扩容
数组尾部插入元素
elementCount++
返回true

扩容

判断是否需要扩容

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

扩容

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    // capacityIncrement默认为0
    // 所以，默认扩容长度为原数组长度的2倍
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);
}

默认扩容至原数组长度的2倍
判断新容量是否满足要求
以新容量作为长度创建新的数组，将旧数组元素复制到新的数组

LinkedList

特点

List的实现类
物理结构：跳转结构；逻辑结构：线性表（双向链表）
查询效率低，删除、增加元素的效率高

成员属性

// 元素个数
transient int size = 0;
// 头节点
transient Node<E> first;
// 尾节点
transient Node<E> last;

内部类Node

private static class Node<E> {
    E item; // 元素
    Node<E> next; // 后一个节点
    Node<E> prev; // 前一个节点

    Node(Node<E> prev, E element, Node<E> next) {
        this.item = element;
        this.next = next;
        this.prev = prev;
    }
}

api

增加：addFirst(E e); addLast(E e);
offer(E e); offerFirst(E e); offerLast(E e);
删除：poll(); pollFirst(); pollLast();
removeFirst(); removeLast();
查看：element();
peek(); peekFirst(); peekLast();
getFirst(); getLast();
indexOf(Obj o); lastIndexOf(Obj o)

构造函数

public LinkedList() {
}

无参构造函数，size为0，头尾节点都为null

add()

public boolean add(E e) {
    linkLast(e);
    return true;
}

尾插法

void linkLast(E e) {
    // 获取尾节点
    final Node<E> l = last;
    // 构造新节点
    final Node<E> newNode = new Node<>(l, e, null);
    // 把新节点作为链表的尾节点
    last = newNode;
    if (l == null)
	// 链表为空，新节点也作为头节点
        first = newNode;
    else
	// 原尾节点的next指向新节点
        l.next = newNode;
    size++;
    modCount++;
}

使用尾插法，元素e作为链表的最后一个元素
获取原尾节点 l
构建新节点，prev指向原尾节点，next指向null
新节点作为链表的新尾结点，即赋值给链表的last
如果原尾节点 l 为null，表示链表为空，则链表的头节点也指向新节点；否则原尾节点的next指向新节点
size++

get()

查找元素

public E get(int index) {
    // 健壮性
    checkElementIndex(index);
    return node(index).item;
}
Node<E> node(int index) {
    // assert isElementIndex(index);
    if (index < (size >> 1)) {
	// 如果index小于size的一半，从头节点开始遍历寻找
        Node<E> x = first;
        for (int i = 0; i < index; i++)
            x = x.next;
        return x;
    } else {
	// 如果index大于等于size的一半，从尾节点开始遍历寻找
        Node<E> x = last;
        for (int i = size - 1; i > index; i--)
            x = x.prev;
        return x;
    }
}

索引和链表的元素个数size进行比较

index小于size的一半，从头节点开始遍历，根据节点的next进行查找
index大于等于size的一半，从尾节点开始遍历，根据节点的prev进行查找

Set

特点

Collection的子接口
元素无序（仅相对List，不等同与随机），不可重复

元素必须重写hashCode() 和 equals() 方法

HashSet

属性

private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();

构造函数

// 无参构造
public HashSet() {
    map = new HashMap<>();
}

底层就是使用HashMap来存储数据

add()

// 添加数据实际就是往hashMap中添加数据
public boolean add(E e) {
    return map.put(e, PRESENT)==null;
}

以数据元素作为key，固定obj对象作为value，保存到hashMap中

HashMap

详情看Java集合-Map

TreeSet

特点

Set的实现类
物流结构：跳转结构；逻辑结构：红黑二叉树
无序：没有记录插入的顺序
有序：根据元素的比较器，升序排列

二叉树的遍历方法

二叉树的遍历方法：
==中序遍历：左–根–右 > TreeSet采用的方法
先序遍历：根–左–右
后序遍历：左–右–根

构造方法

底层通过TreeMap实现

// 无参构造，存放数据必须实现内部比较器Comparable接口
public TreeSet() {
    // 底层通过TreeMap实现
    this(new TreeMap<E,Object>());
}

使用无参构造，数据必须实现内部比较器Comparable接口

// 指定外部比较器Comparator
public TreeSet(Comparator<? super E> comparator) {
    this(new TreeMap<>(comparator));
}

使用有参构造，指定外部比较器Comparator

TreeMap

详情看Java集合-Map

过山车gsc

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
Java集合-Collection

Java集合-Collection，List，Set
复制链接

扫一扫

专栏目录