ArrayList.subList
https://www.techiedelight.com/get-sublist-list-java/
The subList() method throws IndexOutOfBoundsException if starting or ending index is illegal. For instance,
- start < 0
- end > list.size()
- start > end
To avoid IndexOutOfBoundsException from happening, we can check if indexes are within proper bounds before passing to sublist()as shown below:
http://widgetsandshit.com/teddziuba/2008/09/java-sublist-gotcha.html
https://web.archive.org/web/20180426013853/https://blog.applegrew.com/2011/01/java-sublist-gotcha/
http://blog.applegrew.com/2011/01/java-sublist-gotcha/
Sooo… when you say “wrongly” do you mean, not assigning the subList to a new ArrayList?
Yes, particularly when you do not know how you are going to use the sublist.
http://stackoverflow.com/questions/7331154/does-sublistfrom-to-clear-allow-garbage-collection-of-the-cleared-part-of-an
"clear" is relocating objects in the underlying native array (an Object[]), but it doesn't resize the array. If you want reduce the array size after removing some items in the ArrayList, use trimToSize() method.
Unused element references of the array are set to null, so the elements could be garbage collected.
Two things I can think of are:
list.sublist(0, 5)returns an empty list, therefore.clear()does nothing.- Not sure of the inner workings of the List implementation you're using (ArrayList, LinkedList, etc), but having the
equalsandhashCodeimplemented may be important. I had a simiarl issue with Maps, where HashMap definitely needs the hashCode implementation.
一、subList返回仅仅只是一个视图
二、subList生成子列表后，不要试图去操作原列表
从上面我们知道subList生成的子列表只是原列表的一个视图而已，如果我们操作子列表它产生的作用都会在原列表上面表现，但是如果我们操作原列表会产生什么情况呢？
public static void main(String[] args) { List<Integer> list1 = new ArrayList<Integer>(); list1.add(1); list1.add(2); //通过subList生成一个与list1一样的列表 list3 List<Integer> list3 = list1.subList(0, list1.size()); //修改list3 list1.add(3); System.out.println("list1'size：" + list1.size()); System.out.println("list3'size：" + list3.size()); }
该实例如果不产生意外，那么他们两个list的大小都应该都是3，但是偏偏事与愿违，事实上我们得到的结果是这样的：
list1'size：3
Exception in thread "main" java.util.ConcurrentModificationException
at java.util.ArrayList$SubList.checkForComodification(Unknown Source)
at java.util.ArrayList$SubList.size(Unknown Source)
at com.chenssy.test.arrayList.SubListTest.main(SubListTest.java:17)
list1正常输出，但是list3就抛出ConcurrentModificationException异常，看过我另一篇博客的同仁肯定对这个异常非常，fail-fast？不错就是fail-fast机制，在fail-fast机制中，LZ花了很多力气来讲述这个异常，所以这里LZ就不对这个异常多讲了（更多请点这里：Java提高篇（三四）—–fail-fast机制）。我们再看size方法：
public int size() { checkForComodification(); return this.size; }
size方法首先会通过checkForComodification验证，然后再返回this.size。
private void checkForComodification() { if (ArrayList.this.modCount != this.modCount) throw new ConcurrentModificationException(); }
该方法表明当原列表的modCount与this.modCount不相等时就会抛出ConcurrentModificationException。同时我们知道modCount 在new的过程中 “继承”了原列表modCount，只有在修改该列表（子列表）时才会修改该值（先表现在原列表后作用于子列表）。而在该实例中我们是操作原列表，原列表的modCount当然不会反应在子列表的modCount上啦，所以才会抛出该异常。
三、推荐使用subList处理局部列表
在开发过程中我们一定会遇到这样一个问题：获取一堆数据后，需要删除某段数据。例如，有一个列表存在1000条记录，我们需要删除100-200位置处的数据，可能我们会这样处理：
for(int i = 0 ; i < list1.size() ; i++){ if(i >= 100 && i <= 200){ list1.remove(i); /* * 当然这段代码存在问题，list remove之后后面的元素会填充上来， * 所以需要对i进行简单的处理，当然这个不是这里讨论的问题。 */ } }
这个应该是我们大部分人的处理方式吧，其实还有更好的方法，利用subList。在前面LZ已经讲过，子列表的操作都会反映在原列表上。所以下面一行代码全部搞定：
list1.subList(100, 200).clear();
ArrayList
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex;
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// clear to let GC do its work
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
protected void removeRange(int fromIndex, int toIndex) {
checkForComodification();
parent.removeRange(parentOffset + fromIndex,
parentOffset + toIndex);
this.modCount = parent.modCount;
this.size -= toIndex - fromIndex;
}
http://cmsblogs.com/?p=1233一、避免使用基本数据类型数组转换为列表
使用8个基本类型数组转换为列表时会存在一个比较有味的缺陷。先看如下程序：
public static void main(String[] args) { int[] ints = {1,2,3,4,5}; List list = Arrays.asList(ints); System.out.println("list'size：" + list.size()); } ------------------------------------ outPut： list'size：1
程序的运行结果并没有像我们预期的那样是5而是逆天的1，这是什么情况？
二、asList产生的列表不可操作
对于上面的实例我们再做一个小小的修改：
public static void main(String[] args) { Integer[] ints = {1,2,3,4,5}; List list = Arrays.asList(ints); list.add(6); }
该实例就是讲ints通过asList转换为list 类别，然后再通过add方法加一个元素，这个实例简单的不能再简单了，但是运行结果呢？打出我们所料：
Exception in thread "main" java.lang.UnsupportedOperationException
at java.util.AbstractList.add(Unknown Source)
at java.util.AbstractList.add(Unknown Source)
at com.chenssy.test.arrayList.AsListTest.main(AsListTest.java:10)
运行结果尽然抛出UnsupportedOperationException异常，该异常表示list不支持add方法。这就让我们郁闷了，list怎么可能不支持add方法呢？难道jdk脑袋堵塞了？我们再看asList的源码：
public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }
asList接受参数后，直接new 一个ArrayList，到这里看应该是没有错误的啊？别急，再往下看:
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) { if (array==null) throw new NullPointerException(); a = array; } //................. }
这是ArrayList的源码,从这里我们可以看出,此ArrayList不是java.util.ArrayList，他是Arrays的内部类。该内部类提供了size、toArray、get、set、indexOf、contains方法，而像add、remove等改变list结果的方法从AbstractList父类继承过来，同时这些方法也比较奇葩，它直接抛出UnsupportedOperationException异常：
public boolean add(E e) { add(size(), e); return true; } public E set(int index, E element) { throw new UnsupportedOperationException(); } public void add(int index, E element) { throw new UnsupportedOperationException(); } public E remove(int index) { throw new UnsupportedOperationException(); }
通过这些代码可以看出asList返回的列表只不过是一个披着list的外衣，它并没有list的基本特性（变长）。该list是一个长度不可变的列表，传入参数的数组有多长，其返回的列表就只能是多长。所以：
https://www.cnblogs.com/duanxz/p/5013504.htmlJava细节（2.2）：不要试图改变asList返回的列表，否则你会自食苦果。
因此，当我们使用子集合tempList进行元素的修改操作时，会影响原有的list集合。所以在使用subList方法时，一定要想清楚，是否需要对子集合进行修改元素而不影响原有的list集合。
如果需要对子集合的元素进行修改操作而不需要影响原集合时，我们可以使用以下方法进行处理：
List<Object> tempList = new ArrayList<Object>(lists.subList(2, lists.size()));
A view of another object doesn't contain its own data at all. All of its operations are implemented in terms of operations on the other object.
List<String> list = Arrays.asList(strings);
我们简单总结一下，List的subList方法并没有创建一个新的List，而是使用了原List的视图，这个视图使用内部类SubList表示。
所以，我们不能把subList方法返回的List强制转换成ArrayList等类，因为他们之间没有继承关系。
另外，视图和原List的修改还需要注意几点，尤其是他们之间的相互影响：
1、对父(sourceList)子(subList)List做的非结构性修改（non-structural changes），都会影响到彼此。
2、对子List做结构性修改，操作同样会反映到父List上。
3、对父List做结构性修改，会抛出异常ConcurrentModificationException。
所以，阿里巴巴Java开发手册中有另外一条规定：
如何创建新的List
如果需要对subList作出修改，又不想动原list。那么可以创建subList的一个拷贝：
subList = Lists.newArrayList(subList);
list.stream().skip(strart).limit(end).collect(Collectors.toList());