Bilden Sie das Vererbungskonzept. Wenn eine bestimmte Methode in der aktuellen Klasse nicht verfügbar ist, wird in Superklassen nach dieser Methode gesucht. Wenn verfügbar, wird es ausgeführt.
Es führt eine AbstractList<E>Klassenmethode aus add(), die auslöst UnsupportedOperationException.
Wenn Sie von einem Array in ein Sammlungsobjekt konvertieren. Wenn Sie also eine Array-basierte oder eine sammlungsbasierte API verwenden, erhalten Sie ein Sammlungsobjekt mit fester Größe, da das Verhalten des Arrays eine feste Größe hat.
java.util.Arrays.asList (T ... a)
Quellenproben für die Konformation.
public class Arrays {
public static <T> List<T> asList(T... a) {
return new java.util.Arrays.ArrayList.ArrayList<>(a); // Arrays Inner Class ArrayList
}
//...
private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable {
//...
}
}
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
public void add(int index, E element) {
throw new UnsupportedOperationException();
}
public E set(int index, E element) {
throw new UnsupportedOperationException();
}
public E remove(int index) {
throw new UnsupportedOperationException();
}
public Iterator<E> iterator() {
return new Itr();
}
private class Itr implements Iterator<E> {
//...
}
public ListIterator<E> listIterator() {
return listIterator(0);
}
private class ListItr extends Itr implements ListIterator<E> {
//...
}
}
Wenn Sie die obige Quelle bilden, können Sie feststellen, dass diese java.util.Arrays.ArrayListKlasse dies nicht tut @Override add(index, element), set(index, element), remove(index). Also, von Vererbung führt es Super - AbstractList<E>Klasse - add()Funktion , die wirft UnsupportedOperationException.
Da AbstractList<E>es sich um eine abstrakte Klasse handelt, wird die Implementierung bereitgestellt iterator() and listIterator(). Damit wir über das Listenobjekt iterieren können.
List<String> list_of_Arrays = Arrays.asList(new String[] { "a", "b" ,"c"});
try {
list_of_Arrays.add("Yashwanth.M");
} catch(java.lang.UnsupportedOperationException e) {
System.out.println("List Interface executes AbstractList add() fucntion which throws UnsupportedOperationException.");
}
System.out.println("Arrays → List : " + list_of_Arrays);
Iterator<String> iterator = list_of_Arrays.iterator();
while (iterator.hasNext()) System.out.println("Iteration : " + iterator.next() );
ListIterator<String> listIterator = list_of_Arrays.listIterator();
while (listIterator.hasNext()) System.out.println("Forward iteration : " + listIterator.next() );
while(listIterator.hasPrevious()) System.out.println("Backward iteration : " + listIterator.previous());
Sie können sogar Array-Formulare mit fester Größe aus Sammlungen erstellen Collections.unmodifiableList(list);
Beispielquelle:
public class Collections {
public static <T> List<T> unmodifiableList(List<? extends T> list) {
return (list instanceof RandomAccess ?
new UnmodifiableRandomAccessList<>(list) :
new UnmodifiableList<>(list));
}
}
A Collection- manchmal auch Container genannt - ist einfach ein Objekt, das mehrere Elemente zu einer Einheit zusammenfasst. Sammlungen werden zum Speichern, Abrufen, Bearbeiten und Kommunizieren aggregierter Daten verwendet.
@siehe auch