一.Collection接口：

集合可以看做一种容器，即存储各种对象的容器，容器的实现方式有很多种（list，set），每种存储数据的方式（即数据结构）都有区别，但是它有很多共性的功能（增删改查等）。对集合的各种实现的共有方法进行抽取，可以得到一个金字塔形的集合框架，金字塔的最顶端就是Collection接口
Collection接口的子接口及实现类：

Collection接口源码（去掉注释后）

public interface Collection<E> extends Iterable<E> {// Query Operationsint size();boolean isEmpty();boolean contains(Object o);Iterator<E> iterator();Object[] toArray();<T> T[] toArray(T[] a);// Modification Operationsboolean add(E e);boolean remove(Object o);// Bulk Operationsboolean containsAll(Collection<?> c);boolean addAll(Collection<? extends E> c);boolean removeAll(Collection<?> c);boolean retainAll(Collection<?> c);void clear();// Comparison and hashingboolean equals(Object o);int hashCode();
}

JavaSEAPI中对Collection接口部分方法的解析

boolean contains(Object o)
如果此 collection 包含指定的元素，则返回 true。
boolean containsAll(Collection < ? > c)
如果此 collection 包含指定 collection 中的所有元素，则返回 true。
boolean equals(Object o)
比较此 collection 与指定对象是否相等。
int hashCode()
返回此 collection 的哈希码值。
Iterator iterator()
返回在此 collection 的元素上进行迭代的迭代器。

因为java中的集合数据结构都直接或间接的继承或实现了Collection接口。所以Collection接口中定义有集合数据结构普遍有的增删查方法

二.Iterator接口：

Iterator被称作迭代器，是一个接口，通过迭代的方式取集合中的元素，java中所有的集合数据结构都可以通过迭代的方式取出集合中的元素，所以迭代器是所有数据结构的都有的功能，对这项功能进行向上抽取，定义了一个超级接口Iterator接口
Iterator接口的定义也很好的体现了面向对象的理念，定义一个迭代器类，并将用于对集合元素的迭代方法都封装起来定义到这个迭代器类中，当需要对集合中的元素进行迭代时只需要获取这个类的对象，让后调用对象中的方法即可

import java.util.Iterator;public interface Iterable<T> {Iterator<T> iterator();
}

Iterator接口源码（去掉注释）

public interface Iterator<E> {boolean hasNext();E next();void remove();
}

JavaSEAPI中对Iterator接口方法的解析

boolean hasNext()
如果仍有元素可以迭代，则返回 true。
E next()
返回迭代的下一个元素。
void remove()
从迭代器指向的 collection 中移除迭代器返回的最后一个元素（可选操作）。

定义iterator接口的原因：
每一个集合都有自己的数据结构，都有特定的取出自己内部元素的方式。为了便于操作所有的容器，取出元素。将容器内部的取出方式按照一个统一的规则向外提供，这个规则就是Iterator接口
也就说，只要通过该接口就可以取出Collection集合中的元素，至于每一个具体的容器依据自己的数据结构，如何实现的具体取出细节，则不去考虑，这样就降低了取出元素操作和不同数据结构集合的耦合

三.List接口：

1.List集合框架简介：

有序的 Collection（也称为序列）。此接口的用户可以对列表中每个元素的插入位置进行精确地控制。用户可以根据元素的整数索引（在列表中的位置）访问元素，并搜索列表中的元素。与 set 不同，List列表允许重复的元素
List集合框架的特点：
1.有序(元素存入集合的顺序和取出的顺序一致)
2.元素都有索引
3.元素可以重复

List接口源码部分代码（去掉注释后）

package java.util;public interface List<E> extends Collection<E> {// Positional Access OperationsE get(int index);E set(int index, E element);void add(int index, E element);E remove(int index);// Search Operationsint indexOf(Object o);int lastIndexOf(Object o);// List IteratorsListIterator<E> listIterator();ListIterator<E> listIterator(int index);// ViewList<E> subList(int fromIndex, int toIndex);
}

和Collection接口重复的一些方法没有列出，只列出了List接口特有的方法。可以看出，List接口对Collection的扩展方法中很多都是添加了用角标操作集合内的元素

2.List集合框架的常用实现类

2.1 List集合的数组实现ArrayList：

List 接口的数组的实现，大小可变。实现了所有列表操作（增删查，比较等List接口中有的方法），并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法用来存储列表的数组的大小。
ArrayList类在功能上和Vector类非常相似，唯一不同的地方就是ArrayList类是不同步的，而Vector类则是同步的，Vector类已基本不用

ArrayList类的部分源码解析：

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{----------------------------------1.ArrayList类中定义的变量及构造方法-----------------------------//1.1 定义ArrayList的初始容量private static final int DEFAULT_CAPACITY = 10;private static final Object[] EMPTY_ELEMENTDATA = {};//1.2 定义一个Object对象数组用来存储List集合的元素private transient Object[] elementData;//1.3 定义int类型的size属性，记录集合的大小private int size;//1.4 空参构造函数（还有带参的构造函数，这里不一一显示）public ArrayList() {super();this.elementData = EMPTY_ELEMENTDATA;}
----------------------------------2.ArrayList类的特有方法，控制集合容量--------------------------------------//用于在存入元素的过程中集合容量不够用时扩大集合容量private void grow(int minCapacity) {// overflow-conscious codeint 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);}
-------------------------------------------3.ArrayList类的增删改查方法-----------------------------------------//ArrayList添加元素的方法public boolean add(E e) {//调用方法检查容量是否足够ensureCapacityInternal(size + 1);  // Increments modCount!!//List集合存储元素和角标信息一起存储elementData[size++] = e;return true;}//ArrayList的查询方法public E get(int index) {rangeCheck(index);return elementData(index);}//ArrayList检查是否包含元素public boolean contains(Object o) {return indexOf(o) >= 0;}//ArrayList在指定角标地点添加元素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++;}//ArrayList的更改元素方法public E set(int index, E element) {rangeCheck(index);E oldValue = elementData(index);elementData[index] = element;return oldValue;}//ArrayList的删除方法public boolean remove(Object o) {if (o == null) {for (int index = 0; index < size; index++)if (elementData[index] == null) {fastRemove(index);return true;}} else {for (int index = 0; index < size; index++)if (o.equals(elementData[index])) {fastRemove(index);return true;}}return false;}------------------------------------4.ArrayList类的增删改查方法的支持方法-------------------------------------------------public int indexOf(Object o) {if (o == null) {for (int i = 0; i < size; i++)if (elementData[i]==null)return i;} else {for (int i = 0; i < size; i++)if (o.equals(elementData[i]))return i;}return -1;}-------------------------------------------5.ArrayList类的迭代器------------------------------------//5.1 返回一个实现了ListIterator接口的类的对象（一个迭代器对象），从指定的角标处开始迭代   public ListIterator<E> listIterator(int index) {if (index < 0 || index > size)throw new IndexOutOfBoundsException("Index: "+index);return new ListItr(index);}//5.2 返回一个实现了ListIterator接口的类的对象（一个迭代器对象）public ListIterator<E> listIterator() {return new ListItr(0);}//5.3 覆盖了AbstractList抽象类中iterator()方法，返回一个实现了Iterator接口的类的对象public Iterator<E> iterator() {return new Itr();}//5.4 定义一个内部类，这个内部类实现了Iterator接口，根据数组列表的数据结构给出了迭代器的next，hasNext等方法的具体实现private class Itr implements Iterator<E> {int cursor;       // index of next element to returnint lastRet = -1; // index of last element returned; -1 if no suchint expectedModCount = modCount;//5.4.1 覆盖Iterator接口中的方法1：hasNext()public boolean hasNext() {return cursor != size;}//5.4.2 覆盖Iterator接口中的方法2：next()@SuppressWarnings("unchecked")public E next() {checkForComodification();int i = cursor;if (i >= size)throw new NoSuchElementException();Object[] elementData = ArrayList.this.elementData;if (i >= elementData.length)throw new ConcurrentModificationException();cursor = i + 1;return (E) elementData[lastRet = i];}//5.4.3 覆盖Iterator接口中的方法3：remove()public void remove() {if (lastRet < 0)throw new IllegalStateException();checkForComodification();try {ArrayList.this.remove(lastRet);cursor = lastRet;lastRet = -1;expectedModCount = modCount;} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException();}}//5.5 定义一个内部类ListItr，继承了Itr类，实现了ListIterator接口，对Itr类进行了有关List集合的补充及扩展，如通过角标倒序（从后向前）迭代集合private class ListItr extends Itr implements ListIterator<E> {ListItr(int index) {super();cursor = index;}public boolean hasPrevious() {return cursor != 0;}public int nextIndex() {return cursor;}public int previousIndex() {return cursor - 1;}@SuppressWarnings("unchecked")public E previous() {checkForComodification();int i = cursor - 1;if (i < 0)throw new NoSuchElementException();Object[] elementData = ArrayList.this.elementData;if (i >= elementData.length)throw new ConcurrentModificationException();cursor = i;return (E) elementData[lastRet = i];}public void set(E e) {if (lastRet < 0)throw new IllegalStateException();checkForComodification();try {ArrayList.this.set(lastRet, e);} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}public void add(E e) {checkForComodification();try {int i = cursor;ArrayList.this.add(i, e);cursor = i + 1;lastRet = -1;expectedModCount = modCount;} catch (IndexOutOfBoundsException ex) {throw new ConcurrentModificationException();}}}

ArrayList集合总结：

ArrayList实现数组数据结构的原因：
1.2 ArrayList定义一个Object对象数组用来存储List集合的元素，所以ArrayList集合对内部存储的元素的操作是对数组数据结构的操作，具有增删慢，查询快的特点

private transient Object[] elementData;

2.2 List集合的链表实现LinkedList：

LinkedList类的部分源码解析：

public class LinkedList<E>extends AbstractSequentialList<E>implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{-------------------------------------1.LinkedList类中定义的变量及构造方法----------------------------------//集合的长度transient int size = 0;//集合的第一个元素transient Node<E> first;//集合的最后一个元素transient Node<E> last;//构造方法public LinkedList() {}
-----------------------------2.LinkedList类实现链表数据结构的重要部分，静态内部类，节点类-----------------------//定义一个静态内部类--节点类，LinkedList将内部的每一个元素看做一个节点，即一个Node类的对象private static class Node<E> {E item;//每个节点都包保存有它的前一个节点和后一个节点的信息Node<E> next;Node<E> prev;//Node类的含参构造方法，共有3个参数，前一节点，元素对象，后一节点Node(Node<E> prev, E element, Node<E> next) {this.item = element;this.next = next;this.prev = prev;}}-------------------------------------3.LinkedList类的增删改查方法----------------------------------------//3.1 LinkedList在末尾添加元素public boolean add(E e) {linkLast(e);return true;}//3.2 LinkedList在指定角标地点添加元素public void add(int index, E element) {checkPositionIndex(index);if (index == size)linkLast(element);elselinkBefore(element, node(index));}//3.3 LinkedList删除指定元素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;}//3.4 LinkedList删除指定角标的元素public E remove(int index) {checkElementIndex(index);return unlink(node(index));}---------------------------4.LinkedList类的增删改查方法的支持方法（经过抽取得到的）-----------------------------public E get(int index) {checkElementIndex(index);return node(index).item;}public E set(int index, E element) {checkElementIndex(index);Node<E> x = node(index);E oldVal = x.item;x.item = element;return oldVal;}private void checkElementIndex(int index) {if (!isElementIndex(index))throw new IndexOutOfBoundsException(outOfBoundsMsg(index));}private boolean isElementIndex(int index) {return index >= 0 && index < size;}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;elsel.next = newNode;size++;modCount++;}void linkBefore(E e, Node<E> succ) {// assert succ != null;final Node<E> pred = succ.prev;final Node<E> newNode = new Node<>(pred, e, succ);succ.prev = newNode;if (pred == null)first = newNode;elsepred.next = newNode;size++;modCount++;}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;}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;}}---------------------------------5.LinkedList类的迭代器-------------------------------------------//返回一个public ListIterator<E> listIterator(int index) {checkPositionIndex(index);return new ListItr(index);}private class ListItr implements ListIterator<E> {private Node<E> lastReturned = null;private Node<E> next;private int nextIndex;private int expectedModCount = modCount;ListItr(int index) {// assert isPositionIndex(index);next = (index == size) ? null : node(index);nextIndex = index;}public boolean hasNext() {return nextIndex < size;}public E next() {checkForComodification();if (!hasNext())throw new NoSuchElementException();lastReturned = next;next = next.next;nextIndex++;return lastReturned.item;}public boolean hasPrevious() {return nextIndex > 0;}public E previous() {checkForComodification();if (!hasPrevious())throw new NoSuchElementException();lastReturned = next = (next == null) ? last : next.prev;nextIndex--;return lastReturned.item;}public int nextIndex() {return nextIndex;}public int previousIndex() {return nextIndex - 1;}public void remove() {checkForComodification();if (lastReturned == null)throw new IllegalStateException();Node<E> lastNext = lastReturned.next;unlink(lastReturned);if (next == lastReturned)next = lastNext;elsenextIndex--;lastReturned = null;expectedModCount++;}public void set(E e) {if (lastReturned == null)throw new IllegalStateException();checkForComodification();lastReturned.item = e;}public void add(E e) {checkForComodification();lastReturned = null;if (next == null)linkLast(e);elselinkBefore(e, next);nextIndex++;expectedModCount++;}final void checkForComodification() {if (modCount != expectedModCount)throw new ConcurrentModificationException();}}

JavaSE集合框架-01-集合框架体系及表数据结构相关推荐

java集合框架容器 java框架层级继承图结构集合框架的抽象类集合框架主要实现类...
本文关键词: java集合框架框架设计理念容器继承层级结构继承图集合框架中的抽象类主要的实现类实现类特性集合框架分类集合框架并发包并发实现类什么是容器? 由一个或多个确 ...
Spring框架教程集合
Spring是一个开源框架,Spring是于2003 年兴起的一个轻量级的Java 开发框架,由Rod Johnson 在其著作Expert One-On-One J2EE Development a ...
JavaSE基础笔记——不可变集合简介、Stream流体系、异常处理
1.不可变集合简介不可变集合,就是不可被修改的集合. 集合的数据项在创建的时候提供,并且在整个生命周期中都不可改变.否则报错. 为什么要创建不可变集合? 如果某个数据不能被修改,把它防御性地拷贝到不 ...
Android开源框架【集合】
Android开源框架[集合] 图解一览 Square& JakeWharton 框架名称功能描述 Picasso 一个强大的图片下载与缓存的库 OkHttp Square出品,一个Http ...
Spring框架中集合属性为对象的注入方法
Spring框架中集合属性为对象的注入方法前言创建基础类创建`Course`类编写XML配置文件创建测试类执行结果前言在集合的属性注入中,如果注入属性为普通类型(String.int) ...
Java基础（19）数据结构概述、ArrayList集合、Vector集合、LinkedList集合、集合框架练习
1. 数据结构概述 1. 数据结构的概述:数据结构就是数据存储的方式 2. 常见数据结构:栈,队列,数组,链表,二叉树,哈希表 3. 栈和队列 (1)栈:先进后出,后进先出 (2)队列:先进先出,后进 ...
小白学习java集合框架（集合Collection）
希望各位能够留下你们美丽的赞和评论谢谢,或者有好的资源帮帮小编提升实力一起努力,奥里给!! 拒绝垃圾视频:超级好的视频,建议从头开始看:https://www.bilibili.com/video/B ...
Day15 --框架集合 Collection集合和 List 集合
a. 对象数组 --自定义对象类概述 * 创建一个自定义类用于存储学生信息,并且获取到每个学生信息 . 使用 ...
map集合遍历_集合框架的部分内容
集合的定义? 集合:用来保存一组数据的数据结构集合的父接口,实现接口,实现类,实现类的常用方法是什么?(建议以树状图画出来,便于加深印象). Collection list set Arraylis ...
小汤学编程之JAVA基础day11——集合框架：List/Set/Map集合、Collections集合工具类、泛型、TreeMap和TreeSet
一.集合的特点二.继承结构图三.List集合 1.特点 2.ArrayList类 3.LinkedList类 4.两者的对比 5.集合的遍历四.Set集合 1.特 ...

JavaSE集合框架-01-集合框架体系及表数据结构