Detaillierte Erläuterung der Java-Quellcode-Analyse der Arrays.asList-Methode

Vor Kurzem habe ich mir die Zeit genommen, den Quellcode der asList-Methode der Java-Arrays-Tool-Klasse zu analysieren. Ich hoffe, dass er auch den Lesern helfen kann.

Die Arrays-Toolklasse stellt eine Methode asList bereit, mit der ein Parameter oder Array variabler Länge in eine Liste konvertiert werden kann.

Der Quellcode lautet wie folgt:

/**
 * Returns a fixed-size list backed by the specified array. (Changes to
 * the returned list "write through" to the array.) This method acts
 * as bridge between array-based and collection-based APIs, in
 * combination with {@link Collection#toArray}. The returned list is
 * serializable and implements {@link RandomAccess}.
 *
 * <p>This method also provides a convenient way to create a fixed-size
 * list initialized to contain several elements:
 * <pre class="brush:php;toolbar:false">
 *  List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
 * 

* * @param a the array by which the list will be backed * @return a list view of the specified array */ @SafeVarargs public static List asList(T... a) { return new ArrayList<>(a); }

Nach dem Login kopieren

Problemerkennung

Entsprechend der Beschreibung der obigen Methode schreiben wir zunächst einige Beispiele:

/**
 * @author wangmengjun
 *
 */
public class ArrayExample {
  
 public static void main(String[] args) {
   
  /**使用变长参数*/
  List<String> array1 = Arrays.asList("Welcome", "to","Java", "world");
  System.out.println(array1);
   
  /**使用数组*/
  List<String> array2 = Arrays.asList(new String[] {"Welcome", "to","Java", "world"});
  System.out.println(array2);
 }
 
}

Führen Sie das obige Programm aus und geben Sie den folgenden Inhalt aus.

[Willkommen, in, Java, Welt]
[Willkommen, in, Java, Welt]

Aus einer Laune heraus möchte ich plötzlich eine Zeichenfolge zum erstellten hinzufügen Liste" Cool~~~", Gehen Sie eins.

/**使用变长参数*/
 List<String> array1 = Arrays.asList("Welcome", "to","Java", "world");
 array1.add("Cool~~~");

Als Ergebnis ist eine UnsupportedOperationException aufgetreten:

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.AbstractList.add(Unknown Source)
 at java.util.AbstractList.add(Unknown Source)
 at test.ArrayExample.main(ArrayExample.java:36)

Unglaublicherweise wird die von new ArrayList<>(a) generierte Liste als add bezeichnet Methode, und es stellte sich heraus, dass ein Problem aufgetreten ist.

Ursachensuche

Dann ist die Frage, was ist passiert? Schauen wir uns mit Rücksicht auf Fragen an, wie die in Arrays.asList verwendete ArrayList aussieht.

Es stellt sich heraus, dass die ArrayList-Klasse, die von der asList-Methode von Arrays verwendet wird, eine intern definierte Klasse ist, nicht die Klasse java.util.ArrayList.

Der Quellcode lautet wie folgt:

/**
  * @serial include
  */
 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;
   }
 
   public int size() {
     return a.length;
   }
 
   public Object[] toArray() {
     return a.clone();
   }
 
   public <T> T[] toArray(T[] a) {
     int size = size();
     if (a.length < size)
       return Arrays.copyOf(this.a, size,
                  (Class<? extends T[]>) a.getClass());
     System.arraycopy(this.a, 0, a, 0, size);
     if (a.length > size)
       a[size] = null;
     return a;
   }
 
   public E get(int index) {
     return a[index];
   }
 
   public E set(int index, E element) {
     E oldValue = a[index];
     a[index] = element;
     return oldValue;
   }
 
   public int indexOf(Object 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 contains(Object o) {
     return indexOf(o) != -1;
   }
 }

Wie aus der Implementierung dieser internen Klasse ArrayList ersichtlich ist, erbt sie die abstrakte Klasse Java. util.AbstractList, aber die Methoden zum Hinzufügen und Entfernen werden nicht überschrieben und es wird keine spezifische Implementierung angegeben.

Standardmäßig löst die Klasse java.util.AbstractList jedoch direkt UnsupportedOperationException in den Methoden add, set und remove aus. Ein Teil des Quellcodes von AbstractList lautet wie folgt:

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
  /**
   * Sole constructor. (For invocation by subclass constructors, typically
   * implicit.)
   */
  protected AbstractList() {
  }
 
  public E set(int index, E element) {
    throw new UnsupportedOperationException();
  }
 
  /**
   * {@inheritDoc}
   *
   * <p>This implementation always throws an
   * {@code UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws ClassCastException      {@inheritDoc}
   * @throws NullPointerException     {@inheritDoc}
   * @throws IllegalArgumentException   {@inheritDoc}
   * @throws IndexOutOfBoundsException   {@inheritDoc}
   */
  public void add(int index, E element) {
    throw new UnsupportedOperationException();
  }
 
  /**
   * {@inheritDoc}
   *
   * <p>This implementation always throws an
   * {@code UnsupportedOperationException}.
   *
   * @throws UnsupportedOperationException {@inheritDoc}
   * @throws IndexOutOfBoundsException   {@inheritDoc}
   */
  public E remove(int index) {
    throw new UnsupportedOperationException();
  }
}

Dies liegt genau daran, dass die interne Klasse ArrayList der Klasse java.util.Arrays dies nicht tut Überschreiben Sie die Add- und Remove-Methoden. Wenn wir also die Add-Methode aufrufen, rufen wir tatsächlich die Add-Methode der AbstractList-Klasse auf. Das Ergebnis ist, dass direkt eine UnsupportedOperationException ausgelöst wird.

In ähnlicher Weise wird auch beim Aufrufen der Remove-Methode oder beim Aufrufen anderer Methoden (z. B. addAll), die mit den Add- und Remove-Methoden verknüpft sind, eine UnsupportedOperationException-Ausnahme auftreten.

AddAll-Beispiel:

/**
 * @author wangmengjun
 *
 */
public class ArrayExample {
 
  public static void main(String[] args) {
 
    /**使用变长参数*/
    List<String> array1 = Arrays.asList("Welcome", "to", "Java", "world");
    array1.addAll(Arrays.asList("AAA", "BBB"));
  }
 
}

Exception in thread "main" java.lang.UnsupportedOperationException
 at java.util.AbstractList.add(Unknown Source)
 at java.util.AbstractList.add(Unknown Source)
 at java.util.AbstractCollection.addAll(Unknown Source)
 at test.ArrayExample.main(ArrayExample.java:36)

Beispiel festlegen:

/**
 * @author wangmengjun
 *
 */
public class ArrayExample {
 
  public static void main(String[] args) {
 
    /**使用变长参数*/
    List<String> array1 = Arrays.asList("Welcome", "to", "Java", "world");
    System.out.println(array1);
     
    //将Java替换成hello
    array1.set(2, "hello");
    System.out.println(array1);
  }
 
}

Das liegt genau daran, dass die interne Klasse ArrayList of Arrays die Set-Methode neu schreibt, sodass das obige Programm normal ausgeführt werden kann und keine UnsupportedOperationException mehr auslöst.

Die Ergebnisse sind wie folgt:

[Willkommen, in, Java, Welt]
[Willkommen, in, Hallo, Welt]

Nutzungsszenarien

Den obigen Beispielen und der einfachen Analyse nach zu urteilen, stellt die Arrays-Toolklasse eine Methode asList bereit, mit der ein Parameter oder Array variabler Länge in eine Liste konvertiert werden kann.

Die Länge der generierten Liste ist jedoch festgelegt; es können Änderungsvorgänge durchgeführt werden (z. B. das Ändern eines Elements an einer bestimmten Position); nicht durchführbar. Es wird eine UnsupportedOperationException ausgelöst.

Arrays.asList eignet sich besser für Szenarien, in denen Sie bereits über Array-Daten oder einige Elemente verfügen und schnell eine Liste erstellen müssen, die nur zum Lesen von Vorgängen verwendet wird, ohne Vorgänge hinzuzufügen oder zu löschen.

Wenn Sie schnell eine Liste erhalten möchten, die basierend auf bekannten Array-Daten hinzugefügt, gelöscht, geändert und überprüft werden kann, ist eine relativ einfache Methode wie folgt:

Verwenden Sie java.util erneut .ArrayList-Wrapper-Ebene.

/**
 * @author wangmengjun
 *
 */
public class ArrayExample {
 
  public static void main(String[] args) {
 
    /**使用变长参数*/
    List<String> array1 = new ArrayList<>(Arrays.asList("Welcome", "to", "Java", "world"));
    System.out.println(array1);
 
    array1.add("Cool~~~");
    System.out.println(array1);
 
  }
 
}

Die Ergebnisse sind wie folgt:

[Willkommen, in, Java, Welt]
[Willkommen, in, Java, Welt, Cool~~~]

Vielen Dank fürs Lesen, ich hoffe, es kann allen helfen, vielen Dank an alle, die diese Seite unterstützen!

Weitere Java-Quellcode-Analysen und detaillierte Erläuterungen zur Arrays.asList-Methode finden Sie auf der chinesischen PHP-Website!