wake-up-neo.net

Java List.add () UnsupportedOperationException

Ich versuche, einer List<String>-Instanz Objekte hinzuzufügen, aber es wird eine UnsupportedOperationException..__ ausgegeben. Weiß jemand, warum?

Mein Java-Code:

String[] membersArray = request.getParameterValues('members');
List<String> membersList = Arrays.asList(membersArray);

for (String member : membersList) {
    Person person = Dao.findByName(member);
    List<String> seeAlso;
    seeAlso = person.getSeeAlso();
    if (!seeAlso.contains(groupDn)){
        seeAlso.add(groupDn);
        person.setSeeAlso(seeAlso);
    }
}

Die Fehlermeldung:

 Java.lang.UnsupportedOperationException 
 Java.util.AbstractList.add (unbekannte Quelle) 
 Java.util.AbstractList.add (unbekannte Quelle) 
 javax.servlet.http.HttpServlet.service (HttpServlet.Java:641) 
 javax.servlet.http.HttpServlet.service (HttpServlet.Java:722) 
157
FAjir

Nicht jede List -Implementierung unterstützt die add()-Methode.

Ein bekanntes Beispiel ist die List, die von Arrays.asList() zurückgegeben wird: not ist dokumentiert, um strukturelle Änderungen zu unterstützen (d. H. Das Entfernen oder Hinzufügen von Elementen) (Hervorhebung von mir):

Gibt eine fixed-size - Liste zurück, die vom angegebenen Array gesichert wird.

Auch wenn dies nicht die bestimmte List ist, die Sie ändern möchten, gilt die Antwort auch für andere List-Implementierungen, die entweder unveränderlich sind oder nur einige ausgewählte Änderungen zulassen.

Sie können dies erfahren, indem Sie die Dokumentation von UnsupportedOperationException und List.add() lesen, die dies als "(optionale Operation)" dokumentiert. Die genaue Bedeutung dieses Ausdrucks wird oben in der List-Dokumentation erläutert.

Um dieses Problem zu umgehen, können Sie eine Kopie der Liste für eine bekannt modifizierbare Implementierung wie ArrayList erstellen:

seeAlso = new ArrayList<>(seeAlso);
340
Joachim Sauer

Sie müssen Ihre Liste initialisieren. Siehe auch: 

List<String> seeAlso = new Vector<String>();

oder 

List<String> seeAlso = new ArrayList<String>();
4
dwayne

Bilden Sie das Vererbungskonzept. Wenn eine bestimmte Methode in der aktuellen Klasse nicht verfügbar ist, sucht sie in Superklassen nach dieser Methode. Wenn vorhanden, wird es ausgeführt.

Es führt die AbstractList<E> Klasse add() -Methode aus, die UnsupportedOperationException auslöst.


Wenn Sie von einem Array in ein Sammlungsobjekt konvertieren. d. h. Array-basierte bis sammlungsbasierte API, dann wird das Sammlungsobjekt mit fester Größe bereitgestellt, da das Verhalten von Array fest ist.

Java.util.Arrays.asList (T ... a)

Souce-Muster für die Bestätigung .

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> {
        //...
    }
}

Aus der obigen Quelle stellen Sie möglicherweise fest, dass Java.util.Arrays.ArrayList-Klasse nicht @Override add(index, element), set(index, element), remove(index) ist. Von der Vererbung führt sie also eine super AbstractList<E>-Klasse add()-Funktion aus, die UnsupportedOperationException auslöst.

Da AbstractList<E> eine abstrakte Klasse ist, stellt sie die Implementierung für iterator() and listIterator() bereit. So können wir das Listenobjekt durchlaufen.

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 Arrays mit fester Größe erstellen. Collections-Klasse 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));
    }
}

Ein Collection - manchmal auch als Container bezeichnet - ist einfach ein Objekt, das mehrere Elemente in einer einzigen Einheit zusammenfasst. Sammlungen werden zum Speichern, Abrufen, Bearbeiten und Kommunizieren von gesammelten Daten verwendet.

@siehe auch

1
Yash

Viele der List-Implementierungsunterstützung unterstützen nur begrenzte Unterstützung beim Hinzufügen/Entfernen und Arrays.asList (MembersArray). Sie müssen den Datensatz in Java.util.ArrayList einfügen oder den folgenden Ansatz verwenden, um in ArrayList zu konvertieren.

Mit der minimalen Änderung in Ihrem Code können Sie unten eine Liste in ArrayList konvertieren. Die erste Lösung besteht in einer minimalen Änderung Ihrer Lösung, aber die zweite ist mehr optimistisch, denke ich.

    String[] membersArray = request.getParameterValues('members');
    ArrayList<String> membersList = new ArrayList<>(Arrays.asList(membersArray));

OR

    String[] membersArray = request.getParameterValues('members');
    ArrayList<String> membersList = Stream.of(membersArray).collect(Collectors.toCollection(ArrayList::new));
1
krmanish007

List MembersList = Arrays.asList (MembersArray); 

gibt eine unveränderliche Liste zurück, was Sie tun müssen 

neue ArrayList <> (Arrays.asList (MembersArray)); veränderlich machen 

0
Ziv.Ti

anstelle von add () können wir addall () verwenden

{ seeAlso.addall(groupDn); }

add fügt ein einzelnes Element hinzu, während addAll jedes Element einzeln aus der Sammlung hinzufügt. Am Ende geben beide Methoden true zurück, wenn die Auflistung geändert wurde. Im Fall von ArrayList ist dies trivial, da die Auflistung immer geändert wird, andere Auflistungen, wie z. B. Set, jedoch möglicherweise false zurückgeben, wenn Elemente, die hinzugefügt werden, bereits vorhanden sind.

0
Allen