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. }
java.util.List中有一个subList方法，用来返回一个list的一部分的视图。
List<E> subList(int fromIndex, int toIndex);
它返回原来list的从[fromIndex, toIndex)之间这一部分的视图，之所以说是视图，是因为实际上，返回的list是靠原来的list支持的。
所以，你对原来的list和返回的list做的“非结构性修改”(non-structural changes)，都会影响到彼此对方。
所谓的“非结构性修改”，是指不涉及到list的大小改变的修改。相反，结构性修改，指改变了list大小的修改。
那么，如果涉及到结构性修改会怎么样呢？
如果发生结构性修改的是返回的子list，那么原来的list的大小也会发生变化；
而如果发生结构性修改的是原来的list（不包括由于返回的子list导致的改变），那么返回的子list语义上将会是undefined。在AbstractList（ArrayList的父类）中，undefined的具体表现形式是抛出一个ConcurrentModificationException。
因此，如果你在调用了sublist返回了子list之后，如果修改了原list的大小，那么之前产生的子list将会失效，变得不可使用。
如何删除一个list的某个区段，比如删除list的第2-5个元素？
方法是: 可以利用sublist的幕后还是原来的list的这个特性，比如
list.subList(from, to).clear();
这样就可以了。
示例代码：
public static void main(String[] args) {
List<String> parentList = new ArrayList<String>();
for(int i = 0; i < 5; i++){
parentList.add(String.valueOf(i));
}
List<String> subList = parentList.subList(1, 3);
for(String s : subList){
System.out.println(s);//output: 1, 2
}
//non-structural modification by sublist, reflect parentList
subList.set(0, "new 1");
for(String s : parentList){
System.out.println(s);//output: 0, new 1, 2, 3, 4
}
//structural modification by sublist, reflect parentList
subList.add(String.valueOf(2.5));
for(String s : parentList){
System.out.println(s);//output:0, new 1, 2, 2.5, 3, 4
}
//non-structural modification by parentList, reflect sublist
parentList.set(2, "new 2");
for(String s : subList){
System.out.println(s);//output: new 1, new 2
}
//structural modification by parentList, sublist becomes undefined(throw exception)
parentList.add("undefine");
// for(String s : subList){
// System.out.println(s);
// }
// subList.get(0);
}
