Collection,List接口相关介绍

Collection

public interface Collection<E> extends Iterable<E> 
  • Collection实现子类可以存放多个元素,每个元素可以是Object
  • 有些Collection的实现类可以存放重复的元素,有些不可以
  • 有些Collection的实现类,有些是有序的,有些不是有序的
  • Collection接口没有直接的实现子类,是通过它的子接口Set和List来实现的

Collection,List接口相关介绍_第1张图片

  • Collection接口遍历元素方式1,使用Iterator(迭代器)
  • Iterator对象成为迭代器,主要用于遍历Collection集合中的元素
  • 所有实现了Collection接口的集合类都有一个iterator()方法,用以返回一个实现了Iterator接口的对象,即可以返回一个迭代器
  • Iterator仅用于遍历集合,Iterator本身不存放对象(快捷键itit)
    Collection,List接口相关介绍_第2张图片
    在调用iterator.next()方法之前必须调用iterator.hasNext()进行检测。若不调用且下一条记录无效,直接调用it.next()会抛出异常
    增强for循环可以代替iterator迭代器,特点:增强for就是简化版的iterator,本质一样,只能用于遍历集合或数组。(快捷键大写I)

List接口

  • List接口是Collection接口的子接口 List.java
  • List集合中的每个元素都有对应的顺序索引,即支持索引
  • List集合中的每个元素都有其对应的顺序索引,即支持索引
  • List容器中的元素都对应一个整数型的序号记载其在容器中的位置,可以根据序号存取容器中的元素

ArrayList

  • 可以加入null,并且多个
  • 是由数组来实现数据存储的
  • ArrayList基本等同于Vector,除了ArrayList是线程不安全(执行效率高),多线程下不建议使用ArrayList

源码分析:
ArrayList中维护了一个Object类型的数组elementData。transient Object[] elementData(transient 表示瞬间,短暂的,该属性不会被序列化)

  • 当创建ArrayList对象时,如果使用的是无参构造器,则初始elementData容量为0,第一次添加,则扩容elementData为10,如需要再次扩容,则扩容elementData为1.5倍
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
 public boolean add(E e) {
 //确认大小够不够我添加一个数据,先确定是否要扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        //然后再执行赋值操作
        elementData[size++] = e;
        return true;
    }
private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
//该方法确定minCapacity
private static int calculateCapacity(Object[] elementData, int minCapacity) {
//如果elementData是{}
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 1 和 默认10 找一个最大值
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        //第二次添加时,elementData不是{},直接返回
        return minCapacity;
    }
  private void ensureExplicitCapacity(int minCapacity) {
  //记录当前集合修改次数,防止有多个线程来修改它
        modCount++;

        // overflow-conscious code
        //当前最小容量 - 实际数组大小大于0. 10 - 0  > 0
        //第二次添加,2 - 10 < 0,不进行扩容
        if (minCapacity - elementData.length > 0)
        //如果elementData的大小不够就扩容
            grow(minCapacity);
    }
 private void grow(int minCapacity) {
        // overflow-conscious code
        //第一次是0
        //第二次扩容10
        int oldCapacity = elementData.length;
        //第一次是0
        //第二次扩容15
        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:
        //第一次扩容是十个null,使用扩容机制来确定要扩容到多大
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
  • 如果使用的是指定大小的构造器,则初始elementData容量为指定大小,如果需要扩容,则直接扩容elementData为1.5倍
    比如初始化为8容量的数组,如果加到第9个就扩容为12
 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);
        }
    }

Vector

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

Vector底层也是一个对象数组

protected Object[] elementData;

Vector是线程同步的,即线程安全的,Vector类的操作方法带有synchronized,在开发中需要线程同步安全时,考虑使用Vector
Collection,List接口相关介绍_第3张图片

 public Vector() {
        this(10);
    }
 public synchronized void addElement(E obj) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = obj;
    }
  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
        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);
    }

LinkedList

  • 底层实现了双向链表和双端队列特点
  • 可以添加任意元素(元素可以重复),包括null
  • 线程不安全,没有实现同步

Collection,List接口相关介绍_第4张图片

   public LinkedList() {
    }

此时LinkedList的属性first = null last = null

public boolean add(E e) {
        linkLast(e);
        return true;
    }
 Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
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++;
    }
    public boolean remove(Object o) {
        if (o == null) {
            for (Node<E> x = first; x != null; x = x.next) {
                if (x.item == null) {
                    unlink(x);
                    return true;
                }
            }
        } else {
            for (Node<E> x = first; x != null; x = x.next) {
                if (o.equals(x.item)) {
                    unlink(x);
                    return true;
                }
            }
        }
        return false;
    }
E unlink(Node<E> x) {
        // assert x != null;
        final E element = x.item;
        final Node<E> next = x.next;
        final Node<E> prev = x.prev;

        if (prev == null) {
            first = next;
        } else {
            prev.next = next;
            x.prev = null;
        }

        if (next == null) {
            last = prev;
        } else {
            next.prev = prev;
            x.next = null;
        }

        x.item = null;
        size--;
        modCount++;
        return element;
    }

你可能感兴趣的:(java,list,java,数据结构)