Recientemente, me tomé el tiempo para analizar el método Aslist de la clase de herramientas de matrices Java, ordené información relevante en línea y la grabé, ¡con la esperanza de ayudar a los lectores!
La clase de herramientas de matrices proporciona un método ASLIST, que utiliza este método para convertir un parámetro o matriz de longitud variable en una lista.
El código fuente es el siguiente:
/*** Devuelve una lista de tamaño fijo respaldada por la matriz especificada. (Cambia a * La lista devuelta "Escribir" a la matriz). Este método actúa * como puente entre las API basadas en la matriz y las API basadas en la colección, en * combinación con {@link Collection#ToArray}. La lista devuelta es * serializable e implementa {@link randomAccess}. * * <p> Este método también proporciona una forma conveniente de crear una lista de tamaño fijo * inicializado para contener varios elementos: * <pre> * list <String> stands = arrays.aslist ("Larry", "Moe", "Curly"); * </pre> * * @param a la matriz por la cual se respalda la lista * @return una vista de lista de la matriz especificada */ @safevarargs public static <t> list <t> aslist (t ... a) {return new ArrayList <> (a); }Descubrimiento de problemas
Según la descripción del método anterior, primero escribamos algunos ejemplos:
/***@author wangmengjun**/public class ArrayExample {public static void main (string [] args) {/** Use parámetros de longitud variable*/list <tring> array1 = arrays.aslist ("bienvenido", "a", "java", "mundo"); System.out.println (Array1); / ** Use Array*/ List <String> Array2 = Arrays.aslist (nueva cadena [] {"Bienvenido", "a", "Java", "Mundo"}); System.out.println (Array2); }}Ejecute el programa anterior y genere el siguiente contenido.
[Bienvenido, a, Java, mundo]
[Bienvenido, a, Java, mundo]
Por capricho, de repente quería agregar una cadena "Cool ~~~" a la lista creada y ir una.
/ ** Use parámetros de longitud variable*/ list <string> array1 = arrays.aslist ("bienvenido", "a", "java", "mundo"); array1.add ("cool ~~~");Como resultado, se encontró una Excepción de Operación no apoyada:
Excepción en el hilo "principal" java.lang.unsupportedoperationException en java.util.abstractList.add (fuente desconocida) en java.util.abstractList.add (fuente desconocida) en test.arrayExample.main (arrayexample.Java:36)
Increíblemente, la lista generada por New ArrayList <> (a) realmente encontró un problema.
Búsqueda de razón
Entonces la pregunta es, ¿qué pasó exactamente? Con preguntas, verifique cómo se usa la ArrayList en matrices.
Resulta que la clase ArrayList utilizada por el método de matrices Aslist es una clase definida internamente, no la clase java.util.arrayList.
El código fuente es el siguiente:
/ ** * @Serial incluye */ private static class arrayList <E> extiende AbstractList <E> implementa RandomAccess, java.io.serializable {private static final long serialversionUid = -2764017481108945198L; Final privado E [] a; ArrayList (E [] Array) {if (Array == NULL) Throw New NullPoInterException (); a = matriz; } public int size () {return A.Length; } objeto público [] toArray () {return a.clone (); } public <t> t [] ToArray (t [] a) {int size = size (); if (a.length <size) return arrays.copyOf (this.a, tamaño, (clase <? extiende t []>) a.getClass ()); System.ArrayCopy (this.A, 0, a, 0, tamaño); if (a.length> size) a [size] = null; regresar a; } public e get (int index) {return a [index]; } public e set (int index, e elemento) {e oldValue = a [index]; a [índice] = elemento; devolver OldValue; } public int indexOf (objeto o) {if (o == null) {for (int i = 0; i <a.length; i ++) if (a [i] == null) return i; } else {para (int i = 0; i <a.length; i ++) if (o.equals (a [i])) return i; } return -1; } public boolean contiene (objeto o) {return indexOf (o)! = -1; }}A partir de la implementación de esta ArrayList interna de clase, se puede ver que hereda la clase abstracta java.util.abstractList <E>, pero los métodos de agregar y eliminar no se anulan, y la implementación específica no se da.
Sin embargo, de forma predeterminada, la clase java.util.abstractList lanzará directamente una Operación no compatible con los métodos Agregar, establecer y eliminar. Algunos de los códigos fuente de AbstractList son los siguientes:
Public Abstract Class AbstractList <E> extiende AbstractCollection <E> Lista de implementos <E> { /*** Constructor único. (Para la invocación por constructores de subclase, típicamente * implícito.) */ Protegido abstractList () {} public e set (int index, e element) {tire nuevo no comportadoperationException (); } /** * {@inheritdoc} * * <p> Esta implementación siempre arroja un * {@code UnsupportedOperationException}. * * @throws unsupportedOperationException {@inheritdoc} * @throws classCastException {@inheritdoc} * @throws nullPointerException {@inheritDoc} * @throws ilegalArGumentException {@inheritDoc} * @throws indexOutOfBoundSeCe elemento) {lanzar nueva UnpportedOperationException (); } /** * {@inheritdoc} * * <p> Esta implementación siempre arroja un * {@code UnsupportedOperationException}. * * @throws UnsupportedOperationException {@inheritdoc} * @throws indexOutofBoundsexception {@inheritdoc} */ public e remo }}Se debe precisamente a que la clase de matriz de clase interna de Java.Util.Arrays, la clase no anula los métodos Agregar y eliminar, por lo que cuando llamamos su método ADD, en realidad llamamos el método Agregar de la clase Abstract List, y el resultado es que la Excepción de Operación no respaldada se lanza directamente.
Del mismo modo, al llamar al método de eliminación, o llamar a otros métodos asociados con los métodos Agregar y eliminar (como Addall), también encontrará la excepción de OperationException no compatible.
Ejemplo de addall:
/***@author wangmengjun**/public class ArrayExample {public static void main (string [] args) {/** Use parámetros de longitud variable*/list <tring> array1 = arrays.aslist ("bienvenido", "a", "java", "mundo"); array1.addall (arrays.aslist ("aaa", "bbb")); }}Excepción en el hilo "principal" java.lang.unsupportedOperationException en java.util.abstractList.add (fuente desconocida) en java.util.abstractList.add (fuente desconocida) en java.util.abstractCollection.addall (fuente desconocida) en test.arrayaxample.main (arrayaxample:36)
Ejemplo de conjunto:
/***@author wangmengjun**/public class ArrayExample {public static void main (string [] args) {/** Use parámetros de longitud variable*/list <tring> array1 = arrays.aslist ("bienvenido", "a", "java", "mundo"); System.out.println (Array1); // reemplazar java con hello array1.set (2, "hola"); System.out.println (Array1); }}Se debe precisamente a que la lista de matrices interna de Matrays reescribe el método establecido, por lo que el programa anterior puede ejecutarse normalmente y no lanzará una excepción de OperationException sin apoyo.
Los resultados son los siguientes:
[Bienvenido, a, Java, mundo]
[Bienvenido, a, hola, mundo]
Use escenarios
A juzgar por los ejemplos anteriores y el análisis simple, la clase de herramientas de matrices proporciona un método Aslist, que puede convertir un parámetro o matriz de longitud variable en una lista.
Sin embargo, la longitud de la lista generada es fija; Puede realizar operaciones de modificación (como modificar elementos en una determinada posición); No puede realizar operaciones que afecten la longitud (como agregar, eliminar, etc.). Se lanzará una excepción no compatible de OperationException.
Arrays.aslist es más adecuado para escenarios en los que ya hay datos de matriz o algunos elementos, pero es necesario construir rápidamente una lista, que solo se usa para operaciones de lectura, y no realiza operaciones ADD o eliminación.
Si desea obtener rápidamente una lista de listas que se pueden agregar, eliminar, modificar y verificar según los datos de la matriz conocidos, es el siguiente método relativamente simple:
Reutilice java.util.ArrayList para envolver una capa.
/***@author wangmengjun**/public class ArrayExample {public static void main (string [] args) {/** Use parámetros de longitud variable*/list <String> array1 = new ArrayList <> (arrays.aslist ("bienvenida", "," java "," world ")); System.out.println (Array1); array1.add ("cool ~~~"); System.out.println (Array1); }}Los resultados son los siguientes:
[Bienvenido, a, Java, mundo]
[Bienvenido, a, Java, mundo, genial ~~~]
Gracias por leer, espero que pueda ayudarte. ¡Gracias por su apoyo para este sitio!