Dans le concept d'héritage, si une méthode particulière n'est pas disponible dans la classe actuelle, elle sera recherchée dans les classes supérieures. Si elle est disponible, elle l'exécute.
Il exécute AbstractList<E> classe add() qui lance la méthode UnsupportedOperationException .
Lorsque vous convertissez un tableau en un objet de collection, c'est-à-dire une API basée sur un tableau en une API basée sur une collection, vous obtenez un objet de collection de taille fixe, car le comportement d'un tableau est de taille fixe.
java.util.Arrays.asList( T... a )
Soucez des échantillons pour la conformation.
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> {
//...
}
}
A partir de la source ci-dessus, vous pouvez observer que java.util.Arrays.ArrayList La classe n'est pas @Override add(index, element), set(index, element), remove(index) . Donc, de l'héritage il exécute super AbstractList<E> classe add() qui lance la fonction UnsupportedOperationException .
Como AbstractList<E> est une classe abstraite qui fournit l'implémentation de iterator() and listIterator() . Ainsi, nous pouvons itérer sur l'objet liste.
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());
Vous pouvez même créer des tableaux de taille fixe avec la classe Collections. Collections.unmodifiableList(list);
Source de l'échantillon :
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 - parfois appelé conteneur - est simplement un objet qui regroupe plusieurs éléments en une seule unité. Les collections sont utilisées pour stocker, récupérer, manipuler et communiquer des données agrégées.
Voir aussi
