慎用List.subList方法

java List.subList方法中的超级大陷阱

在使用集合中，可能常常需要取集合中的某一部分子集来进行一下操作，于是subList这个方法就映入我们的眼帘，毫不犹豫地使用。 

例如以下代码：

1. public static void main(final String[] args) {  
2.     List<Object> lists = new ArrayList<Object>();  
3.   
4.     lists.add("1");  
5.     lists.add("2");  
6.     lists.add("3");  
7.     lists.add("4");  
8.   
9.     List<Object> tempList = lists.subList(2, lists.size());  
10.   
11.     tempList.add("6");  
12.   
13.     System.out.println(tempList); // 1  
14.   
15.     System.out.println(lists); // 2  
16. }  
    
    
    代码初步写好后，可能我们想达到的效果是：往集合lists的子集合tempList中添加一个元素6，而原有的集合保持不变。 
    
    即到达这样的效果：lists = [1, 2, 3, 4]，tempList = [3, 4, 6]。但是我们看到实际的结果确是lists里边也添加了元素6。 
    
    这是怎么一会事呢，通过查找java原代码我们可以看到：tempList的subList实现代码在AbstractList类里边，然而无论如何，最终的结果都是返回一个AbstractList的子类：SubList（该类是一个使用默认修饰符修饰的类，其源代码位于AbstractList.java类文件里边）， 
    
    SubList类的构造方法： 
    
    1. SubList(AbstractList<E> list, int fromIndex, int toIndex) {  
    2.     if (fromIndex < 0)  
    3.         throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);  
    4.     if (toIndex > list.size())  
    5.         throw new IndexOutOfBoundsException("toIndex = " + toIndex);  
    6.     if (fromIndex > toIndex)  
    7.         throw new IllegalArgumentException("fromIndex(" + fromIndex +  
    8.                                            ") > toIndex(" + toIndex + ")");  
    9.     l = list;  
    10.     offset = fromIndex;  
    11.     size = toIndex - fromIndex;  
    12.     expectedModCount = l.modCount;  
    13. }  
        
        里边，将我们原有的list对象给缓存到SubList类对象的一个属性中去了。 
        
        而SubList类的add/remove等修改元素的方法中，都使用l进行了操作： 
        
        1. public void add(int index, E element) {  
        2.     if (index<0 || index>size)  
        3.         throw new IndexOutOfBoundsException();  
        4.     checkForComodification();  
        5.     l.add(index+offset, element);  
        6.     expectedModCount = l.modCount;  
        7.     size++;  
        8.     modCount++;  
        9. }  
           
           因此，当我们使用子集合tempList进行元素的修改操作时，会影响原有的list集合。所以在使用subList方法时，一定要想清楚，是否需要对子集合进行修改元素而不影响原有的list集合。 
           
           如果需要对子集合的元素进行修改操作而不需要影响原集合时，我们可以使用以下方法进行处理： 
           
           1. public static void main(final String[] args) {  
           2.     List<Object> lists = new ArrayList<Object>();  
           3.   
           4.     lists.add("1");  
           5.     lists.add("2");  
           6.     lists.add("3");  
           7.     lists.add("4");  
           8.   
           9.     //注意这里是和本文顶部的代码不同的....  
           10.     List<Object> tempList = new ArrayList<Object>(lists.subList(2, lists.size()));  
           11.   
           12.     tempList.add("6");  
           13.   
           14.     System.out.println(tempList); // 1  
           15.   
           16.     System.out.println(lists); // 2  
           17. }