'；“线程中的异常”；“主要”；java.lang.UnsupportedOperationException'；

在ListCreator i'when'方法行中添加t时出现异常 你们能告诉我为什么我会得到这个例外吗？Intelij没有发现语法和逻辑上的任何错误，那么问题出在哪里呢？ 我想制作我自己的映射器和选择器（过滤器），我一直都在使用它。这里有什么问题吗？ 你能看看是什么引起的吗？ 我需要使用泛型，但我会迷路

package zad1;
import java.util.*;

public class ListCreator<T> {// Uwaga: klasa musi być sparametrtyzowana

    List<T> list;

    protected ListCreator(List<T> listcreate){
        this.list = listcreate; //kreator robi nowa liste zeby nie modyfikowac
    }

    public static <T> ListCreator<T> collectFrom(List<T> srclist){
        ListCreator<T> listCreator = new ListCreator<>(srclist);
        return listCreator;
    }

    public ListCreator<T> when(Selector<T> selector){
        List<T> nextlist = new ArrayList<>();
        for (T t: this.list){
            if (selector.select(t)){
                this.list.add(t);  //dla kazdego elementu list ktoremu kolejno odpowiada t, jesli spelnia warunek to element jest dodawany do nowej listy
            }
        }
        this.list = nextlist;
        return this;
    }

    public <S> List<S> mapEvery(Mapper<T,S> map){
        List<S> dlist = new ArrayList<>();
        for (T arg: this.list){
            dlist.add(map.map(arg));
        }
        return dlist;
    }
}  


package zad1;



import java.util.*;

public class Main {
  public Main() {
    List<Integer> src1 = Arrays.asList(1,7,9,11,12);
    System.out.println(test1(src1));

    List<String> src2 = Arrays.asList("a", "zzzz", "vvvvvvv");
    System.out.println(test2(src2));
  }

  public List<Integer> test1(List<Integer> src) {
    Selector <Integer> sel = new Selector<Integer>() {
        @Override
        public boolean select(Integer arg) {
            return arg < 10;
        }
    };
    Mapper <Integer,Integer> map = new Mapper<Integer, Integer>() {
        @Override
        public Integer map(Integer arg) {
            return arg + 10;
        }
    };
    return ListCreator.collectFrom(src).when(sel).mapEvery(map);
  }

  public List<Integer> test2(List<String> src) {
    Selector <String> sel = new Selector<String>() {
        @Override
        public boolean select(String arg) {
            if (arg.length() > 3)
                return true;
            else
                return false;
        }
    };
    Mapper <String, Integer> map = new Mapper<String, Integer>() {
        @Override
        public Integer map(String arg) {
            return arg.length() + 10;
        }
    };
    return ListCreator.collectFrom(src).when(sel).mapEvery(map);
  }

  public static void main(String[] args) {
    new Main();
  }
}

zad1包；
导入java.util.*；
公共类列表创建者{//Uwaga:klasa musi byćSparametryzowana
名单；
受保护的ListCreator（列表listcreate）{
this.list=listcreate；//kreator robi nowa liste zeby nie modyfikowac
}
公共静态ListCreator collectFrom（列表srclist）{
ListCreator ListCreator=新ListCreator（srclist）；
返回列表创建者；
}
public ListCreator when（选择器）{
List nextlist=new ArrayList（）；
for（T:this.list）{
如果（选择器。选择（t））{
this.list.add（t）；//dla kazdego元素列表ktoremu kolejno odpowiada t，jesli spelnia warunek到元素jest dodawany do nowej listy
}
}
this.list=nextlist；
归还这个；
}
公共列表映射（映射器映射）{
List dlist=new ArrayList（）；
for（T参数：this.list）{
dlist.add（map.map（arg））；
}
返回数据列表；
}
}  
zad1包；
导入java.util.*；
公共班机{
公用干管（）{
List src1=Arrays.asList（1,7,9,11,12）；
System.out.println（test1（src1））；
List src2=Arrays.asList（“a”、“zzzz”、“vvv”）；
System.out.println（test2（src2））；
}
公共列表test1（列表src）{
选择器sel=新选择器（）{
@凌驾
公共布尔选择（整数参数）{
返回arg<10；
}
};
映射器映射=新映射器（）{
@凌驾
公共整数映射（整数参数）{
返回arg+10；
}
};
返回ListCreator.collectFrom（src）.when（sel）.mapEvery（map）；
}
公共列表测试2（列表src）{
选择器sel=新选择器（）{
@凌驾
公共布尔选择（字符串参数）{
如果（参数长度（）>3）
返回true；
其他的
返回false；
}
};
映射器映射=新映射器（）{
@凌驾
公共整数映射（字符串参数）{
返回参数长度（）+10；
}
};
返回ListCreator.collectFrom（src）.when（sel）.mapEvery（map）；
}
公共静态void main（字符串[]args）{
新的Main（）；
}
}

由

数组#asList

返回的

列表

不支持

添加

或

删除

，因为它是一个固定大小的列表。调用这些方法将给您一个

不支持操作异常

。此外，您似乎正在向

列表添加内容，同时对其进行迭代；这可能会导致出现
ConcurrentModificationException
。感谢您帮助解决了这个问题