Forme o conceito de herança. Se algum método perticular não estiver disponível na classe atual, ele buscará esse método nas superclasses. Se disponível, ele é executado.
Ele executa o método de AbstractList<E>classe add()que lança UnsupportedOperationException.
Quando você está convertendo de uma matriz para um objeto de coleção. ou seja, com base em array para API baseada em coleção, ele fornecerá um objeto de coleção de tamanho fixo, porque o comportamento da matriz é de tamanho fixo.
java.util.Arrays.asList (T ... a)
Amostras de molho para conformação.
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> {
//...
}
}
Forme a fonte acima, você pode observar que a java.util.Arrays.ArrayListclasse não @Override add(index, element), set(index, element), remove(index). Portanto, a partir da herança, ele executa a função de super AbstractList<E>classe add()que lança UnsupportedOperationException.
Como AbstractList<E>é uma classe abstrata, ela fornece a implementação iterator() and listIterator(). Assim, podemos iterar sobre o objeto da 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());
Você pode até criar um array de tamanho fixo na classe Collections Collections.unmodifiableList(list);
Fonte da amostra:
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- às vezes chamado de contêiner - é simplesmente um objeto que agrupa vários elementos em uma única unidade. As coleções são usadas para armazenar, recuperar, manipular e comunicar dados agregados.
@Veja também