Forme el concepto de herencia, si algún método perticular no está disponible en la clase actual, buscará ese método en superclases. Si está disponible, se ejecuta.
Ejecuta el método de AbstractList<E>clase add()que arroja UnsupportedOperationException.
Cuando está convirtiendo de una matriz a una colección Obejct. es decir, basado en matriz a API basada en colección, entonces le proporcionará un objeto de colección de tamaño fijo, porque el comportamiento de la matriz es de tamaño fijo.
java.util.Arrays.asList (T ... a)
Muestras de salsa para conformación.
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> {
//...
}
}
Forma la fuente anterior, puedes observar que la java.util.Arrays.ArrayListclase no @Override add(index, element), set(index, element), remove(index). Por lo tanto, de la herencia se ejecuta súper AbstractList<E>clase de add()función que lanza UnsupportedOperationException.
Como AbstractList<E>es una clase abstracta, proporciona la implementación a iterator() and listIterator(). Entonces, podemos iterar sobre el objeto de la lista.
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());
Incluso puede crear la clase de forma de matriz de tamaño fijo. Collections.unmodifiableList(list);
Fuente de muestra:
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, a veces llamado contenedor, es simplemente un objeto que agrupa múltiples elementos en una sola unidad. Las colecciones se utilizan para almacenar, recuperar, manipular y comunicar datos agregados.
@ver también