关于将int数组使用系统提供的API转成集合后，不可以进行的操作是(  )
a)增加集合中的元素
b)迭代集合
c)修改集合中的元素
d)获取集合中元素的个数

rick1991chen 发表于 2015-5-21 20:16
diaodiaodiao学习到了，虽然没看懂

里面的集合还没有看到，绞尽脑汁都看不懂

diaodiaodiao学习到了，虽然没看懂

果断是A啊

A为整洁

这道题我做错了,哎

数组定长.   A

sss18310878521 发表于 2015-5-21 16:10
答案是a，你说的集合应该是ArrayList，因为它的底层结构就是数组，既然是数组，那么它的长度就不能被修改， ...

其实ArrayList的底层本身就是数组，，可以参考源码，，，或看楼上回复

王建伟 发表于 2015-5-21 15:19
list不是可以变长的吗？很迷惑啊。。。。

list只是一个接口，，能不能自动变长，取决于子类的实现，但Arrays.asList方法返回的对象不是java.util.ArrayList，是Arrays的内部类，可以参考一下我刚研究的：
教你如何一句代码将数组转为可变长度的集合
http://bbs.itheima.com/thread-198008-1-1.html
(出处: 黑马程序员IT技术论坛)

a嘛~~！！！！

答案是a，你说的集合应该是ArrayList，因为它的底层结构就是数组，既然是数组，那么它的长度就不能被修改，（这跟我们平常所说的集合长度可以自由增长不一样，因为这个是由数组转过来的）

明显是A选项

as604049322 发表于 2015-5-21 15:13
Arrays.asList()返回的是Arrays的内部类，这个类没有复写add和remove方法，而父类AbstractList的增删操作直 ...

list不是可以变长的吗？很迷惑啊。。。。

Arrays.asList()返回的是Arrays的内部类，这个类没有复写add和remove方法，而父类AbstractList的增删操作直接抛出UnsupportedOperationException()异常。

1. public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
   
2.    
   
3.     protected AbstractList() {
   
4.     }
   
5. 
   
6.     public boolean add(E e) {
   
7.         add(size(), e);
   
8.         return true;
   
9.     }
   
10. 
    
11.     public void add(int index, E element) {
    
12.         throw new UnsupportedOperationException();
    
13.     }
    
14. 
    
15.     public E remove(int index) {
    
16.         throw new UnsupportedOperationException();
    
17.     }
    
18. }

复制代码

1. 
   
2. public static <T> List<T> asList(T... a) {
   
3.         return new ArrayList<>(a);
   
4.     }
   
5. 
   
6.     /**
   
7.      * @serial include
   
8.      */
   
9.     private static class ArrayList<E> extends AbstractList<E>
   
10.         implements RandomAccess, java.io.Serializable
    
11.     {
    
12.         private static final long serialVersionUID = -2764017481108945198L;
    
13.         private final E[] a;
    
14. 
    
15.         ArrayList(E[] array) {
    
16.             a = Objects.requireNonNull(array);
    
17.         }
    
18. 
    
19.         @Override
    
20.         public int size() {
    
21.             return a.length;
    
22.         }
    
23. 
    
24.         @Override
    
25.         public Object[] toArray() {
    
26.             return a.clone();
    
27.         }
    
28. 
    
29.         @Override
    
30.         @SuppressWarnings("unchecked")
    
31.         public <T> T[] toArray(T[] a) {
    
32.             int size = size();
    
33.             if (a.length < size)
    
34.                 return Arrays.copyOf(this.a, size,
    
35.                                      (Class<? extends T[]>) a.getClass());
    
36.             System.arraycopy(this.a, 0, a, 0, size);
    
37.             if (a.length > size)
    
38.                 a[size] = null;
    
39.             return a;
    
40.         }
    
41. 
    
42.         @Override
    
43.         public E get(int index) {
    
44.             return a[index];
    
45.         }
    
46. 
    
47.         @Override
    
48.         public E set(int index, E element) {
    
49.             E oldValue = a[index];
    
50.             a[index] = element;
    
51.             return oldValue;
    
52.         }
    
53. 
    
54.         @Override
    
55.         public int indexOf(Object o) {
    
56.             E[] a = this.a;
    
57.             if (o == null) {
    
58.                 for (int i = 0; i < a.length; i++)
    
59.                     if (a[i] == null)
    
60.                         return i;
    
61.             } else {
    
62.                 for (int i = 0; i < a.length; i++)
    
63.                     if (o.equals(a[i]))
    
64.                         return i;
    
65.             }
    
66.             return -1;
    
67.         }
    
68. 
    
69.         @Override
    
70.         public boolean contains(Object o) {
    
71.             return indexOf(o) != -1;
    
72.         }
    
73. 
    
74.         @Override
    
75.         public Spliterator<E> spliterator() {
    
76.             return Spliterators.spliterator(a, Spliterator.ORDERED);
    
77.         }
    
78. 
    
79.         @Override
    
80.         public void forEach(Consumer<? super E> action) {
    
81.             Objects.requireNonNull(action);
    
82.             for (E e : a) {
    
83.                 action.accept(e);
    
84.             }
    
85.         }
    
86. 
    
87.         @Override
    
88.         public void replaceAll(UnaryOperator<E> operator) {
    
89.             Objects.requireNonNull(operator);
    
90.             E[] a = this.a;
    
91.             for (int i = 0; i < a.length; i++) {
    
92.                 a[i] = operator.apply(a[i]);
    
93.             }
    
94.         }
    
95. 
    
96.         @Override
    
97.         public void sort(Comparator<? super E> c) {
    
98.             Arrays.sort(a, c);
    
99.         }
    
100.     }

复制代码

将数组变成集合,不可以使用集合的增删方法；
因为数组的长度是固定的；

A