Comparación de las ventajas y desventajas de tres métodos de conversión de matrices a List en Java

Prefacio

Este artículo presenta la comparación de los pros y los contras de los tres casos de conversión de una matriz a una lista en Java, así como la comparación de escenarios de aplicación y el análisis de las causas de los errores de conversión de tipos que los programadores suelen cometer.

1. La forma más común (no necesariamente la mejor) es a
través de la forma Arrays.asList (strArray), después de que la matriz se convierte a la Lista, la Lista no se puede agregar ni eliminar, pero la lista solo se puede verificar y cambiar, de lo contrario, se lanzará una excepción.

Código clave: List list = Arrays.asList (strArray);

private void testArrayCastToListError() {
    
    
		String[] strArray = new String[2];
		List list = Arrays.asList(strArray);
		//对转换后的list插入一条数据
		list.add("1");
		System.out.println(list);
	}

Resultados de:

Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractList.add(AbstractList.java:148)
	at java.util.AbstractList.add(AbstractList.java:108)
	at com.darwin.junit.Calculator.testArrayCastToList(Calculator.java:19)
	at com.darwin.junit.Calculator.main(Calculator.java:44)

Análisis de motivos: el valor de retorno de Arrays.asList (strArray) es una clase interna estática privada java.util.Arrays.ArrayList en la clase java.util.Arrays, que no es la clase java.util.ArrayList. La clase java.util.Arrays.ArrayList tiene set (), get (), contains () y otros métodos, pero no tiene el método add () o remove (), por lo que llamar al método add () reportará un error.

Escenario de uso: el método Arrays.asList (strArray) solo se puede usar después de que el arreglo se convierta en una Lista. No es necesario agregar o eliminar los valores en él. Solo se usa como fuente de datos para la lectura.

2. Una vez que la matriz se convierte en una lista, se admite el método de agregar, eliminar, modificar y verificar

A través del constructor ArrayList, el valor de retorno de Arrays.asList (strArray) se convierte de java.util.Arrays.ArrayList a java.util.ArrayList.

关键 代码 ： ArrayList list = new ArrayList (Arrays.asList (strArray));

private void testArrayCastToListRight() {
    
    
		String[] strArray = new String[2];
		ArrayList<String> list = new ArrayList<String>(Arrays.asList(strArray)) ;
		list.add("1");
		System.out.println(list);
	}

Resultado de la ejecución: se agregó correctamente un elemento "1".

[null, null, 1]

Escenario de uso: debe agregar, eliminar, modificar y verificar la Lista después de convertir la matriz en una Lista. Se puede usar cuando la cantidad de datos en la Lista no es grande.

Tres. A través de la clase de herramienta de recolección, el método Collections.addAll () (el más eficiente)

A través del método collections.addAll (arrayList, strArray), cree una Lista de la misma longitud de acuerdo con la longitud de la matriz, y luego use el método Collections.addAll () para convertir los elementos en la matriz a binario, y luego agregue a la Lista. Este es el método más eficiente.

Clave:

ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
Collections.addAll(arrayList, strArray);

prueba:

private void testArrayCastToListEfficient(){
    
    
		String[] strArray = new String[2];
		ArrayList< String> arrayList = new ArrayList<String>(strArray.length);
		Collections.addAll(arrayList, strArray);
		arrayList.add("1");
		System.out.println(arrayList);
	}

Resultado de la ejecución: también se agregó correctamente un elemento "1".

[null, null, 1]

Escenario de uso: debe agregar, eliminar, modificar y verificar la Lista después de convertir la matriz en una Lista. Cuando la cantidad de datos en la Lista es enorme, utilícela primero para mejorar la velocidad de operación.

Nota: Se adjunta el código fuente del método Collections.addAll ():

public static <T> boolean addAll(Collection<? super T> c, T... elements) {
    
    
        boolean result = false;
        for (T element : elements)
            result |= c.add(element);//result和c.add(element)按位或运算,然后赋值给result
        return result;
    }

Cuatro. Java8 puede convertir 3 tipos básicos de matrices en List through stream

Si la versión de JDK es superior a 1.8, puede utilizar la secuencia para convertir rápidamente los siguientes tres tipos de matrices en List, que son int [], long [], double [] y otros tipos de datos como short [], byte [ ], char [], actualmente no es compatible con JDK1.8. Dado que esto es solo una encapsulación de un método común, ya no se incluye una nueva forma de conversión de matriz a lista. Por el momento, es un método de herramienta común que Java nos transmite.

El ejemplo del código de conversión es el siguiente:

List<Integer> intList= Arrays.stream(new int[] {
    
     1, 2, 3, }).boxed().collect(Collectors.toList());
List<Long> longList= Arrays.stream(new long[] {
    
     1, 2, 3 }).boxed().collect(Collectors.toList());
List<Double> doubleList= Arrays.stream(new double[] {
    
     1, 2, 3 }).boxed().collect(Collectors.toList());

Si es una matriz de String o tipo de referencia (Integer u objeto, etc.), también puede usar Stream para convertir de esta manera:

String[] arrays = {
    
    "tom", "jack", "kate"};
List<String> stringList= Stream.of(arrays).collect(Collectors.toList());

adicional

Al declarar una matriz, use int [] o Integer [], ¿qué forma de declaración se puede convertir a List correctamente?

Respuesta: Solo puede usar Integer [] para convertir a List, es decir, solo puede usar el tipo de empaquetado del tipo de datos básico para convertir directamente a List.

Las razones son las siguientes:

Veamos la definición de Lista en el código fuente de Java (no tema no entender el código fuente, es fácil de entender según mi análisis):

La lista de interfaz pública extiende la colección {omitido ...}
Mire la definición de Arrays.asList () en el código fuente de Java:

 public static <T> List<T> asList(T... a) {
    
    
        return new ArrayList<>(a);
    }

Como se puede ver en el código fuente anterior, cuando se declara List, se debe pasar un tipo genérico como parámetro formal, y el tipo de parámetro asList () también es un tipo comodín en genéricos. Todos los tipos genéricos en Java deben ser tipos de referencia.

¿Qué es un tipo de referencia? Integer es un tipo de referencia, ¿qué tipo es int? Int es un tipo de datos básico, no un tipo de referencia. Es por eso que no hay List en java, solo List.

Deduzca otras cosas: los otros ocho tipos de datos básicos byte, short, int, long, float, double y char no son tipos de referencia, por lo que ninguno de los ocho tipos de datos básicos puede usarse como parámetros formales de List. Sin embargo, String, array, class e interfaz son tipos de referencia, que pueden usarse como parámetros formales de List, por lo que hay una colección de tipos de interfaz List, una colección de tipos de array List <int []> y una colección de clases de lista. Pero no hay tipos básicos de colecciones como listas y listas.

Con el conocimiento básico anterior, veamos por qué la segunda línea de las siguientes dos líneas de código puede compilarse y pasar, pero la tercera línea compila un error.

int[] intArray1 = new int[1]; 
Arrays.asList(intArray1);//编译不报错
List<Integer> list1 = Arrays.asList( intArray1);//编译报错

responder:

En la segunda línea de código, el parámetro de entrada del método Arrays.asList () es un tipo de referencia int [], luego el tipo de valor de retorno debe ser List <int []>, y el código completo es: List <int [ ]> intsArray = Arrays. asList (intArray1) ;, por lo que la compilación pasa, no hay problema.

La tercera línea reporta un error, porque los tipos en ambos lados del signo igual son inconsistentes, a la izquierda: List, a la derecha List <int []>, por lo que se reporta un error en tiempo de compilación.