Java学习笔记——集合I

Java中的集合学习笔记I

集合概述

集合分类

Java集合可以分为Collection 与 Map两个分支。Collection 存储着单列数据、Map存储着双列数据——键值（Key、Value）对的集合。其中Collection下又分为两个主要的类别。List接口（有序、可重复）、Set接口（无序不可重复）

集合整体框架

Iterable接口

Interface Iterable<T(迭代器返回的元素的类型)>

Iterable接口（迭代器）是一种设计模式。实现了此接口的对象可以遍历并选择序列中的对象。Collection接口与Map接口均继承了Iterable接口。实现此接口可以允许一个对象使用“for—each”循环。

for-each循环使用方法

public class CollectionNote {
    public static void main(String[] args) {
        //使用foreach循环遍历数组中的元素
        int[] ints = {1, 2, 3, 4};
        for (int i:ints) {
            System.out.print(i + "\t");
        }
    }
}

使用迭代器对象遍历集合

public class CollectionNote {
    public static void main(String[] args) {
        ArrayList<Integer> arr = new ArrayList<Integer>();
        for (int i = 0; i < 5; i++) {
            arr.add((int)(Math.random() * 5));
        }
        //获取一个序列的迭代器对象
        Iterator<Integer> iter = arr.iterator();
        //对序列进行遍历
        while (iter.hasNext()){
            System.out.println(iter.next());
        }

    }
}

Collection接口

Collection是集合框架结构中的根接口之一。JDK之中不提供此接口的任何直接实现，而是提供了更具体的更具体的子接口的实现。这里对学习过程中最经常遇到的两个接口——List、Set整理记录。

List接口

List集合类中的元素，有序且可重复。集合中的每个元素都有其对应的顺序索引。其常见的实现类有ArrayList、LinkedList和Vector（与ArrayList类似，但线程安全）

List接口常用方法

​ *void add(int index, E element);

​ *boolean addAll(int index, Collection<? extends E> c);

​ *get(int index);

​ *remove(int index);

​ *set(int index, E element);

ArrayList

ArrayList是List接口中的主要实现类（可以把它理解为一个变长的数组）

ArrayList底层实现

ArrayList 创建初始化一个大小为0的数组，添加第一个元素是开始扩容（首次扩容容量大小为10），每次以当前数组大小1.5倍进行扩容

源码分析：成员变量与构造器

//属性
//默认初始容量
private static final int DEFAULT_CAPACITY = 10;
//空数组
private static final Object[] EMPTY_ELEMENTDATA = {};
//默认空数组（无参构造器时调用）
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//实际存储元素的数组
transient Object[] elementData; 
//数组大小
private int size;

//构造方法
//无参构造方法 —— 生成一个空的数组
 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);
        }
    }
//传入一个集合
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;
        }
    }

API方法

//获取集合大小
public int size() {
    return size;
}


//添加一个元素
public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 需要确保当前数组未满
        elementData[size++] = e;
        return true;
    }
//添加元素到指定位置
 public void add(int index, E element) {
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
    }
//内部方法，确定当前数组是否未满
private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }

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);  //新的数组容量扩容为原来的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);
    }


//获取指定索引上的元素
 public E get(int index) {
            rangeCheck(index);
            checkForComodification();
            return ArrayList.this.elementData(offset + index);
        }


//删除一个元素 （本质上也需要
）
public E remove(int index) {
            rangeCheck(index); //确保数组没有越界
            checkForComodification();
            E result = parent.remove(parentOffset + index);
            this.modCount = parent.modCount;
            this.size--;
            return result;
        }

CRUD时间复杂度：

​ 直接添加元素至列表的末尾：O（1）

​ 添加到指定位置（插入）O（n）

​ 获取指定索引元素 O（1）

​ 删除指定索引的元素 O（n）

LinkedList

双向链表 ，List接口的主要实现类之一，也是Deque的主要实现类。

特有相关API方法

​ 栈相关：void push（E e）将一个元素压入栈

​ E peek（） 查看栈顶元素

​ E pop（） 弹出栈顶元素

​ 双端队列相关：

​ boolean offer（E e） 向列表的尾部添加元素

​ boolean offerFirst（E e）在列表的头部插入指定元素

​ boolean offerLast （E e）在列表的尾部添加元素

​ E peek（） 检索列表的头部元素

​ E peekFirst（） 检索列表的头部元素

​ E peekLast（） 检索列表的尾部元素

​ E poll（）检索并删除列表头部元素

​ E pollFirst（） 检索并删除列表头部元素

​ E pollLast（） 检索并删除列表尾部元素

LinkedList底层实现

（1）内部类——Node（节点）

private static class Node<E> {
    E item;   //节点的值（元素本身）
    LinkedList.Node<E> next;  //指向下一个节点的指针
    LinkedList.Node<E> prev;  //指向前一个节点的指针

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

（2）成员变量 构造器

transient int size; // 维护链表的长度（元素的个数）
transient LinkedList.Node<E> first;  //头节点
transient LinkedList.Node<E> last;	//尾节点
public LinkedList() {  	//空参构造器
        this.size = 0;
    }

（3）部分API方法

//添加元素
public boolean add(E e) {
    this.linkLast(e);   //调用非公有方法linkLast
    return true;
}

void linkLast(E e) {
        LinkedList.Node<E> l = this.last; 
        LinkedList.Node<E> newNode = new LinkedList.Node(l, e, (LinkedList.Node)null);
        this.last = newNode;  //将链表的尾节点指向新添加的节点
        if (l == null) {
            this.first = newNode;   //如果链表为空，此节点亦为头节点
        } else {
            l.next = newNode;   //否则，将原尾节点的next指针指向当前节点
        }

        ++this.size;    //更新链表长度
        ++this.modCount;
    }

//删除元素
public boolean remove(Object o) {
        LinkedList.Node x;  //临时初始化一个指针
        if (o == null) {
            for(x = this.first; x != null; x = x.next) {
                if (x.item == null) {
                    this.unlink(x);
                    return true;
                }
            }
        } else {
            for(x = this.first; x != null; x = x.next) {  //从链表头开始遍历
                if (o.equals(x.item)) {		//找到指定节点
                    this.unlink(x);		//调用非公有方法 unlike
                    return true;	//删除成功返回true
                }
            }
        }

        return false;	//删除失败，返回false
    }

E unlink(LinkedList.Node<E> x) {  //非公有方法unlike
        E element = x.item;		//去除待返回的元素
        LinkedList.Node<E> next = x.next;	//两个临时指针
        LinkedList.Node<E> prev = x.prev;
        if (prev == null) {
            this.first = next;
        } else {
            prev.next = next;		//重置前一个节点的next指针
            x.prev = null;		//置空prev指针
        }

        if (next == null) {
            this.last = prev;
        } else {
            next.prev = prev;  //重置后一个节点的prev指针
            x.next = null;	//置空next指针
        }

        x.item = null;
        --this.size;	//更新链表长度
        ++this.modCount;
        return element;
    }

//查询方法

public E get(int index) {
        this.checkElementIndex(index);  //检查索引是否合法
        return this.node(index).item;	//调用非公有方法node（int index)
    }

 LinkedList.Node<E> node(int index) {   //非公有方法node（int index)
        LinkedList.Node x;
        int i;
        if (index < this.size >> 1) {  //如果索引小于长度的一半，从头开始找目标元素
            x = this.first;

            for(i = 0; i < index; ++i) {
                x = x.next;
            }

            return x;
        } else { 		///否则，从尾部开始向前寻找目标元素
            x = this.last;

            for(i = this.size - 1; i > index; --i) {
                x = x.prev;
            }

            return x;
        }
    }

//插入元素
public void add(int index, E element) {
        this.checkPositionIndex(index);  //判断索引是否合法
        if (index == this.size) {
            this.linkLast(element);		//插入到队尾
        } else {
            this.linkBefore(element, this.node(index));  //调用非公有方法linkBefore  node
        }

    }

void linkBefore(E e, LinkedList.Node<E> succ) {  //非公有方法linkBefore  （传入插入元素，与插入位置后一个节点）
        LinkedList.Node<E> pred = succ.prev;	//找到插入位置前一个节点
        LinkedList.Node<E> newNode = new LinkedList.Node(pred, e, succ);  //创建存储当前元素的节点
        succ.prev = newNode;  //重置后一个节点的prev指针
        if (pred == null) {
            this.first = newNode;  //特殊情况（插入在头节点处）
        } else {
            pred.next = newNode;  //重置前一个节点next指针
        }

        ++this.size;  //更新数组大小
        ++this.modCount;
    }

CRUD时间复杂度

​ 直接添加元素至列表的末尾：O（1）

​ 添加到指定位置（插入）O（n） 实际上也需要便遍历寻找待插入的位置。但插入本身这个操作的时间复杂度为O（1）

​ 获取指定索引元素 O（n）