Dans le processus de développement actuel, nous utilisons souvent asList pour convertir des tableaux en listes. Cette méthode est très pratique à utiliser, mais la méthode asList présente plusieurs défauts :

. 1. Évitez d'utiliser des tableaux de types de données de base dans une liste

Lors de la conversion de 8 tableaux de types de base en une liste, il y aura un défaut plus savoureux. Regardons d'abord le programme suivant :

public static void main(String[] args) {
        int[] ints = {1,2,3,4,5};
        List list = Arrays.asList(ints);
        System.out.println("list'size：" + list.size());
    }
    ------------------------------------
    outPut：
    list'size：1

                                                                                                                                                                                     5 est un 1 inattendu. Que se passe-t-il ? Regardons d'abord le code source :

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

Le paramètre accepté par asList est une variable générique Paramètre -length. Nous savons que les types de données de base ne peuvent pas être stylisés, ce qui signifie que les 8 types de base ne peuvent pas être utilisés comme paramètres d'asList. S'ils veulent être utilisés comme paramètres génériques, leurs types d'empaquetage correspondants doivent être utilisés. Mais pourquoi rien ne s’est mal passé dans ce cas-ci ? Étant donné que cette instance utilise un tableau de type int comme paramètre et qu'un tableau est un objet en Java, il peut être générique. Cet exemple ne produira donc pas d’erreurs. Étant donné que l'exemple utilise l'intégralité du tableau de type int comme paramètre générique, il n'y aura qu'une seule liste int après la conversion asList. Comme suit :

public static void main(String[] args) {
    int[] ints = {1,2,3,4,5};
    List list = Arrays.asList(ints);
    System.out.println("list 的类型:" + list.get(0).getClass());
    System.out.println("list.get(0) == ints：" + list.get(0).equals(ints));
}
--------------------------------------------
outPut:
list 的类型:class [I
list.get(0) == ints：true

À partir de ce résultat courant, nous pouvons pleinement prouver que les éléments de la liste sont des tableaux int. Une fois que vous aurez compris cela, la méthode de modification sera claire en un coup d'œil : changez int en Integer.

public static void main(String[] args) {
        Integer[] ints = {1,2,3,4,5};
        List list = Arrays.asList(ints);
        System.out.println("list'size：" + list.size());
        System.out.println("list.get(0) 的类型:" + list.get(0).getClass());
        System.out.println("list.get(0) == ints[0]：" + list.get(0).equals(ints[0]));
    }
    ----------------------------------------
    outPut:
    list'size：5
    list.get(0) 的类型:class java.lang.Integer
    list.get(0) == ints[0]：true

> N'utilisez pas de types de données de base comme paramètres lors de l'utilisation d'asList.

2. La liste générée par asList n'est pas exploitable

Nous allons apporter une autre petite modification à l'exemple ci-dessus :

public static void main(String[] args) {
        Integer[] ints = {1,2,3,4,5};
        List list = Arrays.asList(ints);
        list.add(6);
    }

Cet exemple consiste à convertir des ints en une catégorie de liste via asList, puis à en ajouter un via le add method Element, cet exemple ne pourrait pas être plus simple, mais qu'en est-il des résultats en cours d'exécution ? En tapant ce à quoi nous nous attendions :

Exception in thread "main" java.lang.UnsupportedOperationException
    at java.util.AbstractList.add(Unknown Source)
    at java.util.AbstractList.add(Unknown Source)
    at com.chenssy.test.arrayList.AsListTest.main(AsListTest.java:10)

Le résultat en cours d'exécution lève une exception UnsupportedOperationException, qui représente la liste La méthode add n'est pas prise en charge. Cela nous déprime. Comment la liste pourrait-elle ne pas prendre en charge la méthode add ? Le cerveau de jdk est-il bloqué ? Regardons le code source d'asList :

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

Après que asList ait accepté les paramètres, il directement crée une nouvelle ArrayList Il ne devrait y avoir aucune erreur ici, n'est-ce pas ? Ne vous inquiétez pas, lisez la suite :

private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, java.io.Serializable{
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

        ArrayList(E[] array) {
            if (array==null)
                throw new NullPointerException();
            a = array;
        }
        //.................
    }

Voici le code source d'ArrayList, de ici, on peut voir que cet ArrayList n'est pas java.util.ArrayList, c'est une classe interne de Arrays. Cette classe interne fournit size, toArray, get, set, indexOf et contient des méthodes, et des méthodes telles que add et delete qui modifient les résultats de la liste sont héritées de la classe parent AbstractList. En même temps, ces méthodes sont également assez étranges. Il lève directement une exception UnsupportedOperationException :

public boolean add(E e) {
        add(size(), e);
        return true;
    }
    
    public E set(int index, E element) {
        throw new UnsupportedOperationException();
    }
    
    public void add(int index, E element) {
        throw new UnsupportedOperationException();
    }
    
    public E remove(int index) {
        throw new UnsupportedOperationException();
    }

                                                        manteau, il ne possède pas les caractéristiques de base de liste (variable longueur). La liste est une liste de longueur immuable. La liste renvoyée ne peut être aussi longue que le tableau de paramètres transmis. Alors :

>