List集合_创建一个list对象

1.List的常用操作

List是一个接口，可以使用实现它的类LinkedList或ArrayList创建对象 1.使用LinkedList创建List对象

// 使用LinkedList创建List对象
LinkedList list = new LinkedList();
LinkedList list1 = new LinkedList();

2.add()方法将指定的元素追加到此列表的末尾

// add()方法将指定的元素追加到此列表的末尾
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
System.out.println(list);
/*输出为
 *[1, 2, 3, 4, 5]
 */

3.add(int index, E element)方法在此列表中的指定位置插入指定的元素

// add(int index, E element)方法在此列表中的指定位置插入指定的元素
list.add(2,9);
System.out.println(list);
/*输出为
 *[1, 2, 9, 3, 4, 5]
 */

4.addAll(int index, Collection<? extends E> c) 从指定的位置开始，将指定集合中的所有元素插入到此列表中

// addAll(int index, Collection<? extends E> c) 
// 将指定集合中的所有元素插入到此列表中，从指定的位置开始。 
list1.add('a');
list1.add('b');
list1.add('c');
list.add(3,list1);
System.out.println(list1);
System.out.println(list);
/*输出为
 *[a, b, c]
 *[1, 2, 9, [a, b, c], 3, 4, 5]
 */

5.addAll(Collection<? extends E> c) 按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到此列表的末尾

// addAll(Collection<? extends E> c) 
// 按照指定集合的迭代器返回的顺序将指定集合中的所有元素追加到此列表的末尾
list.add(list1);
System.out.println(list);
/*输出为
 *[1, 2, 9, [a, b, c], 3, 4, 5, [a, b, c]]
 */

6.clear() 从列表中删除所有元素。

list1.clear();
System.out.println(list1);
/*输出为
 *[]
 */

7.get(int index) 返回此列表中指定位置的元素。

// get(int index) 返回此列表中指定位置的元素。 
System.out.println(list.get(0));
/*输出为
 *1
 */

8.remove(int index) 删除该列表中指定位置的元素

// remove(int index) 删除该列表中指定位置的元素 
list.remove(3);
System.out.println(list);
/*输出为
 *[1, 2, 9, 3, 4, 5, []]
 */

9.remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）

// remove(Object o) 从列表中删除指定元素的第一个出现（如果存在）。 
list.remove((Object)9);
System.out.println(list);
/*输出为
 *[1, 2, 3, 4, 5, []]
 */

10.size() 返回此列表中的元素数

// size() 返回此列表中的元素数
System.out.println(list.size());
/*输出为
*6
*/

11.toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组

// toArray() 以正确的顺序（从第一个到最后一个元素）返回一个包含此列表中所有元素的数组
list.remove(list1);
Object[] array = list.toArray();
System.out.println(Arrays.toString(array));
/*输出为
*[1, 2, 3, 4, 5]
*/

12.getFirst() 返回此列表中的第一个元素

// getFirst() 返回此列表中的第一个元素
System.out.println(list.getFirst());
/*输出为
*1
*/

13.getLast() 返回此列表中的第一个元素

// getLast() 返回此列表中的第一个元素
System.out.println(list.getLast());
/*输出为
*5
*/

14.remove() 检索并删除此列表的头（第一个元素）

// remove() 检索并删除此列表的头（第一个元素）。 
list.remove();
System.out.println(list);
/*输出为
*[2, 3, 4, 5]
*/

15.removeFirst() 从此列表中删除并返回第一个元素

// removeFirst() 从此列表中删除并返回第一个元素
System.out.println(list.removeFirst());
System.out.println(list);
/*输出为
*2
*[3, 4, 5]
*/

2.应用

list对标的数组

不考虑长度

读写不如数组方便

除了读写操作外，有很多集合操作

轻松方便的删除方式

不主动应用数组

3.List的原理

1.存储结构

数组 ArrayList

链表 LinkedList

2.ArrayList与LinkedList的区别

它们都实现了List接口

实现不同

1.添加元素

1.1尾部添加

ArrayList略慢

1.2中间插入一个元素

ArrayList慢很多

2.删除元素

ArrayList慢很多

3.修改元素的值

ArrayList略快

4.获取元素

4.1遍历所有的元素

一样快

4.2随机访问

ArrayList快很多（优点）

3.Arraylist

1.ArrayList的扩容

初始化：无参构造默认长度为0，一个空数组。有参构造可指定容量

第一次扩容（无参构造第一次add）扩容为10，其后每次扩容原来容量的1.5倍

    // ArrayList的扩容源码
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
​
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
​
    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);
    }

2.ArrayList的缩减

    // 缩减源码
    public void trimToSize() {
        modCount++;
        if (size < elementData.length) {
            elementData = (size == 0)
              ? EMPTY_ELEMENTDATA
              : Arrays.copyOf(elementData, size);
        }
    }

3.底层实现

使用数组实现

    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    // 无参构造源码
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    // 有参构造源码
    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);
        }
    }

4.LinkedList

1.底层实现

底层实现为链表

    // 底层部分源码
    Node<E> node(int index) {
        // assert isElementIndex(index);
​
        if (index < (size >> 1)) {
            Node<E> x = first;
            for (int i = 0; i < index; i++)
                x = x.next;
            return x;
        } else {
            Node<E> x = last;
            for (int i = size - 1; i > index; i--)
                x = x.prev;
            return x;
        }
    }