Im eigentlichen Entwicklungsprozess verwenden wir oft asList, um Arrays in Listen umzuwandeln. Diese Methode ist sehr praktisch, aber die asList-Methode weist mehrere Mängel auf:

1. Vermeiden Sie die Verwendung von Basisdatentyp-Arrays in einer Liste

Beim Konvertieren von 8 Basistyp-Arrays in eine Liste tritt ein geschmackvollerer Fehler auf. Schauen wir uns zunächst das folgende Programm an:

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

                                                                                                                                                 Das Programm ist nicht wie erwartet ein unerwartetes 1. Was ist los? Schauen wir uns zunächst den Quellcode an:

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

Der von asList akzeptierte Parameter ist eine generische Variable -length-Parameter. Wir wissen, dass grundlegende Datentypen nicht gestylt werden können, was bedeutet, dass die 8 Basistypen nicht als Parameter von asList verwendet werden können. Wenn sie als generische Parameter verwendet werden sollen, müssen ihre entsprechenden Verpackungstypen verwendet werden. Aber warum gibt es in diesem Fall keinen Fehler? Da diese Instanz ein Array vom Typ int als Parameter verwendet und ein Array in Java ein Objekt ist, kann es generisch werden. Daher wird dieses Beispiel keine Fehler erzeugen. Da das Beispiel das gesamte Array vom Typ int als generischen Parameter verwendet, gibt es nach der asList-Konvertierung nur eine int-Liste. Wie folgt:

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

Aus diesem Operationsergebnis können wir vollständig beweisen, dass die Elemente in der list sind int-Arrays. Sobald Sie dies verstanden haben, ist die Änderungsmethode auf einen Blick klar: Ändern Sie int in 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

> Verwenden Sie bei Verwendung von asList keine grundlegenden Datentypen als Parameter.

2. Die von asList generierte Liste ist nicht bedienbar

Wir werden eine weitere kleine Änderung am obigen Beispiel vornehmen:

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

In diesem Beispiel geht es darum, Ints über asList in eine Listenkategorie umzuwandeln und dann über asList eine hinzuzufügen Fügen Sie das Methodenelement hinzu. Dieses Beispiel könnte nicht einfacher sein, aber was ist mit den laufenden Ergebnissen? Geben Sie ein, was wir erwartet haben:

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)

Das laufende Ergebnis löst eine UnsupportedOperationException-Ausnahme aus, die die Liste darstellt Die Add-Methode wird nicht unterstützt. Das macht uns deprimiert. Wie konnte die Liste die Add-Methode nicht unterstützen? Ist das Gehirn von JDK blockiert? Schauen wir uns den Quellcode von asList an:

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

Nachdem asList die Parameter akzeptiert hat, wird es direkt Erstellt eine neue ArrayList. Hier sollten keine Fehler auftreten, oder? Keine Sorge, lesen Sie weiter:

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;
        }
        //.................
    }

Dies ist der Quellcode von ArrayList, von Hier sehen wir, dass diese ArrayList nicht java.util.ArrayList ist, sondern eine interne Klasse von Arrays. Diese interne Klasse stellt Größe, toArray, get, set, indexOf bereit und enthält Methoden, und Methoden wie add und remove, die die Listenergebnisse ändern, werden von der übergeordneten Klasse AbstractList geerbt. Gleichzeitig sind diese Methoden auch ziemlich seltsam. Es löst direkt eine UnsupportedOperationException-Ausnahme aus:

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();
    }

                              , es verfügt nicht über die grundlegenden Eigenschaften einer Liste (Variable). Länge). Die Liste ist eine Liste unveränderlicher Länge. Die zurückgegebene Liste kann nur so lang sein wie das übergebene Parameterarray. Also:

>

Das Obige ist der Inhalt von Java Improvement Chapter (36) -----Java Collection Details (2): Defekte von asList Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (m.sbmmt.com)!