Lists 的subList

转载 2016年05月30日 18:30:38
在使用集合中,可能常常需要取集合中的某一部分子集来进行一下操作,于是subList这个方法就映入我们的眼帘,毫不犹豫地使用。
例如以下代码:
public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    List<Object> tempList = lists.subList(2, lists.size());   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   
}  


代码初步写好后,可能我们想达到的效果是:往集合lists的子集合tempList中添加一个元素6,而原有的集合保持不变。
即到达这样的效果:lists = [1, 2, 3, 4],tempList = [3, 4, 6]。但是我们看到实际的结果确是lists里边也添加了元素6。
这是怎么一会事呢,通过查找java原代码我们可以看到:tempList的subList实现代码在AbstractList类里边,然而无论如何,最终的结果都是返回一个AbstractList的子类:SubList(该类是一个使用默认修饰符修饰的类,其源代码位于AbstractList.java类文件里边),
SubList类的构造方法:
SubList(AbstractList<E> list, int fromIndex, int toIndex) {   
    if (fromIndex < 0)   
        throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);   
    if (toIndex > list.size())   
        throw new IndexOutOfBoundsException("toIndex = " + toIndex);   
    if (fromIndex > toIndex)   
        throw new IllegalArgumentException("fromIndex(" + fromIndex +   
                                           ") > toIndex(" + toIndex + ")");   
    l = list;   
    offset = fromIndex;   
    size = toIndex - fromIndex;   
    expectedModCount = l.modCount;   
}  


里边,将我们原有的list对象给缓存到SubList类对象的一个属性中去了。
而SubList类的add/remove等修改元素的方法中,都使用l进行了操作:
public void add(int index, E element) {   
    if (index<0 || index>size)   
        throw new IndexOutOfBoundsException();   
    checkForComodification();   
    l.add(index+offset, element);   
    expectedModCount = l.modCount;   
    size++;   
    modCount++;   



因此,当我们使用子集合tempList进行元素的修改操作时,会影响原有的list集合。所以在使用subList方法时,一定要想清楚,是否需要对子集合进行修改元素而不影响原有的list集合。
如果需要对子集合的元素进行修改操作而不需要影响原集合时,我们可以使用以下方法进行处理:
public static void main(final String[] args) public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    //注意这里是和本文顶部的代码不同的....   
    List<Object> tempList = new ArrayList<Object>(lists.subList(2, lists.size()));   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   





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将会失效,变得不可使用。




 




tips: 如何删除一个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);
    }
复制代码
















在使用集合中,可能常常需要取集合中的某一部分子集来进行一下操作,于是subList这个方法就映入我们的眼帘,毫不犹豫地使用。
例如以下代码:
public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    List<Object> tempList = lists.subList(2, lists.size());   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   
}  




代码初步写好后,可能我们想达到的效果是:往集合lists的子集合tempList中添加一个元素6,而原有的集合保持不变。
即到达这样的效果:lists = [1, 2, 3, 4],tempList = [3, 4, 6]。但是我们看到实际的结果确是lists里边也添加了元素6。
这是怎么一会事呢,通过查找java原代码我们可以看到:tempList的subList实现代码在AbstractList类里边,然而无论如何,最终的结果都是返回一个AbstractList的子类:SubList(该类是一个使用默认修饰符修饰的类,其源代码位于AbstractList.java类文件里边),
SubList类的构造方法:
SubList(AbstractList<E> list, int fromIndex, int toIndex) {   
    if (fromIndex < 0)   
        throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);   
    if (toIndex > list.size())   
        throw new IndexOutOfBoundsException("toIndex = " + toIndex);   
    if (fromIndex > toIndex)   
        throw new IllegalArgumentException("fromIndex(" + fromIndex +   
                                           ") > toIndex(" + toIndex + ")");   
    l = list;   
    offset = fromIndex;   
    size = toIndex - fromIndex;   
    expectedModCount = l.modCount;   
}  




里边,将我们原有的list对象给缓存到SubList类对象的一个属性中去了。
而SubList类的add/remove等修改元素的方法中,都使用l进行了操作:
public void add(int index, E element) {   
    if (index<0 || index>size)   
        throw new IndexOutOfBoundsException();   
    checkForComodification();   
    l.add(index+offset, element);   
    expectedModCount = l.modCount;   
    size++;   
    modCount++;   





因此,当我们使用子集合tempList进行元素的修改操作时,会影响原有的list集合。所以在使用subList方法时,一定要想清楚,是否需要对子集合进行修改元素而不影响原有的list集合。
如果需要对子集合的元素进行修改操作而不需要影响原集合时,我们可以使用以下方法进行处理:
public static void main(final String[] args) public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    //注意这里是和本文顶部的代码不同的....   
    List<Object> tempList = new ArrayList<Object>(lists.subList(2, lists.size()));   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   









在使用集合中,可能常常需要取集合中的某一部分子集来进行一下操作,于是subList这个方法就映入我们的眼帘,毫不犹豫地使用。
例如以下代码:
public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    List<Object> tempList = lists.subList(2, lists.size());   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   
}  




代码初步写好后,可能我们想达到的效果是:往集合lists的子集合tempList中添加一个元素6,而原有的集合保持不变。
即到达这样的效果:lists = [1, 2, 3, 4],tempList = [3, 4, 6]。但是我们看到实际的结果确是lists里边也添加了元素6。
这是怎么一会事呢,通过查找java原代码我们可以看到:tempList的subList实现代码在AbstractList类里边,然而无论如何,最终的结果都是返回一个AbstractList的子类:SubList(该类是一个使用默认修饰符修饰的类,其源代码位于AbstractList.java类文件里边),
SubList类的构造方法:
SubList(AbstractList<E> list, int fromIndex, int toIndex) {   
    if (fromIndex < 0)   
        throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);   
    if (toIndex > list.size())   
        throw new IndexOutOfBoundsException("toIndex = " + toIndex);   
    if (fromIndex > toIndex)   
        throw new IllegalArgumentException("fromIndex(" + fromIndex +   
                                           ") > toIndex(" + toIndex + ")");   
    l = list;   
    offset = fromIndex;   
    size = toIndex - fromIndex;   
    expectedModCount = l.modCount;   
}  




里边,将我们原有的list对象给缓存到SubList类对象的一个属性中去了。
而SubList类的add/remove等修改元素的方法中,都使用l进行了操作:
public void add(int index, E element) {   
    if (index<0 || index>size)   
        throw new IndexOutOfBoundsException();   
    checkForComodification();   
    l.add(index+offset, element);   
    expectedModCount = l.modCount;   
    size++;   
    modCount++;   





因此,当我们使用子集合tempList进行元素的修改操作时,会影响原有的list集合。所以在使用subList方法时,一定要想清楚,是否需要对子集合进行修改元素而不影响原有的list集合。
如果需要对子集合的元素进行修改操作而不需要影响原集合时,我们可以使用以下方法进行处理:
public static void main(final String[] args) public static void main(final String[] args) {   
    List<Object> lists = new ArrayList<Object>();   
  
    lists.add("1");   
    lists.add("2");   
    lists.add("3");   
    lists.add("4");   
  
    //注意这里是和本文顶部的代码不同的....   
    List<Object> tempList = new ArrayList<Object>(lists.subList(2, lists.size()));   
  
    tempList.add("6");   
  
    System.out.println(tempList); // 1   
  
    System.out.println(lists); // 2   

subList用法详解

List集合里有a,b,c,d,e这几个字符,subList(1,3)就会返回一个包含b,c字符subList
  • sinat_29384657
  • sinat_29384657
  • 2016年11月17日 11:58
  • 2512

java ArrayList补充——subList

首先看一个关于subList的问题:下面这段代码的输出结果是什么? List list = new ArrayList(); list.add(1); list.add(2); list...
  • daydreary
  • daydreary
  • 2015年12月02日 16:22
  • 1523

小心List.subList---返回的引用视图而不是拷贝

list.subList(from, to).clear(); 会反作用于原来的list对象上,达到的效果就是删除list中对应的区间 你对 list.subList(from, to) ...
  • suncaishen
  • suncaishen
  • 2015年11月27日 15:56
  • 1085

List sublist的toIndex不能超过500

今天想在项目中使用多线程时,想将一个长度为700多的Llist链表,分割 成几个长度为50的子链表作为各个线程的参数,最后发现但sunblist的toIndex超过500时就会报Exception i...
  • dhtx_wzgl
  • dhtx_wzgl
  • 2015年11月22日 14:59
  • 682

List 中subList 慎用(减法陷阱)

查找java原代码我们可以看到:tempList的subList实现代码在AbstractList类里边,然而无论如何,最终 的结果都是返回一个AbstractList的子类:SubList(该类是一...
  • cp1820957097
  • cp1820957097
  • 2015年02月28日 17:37
  • 7039

java.util.List里的subList方法使用

//增加分页的功能             PageBean page = new PageBean();             String pageNo = request.getPar...
  • IBelieveKDM
  • IBelieveKDM
  • 2013年08月02日 14:49
  • 3650

java中list数据拆分为sublist实现分页的简单代码

package com.test; import java.util.ArrayList; import java.util.List; public class ListSplit { /** ...
  • ycb1689
  • ycb1689
  • 2015年02月16日 17:59
  • 4783

【Java】List的subList方法

Java的容器类ArrayList很常用,旗下存在一个subList方法,是值得注意的。 subList方法仅能够取出此ArrayList的引用,即使其看起来,好像是取出一个ArrayLis...
  • yongh701
  • yongh701
  • 2015年11月11日 20:44
  • 1016

Java提高配(三七)—–Java集合细节(三):subList的缺陷

我们经常使用subString方法来对String对象进行分割处理,同时我们也可以使用subList、subMap、subSet来对List、Map、Set进行分割处理,但是这个分割存在某些瑕疵。一、...
  • chenssy
  • chenssy
  • 2015年03月06日 18:20
  • 12648

subList

public ListE> subList(int fromIndex,                       int toIndex)返回列表中指定的 fromIndex(包括 )和 toIn...
  • rocgege
  • rocgege
  • 2008年12月02日 16:19
  • 2553
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:Lists 的subList
举报原因:
原因补充:

(最多只允许输入30个字)