Récemment, j'ai pris le temps d'analyser la méthode ASList de la classe d'outils Java Arrays, de régler les informations pertinentes en ligne et de les enregistrer, dans l'espoir d'aider les lecteurs!
La classe d'outils Arrays fournit une méthode ASSList, qui utilise cette méthode pour convertir un paramètre ou un tableau de longueur variable en une liste.
Le code source est le suivant:
/ ** * Renvoie une liste de taille fixe soutenue par le tableau spécifié. (Modifie * la liste renvoyée "Écrire" dans le tableau.) Cette méthode agit * comme un pont entre les API basé sur le tableau et basé sur la collection, en * combinaison avec {@Link Collection # TOArray}. La liste renvoyée est * sérialisable et implémente {@Link RandomAccess}. * * <p> Cette méthode fournit également un moyen pratique de créer une liste de taille fixe * initialisée pour contenir plusieurs éléments: * <pre> * liste <string> stands = arrays.aslist ("larry", "moe", "curly"); * </ pre> * * @param a le tableau par lequel la liste sera soutenue * @return une vue de liste du tableau spécifié * / @safevarargs public static <T> list <T> aslist (t ... a) {return New ArrayList <> (a); }Découverte de problèmes
Sur la base de la description de la méthode ci-dessus, écrivons d'abord quelques exemples:
/ ** * @author wangMengjun * * / public class arrayExample {public static void main (String [] args) {/ ** Utiliser des paramètres de longueur variable * / list <string> array1 = arrays.aslist ("bienvenue", "to", "java", "world"); System.out.println (array1); / ** Utilisez Array * / list <string> array2 = arrays.aslist (new String [] {"bienvenue", "à", "java", "world"}); System.out.println (Array2); }}Exécutez le programme ci-dessus et sortez le contenu suivant.
[Bienvenue, à, java, monde]
[Bienvenue, à, java, monde]
Sur un coup de tête, je voulais soudain ajouter une chaîne "cool ~~~" à la liste créée et en faire une.
/ ** Utilisez des paramètres de longueur variable * / list <string> array1 = arrays.aslist ("bienvenue", "à", "java", "monde"); array1.add ("cool ~~~");En conséquence, une conception non soutenue de l'Opération a été rencontrée:
Exception dans Thread "Main" java.lang.unsupportedOperationException à java.util.abstractList.add (source inconnue) sur java.util.abstractList.add (source inconnue) sur test.arrayexample.main (arrayexample.java:36)
Incroyablement, la liste générée par New ArrayList <> (a) a en fait rencontré un problème.
Recherche de raisons
La question est donc: que s'est-il passé exactement? Avec des questions, vérifiez à quoi ressemble la liste des arrays.
Il s'avère que la classe ArrayList utilisée par la méthode ASList de Arrays est une classe définie en interne, pas la classe java.util.arraylist.
Le code source est le suivant:
/ ** * @Serial Inclure * / classe statique privée ArrayList <e> étend AbstractList <e> implémente RandomAccess, java.io.serializable {private static final SerialVersionUID = -2764017481108945198l; final privé e [] a; ArrayList (e [] array) {if (array == null) lance un nouveau nullpointerException (); a = tableau; } public int size () {return a.Length; } objet public [] toArray () {return a.clone (); } public <T> t [] toArray (t [] a) {int size = size (); if (a.Length <size) return arrays.copyof (this.a, size, (classe <? étend t []>) a.getClass ()); System.ArrayCopy (this.a, 0, a, 0, taille); if (a.length> taille) a [size] = null; retourner a; } public e get (int index) {return a [index]; } public e set (int index, e élément) {e oldvalue = a [index]; a [index] = élément; Retour OldValue; } public int indexof (objet o) {if (o == null) {for (int i = 0; i <a.length; i ++) if (a [i] == null) return i; } else {for (int i = 0; i <a.Length; i ++) if (o.equals (a [i])) return i; } return -1; } public boolean contient (objet o) {return indexof (o)! = -1; }}D'après la mise en œuvre de cette classe de classe interne, on peut voir qu'il hérite de la classe abstraite java.util.abstractList <e>, mais les méthodes ADD et Supprimer ne sont pas remplacées et l'implémentation spécifique n'est pas donnée.
Cependant, par défaut, la classe java.util.abstractList lancera directement une conception non soutenue deOperation dans les méthodes ADD, définit et supprimera. Certains des codes source d'AbstractList sont les suivants:
classe abstrait publique AbstractList <E> étend AbstractCollection <e> implémente List <e> {/ ** * Constructeur unique. (Pour l'invocation par les constructeurs de sous-classe, généralement * implicite.) * / AbstractList protégé () {} public e set (int index, e élément) {throw new UnsupportedOperationException (); } / ** * {@InheritDoc} * * <p> Cette implémentation lance toujours un * {@code UnporttedOperationException}. * * @Throws UnsupportedOperationException {@InheRitDoc} * @throws classcastException {@InheRitDoc} * @throws nullpointerException {@InheRitDoc} * @throws illégalArgumentException {@inheritDoc} * @throws indexoutofboundsexception {@inheritdoc} * / public indexoutofboundsexception {@inheritdoc} * / public indexoutofboundsexception {@inheritdoc} * / public indexe élément) {lancez un nouveau non soutenues OperationException (); } / ** * {@InheritDoc} * * <p> Cette implémentation lance toujours un * {@code UnporttedOperationException}. * * @Throws UnsupportedOperationException {@InheRitDoc} * @throws indexoutofboundSException {@InheRitDoc} * / public e remove (int index) {Throw New UnsupportEdOperException (); }}C'est précisément parce que la classe de classe intérieure de la classe Java.util.array ne remplace pas les méthodes ADD et supprimez, donc lorsque nous appelons sa méthode ADD, nous appelons réellement la méthode ADD de la classe AbstractList, et le résultat est que la conception non soutenue de laOperation est directement lancée.
De même, lorsque vous appelez la méthode de suppression ou appelez d'autres méthodes associées aux méthodes ADD et supprimez (telles que Addall), vous rencontrerez également l'exception non soutenue de l'Exception.
Exemple d'addall:
/ ** * @author wangMengjun * * / public class arrayExample {public static void main (String [] args) {/ ** Utiliser des paramètres de longueur variable * / list <string> array1 = arrays.aslist ("bienvenue", "to", "java", "world"); array1.addall (arrays.aslist ("aaa", "bbb")); }}Exception dans Thread "Main" java.lang.unsupportedOperationException sur java.util.abstractList.add (source inconnue) sur java.util.abstractList.add (source inconnue) sur java.util.abstralisexample.java:36) à Test.ArayExample.Main (ArrayExample.Java:36) à Test.ArrayExample.Main (ArrayExample.Java:36)
Exemple de jeu:
/ ** * @author wangMengjun * * / public class arrayExample {public static void main (String [] args) {/ ** Utiliser des paramètres de longueur variable * / list <string> array1 = arrays.aslist ("bienvenue", "to", "java", "world"); System.out.println (array1); // remplacer Java par Hello Array1.set (2, "Hello"); System.out.println (array1); }}C'est précisément parce que l'arrayList de classe interne de Arrays réécrit la méthode SET, de sorte que le programme ci-dessus peut s'exécuter normalement et ne lancera pas une exception non soutenue d'Exception.
Les résultats sont les suivants:
[Bienvenue, à, java, monde]
[Bienvenue, à, bonjour, monde]
Utiliser des scénarios
À en juger par les exemples ci-dessus et une analyse simple, la classe d'outils des tableaux fournit une méthode aslist, qui peut convertir un paramètre ou un tableau de longueur variable en liste.
Cependant, la longueur de la liste générée est fixe; Il peut effectuer des opérations de modification (telles que la modification des éléments à une certaine position); Il ne peut pas effectuer d'opérations qui affectent la longueur (comme l'ajout, la suppression, etc.). Une exception non soutenue d'Exception de l'Opération sera lancée.
Arrays.aslist convient plus aux scénarios où il y a déjà des données de tableau ou certains éléments, mais il est nécessaire de créer rapidement une liste, qui n'est utilisé que pour les opérations de lecture, et n'effectue pas d'opérations ADD ou de suppression.
Si vous souhaitez obtenir rapidement une liste de listes qui peuvent être ajoutées, supprimées, modifiées et vérifiées en fonction des données de tableau connues, une méthode relativement simple est la suivante:
Réutilisez java.util.arraylist pour envelopper une couche.
/ ** * @author wangMengjun * * / public class arrayExample {public static void main (String [] args) {/ ** Utiliser des paramètres de longueur variable * / list <string> array1 = new ArrayList <> (arrays.aslist ("bienvenue", "to", "java", "world")); System.out.println (array1); array1.add ("cool ~~~"); System.out.println (array1); }}Les résultats sont les suivants:
[Bienvenue, à, java, monde]
[Bienvenue, à, java, monde, cool ~~~]
Merci d'avoir lu, j'espère que cela peut vous aider. Merci pour votre soutien à ce site!