Formez le concept d'héritage, si une méthode perticulaire n'est pas disponible dans la classe actuelle, elle recherchera cette méthode dans les super classes. S'il est disponible, il s'exécute.
Il exécute AbstractList<E>la add()méthode de classe qui lance UnsupportedOperationException.
Lorsque vous convertissez un tableau en un objet de collection. c'est-à-dire, basé sur un tableau vers une API basée sur une collection, il vous fournira un objet de collection de taille fixe, car le comportement d'Array est de taille fixe.
java.util.Arrays.asList (T ... a)
Échantillons de Souce 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> {
//...
}
}
Formez la source ci-dessus, vous remarquerez que la java.util.Arrays.ArrayListclasse ne le fait pas @Override add(index, element), set(index, element), remove(index). Donc, à partir de l'héritage, il exécute une fonction de super AbstractList<E>classe add()qui lance UnsupportedOperationException.
Comme AbstractList<E>c'est une classe abstraite, elle fournit l'implémentation à iterator() and listIterator(). Donc, que 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 une classe Collections sous forme de tableau à taille fixe Collections.unmodifiableList(list);
Exemple de source:
public class Collections {
public static <T> List<T> unmodifiableList(List<? extends T> list) {
return (list instanceof RandomAccess ?
new UnmodifiableRandomAccessList<>(list) :
new UnmodifiableList<>(list));
}
}
Un 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 également