java集合及List接口和实现_java 接口创建集合数据-优快云博客

本文深入探讨了Java集合框架中的ArrayList和LinkedList。ArrayList基于数组实现，查询速度快但增删慢；LinkedList采用链表结构，增删快速但查询效率较低。此外，还介绍了迭代器的使用和List接口的遍历方法。文章通过源码分析展示了ArrayList的扩容机制和LinkedList的添加元素过程，并提及了线程安全的Vector类。

集合

概念：对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。

和数组的区别：

数组长度固定，集合长度不固定
数组可以存储基本类型和引用类型，集合只能存储引用类型

位置：java.util.*

Collection Class

List：有序，有下标，元素可重复

Set：无序，无下标，元素不可重复

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;

public class CollectionDemo {

    public static void main(String[] args) {
        Collection c = new ArrayList();
        c.add("apple");
        c.add("orange");
        c.add("peach");
				
      	// 
        Iterator itr = c.iterator();
        while (itr.hasNext()) {
            String e = (String)itr.next();
            System.out.println(e);
//            c.clear();  // 报错 java.util.ConcurrentModificationException
            // 迭代器中不能使用collection的方法
        }
    }
}

List 接口

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class Demo01 {

    public static void main(String[] args) {

        List list = new ArrayList();
        list.add(10); // 基本类型会自动装箱
        list.add(20);
        list.add(30);
        list.add(40);
        list.add(50);
        list.add(60);

        // 遍历
        // 1. for
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
        System.out.println("-----------------");

        // 2. foreach
        for (Object o : list) {
            System.out.println(o);
        }
        System.out.println("-----------------");

        // 3. 迭代器
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Object o = it.next();
            System.out.println(o);
        }
        System.out.println("-----------------");

        // 4. 列表迭代器
        // 可以向前或向后，添加元素，删除，修改元素
        ListIterator lit = list.listIterator();
        while (lit.hasNext()) {
            System.out.println(lit.nextIndex() + ": " + lit.next());
        }
        System.out.println("-----------------");
        while (lit.hasPrevious()) {
            System.out.println(lit.previousIndex() + ": " + lit.previous());
        }

        // 删除元素
//        list.remove(20); // 报错 java.lang.IndexOutOfBoundsException
        list.remove((Object) 20); // 或者 new Integer(20)
        System.out.println(list.toString());

        // subList 方法 含头不含尾
        List sublist = list.subList(1, 4);
        System.out.println(sublist.toString());
    }
}

ArrayList

数组结构实现，查询快，增删慢（需要开辟连续空间）

运行效率快，线程不安全

源码分析：

DEFAULT_CAPACITY = 10 默认容量。注意：假如没有向集合中添加任何元素，容量为0。添加任意一个元素之后，容量就是10了。
扩容：每次扩容到原来的容量1.5倍
elementData 存放元素的数组
size 实际元素个数

add() 方法相关源码

public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
}

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

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

LinkedList

链表结构实现，增删快，查询慢（无需开辟连续空间）

源码分析：

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
        l.next = newNode;
    size++;
    modCount++;
}