Colección de caminos de aprendizaje de Java

Visión general

Definición de colección

¿Qué es una colección? Un conjunto es "un todo compuesto por ciertos elementos".

Desde un punto de vista conceptual, las colecciones y las matrices son muy similares, entonces, ¿por qué necesitamos recopilar cuando tenemos una matriz?

El tamaño de la matriz es inmutable después de la inicialización;
Solo se puede acceder a la matriz en orden de índice;
...

Debido a que las matrices tienen las deficiencias anteriores, las colecciones se proporcionan en Java para que las usemos.

Tipos y características de colecciones

La biblioteca estándar de Java que viene con java.utilel paquete proporciona una colección de clases: Collectiones además de Mapla interfaz raíz para todas las demás clases de colección. El java.utilpaquete Java proporciona principalmente los siguientes tres tipos de colecciones:

List: Una colección de listas ordenadas;
Set: Una colección que garantiza que no haya elementos duplicados;
Map: Una colección de tablas de mapeo buscadas por clave-valor.

Las colecciones de Java tienen las siguientes características:

Interfaz separada y clase de implementación;
La segunda es para admitir genéricos, podemos limitarnos a que una colección solo pueda poner elementos del mismo tipo de datos.

El acceso de Java a las colecciones se logra a través de un iterador de forma unificado (Iterator), con él solo podemos preocuparnos por el uso de la capa superior y no el tipo de la capa inferior.

1. `Collection`Métodos comunes de interfaz

1. Agrega elementos

add(int index，E element): Agrega un artículo a la colección;
- index(Parámetro opcional): indica el valor del índice donde se inserta el elemento;
- element -El elemento a insertar;
- Valor de retorno: si el elemento se inserta correctamente, devuelve verdadero;
  
  Si el índice está fuera de rango, entonces el método add () lanza una IndexOutOfBoundsExceptionexcepción.
addAll(int index, Collection c)：
- index(Parámetro opcional): indica el valor del índice donde se inserta el elemento;
- c-el elemento de colección que se insertará;
- Valor de retorno: si el elemento se inserta correctamente, devuelve verdadero;
  
  Si el conjunto dado es nulo, el exceso es NullPointerExceptionanormal;
  
  Si el índice está fuera de rango, entonces el método add () lanza una IndexOutOfBoundsExceptionexcepción.

2. Obtenga la cantidad de elementos válidos

size(): Devuelve el número de elementos de la matriz.
- Valor de retorno: devuelve el número de elementos de la matriz.

3. Vacíe la colección

clear(): Elimina todos los elementos de la colección dinámica.

4. ¿Es un conjunto vacío?

isEmpty(): Determina si la colección está vacía.
- Valor de retorno: si no hay elementos en la matriz, devuelve verdadero;
  
  Si hay elementos en la matriz, devuelve falso.

5. ¿Contiene un elemento?

contains(Object obj): Se utiliza para determinar si el elemento está en el conjunto;
- obj -Elementos a detectar;
- Valor de retorno: si el elemento especificado existe en la matriz dinámica, devuelve verdadero;
  
  Si el elemento especificado no existe en la matriz dinámica, se devuelve falso.
containsAll(Collection c): Compruebe si el conjunto contiene todos los elementos del conjunto especificado.
- collection -Establecer parámetros;
- Valor de retorno: si todos los elementos de la colección están contenidos en la matriz dinámica, devuelve verdadero;
- Si la colección con los elementos especificados presentes en Collectionelementos incompatibles en los Throws ClassCastException;
- Si la colección contiene elementos nulos y no se permite establecer un valor nulo, se lanza una NullPointerExceptionexcepción.

6. Eliminar elementos

remove(Object obj / int index): Elimina un solo elemento de la colección;
- obj: el elemento que se va a eliminar, si el elemento obj aparece varias veces, elimine el elemento que aparece primero en la matriz;
- índice: el valor de índice del elemento que se va a eliminar;
- Valor de retorno: si el elemento se pasa y la eliminación es exitosa, devuelve verdadero;
  
  Si se pasa el valor del índice, se devuelve el elemento eliminado;
  
  Si el índice especificado está fuera de rango, el método lanza IndexOutOfBoundsExceptionuna excepción.
removeAll(Collection c): Elimina los elementos de matriz dinámica que existen en la colección especificada.
- c-La colección de elementos que se eliminarán en la lista de matriz dinámica;
- Valor de retorno: devuelve verdadero si el elemento se elimina correctamente de la colección;
  
  Si el conjunto de elementos presentes en la clase con el Collectionelemento especificado no es compatible con la clase, se lanza una ClassCastExceptionexcepción;
  
  Si la colección contiene un elemento nulo y el especificado Collectionno permite elementos nulos, lanza NullPointerExceptionuna excepción.

7. Encuentra la intersección

retainAll(Collection c): Mantener ArrayListesos elementos en la colección especificada también está presente.
- parámetros colección-colección;
- Valor de retorno: verdadero si el elemento se elimina de la colección;
  
  Si el conjunto de elementos presentes en el Collectionelemento de clase incompatible especificado se lanza una ClassCastExceptionexcepción;
  
  Si la colección contiene un elemento nulo y el especificado Collectionno permite elementos nulos, se lanza NullPointerException.

8. Determine si el conjunto es igual

eauqls(Collection c): Determina si dos conjuntos son iguales.
- parámetros colección-colección;
- Valor de retorno: devuelve verdadero si los dos conjuntos son iguales.

9. Convierta a una matriz

toArray(T[] arr): Convierte el objeto de colección en una matriz.
- T [] arr (parámetro opcional) -una matriz utilizada para almacenar elementos de matriz;
- Valor de retorno: si el parámetro T [] arr se pasa al método como parámetro, se devolverá una matriz de tipo T;
  
  Si no se pasa ningún parámetro, se devuelve una matriz de tipo de objeto.

10. Obtenga el valor hash del objeto de colección

hashCode(): Devuelve el valor hash de la colección.

11. Recorre la colección

iterator(): Devuelve la Iteratorinstancia de una interfaz, para un conjunto de poligonales.

En segundo lugar, usar `Iterator`la interfaz a través de la colección

En un programa Java, Iterator(iterador) no es una colección, es un método para acceder a una colección.

GoF define los iteradores como: Proporcionar un método para acceder a cada elemento en un objeto contenedor sin exponer los detalles internos del objeto.

1. Métodos comunes de iteradores

next(): Devuelve el siguiente elemento del iterador y actualiza el estado del iterador;
hasNext(): Se utiliza para detectar si hay elementos en el conjunto. Verdadero si lo hay, falso si no;
remove(): Elimina el elemento devuelto por el iterador.

2. Obtén un iterador

Para usar un objeto iterador para recorrer la colección, primero necesita obtener un iterador. Puede llamar a un iterator()método set para obtener un iterador.

// 创建集合
Collection collection = new ArrayList();

// 添加元素
collection.add(123);
collection.add("123");
collection.add(123L);
collection.add('A');

Iterator iterator = collection.iterator();

3. Recorre la colección

El uso de iteraciones sobre la colección es esencialmente una llamada constante al next()método de procedimiento. Cuando los elementos de la colección se hayan atravesado después, esta vez para llamar al next()método arrojará NoSuchElementExceptionun error.

Por lo tanto, la recomendación utiliza el siguiente método para atravesar:

while (iterator.hasNext()) {
    
    
	System.out.println(iterator.next());
}

Tres colecciones de uso común

Las siguientes son las cuatro colecciones que se utilizan con frecuencia en nuestro desarrollo diario:

LinkedList: Esta clase implementa la Listinterfaz y permite elementos nulos (vacíos). Se utiliza principalmente para crear una estructura de datos de lista enlazada. Esta clase no tiene método de sincronización. Si varios subprocesos acceden a uno al mismo tiempo List, debe implementar la sincronización de acceso por su cuenta. La solución es Listconstruir una sincronización al crear List;
ArrayList: Esta clase también es una Listinterfaz implementada , que implementa una matriz de tamaño variable, que proporciona un mejor rendimiento al acceder y atravesar elementos aleatoriamente. Esta clase también es asincrónica y no debe usarse en situaciones de subprocesos múltiples. Su eficacia de inserción y eliminación es baja;
HashSet: Esta clase implementa la Setinterfaz, no permite elementos duplicados, no garantiza el orden de los elementos de la colección y permite contener elementos con valor nulo, pero como máximo uno;
HashMap: HashMapEs una tabla hash y su contenido almacenado es un mapeo clave-valor. Esta clase implementa la Mapinterfaz, HashCodealmacena datos de acuerdo con el valor de la clave y tiene una velocidad de acceso rápida, la clave de un registro puede ser nula como máximo y la sincronización de subprocesos no es compatible.

1. `LinkedList`

Ejemplo

import java.util.LinkedList;

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        LinkedList<String> sites = new LinkedList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);  // [Google, Runoob, Taobao, Weibo]
    }
}

Método común

método	descripción
`public boolean add(E e)`	Agregue un elemento al final de la lista enlazada y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public void add(int index, E element)`	Inserta un elemento en la posición especificada.
`public boolean addAll(Collection c)`	Agregue todos los elementos de un conjunto al final de la lista vinculada y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public boolean addAll(int index, Collection c)`	Agregue todos los elementos de un conjunto a la posición especificada de la lista vinculada y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public void addFirst(E e)`	El elemento se agrega a la cabeza.
`public void addLast(E e)`	El elemento se agrega al final.
`public boolean offer(E e)`	Agregue un elemento al final de la lista vinculada y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public boolean offerFirst(E e)`	Inserte un elemento al principio y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public boolean offerLast(E e)`	Inserte un elemento al final y devuelva si tiene éxito o no. El éxito es verdadero y el fracaso es falso.
`public void clear()`	Limpia la lista vinculada.
`public E removeFirst()`	Elimina y devuelve el primer elemento.
`public E removeLast()`	Elimina y devuelve el último elemento.
`public boolean remove(Object o)`	Elimina un elemento y devuelve si es correcto, si el éxito es verdadero y el error es falso.
`public E remove(int index)`	Elimina el elemento en la posición especificada.
`public E poll()`	Elimina y devuelve el primer elemento.
`public E remove()`	Elimina y devuelve el primer elemento.
`public boolean contains(Object o)`	Determina si contiene un elemento.
`public E get(int index)`	Devuelve el elemento en la posición especificada.
`public E getFirst()`	Devuelve el primer elemento.
`public E getLast()`	Devuelve el último elemento.
`public int indexOf(Object o)`	Encuentre el índice de la primera aparición del elemento especificado desde el frente hacia atrás.
`public int lastIndexOf(Object o)`	Busque el índice de la última aparición del elemento especificado.
`public E peek()`	Devuelve el primer elemento.
`public E element()`	Devuelve el primer elemento.
`public E peekFirst()`	Devuelve el elemento de cabeza.
`public E peekLast()`	Devuelve el elemento de cola.
`public E set(int index, E element)`	Coloca el elemento en la posición especificada.
`public Object clone()`	Clona la lista.
`public Iterator descendingIterator()`	Devuelve el iterador inverso.
`public int size()`	Devuelve el número de elementos de la lista vinculada.
`public ListIterator listIterator(int index)`	Devuelve un iterador desde la posición especificada hasta el final.
`public Object[] toArray()`	Devuelve una matriz de elementos de lista vinculados.
`public T[] toArray(T[] a)`	Devuelve una matriz convertida a partir de elementos de lista vinculados.

2. `ArrayList`

Ejemplo

import java.util.ArrayList;

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        ArrayList<String> sites = new ArrayList<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Weibo");
        System.out.println(sites);  // [Google, Runoob, Taobao, Weibo]
    }
}

Método común

método	descripción
`add()`	El elemento insertado en la posición especificada `ArrayList`en
`addAll()`	添加集合中的所有元素到 `ArrayList`中
`clear()`	删除 `ArrayList`中的所有元素
`clone()`	复制一份 `ArrayList`
`contains()`	判断元素是否在 `ArrayList`
`get()`	通过索引值获取 `ArrayList`中的元素
`indexOf()`	返回 `ArrayList`中元素的索引值
`removeAll()`	删除存在于指定集合中的 `ArrayList`里的所有元素
`remove()`	删除 `ArrayList`里的单个元素
`size()`	返回 `ArrayList`里元素数量
`isEmpty()`	判断 `ArrayList`是否为空
`subList()`	截取部分 `ArrayList`的元素
`set()`	替换 `ArrayList`中指定索引的元素
`sort()`	对 `ArrayList`元素进行排序
`toArray()`	将 `ArrayList`转换为数组
`toString()`	将 `ArrayList`转换为字符串
`ensureCapacity()`	设置指定容量大小的 `ArrayList`
`lastIndexOf()`	返回指定元素在 `ArrayList`中最后一次出现的位置
`retainAll()`	保留 `ArrayList`中在指定集合中也存在的那些元素
`containsAll()`	查看 `ArrayList`是否包含指定集合中的所有元素
`trimToSize()`	将 `ArrayList`中的容量调整为数组中的元素个数
`removeRange()`	删除 `ArrayList`中指定索引之间存在的元素
`replaceAll()`	将给定的操作内容替换掉数组中每一个元素
`removeIf()`	删除所有满足特定条件的 `ArrayList`元素
`forEach()`	遍历 `ArrayList`中每一个元素并执行特定操作

3. `HashSet`

示例

import java.util.HashSet;

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        HashSet<String> sites = new HashSet<String>();
        sites.add("Google");
        sites.add("Runoob");
        sites.add("Taobao");
        sites.add("Zhihu");
        sites.add("Runoob");     // 重复的元素不会被添加
        sites.remove("Taobao");  // 删除元素，删除成功返回 true，否则为 false
        System.out.println(sites);  // [Google, Runoob, Zhihu]
    }
}

常用方法

方法	描述
`add()`	添加元素
`remove()`	删除元素
`clear()`	删除所有元素
`contains()`	是否包含指定元素
`isEmpty()`	判断是否为空
`size()`	获取集合中元素个数

4. `HashMap`

示例

import java.util.HashMap;

public class Demo {
    
    
    public static void main(String[] args) {
    
    
        // 创建 HashMap 对象 Sites
        HashMap<Integer, String> Sites = new HashMap<Integer, String>();
        // 添加键值对
        Sites.put(1, "Google");
        Sites.put(2, "Runoob");
        Sites.put(3, "Taobao");
        Sites.put(4, "Zhihu");
        System.out.println(Sites);  // {1=Google, 2=Runoob, 3=Taobao, 4=Zhihu}
    }
}

常用方法

方法	描述
`clear()`	删除 `HashMap` 中的所有键/值对
clone()	复制一份 `HashMap`
`isEmpty()`	判断 `HashMap`是否为空
`size()`	计算 `HashMap`中键/值对的数量
`put()`	将键/值对添加到 `HashMap`中
`putAll()`	将所有键/值对添加到 `HashMap`中
`putIfAbsent()`	如果 `HashMap`中不存在指定的键，则将指定的键/值对插入到 `HashMap`中。
`remove()`	删除 `HashMap`中指定键 key 的映射关系
`containsKey()`	检查 `HashMap`中是否存在指定的 key 对应的映射关系。
`containsValue()`	检查 `HashMap`中是否存在指定的 value 对应的映射关系。
`replace()`	替换 `HashMap`中是指定的 key 对应的 value。
`replaceAll()`	将 `HashMap`中的所有映射关系替换成给定的函数所执行的结果。
`get()`	获取指定 key 对应对 value
`getOrDefault()`	获取指定 key 对应对 value，如果找不到 key ，则返回设置的默认值
`forEach()`	对 `HashMap`中的每个映射执行指定的操作。
`entrySet()`	返回 `HashMap`中所有映射项的集合集合视图。
`keySet()`	返回 `HashMap`中所有 key 组成的集合视图。
`values()`	返回 `HashMap`中存在的所有 value 值。
`merge()`	添加键值对到 `HashMap`中
`compute()`	对 `HashMap`中指定 key 的值进行重新计算
`computeIfAbsent()`	对 `HashMap`中指定 key 的值进行重新计算，如果不存在这个 key，则添加到 `HashMap`中
`computeIfPresent()`	对 `HashMap`中指定 key 的值进行重新计算，前提是该 key 存在于 `HashMap`中。