Colección Java más análisis de código fuente

Introducir

1. Las colecciones y las matrices son estructuras que pueden almacenar varios datos, denominados contenedores Java para abreviar
2. Características de los datos de almacenamiento de matrices:
   1. Una vez que se inicializa la matriz, se determina la longitud de la matriz
   2. Una vez que se define la matriz, se determina el tipo de datos que puede almacenar los elementos
3. Desventajas de almacenar datos en matrices:
   1. Longitud inmutable
   2. Los métodos proporcionados en la matriz son limitados, lo cual es inconveniente para operaciones como agregar y eliminar, y la eficiencia no es alta.
   3. Es difícil obtener el número de elementos válidos en la matriz.
   4. Incapaz de satisfacer necesidades desordenadas y no repetitivas

Uno, marco de recopilación de Java

Interfaz de colección: colección de una sola columna, almacenando objetos uno por uno

Interfaz de lista: datos ordenados y repetibles (se puede entender como una matriz dinámica)

ArrayList 、 LinkedHashSet 、 Vector

Interfaz de conjunto: datos desordenados y no repetibles (se puede entender como un conjunto en matemáticas de la escuela secundaria)

HashSet 、 LinkedHashSet 、 TreeSet

Interfaz de mapa: recopilación de dos columnas, que almacena un par de datos (clave-valor) (se puede entender como una función)

HashMap 、 LinkedHashMap 、 TreeMap 、 HashTable 、 Propiedades

Dos, método de interfaz de colección

Mirando la interfaz de Colección, podemos ver que hay 15 métodos abstractos para que la clase de implementación implemente, 13 de ellos se explican en detalle a continuación.

---

1 boolean add(E e)	向集合中添加元素，只能添加引用类型，不能添加基本类型
    
2 boolean addAll(Collection c)	将形参集合的元素添加到当前集合
    
3 void clear()	删除当前集合所有元素
    
4 boolean comtains(Object obj)	会调用obj对象所在类的equals方法，判断形参传入集合中的值是否在当前集合内
    
5 boolean contains(Collection coll)	判断形参coll的元素是否都在当前集合内
    
6 boolean equals(Object o)	判断当前集合和形参集合元素是否相等
    
7 int hashCode()	返回当前集合的hashCode值
    
8 boolean isEmpty()		判断当前集合是否为空
   
9 boolean remove(Object obj)		从当前集合删除obj元素
    
10 boolean removeAll(Collection coll)	从当前集合删除coll集合的所有元素
    
11 boolean retainAll(Collection coll) 	求两个集合的交集，并返回给当前集合
    
12 int size()		返回当前集合的长度
    
13 Object[] toArray() 		将当前集合转换为数组

Tres, interfaz de iterador

El objeto Iterator se llama iterador, que se utiliza principalmente para recorrer los elementos de la colección Collection, y también puede eliminar elementos de la colección mientras se recorre

El iterador solo se aplica al recorrido de la colección

El objeto de colección obtendrá un nuevo objeto iterador cada vez que se llame al método iterator (), y el cursor predeterminado está antes del primer elemento de la colección

Collection coll = new ArrayList();
Iterator iterator = coll.iterator();

//遍历集合
while(iterator.hasNext()){
    
    
    iterator.next();
}

hasNext()   判断是否还有下一个元素
next()   指针下移、下移后将集合位置上的元素返回

Cuatro, subinterfaz de colección 1: Lista

List Las clases de implementación de interfaces más utilizadas son:ArrayList LinkedList Vector

Similitudes y diferencias:

Igual: las tres clases implementan la interfaz de lista

Lista de arreglo	Como la clase de implementación principal de List, el subproceso no es seguro, eficiente y la capa inferior usa el almacenamiento Object []
Lista enlazada	La capa inferior utiliza una lista doblemente vinculada para almacenar, agregar con frecuencia y eliminar de manera eficiente
Vector	Como una clase de implementación antigua de List, seguridad de subprocesos, baja eficiencia y almacenamiento de objetos [] en la parte inferior

Métodos comunes de la interfaz List

void add(int index,Object ele)	在index位置插入ele元素

boolean addAll(int index,Collection eles)	从index位置开始将eles中的所有元素添加进来
    
Object get(int index)	获取index位置的元素
    
int indexOf(Object obj)		返回obj第一次出现的索引
    
int lastIndexOf(Object obj)		返回obj在当前集合最后一次出现的索引
    
Object remove(int index)	移除index位置的元素，并返回该元素
    
Object set(int index,Object obj)	设置index位置的元素为obj
    
list subList(int fromIndex,int toIndex)		返回从fromIndex到toIndex的子集合	

Recorrido de lista (tres formas)

ArrayList list = new ArrayList();
list.add(123);
list.add("asd");

//方式一：Iterator方式
Iterator iterator = list.iterator();
while(iterator.hasNext()){
    
    
    iterator.next();
}
//方式二：增强for循环
for(Object obj : list){
    
    
    System.out.println(obj);
}
//方式三：普通for循环
for(int i = 0; i < list.size ; i++){
    
    
    System.out.println(list.get(i));
}

Análisis del código fuente de ArrayList:

ArrayList arr = new ArrayList();	//底层创建长度为10的Object[]数组

arr.add(123);	//elementDate[0] = 123
...
arr.add(11);	
//如果此次添加元素导致底层elementDate数组容量不够，则扩容，默认情况下扩容为原来的1.5倍，同时将原数组的元素复制到新数组中
int newCapacity = oldCapacity + (oldCapacity >> 1);
elementData = Arrays.copyOf(elementData, newCapacity);

ArrayList arr = new ArrayList();//底层并没有创建长度为10的数组
arr.add(123);	//第一次调用add方法时，才创建长度为10的数组
后续和7之前一样
    
总结：
    7类似于饿汉式、8类似于懒汉式，节省内存

Cinco, subinterfaz de colección 2: Establecer

La interfaz Set es una subinterfaz de la interfaz Collection. No proporciona métodos adicionales . Se utilizan todos los métodos declarados por Collection.

No se permite que las colecciones de conjuntos contengan los mismos elementos

1. Comprensión de Set

1.1 Trastorno

Los elementos almacenados no se agregan en el orden del índice de la matriz en la parte inferior, sino que se determinan de acuerdo con el valor hash de la matriz.

1.2, no repetibilidad

1.3, el proceso de agregar elementos al conjunto

Paso 1: agregue el elemento a al hashSet. Primero llame al método hashCode de la clase donde se encuentra a para calcular el valor hash, y luego use este valor hash para calcular el valor del índice del elemento almacenado en la matriz a través de un algoritmo determinado .

Paso 2: Después de obtener el valor del índice, juzgue si hay un elemento en la posición, si no hay ningún elemento en esta posición, la adición es exitosa.

Si hay un elemento en esta posición, primero compare a y el valor hash del elemento en esta posición

Si el valor hash es diferente, el elemento a se agrega con éxito

Paso 3: si los valores hash son los mismos, llame al método equals de la clase donde está a y pase otros elementos a los parámetros formales del método equals

Si el método devuelve verdadero, el elemento a no se pudo agregar

Si el método devuelve falso, la adición se realiza correctamente (se almacena en una lista vinculada)

2 、 árbol

1. Los elementos agregados al treeSet deben ser objetos de la misma clase (para que se pueda comparar el tamaño)

Dos, dos métodos de clasificación

Clasificación natural (implementar interfaz comparable)

El criterio para comparar dos objetos con el mismo ya no es igual, pero el método compareTo devuelve 0

Orden personalizado

El criterio para comparar si dos objetos son iguales no es igual, sino

Seis, interfaz de mapa

1. Estructura del marco de la interfaz del mapa

| ------ Mapa: almacena los datos de los pares clave-valor

| ------ HashMap: como la principal clase de implementación de Map; el hilo no es seguro; alta eficiencia

| ------ LinkedHashMap

| ------ TreeMap: puede ser ordenado (ordenado por clave)

| ------ Hashtable: como una clase de implementación antigua de Map; seguro para subprocesos; baja eficiencia

| ------ Propiedades: comúnmente utilizado para procesar archivos de configuración; los pares clave-valor son todos tipos de cadena

¿El principio de implementación subyacente de HashMap?

2. Comprensión de la clave-valor

① Teclee el mapa: desordenado, no repetible (almacenado con set) La clase donde se encuentra debe anular el método equals y el método hashCode (para HashMap)

② Valor en el mapa: desordenado, repetible (almacenado en la colección) El método igual de la clase debe reescribirse (para HashMap)

③ Un par clave-valor constituye un objeto Entry (almacenado con set)

El par clave-valor introducido se almacena realmente en el objeto Entrada. La entrada tiene dos atributos, clave y valor

La entrada es desordenada y no repetible.

3. El principio de implementación subyacente de HashMap

以JDK7说明
    
HashMap map = new HashMap();	实例化以后，底层创建了长度为16的数组Entry[] table
map.put(key,value);		
首先调用key所在类的hashCode方法，计算key的哈希值，此哈希值经过某种算法计算后，得到key在Entry[]中的存放位置
如果此位置数据为空，则键值对添加成功
    如果此位置数据不为空（意味着此位置存放一个或多个数据（链表存储）），比较当前key和这些数据的哈希值，
    	如果key的哈希值与已经存在的数据局哈希值都不相同，则键值对添加成功
    	如果key的哈希值与已经存在的某个key的哈希值相同，则调用key所在类的equal方法
    		返回true，用value去替换已经存在key的value值
    		返回false，则键值对添加成功
默认扩容方式为原来的2倍，并且赋值过来
    
8与7的不同点
    1 在new时，底层并没有创建长度为16的数组
    2 jdk8底层的数组是 Node[],而非Entry[]
    3 首次调用put方法时，底层创建长度为16的数组
    4 JDK8底层使用 数组+链表+红黑树（当数组的某个索引位置上以链表形式存在的数据个数>8且当前数组长度>64，此时索引位置上的所有数据改为使用红黑树存储）

4. Métodos habituales en la interfaz del mapa

V put(K key,V value)	向map中添加数据
  
V remove(Object key)	通过指定key移除键值对
    
void clear()	清空map集合
    
Object get(Object key)		通过key获取指定value
    
Boolean containsKey(Object key)		是否包含指定的key
    
Boolean containsValue(Object value)		是否包含指定的value
    
int size() 		返回map键值对的个数
    
Boolean isEmpty()	判断map是否为空
    
Boolean equals(Object obj)	判断两个map是否相等

5. Recorrido del mapa

        //遍历所有key
        Set keySet = map.keySet();
        Iterator iterator = keySet.iterator();
        while(iterator.hasNext()){
    
    
            System.out.println(iterator.next());
        }

        //遍历所有value
        Collection values = map.values();
        Iterator iterator1 = values.iterator();
        while(iterator1.hasNext()){
    
    
            System.out.println(iterator1.next());
        }

        //遍历所有键值对
        Set set = map.entrySet();
        for (Object o : set){
    
    
            Map.Entry entry = (Map.Entry) o;
            System.out.println(entry.getKey());
            System.out.println(entry.getValue());
        }

Siete, herramientas de colección

Colecciones es una clase de herramienta que puede manipular conjuntos, listas y mapas.

reverse(List)	反转List中元素的顺序
    
shuffle(List)	对List集合中的元素进行随机排序
    
sort(List)		根据元素的自然排序对List集合元素进行升序排序
    
sort(List,Comparator)	根据指定的Comparator产生的顺序对List进行排序
    
swap(List,int,int)		将指定List集合中的i处元素和j处元素进行交换
    
int frequency(Collection Object)	返回指定元素出现的次数
    
void copy(List dest,List src)		将原集合复制带目标集合