¿Por qué obtengo una UnsupportedOperationException cuando intento eliminar un elemento de una Lista?

Tengo este codigo:

public static String SelectRandomFromTemplate(String template,int count) {
   String[] split = template.split("|");
   List<String> list=Arrays.asList(split);
   Random r = new Random();
   while( list.size() > count ) {
      list.remove(r.nextInt(list.size()));
   }
   return StringUtils.join(list, ", ");
}

Entiendo esto:

06-03 15:05:29.614: ERROR/AndroidRuntime(7737): java.lang.UnsupportedOperationException
06-03 15:05:29.614: ERROR/AndroidRuntime(7737):     at java.util.AbstractList.remove(AbstractList.java:645)

¿Cómo sería esta la forma correcta? Java.15

Algunos problemas con su código:

Al Arrays.asListdevolver una lista de tamaño fijo

De la API:

Arrays.asList: Devuelve una lista de tamaño fijo respaldada por la matriz especificada.

No puedes addhacerlo; no puedes removede eso. No se puede modificar estructuralmente el List.

Reparar

Cree un LinkedList, que admite más rápido remove.

List<String> list = new LinkedList<String>(Arrays.asList(split));

Al splittomar expresiones regulares

De la API:

String.split(String regex): Divide esta cadena alrededor de coincidencias de la expresión regular dada .

|es un metacarácter regex; si desea dividir en un literal |, debe escapar a él \|, que es un literal de cadena Java "\\|".

Reparar:

template.split("\\|")

En mejor algoritmo

En lugar de llamar removeuno a la vez con índices aleatorios, es mejor generar suficientes números aleatorios en el rango, y luego atravesar Listuna vez con un listIterator(), llamando remove()a los índices apropiados. Hay preguntas sobre stackoverflow sobre cómo generar números aleatorios pero distintos en un rango dado.

Con esto, su algoritmo sería O(N).

Este me ha quemado muchas veces. Arrays.asListcrea una lista no modificable. Desde el Javadoc: Devuelve una lista de tamaño fijo respaldada por la matriz especificada.

Crea una nueva lista con el mismo contenido:

newList.addAll(Arrays.asList(newArray));

Esto creará un poco de basura extra, pero podrás mutarlo.

Probablemente porque estás trabajando con un contenedor no modificable .

Cambia esta línea:

List<String> list = Arrays.asList(split);

a esta línea:

List<String> list = new LinkedList<>(Arrays.asList(split));

Creo que reemplazando:

List<String> list = Arrays.asList(split);

con

List<String> list = new ArrayList<String>(Arrays.asList(split));

resuelve el problema

La lista devuelta por Arrays.asList()podría ser inmutable. Podrías intentar

List<String> list = new ArrayList(Arrays.asList(split));

Simplemente lea el JavaDoc para el método asList:

Devuelve una {@code List} de los objetos en la matriz especificada. El tamaño de la {@code List} no se puede modificar, es decir, agregar y eliminar no son compatibles, pero los elementos se pueden configurar. Establecer un elemento modifica la matriz subyacente.

Esto es de Java 6 pero parece que es lo mismo para el Android Java.

EDITAR

El tipo de la lista resultante es Arrays.ArrayList, que es una clase privada dentro de Arrays.class. En términos prácticos, no es más que una vista de lista en la matriz con la que ha pasado Arrays.asList. Con una consecuencia: si cambia la matriz, la lista también cambia. Y debido a que una matriz no es redimensionable, la operación de eliminar y agregar no debe ser compatible.

Arrays.asList () devuelve una lista que no permite operaciones que afecten su tamaño (tenga en cuenta que esto no es lo mismo que "no modificable").

Podría hacer new ArrayList<String>(Arrays.asList(split));para crear una copia real, pero viendo lo que está tratando de hacer, aquí hay una sugerencia adicional (tiene un O(n^2)algoritmo justo debajo de eso).

Desea eliminar list.size() - count(llamemos a esto k) elementos aleatorios de la lista. Simplemente elija tantos elementos aleatorios y cámbielos a las kposiciones finales de la lista, luego elimine todo ese rango (por ejemplo, usando subList () y clear () en eso). Eso lo convertiría en un O(n)algoritmo magro y medio ( O(k)es más preciso).

Actualización : como se indica a continuación, este algoritmo solo tiene sentido si los elementos no están ordenados, por ejemplo, si la Lista representa una Bolsa. Si, por otro lado, la Lista tiene un orden significativo, este algoritmo no lo preservaría (el algoritmo de los poligeneles lubricantes lo haría).

Actualización 2 : Entonces, en retrospectiva, un algoritmo mejor (lineal, manteniendo el orden, pero con números aleatorios O (n)) sería algo como esto:

LinkedList<String> elements = ...; //to avoid the slow ArrayList.remove()
int k = elements.size() - count; //elements to select/delete
int remaining = elements.size(); //elements remaining to be iterated
for (Iterator i = elements.iterator(); k > 0 && i.hasNext(); remaining--) {
  i.next();
  if (random.nextInt(remaining) < k) {
     //or (random.nextDouble() < (double)k/remaining)
     i.remove();
     k--;
  }
}

Tengo otra solución para ese problema:

List<String> list = Arrays.asList(split);
List<String> newList = new ArrayList<>(list);

trabajar en newList;)

Esta excepción de operación no admitida se produce cuando intenta realizar alguna operación en la recopilación donde no está permitido y, en su caso, cuando llama Arrays.asListno devuelve a java.util.ArrayList. Devuelve un java.util.Arrays$ArrayListque es una lista inmutable. No puede agregarle ni eliminarlo.

Sí, en Arrays.asList, devolviendo una lista de tamaño fijo.

Aparte de usar una lista vinculada, simplemente use la addAlllista de métodos.

Ejemplo:

String idList = "123,222,333,444";

List<String> parentRecepeIdList = new ArrayList<String>();

parentRecepeIdList.addAll(Arrays.asList(idList.split(","))); 

parentRecepeIdList.add("555");

Reemplazar

List<String> list=Arrays.asList(split);

a

List<String> list = New ArrayList<>();
list.addAll(Arrays.asList(split));

o

List<String> list = new ArrayList<>(Arrays.asList(split));

o

List<String> list = new ArrayList<String>(Arrays.asList(split));

o (Mejor para eliminar elementos)

List<String> list = new LinkedList<>(Arrays.asList(split));

Arraylist narraylist = Arrays.asList (); // Devuelve una lista de matrices inmutable Para que sea una solución mutable sería: Arraylist narraylist = new ArrayList (Arrays.asList ());

A continuación se muestra un fragmento de código de matrices

public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

    /**
     * @serial include
     */
    private static class ArrayList<E> extends AbstractList<E>
        implements RandomAccess, java.io.Serializable
    {
        private static final long serialVersionUID = -2764017481108945198L;
        private final E[] a;

Entonces, lo que sucede es que cuando se llama al método asList, devuelve una lista de su propia versión de clase estática privada que no anula la función agregar de AbstractList para almacenar el elemento en la matriz. Entonces, por defecto, el método add en la lista abstracta arroja una excepción.

Por lo tanto, no es una lista de matriz regular.

No puede eliminar ni agregar a una lista de matrices de tamaño fijo.

Pero puedes crear tu sublista desde esa lista.

list = list.subList(0, list.size() - (list.size() - count));

public static String SelectRandomFromTemplate(String template, int count) {
   String[] split = template.split("\\|");
   List<String> list = Arrays.asList(split);
   Random r = new Random();
   while( list.size() > count ) {
      list = list.subList(0, list.size() - (list.size() - count));
   }
   return StringUtils.join(list, ", ");
}

* Otra forma es

ArrayList<String> al = new ArrayList<String>(Arrays.asList(template));

esto creará ArrayList que no tiene un tamaño fijo como Arrays.asList

Arrays.asList() utiliza una matriz de tamaño fijo internamente.
No puede agregar o quitar dinámicamente de estoArrays.asList()

Utilizar este

Arraylist<String> narraylist=new ArrayList(Arrays.asList());

En narraylistpuedes agregar o quitar elementos fácilmente.

Crear una nueva lista y completar valores válidos en una nueva lista me funcionó.

Error de lanzamiento de código:

List<String> list = new ArrayList<>();
   for (String s: list) {
     if(s is null or blank) {
        list.remove(s);
     }
   }
desiredObject.setValue(list);

Después de arreglarlo

 List<String> list = new ArrayList<>();
 List<String> newList= new ArrayList<>();
 for (String s: list) {
   if(s is null or blank) {
      continue;
   }
   newList.add(s);
 }
 desiredObject.setValue(newList);