这里主要谈下Java集合在使用中容易被忽略、又容易出现的两个“坑”，一个是集合与数组互相转换，另一个是集合遍历删除。主要通过代码演示。
一.集合与数组互相转换中的“坑”
//Test1.java
package com.itszt.test0419;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
/**
* 集合与数组互相转换，含list集合元素反序排列
*/
public class Test1 {
public static void main(String[] args) {
//一个集合对象
ArrayList<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//集合元素正反序转换
System.out.println("正序---list = " + list.toString());
Collections.reverse(list);
System.out.println("反序---list = " + list.toString());
Collections.reverse(list);
System.out.println("恢复初始状态---list"+list);
//(1)集合转数组
Object[] listArray1 = list.toArray();//方法1
System.out.println("方法1---listArray1 = " + Arrays.toString(listArray1));
String[] listArray2 = list.toArray(new String[list.size()]);//方法2
System.out.println("方法2---listArray2 = " + Arrays.toString(listArray2));
String[] listArray3=new String[list.size()];//方法3
for(int i=0;i<list.size();i++){
listArray3[i]=list.get(i);
}
System.out.println("方法3---listArray3 = " + Arrays.toString(listArray3));
//(2)数组转集合
List<Object> asList = Arrays.asList(listArray1);
/*
此时返回的ArrayList是Arrays的一个私有静态内部类，
可以遍历查询，但是不可以像普通集合那样增删元素
*/
System.out.println("asList = " + asList.toString());
/*
asList.add("f");
asList.remove("a");
//若增删元素，均会抛出异常 java.lang.UnsupportedOperationException
*/
//下述方法成功地将数组转化为集合
ArrayList arrayList = new ArrayList<>(asList);
arrayList.add("f");
arrayList.remove("a");
System.out.println("arrayList = " + arrayList.toString());
}
}
二.集合遍历删除中的“坑”
//Test2.java
package com.itszt.test0419;
import java.util.ArrayList;
import java.util.Iterator;
/**
* 集合遍历删除中的坑
* 推荐对JAVA集合进行遍历删除时用迭代器
*/
public class Test2 {
public static void main(String[] args) {
//一个集合对象
ArrayList<String> list=new ArrayList<>();
list.add("a");
list.add("b");
list.add("c");
list.add("d");
list.add("e");
//下面是错误的遍历删除方式，抛出异常：java.util.ConcurrentModificationException
/*for(String s:list){
list.remove(s);
}*/
//其实，上述代码在执行时，会转换成迭代器执行，但删除操作却用了错误的方法，如下所示：
/*for(Iterator<String> it=list.iterator();it.hasNext();){
String next = it.next();
list.remove(next);
}*/
//若将上述代码予以改写，就可以正常执行：
/*for(Iterator<String> it=list.iterator();it.hasNext();){
it.remove();
}
System.out.println("list = " + list.size());*/
/*
另外，下述方式不会报异常，但只能遍历删除部分元素。
这是因为：该方法中有一个严重的错误。
当一个元素被删除时，列表的大小缩小并且下标变化，
所以当你想要在一个循环中用下标删除多个元素的时候，它并不会正常生效。
*/
/*for(int i=0;i<list.size();i++){
list.remove(i);
}
System.out.println("list = " +
list.size()+"---"+
list.toString());*/
//下述方法可以清空集合内的所有元素
/*list.clear();
System.out.println("list = " +list.size());*/
//下述方式可以正确地删除指定内容的元素
/*for(int i=0;i<list.size();i++){
if("a".equals(list.get(i))){
list.remove(i);
}
}
System.out.println("list = " + list.toString());*/
/**
* 那么，为什么List集合使用迭代后，就不能再用集合自身的删除方法list.remove(i)了呢？
* 这是因为，ArrayList与Iterator混合使用时会导致各自的状态出现不一样，最终出现异常。
* ArrayList采用size属性来维护自已的状态，而Iterator采用cursor来来维护自已的状态。
* 当size出现变化时，cursor并不一定能够得到同步，除非这种变化是Iterator主动导致的。
* Iterator.remove方法导致ArrayList列表发生变化时，会自动更新cursor来同步这一变化。
* 但其他方式导致的ArrayList变化，Iterator是无法感知的。
* ArrayList不会主动通知Iterator，这将有损效率。
* 为了防止状态不一致可能引发的无法设想的后果，
* Iterator会经常做checkForComodification检查，以防有变。
* 如果有变，则以异常抛出，所以就抛出了上面的异常：
* java.util.ConcurrentModificationException
* 再来比较下面两种遍历删除方法：
*/
//错误的删除方法 抛出异常：java.util.ConcurrentModificationException
/*for(String s:list){
if("a".equals(s)){
list.remove(s);
}
}
System.out.println("list = " + list.toString());*/
//正确的删除方法
/*for(Iterator<String> it=list.iterator();it.hasNext();){
if("a".equals(it.next())){
it.remove();
}
}
System.out.println("list = " + list.toString());*/
/**
* 上述两种方法的不同结果是因为：
*.next()必须在.remove()之前调用。
* 在一个foreach循环中，编译器会使.next()在删除元素之后被调用，
* 因此就会抛出ConcurrentModificationException异常。
* 总之：
* Iterator 支持从源集合中安全地删除对象，
* 只需在 Iterator 上调用 remove() 即可。
* 这样做的好处是可以避免 ConcurrentModificationException ，
* 这个异常顾名思意：当打开 Iterator 迭代集合时，同时又在对集合进行修改。
* 为此，在对集合迭代时删除或添加元素时，调用 Iterator 的remove() 方法是个安全的做法。
*/
}
}