Directorio artículo
1 #####. Colección
interfaz Iterable en Java Mapa interfaz del sistema de contabilidad en la posición principal, sustancialmente la totalidad de las estructuras de datos se basan en las dos interfaces, una es una iteración lineal puede ser una tabla hash.
Visto por la figura, el sistema de interfaz de colección como la interfaz conjunto de padres, mapa sistema de tabla hash como una interfaz.
La fuente principal es proporcionar un método de Colecciones:
public interface Collection<E> extends Iterable<E> {
int size(); // 集合大小
boolean isEmpty(); // 是否为空
boolean contains(Object o); // 是否包含某个元素
Iterator<E> iterator(); // 返回迭代器
Object[] toArray(); // 返回 Object 数组
<T> T[] toArray(T[] a); // 返回指定泛型的数组
boolean add(E e); // 添加一个元素，返回是否添加成功
boolean remove(Object o); // 移除一个元素，返回是否添加成功
boolean containsAll(Collection<?> c); // 是否包含另一个集合
boolean addAll(Collection<? extends E> c); // 将另一个集合添加到当前集合
boolean removeAll(Collection<?> c); // 移除当前集合的元素，返回集合是否被修改过
default boolean removeIf(Predicate<? super E> filter); // 根据添加移除元素
boolean retainAll(Collection<?> c); // 仅保留存在于给定集合的元素，返回集合是否被修改过
void clear(); // 清空集合
boolean equals(Object o); // 判断是否相等
int hashCode(); // 返回hash值
}
##### 2. Lista
- Datos característicos almacenados: almacenar una, los datos repetible ordenada.
- clase de implementación común:
- Colección de interfaz: un conjunto único, para el almacenamiento de un objeto de una
- Lista de interfaz: secuencia de almacenamiento, los datos reproducibles. -> array "dinámica", en sustitución de la matriz original
- ArrayList: lista como una clase de implementación interfaz principal; thread-safe, de alta eficiencia; capa inferior usando Object [] de almacenamiento elementData, con el aumento de elemento de expansión dinámica
- LinkedList: Para la inserción frecuente, eliminación, uso de tal eficiencia superior a la ArrayList; almacenamiento subyacente utilizando una lista doblemente enlazada, como el elemento, mientras que el extremo trasero de la lista cada vez mayor del nodo
###### 2.1 Interfaz Lista
#List方法
A:添加功能
boolean add(E e):向集合的尾部添加一个元素
* void add(int index, E element):在指定位置添加元素
boolean addAll(Collection<? extends E> c)：在集合中尾部添加一个集合。
* boolean addAll(int index, Collection<? extends E> c);// 在集合指定位置添加一个集合。
B:删除功能
void clear()：删除集合中的所有元素
* E remove(int index)：删除集合指定位置的元素，并把删除的元素返回
boolean remove(Object o)：删除集合中指定的元素
boolean removeAll(Collection<?> c):删除两个集合的交集 。
* default void replaceAll(UnaryOperator<E> operator) // 将集合中的元素特换成指定元素
C:修改功能
void clear(); // 清空集合元素
E set(int index, E element):把指定索引位置的元素修改为指定的值，返回修改前的值。
D:获取功能
* E get(int index)：获取指定位置的元素
* int indexOf(Object o);// 获取元素在集合中首次出现的位置，获取不到返回 -1
* int lastIndexOf(Object o);// 获取元素在集合中最后出现的位置，获取不到返回 -1
* List<E> subList(int fromIndex, int toIndex);// 截取指定区间位置内的集合
E:迭代器
Iterator iterator():获取集合中每一个元素。
* ListIterator<E> listIterator(int index); // 获取集合从特定位置开始的每个元素
F:判断功能
boolean isEmpty()：判断集合是否为空：size==0
boolean contains(Object o)：判断集合中是否存在指定的元素。
boolean containsAll(Collection<?> c)：判断集合C是否为当前集合的子集。
* boolean retainAll(Collection<?> c); // 求两个集合的交集，并将交集赋值给当前集合，若集合有变化则返回true，若两集合相等则返回false
boolean equals(Object o);// 判断两个集合是否相等：集合长度、元素、元素位置
G:数组功能
int hashCode();
int size():获取集合中的元素个数
* default void sort(Comparator<? super E> c)// 对集合进行特定排序
H:把集合转换成数组
Object[] toArray():把集合变成数组。
public <T> T[] toArray(T[] a) ;
2.2 clase ArrayList
ArrayList Marco de colecciones de Java es el más utilizado en una clase, es una cola de matriz, colección thread-safe.
Hereda AbstractList, Lista implementos, acceso aleatorio, Cloneable, interfaz Serializable.
- ArrayList aplicar Lista, Lista infraestructura de recogida ha sido la base de la función;
- ArrayList lograr el acceso aleatorio, para obtener una rápida elemento funcional memoria de acceso aleatorio, el acceso aleatorio es una interfaz de marcador, no hay ninguna manera;
- ArrayList lograr el Cloneable, para obtener un método clone () puede ser implementada la función de clonación;
- ArrayList lograr el Serializable, la representación se puede serializar, la serialización a protocolos de transferencia de aplicación típica es la arpillera.
2.2.1 estructura de la clase ArrayList características:
- Capacidad no es fija, como la expansión de los aumentos de capacidad dinámicamente (sustancialmente no alcanzar el valor umbral)
- conjunto ordenado (el orden de salida de secuencia de inserción ==)
- elementos insertados pueden ser nula
- CRUD más eficiente (en relación con LinkedList es)
- seguro para hilos
2.2.2 común clase ArrayList método
Lista ArrayList función de base del marco de la colección implementado, la lógica de aplicación implementada en todos los métodos, no hay nuevos métodos públicos, el nuevo método es también sólo ayudan a la lógica de procesamiento privado.
- 1.ArrayList variables globales
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
private static final int DEFAULT_CAPACITY = 10; // 默认初始化容量为10
private static final Object[] EMPTY_ELEMENTDATA = {}; // 创建一个空数组
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 创建一个拥有默认容量为10的空数组
transient Object[] elementData; // ArrayList底层使用数组进行存储。设置为DEFAULTCAPACITY_EMPTY_ELEMENTDATA的list，在首次调用add方法时，容量会扩容为10.
private int size; // ArrayList的大小，即元素的个数
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // list的最大容量
}
- constructor 2.ArrayList
ArrayList tres constructores:
- Sin argumentos: una matriz vacía, la matriz se crea de forma predeterminada cuando se llama al método capacidad de 10
- lista longitud especifica: crear una matriz de las constantes especificadas
- elementos especificados: la capacidad de crear una matriz de elementos establecidos de tamaño y longitud determinada
// 1. 创建空数组，调用方法时默认创建数组的容量为10
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 2. 创建指定长度的list：底层创建指定长度的数组
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);
}
}
// 3. 创建一个包含指定元素的集合列表
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;// 创建空数组
}
}
- 3 ArrayList elementos añadir y expansión
método add ArrayList Hay dos categorías principales:
- Añadir lista o conjunto de elementos de arrastre: (<? Extiende E> Colección c) añadir (Ee), addAll
- Añadir la ubicación especificada o elemento en el conjunto de la lista: add (int index, elemento E), addAll (int index, Colección <? Extiende E> c)
Después segundo método de clase implica el desplazamiento de la posición especificada del elemento, el elemento de origen es principalmente método System.arraycopy llamado después de desplazar y asignación; Método de la clase 1 se añade directamente al final, no se trata de elementos móviles.
ArrayList comprobará primero al llamar al método añadir la capacidad actual cumple con la demanda de tamaño 1 + (numNew), si continúa a añadir a cumplir, si no se cumplen para la expansión.
Nota: ArrayList permite añadir nulo, mientras que el tamaño + 1; el vaciado del elemento de recogida se establece en NULL, size = 0
// 1.在list尾部添加元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//2.将集合c元素添加到在list尾部
public boolean addAll(Collection<? extends E> c){
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
//3.在指定位置插入元素
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++;
}
//4.在指定位置插入集合元素
public boolean addAll(int index, Collection<? extends E> c){
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
lógica expansión ArrayList:
- La capacidad mínima cálculo: minCapacity = tamaño + 1 (numNew)
- Si la lista es DEFAULTCAPACITY_EMPTY_ELEMENTDATA, la capacidad mínima requerida: Math.max (DEFAULT_CAPACITY, minCapacity)
- De lo contrario, la capacidad mínima requerida: minCapacity
- La capacidad actual y la capacidad mínima (ser minCapacity) determina:
- Si la capacidad actual de la> capacidad mínima (minCapacity), se añade normalmente
- Si la capacidad actual <capacidad mínima (minCapacity), se realiza la expansión
- expansión:
- La capacidad actual ampliado a 1,5 veces para obtener una nueva capacidad
- Si la nueva capacidad> capacidad mínima (minCapacity), la capacidad de la nueva creación, y si la nueva capacidad <capacidad mínima (minCapacity), a continuación, la nueva capacidad = capacidad mínima (ser minCapacity)
- La nueva determinación umbral de capacidad: MAX_ARRAY_SIZE
- Si la nueva capacidad <MAX_ARRAY_SIZE, el establecimiento de la nueva capacidad
- Si la nueva capacidad de más de MAX_ARRAY_SIZE
- Si la capacidad mínima (minCapacity) <MAX_ARRAY_SIZE, a continuación, la nueva capacidad = MAX_ARRAY_SIZE
- Si la capacidad mínima (minCapacity)> MAX_ARRAY_SIZE, a continuación, la nueva capacidad = Integer.MAX_VALUE
Nota: Lista de expansión actual es copiar elementos a la nueva matriz y devuelve una nueva matrizelementData = Arrays.copyOf(elementData, newCapacity)
// 与扩容相关的方法
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);
}
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
- 4.ArrayList intersección, diferencia
métodos removeAll y retainAll implican la eliminación de elementos de la parte inferior que se llama método batchRemove, diferentes parámetros de paso
de procesamiento método batchRemove lógica:- Los elementos de reposicionamiento cualificados en el array (comenzando con índice 0)
- Después de todo cribado, los elementos restantes de la ubicación se establece en NULL
// 删除两个集合的交集
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, false);
}
// 保留两个集合的交集
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c);
return batchRemove(c, true);
}
// 集合操作过程
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
if (w != size) {
// clear to let GC do its work
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;
size = w;
modified = true;
}
}
return modified;
}
- 5.ArrayList elemento se mueve
debido a ArrayList es contigua elemento de almacenamiento de direcciones, cuando el complemento o la lista de elementos de borrado (o conjunto) en la ubicación especificada, después de que todos los elementos necesarios para especificar la posición de un movimiento hacia adelante o hacia atrás (o N bits).
ArrayList método correspondiente son:
- add (int index, elemento E), addAll (int index, Colección <? extiende E> c)
- remove (int index), removeRange (int fromIndex, int toIndex), remove (Object o)
Tales métodos se invocan método subyacente System.arraycopy para los elementos móviles.
// 1.在指定位置添加元素
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++;
}
// 2.在指定元素添加集合元素
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew, numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
// 3.删除指定位置的元素
public E remove(int index);
{
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index, numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
// 4.删除指定范围内的元素
protected void removeRange(int fromIndex, int toIndex){
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex, numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
// 5.删除指定元素
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;
}
// 快速删除指定位置元素
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
}
- 6.ArrayList iterador
ArrayList construyó dos iteradores: ITR, ListItr:
- Itr logra Iterator interfaz, principalmente para un conjunto de operaciones que definen la lógica de la hasNext método, al lado, quitar, etc.
- Itr ListItr clase implementa herencia la ListIterator interfaz, principalmente para la lista de conjunto operación, que definen el nextIndex lógico, anterior, previousIndex, set, añadir y otros métodos de
ArrayList-implementado construido método de la lógica construido AbstractList iterador iterador mismo proceso lógico.
Hay tres maneras de invocar ArrayList iterador: iterador (), listIterator (), listIterator (int index)
Nota: Al llamar al iterador, no se puede modificar el funcionamiento de la lista original, al mismo tiempo, a conjunto, complemento, métodos eliminan sólo pueden hacerlo una vez. Iterator lógica materializa visible] [iterador conjunto detallado
// 1.调用Itr迭代器
public Iterator<E> iterator() {
return new Itr();
}
// 2.调用listIterator迭代器
public ListIterator<E> listIterator() {
return new ListItr(0);
}
// 3.指定位置开始调用listIterator迭代器
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
- enfoque general común 7.ArrayList
- Tenga en cuenta que el número de elementos en distinguir ArrayList (tamaño) y las matrices de capacidad
- método TrimToSize () para eliminar el exceso de capacidad, el número de elementos igual a la nueva posición de la matriz asignado a la matriz actual.
- clone () devuelve el método un nuevo conjunto de posiciones de los elementos igual al número de
- clear () para configurar todo el nulo elementos, tamaño = 0
- estaVacia () determina el tamaño == 0
public boolean isEmpty() {
return size == 0;
}
* E elementData(int index) {
return (E) elementData[index];
}
public int indexOf(Object o);// 返回元素在集合中第一次出现的位置，元素O可以为null，查找不到返回-1
// 去掉预留元素位置：使数组容量=数组元素个数（size）
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
//克隆当前集合为新的集合对象
* public Object clone(){
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
3 #####. Queue
###### 3.1.Queue Interface
interfaz de cola se extiende la interfaz Collection, sobre la base del funcionamiento básico de la interfaz Collection en el nuevo complemento, llegar, los métodos de eliminación, cada método tiene dos modos: 1 lanzar una excepción si falla la operación; 2 Si la operación no puede devolver nula .. o falsa.
public interface Queue<E> extends Collection<E> {
#添加元素
boolean add(E e);// 添加成功返回true；如果因为容量有限添加失败，则抛出异常IllegalStateException
boolean offer(E e);// 添加成功返回true，否则返回false。
#删除头元素
E remove();// 删除头元素，如果队列为空，抛出异常NoSuchElementException
E poll();// 获取头元素，如果队列为空返回null
#查询头元素，并不删除头元素
E element();// 查询头元素，如果队列为空抛出异常NoSuchElementException
E peek();// 查询头元素，如果队列为空返回null
}
Interfaz 3.2.Deque
métodos de interfaz deque se pueden dividir en:
- . Para deque: 1 en la primera cola, pasado por añadir, quitar, 6 categorías de métodos consiguen; 2 elementos específicos de eliminación :. RemoveFirstOccurrence (Object o), removeLastOccurrence (Object o).
- Para cola: añadir, eliminar, 3 categorías de métodos consiguen.
- Para la pila: empuje, 2 métodos de Ge de pop
- . Para un conjunto de: la obtención de un elemento particular o eliminado: contains (Object o), remove (Object o); 2 el número de elementos :. Tamaño (); 3 iterador :. iterador (), descendingIterator ()
Interfaz deque Características:
interfaz deque Cola amplía la interfaz, por lo que se trata de añadir, eliminar, obtener operación proporciona dos maneras: 1 operación excepción tiro falló; 2 operación nula fracasado retorno o falsa ...
deque interfaz para acceder a los elementos no son compatibles con el índice.
public interface Deque<E> extends Queue<E> {
/** 双端队列的方法
*/
#添加元素至队列头部
void addFirst(E e);// 添加成功返回true，若因容量受限添加失败，抛出异常：IllegalStateException
boolean offerFirst(E e); // 添加成功返回true，否则返回false
#添加元素至队列尾部
void addLast(E e);// 添加成功返回true，若因容量受限添加失败，抛出异常：IllegalStateException
boolean offerLast(E e);// 添加成功返回true，否则返回false
#删除队列头元素
E removeFirst();// 删除头元素，如果队列为空，抛出异常：NoSuchElementException
E pollFirst();// 删除头元素，如果队列为空返回null
#删除队列尾元素
E removeLast();// 删除尾元素，如果队列为空，抛出异常：NoSuchElementException
E pollLast();// 删除尾元素，如果队列为空返回null
#获取队列头元素
E getFirst();// 获取头元素，如果队列为空，抛出异常：NoSuchElementException
E peekFirst();// 获取头元素，如果队列为空返回null
#获取队列尾元素
E getLast();// 获取尾元素，如果队列为空，抛出异常：NoSuchElementException
E peekLast();// 获取尾元素，如果队列为空返回null
#将队列首次出现的元素o删除
boolean removeFirstOccurrence(Object o);// 如果删除成功返回true
#将队列最后出现的元素o删除
boolean removeLastOccurrence(Object o);// 如果删除成功返回true
/** Queue接口方法
*/
#在队列尾部添加元素
boolean add(E e);// 添加成功返回true；如果因为容量有限添加失败，则抛出异常IllegalStateException
boolean offer(E e);// 添加成功返回true，否则返回false。
#删除队列尾部元素
E remove();// 如果队列为空，抛出异常NoSuchElementException
E poll();// 如果队列为空返回null
#查询队列头元素，并不删除头元素
E element();// 如果队列为空抛出异常NoSuchElementException
E peek();// 如果队列为空返回null
/** 栈Stack方法，只在栈顶进行元素的入栈和出栈
*/
#元素入栈
void push(E e);// 入栈成功返回true，如果因为容量受限，抛出异常：IllegalStateException
#元素出栈
E pop();// 如果队列为空，抛出异常：NoSuchElementException
/** 集合Collection方法
*/
# 删除队列首次出现的元素o
boolean remove(Object o);// 删除成功返回true。 方法等同于 removeFirstOccurrence(Object o) 方法
# 判断队列中是否包含元素o
boolean contains(Object o);// 如果包含返回true，否则返回false
# 队列元素个数
public int size();
#队列迭代器
Iterator<E> iterator();
#队列反转的迭代器
Iterator<E> descendingIterator();
}
3.3.LinkedList
LinkedList es una lista doblemente enlazada, cada nodo tiene un punto de referencia antes y después del nodo. En ArrayList, LinkedList menor en comparación con la eficacia del acceso al azar.
Hereda AbstractSequentialList, Lista implementos, deque, Cloneable, interfaz Serializable.
(1) LinkedList se dio cuenta de Lista, Lista obtenido funcionalidad base del marco de la recogida;
(2) la LinkedList implementa Deque, Deque es una cola de doble extremo, es decir, ya sea FIFO, después, sino también el primero en salir, dicho más simple que tanto en la primera elemento porción de aditivos se puede añadir elementos al final;
la LinkedList lograr el Cloneable, para obtener un método clone () puede ser implementado de clonación de capacidad (3.);
(. 4) la LinkedList implementar el serializable, la representación se puede serializar, la serialización a la transmisión, típicamente la aplicación es el protocolo de arpillera.
2. El método común
3. análisis de código fuente
LinkedList list = new LinkedList(); 内部声明了Node类型的first和last属性，默认值为null
list.add(123);//将123封装到Node中，创建了Node对象。
其中，Node定义为：体现了LinkedList的双向链表的说法
private static class Node<E> {
E item;
Node<E> next;
Node<E> prev;
Node(Node<E> prev, E element, Node<E> next) {
this.item = element;
this.next = next;
this.prev = prev;
}
}
###### 3.4. ArrayList y LinkedList comparan
la principal diferencia es la diferencia entre matrices y listas enlazadas antes LinkedList y ArrayList.
La asignación de matriz consulta y más rápido, porque se puede marcar mediante una matriz de acceso directo a la ubicación especificada.
Para borrar la lista y aumentar más rápido porque directamente mediante la modificación de la lista de punteros (Java ningún puntero aquí puede entenderse simplemente como una guía. De hecho, es designado por la variable de nodo de nodo) añadir o elementos de borrado.
Así, LinkedList y ArrayList compararon las deleciones más rápido. Sin embargo, la consulta y modificar el valor de lento. Mientras tanto, LinkedList también implementa la interfaz de colas, por lo que también ofrecen ofertas (), ojeada (), poll () métodos.
https://www.jianshu.com/p/63b01b6379fb
4 #####. Vector
Vector y ArrayList, se logra a través de la matriz, pero Vector es thread-safe. Y en comparación con ArrayList, que son muchas maneras de asegurar el hilo de seguridad a través del proceso de sincronización (sincronizado).
Si el programa no implica hilo de seguridad, a continuación, utilizar ArrayList es una opción mejor (debido a que el uso de Vector sincronizado, afectará inevitablemente a la eficiencia).
No existe también una diferencia entre los dos es la misma estrategia de expansión. Cuando se creó la primera lista, habrá un tamaño inicial, con los elementos de aumento a la Lista, la lista cuando la capacidad no es tiempo suficiente para pensar que será la expansión. Automático doble del aumento de la longitud original de la matriz de incumplimiento bajo Vector, crecimiento ArrayList del original 50%.
##### 5. ¿Cómo seleccionar
si se trata de multi-hilo, a continuación, seleccione vectorial (Por supuesto, también puede utilizar su propio ArrayList y sincronización).
Si no se relaciona con múltiples hilos, ArrayList selecciona del LinkedList. LinkedList más adecuado para la inserción o eliminación (una lista característica) a partir del intermedio. ArrayList es más adecuado para recuperar y insertar o eliminar (característica de la matriz) final.
Link: https: //www.jianshu.com/p/1149f1bf1736
