List的简单理解

鍠皝

于 2023-06-29 10:30:00 发布

阅读量316

点赞数

文章标签： list 数据结构 java

本文链接：https://blog.csdn.net/weixin_61632575/article/details/131438039

版权

List

List是有序，可重复的
有序： List每个元素都有索引标记，可根据元素的索引标记访问元素.
可重复：List允许加入重复的元素.
list有三个常用实现类：ArrayList，LinedList，Vector

list的API

返回类型	方法名称	解释
boolean	add(E e)	将指定的元素追加到此列表的末尾（可选操作）
void	add(int index, E element)	将指定的元素插入此列表中的指定位置（可选操作）。
boolean	addAll(Collection<? extends E> c)	按指定集合的迭代器（可选操作）返回的顺序将指定集合中的所有元素附加到此列表的末尾。
boolean	addAll(int index, Collection<? extends E> c)	将指定集合中的所有元素插入到此列表中的指定位置（可选操作）。
void	clear()	从此列表中删除所有元素（可选操作）。
boolean	contains(Object o)	如果此列表包含指定的元素，则返回 true 。
boolean	containsAll(Collection<?> c)	如果此列表包含指定集合的所有元素，则返回true。
boolean	equals(Object o)	将指定的对象与此列表进行比较以获得相等性。
E	get(int index)	返回此列表中指定位置的元素。
int	hashCode()	返回此列表的哈希码值。
int	indexOf(Object o)	返回此列表中指定元素的第一次出现的索引，如果此列表不包含元素，则返回-1。
boolean	isEmpty()	如果此列表不包含元素，则返回 true 。
Iterator<E>	iterator()	以正确的顺序返回该列表中的元素的迭代器。
int	lastIndexOf(Object o)	返回此列表中指定元素的最后一次出现的索引，如果此列表不包含元素，则返回-1。
ListIterator<E>	listIterator()	返回列表中的列表迭代器（按适当的顺序）。
ListIterator<E>	listIterator(int index)	从列表中的指定位置开始，返回列表中的元素（按正确顺序）的列表迭代器。
E	remove(int index)	删除该列表中指定位置的元素（可选操作）。
boolean	remove(Object o)	从列表中删除指定元素的第一个出现（如果存在）（可选操作）。
boolean	removeAll(Collection<?> c)	从此列表中删除包含在指定集合中的所有元素（可选操作）。
default void	replaceAll(UnaryOperator<E> operator)	将该列表的每个元素替换为将该运算符应用于该元素的结果。
boolean	retainAll(Collection<?> c)	仅保留此列表中包含在指定集合中的元素（可选操作）。
E	set(int index, E element)	用指定的元素（可选操作）替换此列表中指定位置的元素。
int	size()	返回此列表中的元素数。
default void	sort(Comparator<? super E> c)	使用随附的 Comparator排序此列表来比较元素。
default Spliterator<E>	spliterator()	在此列表中的元素上创建一个Spliterator 。
List<E>	subList(int fromIndex, int toIndex)	返回此列表中指定的 fromIndex （含）和 toIndex之间的视图。
Object[]	toArray()	以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组。
<T> T[]	toArray(T[] a)	以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运行时类型是指定数组的运行时类型。

ArrayList

ArrayList是个动态数组，实现List接口，主要用来存储数据，如果存储基本类型的数据，如int，long，boolean，short，byte，那只存储它们对应的包装类。线程不安全
增删慢：每次删除元素，都需要更改数组长度、拷贝以及移动元素位置。
查询快：由于数组在内存中是一块连续空间，因此可以根据地址+索引的方式快速获取对应位置上的元素。

创建ArrayList

1.ArrayList()

构造一个初始容量为10的空列表。

List<E> list = new ArrayList<E>();
ArrayList<E> arrayList = new ArrayList<E>();

ArrayList(Collection<? extends E> c)

构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

ArrayList<E> arrayList = new ArrayList<E>(Collection T);

ArrayList(int initialCapacity)

构造具有指定初始容量的空列表。

ArrayList<E> arrayList = new ArrayList<E>(int initialCapacity);

通过源码了解默认长度和扩容机制

创建时的大小

    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access

    private int size;

    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {
            // c.toArray might (incorrectly) not return Object[] (see 6260652)
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // replace with empty array.
            this.elementData = EMPTY_ELEMENTDATA;
        }
}

扩容（newCapacity = oldCapacity + (oldCapacity >> 1)），1.5倍扩容

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

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        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);
    }

ArrayList的API

ArrayList实现了List，所以有list的方法

返回类型	方法名称	解释
Object	clone()	返回此 ArrayList实例的浅拷贝。
void	trimToSize()	修改这个 ArrayList实例的容量是列表的当前大小。
void	ensureCapacity(int minCapacity)	如果需要，增加此 ArrayList实例的容量，以确保它可以至少保存最小容量参数指定的元素数。

LinedList

1、LinkedList底层是通过链表实现的，链表中的一个节点是一个Node类型的数据结构，其保存了一个指向前驱节点的引用、真实数据和一个指向后继节点的引用；
2、特点是随机访问效率低，删除和插入快；
3、可以当作栈，队列和双端队列来使用。

创建 LinedList

1.LinkedList()

构造一个空列表。

List<E> list = new LinkedList<E>();
LinkedList<E> linkedList = new LinkedList<E>();

#2.LinkedList(Collection<? extends E> c)

构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

LinkedList<E> linkedList = new LinkedList<E>(Collection T);

通过源码了解默认长度和扩容机制

添加一个长度加一，删除一个长度减一

	transient int size = 0;

    transient Node<E> first;

    transient Node<E> last;

    public LinkedList() {
    }

    public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
    }

LinedList的API

LinedList实现了List和Deque，所以有List的所有方法，和Deque的头加、尾加；头查、尾查；头删、尾删；头检索但不删除、尾检索但不删除；头检索也删除、尾检索也删除…

返回类型	方法名称	解释
Object	clone()	返回此 LinkedList的浅版本。
Iterator<E>	descendingIterator()	以相反的顺序返回此deque中的元素的迭代器。

Vector

1、Vector是基于数组实现的。其内部包含一个存储元素的数组，所有的元素都被存储在这个数组中。这种基于数组的实现方式使得Vector的访问速度非常快，因为它只需要简单的访问数组的索引即可。
与传统的数组不同，Vector可以根据需要动态地增加或减小其大小。当需要增加或减少元素的数量时，Vector会自动调整数组的大小。
2、Vector的大小是指其包含的元素数量，而容量是指Vector底层数组的大小。当Vector的大小超过容量时，它会自动扩展容量。
3、Vector是线程安全的。

Vector的创建

1、Vector()

构造一个空向量，使其内部数据数组的大小为10，其标准容量增量为零。Vector vec=new Vector();

Vector<E> vector = new Vector<E>();

2、Vector(Collection<? extends E> c)

构造一个包含指定collection中的元素的向量，这些元素按其collection的迭代器返回元素的顺序排列。

 Vector<E> vector = new Vector<E>(Collection T);

3、Vector(int initialCapacity)

使用指定的初始容量和等于零的容量增量构造一个空向量。

 Vector<E> vector = new Vector<E>(int initialCapacity);

4、Vector(int initialCapacity,int capacityIncrement)

使用指定的初始容量和容量增量构造一个空的向量。

 Vector<E> vector = new Vector<E>(int initialCapacity,int capacityIncrement));

通过源码了解默认长度和扩容机制

public Vector() {
        this(10);
    }

扩容
如果没有自己设置扩容大小，每次扩容是原来的两倍，如果设置则是每次增加capacityIncrement

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

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

Vector的API

Vector实现List，所以有list中的方法

返回类型	方法名称	解释
int	capacity()	返回此向量的当前容量。
void	addElement(E obj)	在集合后面添加一个元素，无论该元素是什么类型的，都会把他的toString()的返回值添加进去。
void	copyInto(Object[] anArray)	把集合中的元素复制到anArray数组中去
E	elementAt(int index)	返回索引位置的元素
Enumeration	elements()	返回集合的枚举
void	insertElementAt(E obj, int index)	在指定索引位置中插入obj元素
void	removeAllElements()	删除集合的所有元素，并且设置容量为0，和clear()方法一样，clear底层也是用removeAllElements()方法的
void	setSize(int newSize)	设置集合的容量大小为newSize，如果newSize大于集合元素个数，那么会在后面添加null，如果newSize小于集合元素个数，那么直保留newSize个元素
void	trimToSize()	整理集合的容量大小，如果集合元素个数等于容量大小，那么没有变化，如果集合个数小于容量大小，那么容量会设置为元素个数大小