（记）项目开发中遇到的问题：List＜String＞转为List＜Long＞踩坑

本文介绍了在Java项目开发中将List<String>转换为List<Long>时遇到的问题。通过两种转换方式的对比，强调了使用stream流转换的正确性，以及使用Arrays.asList()方法时因内部类ArrayList未重写add方法导致的错误。建议在转换时使用new ArrayList<>()以避免此类问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

List转为List

- - List\转List\ 的两种方式

今天，测试在测试小程序过程中，偶然发现了之前的功能bug，因为那一块一直没动过，所以知道今天才发现，那就记录下吧。

java代码有一处是要把 List<String> 转为List<Long> ,我看最初代码也转了但是方式不对，

List<String>转List<Integer> 的两种方式

方式一：

   List<String>  list1 =  Array.asList()   
   list.add(XXX)
   List<Long>   list2   =   list1.stream.map(Long :: parseValue).collect(Collector.toList)

方式二：

  List<String>  list1 =  Array.asList()   
       list.add(XXX)
       List<Long>  list2 =  Array.asList()   
       CollectionUtils.collect(list1 ,new Transformer(){
        @override
          public Object transform(Object o) {
                    return Long.parseLong(o.toString());
                }
       },list2)

第一种方式使用stream流的方式转换没有问题功能实现，但是在使用第二种方式
debug的时候发现一处报错：

	    java.lang.UnsupportedOperationException
	    at java.util.AbstractList.add(AbstractList.java:148)
	    at java.util.AbstractList.add(AbstractList.java:108)
	    at com.atguigu.test.ListTest.main(ListTest.java:11)
	    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)

查资料发现这是 ArrayList 报的错误。为什么呢？
原因：
这个 asList方法给我们创建了一个 ArrayList ,但是这个ArrayList 并不是 java.util.ArrayList包,asList 创建了一个内部静态类ArrayList 继承 AbstractList静态类，

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

点开ArrayList类你会发现他并没有重写add方法，在转换过程中调用了父类的add方法，但是并没有具体实现。

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

       ArrayList(E[] array) {
           a = Objects.requireNonNull(array);
       }

       @Override
       public int size() {
           return a.length;
       }

       @Override
       public Object[] toArray() {
           return a.clone();
       }

       @Override
       @SuppressWarnings("unchecked")
       public <T> T[] toArray(T[] a) {
           int size = size();
           if (a.length < size)
               return Arrays.copyOf(this.a, size,
                                    (Class<? extends T[]>) a.getClass());
           System.arraycopy(this.a, 0, a, 0, size);
           if (a.length > size)
               a[size] = null;
           return a;
       }

       @Override
       public E get(int index) {
           return a[index];
       }

       @Override
       public E set(int index, E element) {
           E oldValue = a[index];
           a[index] = element;
           return oldValue;
       }

       @Override
       public int indexOf(Object o) {
           E[] a = this.a;
           if (o == null) {
               for (int i = 0; i < a.length; i++)
                   if (a[i] == null)
                       return i;
           } else {
               for (int i = 0; i < a.length; i++)
                   if (o.equals(a[i]))
                       return i;
           }
           return -1;
       }

       @Override
       public boolean contains(Object o) {
           return indexOf(o) != -1;
       }

       @Override
       public Spliterator<E> spliterator() {
           return Spliterators.spliterator(a, Spliterator.ORDERED);
       }

       @Override
       public void forEach(Consumer<? super E> action) {
           Objects.requireNonNull(action);
           for (E e : a) {
               action.accept(e);
           }
       }

       @Override
       public void replaceAll(UnaryOperator<E> operator) {
           Objects.requireNonNull(operator);
           E[] a = this.a;
           for (int i = 0; i < a.length; i++) {
               a[i] = operator.apply(a[i]);
           }
       }

       @Override
       public void sort(Comparator<? super E> c) {
           Arrays.sort(a, c);
       }
   }