ITPub博客
首页 博客 专栏 学院 社区 IT新媒体评选
发博

首页 > 应用开发 > Java > JDK7集合框架源码学习-ArrayList(4)SubList

JDK7集合框架源码学习-ArrayList(4)SubList

原创 Java 作者：壹頁書 时间：2016-07-11 15:28:12 0 删除 编辑
源码镇楼

  1. public List<E> subList(int fromIndex, int toIndex) {  
  2.     subListRangeCheck(fromIndex, toIndex, size);  
  3.     return new SubList(this, 0, fromIndex, toIndex);  
  4. }  
  5.   
  6. static void subListRangeCheck(int fromIndex, int toIndex, int size) {  
  7.     if (fromIndex < 0)  
  8.         throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);  
  9.     if (toIndex > size)  
  10.         throw new IndexOutOfBoundsException("toIndex = " + toIndex);  
  11.     if (fromIndex > toIndex)  
  12.         throw new IllegalArgumentException("fromIndex(" + fromIndex +  
  13.                                            ") > toIndex(" + toIndex + ")");  
  14. }  
  15.   
  16. private class SubList extends AbstractList<E> implements RandomAccess {  
  17.     private final AbstractList<E> parent;  
  18.     private final int parentOffset;  
  19.     private final int offset;  
  20.     int size;  
  21.   
  22.     SubList(AbstractList<E> parent,  
  23.             int offset, int fromIndex, int toIndex) {  
  24.         this.parent = parent;  
  25.         this.parentOffset = fromIndex;  
  26.         this.offset = offset + fromIndex;  
  27.         this.size = toIndex - fromIndex;  
  28.         this.modCount = ArrayList.this.modCount;  
  29.     }  
  30.   
  31.     public E set(int index, E e) {  
  32.         rangeCheck(index);  
  33.         checkForComodification();  
  34.         E oldValue = ArrayList.this.elementData(offset + index);  
  35.         ArrayList.this.elementData[offset + index] = e;  
  36.         return oldValue;  
  37.     }  
  38.   
  39.     public E get(int index) {  
  40.         rangeCheck(index);  
  41.         checkForComodification();  
  42.         return ArrayList.this.elementData(offset + index);  
  43.     }  
  44.   
  45.     public int size() {  
  46.         checkForComodification();  
  47.         return this.size;  
  48.     }  
  49.   
  50.     public void add(int index, E e) {  
  51.         rangeCheckForAdd(index);  
  52.         checkForComodification();  
  53.         parent.add(parentOffset + index, e);  
  54.         this.modCount = parent.modCount;  
  55.         this.size++;  
  56.     }  
  57.   
  58.     public E remove(int index) {  
  59.         rangeCheck(index);  
  60.         checkForComodification();  
  61.         E result = parent.remove(parentOffset + index);  
  62.         this.modCount = parent.modCount;  
  63.         this.size--;  
  64.         return result;  
  65.     }  
  66.   
  67.     protected void removeRange(int fromIndex, int toIndex) {  
  68.         checkForComodification();  
  69.         parent.removeRange(parentOffset + fromIndex,  
  70.                            parentOffset + toIndex);  
  71.         this.modCount = parent.modCount;  
  72.         this.size -= toIndex - fromIndex;  
  73.     }  
  74.   
  75.     public boolean addAll(Collection<? extends E> c) {  
  76.         return addAll(this.size, c);  
  77.     }  
  78.   
  79.     public boolean addAll(int index, Collection<? extends E> c) {  
  80.         rangeCheckForAdd(index);  
  81.         int cSize = c.size();  
  82.         if (cSize==0)  
  83.             return false;  
  84.   
  85.         checkForComodification();  
  86.         parent.addAll(parentOffset + index, c);  
  87.         this.modCount = parent.modCount;  
  88.         this.size += cSize;  
  89.         return true;  
  90.     }  
  91.   
  92.     public Iterator<E> iterator() {  
  93.         return listIterator();  
  94.     }  
  95.   
  96.     public ListIterator<E> listIterator(final int index) {  
  97.         checkForComodification();  
  98.         rangeCheckForAdd(index);  
  99.         final int offset = this.offset;  
  100.   
  101.         return new ListIterator<E>() {  
  102.             int cursor = index;  
  103.             int lastRet = -1;  
  104.             int expectedModCount = ArrayList.this.modCount;  
  105.   
  106.             public boolean hasNext() {  
  107.                 return cursor != SubList.this.size;  
  108.             }  
  109.   
  110.             @SuppressWarnings("unchecked")  
  111.             public E next() {  
  112.                 checkForComodification();  
  113.                 int i = cursor;  
  114.                 if (i >= SubList.this.size)  
  115.                     throw new NoSuchElementException();  
  116.                 Object[] elementData = ArrayList.this.elementData;  
  117.                 if (offset + i >= elementData.length)  
  118.                     throw new ConcurrentModificationException();  
  119.                 cursor = i + 1;  
  120.                 return (E) elementData[offset + (lastRet = i)];  
  121.             }  
  122.   
  123.             public boolean hasPrevious() {  
  124.                 return cursor != 0;  
  125.             }  
  126.   
  127.             @SuppressWarnings("unchecked")  
  128.             public E previous() {  
  129.                 checkForComodification();  
  130.                 int i = cursor - 1;  
  131.                 if (i < 0)  
  132.                     throw new NoSuchElementException();  
  133.                 Object[] elementData = ArrayList.this.elementData;  
  134.                 if (offset + i >= elementData.length)  
  135.                     throw new ConcurrentModificationException();  
  136.                 cursor = i;  
  137.                 return (E) elementData[offset + (lastRet = i)];  
  138.             }  
  139.   
  140.             public int nextIndex() {  
  141.                 return cursor;  
  142.             }  
  143.   
  144.             public int previousIndex() {  
  145.                 return cursor - 1;  
  146.             }  
  147.   
  148.             public void remove() {  
  149.                 if (lastRet < 0)  
  150.                     throw new IllegalStateException();  
  151.                 checkForComodification();  
  152.   
  153.                 try {  
  154.                     SubList.this.remove(lastRet);  
  155.                     cursor = lastRet;  
  156.                     lastRet = -1;  
  157.                     expectedModCount = ArrayList.this.modCount;  
  158.                 } catch (IndexOutOfBoundsException ex) {  
  159.                     throw new ConcurrentModificationException();  
  160.                 }  
  161.             }  
  162.   
  163.             public void set(E e) {  
  164.                 if (lastRet < 0)  
  165.                     throw new IllegalStateException();  
  166.                 checkForComodification();  
  167.   
  168.                 try {  
  169.                     ArrayList.this.set(offset + lastRet, e);  
  170.                 } catch (IndexOutOfBoundsException ex) {  
  171.                     throw new ConcurrentModificationException();  
  172.                 }  
  173.             }  
  174.   
  175.             public void add(E e) {  
  176.                 checkForComodification();  
  177.   
  178.                 try {  
  179.                     int i = cursor;  
  180.                     SubList.this.add(i, e);  
  181.                     cursor = i + 1;  
  182.                     lastRet = -1;  
  183.                     expectedModCount = ArrayList.this.modCount;  
  184.                 } catch (IndexOutOfBoundsException ex) {  
  185.                     throw new ConcurrentModificationException();  
  186.                 }  
  187.             }  
  188.   
  189.             final void checkForComodification() {  
  190.                 if (expectedModCount != ArrayList.this.modCount)  
  191.                     throw new ConcurrentModificationException();  
  192.             }  
  193.         };  
  194.     }  
  195.   
  196.     public List<E> subList(int fromIndex, int toIndex) {  
  197.         subListRangeCheck(fromIndex, toIndex, size);  
  198.         return new SubList(this, offset, fromIndex, toIndex);  
  199.     }  
  200.   
  201.     private void rangeCheck(int index) {  
  202.         if (index < 0 || index >= this.size)  
  203.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
  204.     }  
  205.   
  206.     private void rangeCheckForAdd(int index) {  
  207.         if (index < 0 || index > this.size)  
  208.             throw new IndexOutOfBoundsException(outOfBoundsMsg(index));  
  209.     }  
  210.   
  211.     private String outOfBoundsMsg(int index) {  
  212.         return "Index: "+index+", Size: "+this.size;  
  213.     }  
  214.   
  215.     private void checkForComodification() {  
  216.         if (ArrayList.this.modCount != this.modCount)  
  217.             throw new ConcurrentModificationException();  
  218.     }  
  219. }  

ArrayList的subList方法,首先调用subListRangeCheck方法做了一个范围检查.
然后创建并返回了一个SubList的内部类对象.

仔细对比SubList和ArrayList的定义.
public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

private class SubList extends AbstractList<E> implements RandomAccess

他们同样继承了AbstractList,并实现了RandomAccess标记接口.
而AbstractList是一个抽象类,除了一些抽象方法,还有一些方法干脆没有实现.
比如:
  1. abstract public E get(int index);  
  2. public E set(int index, E element) {  
  3.     throw new UnsupportedOperationException();  
  4. }  
  5.   
  6. public void add(int index, E element) {  
  7.     throw new UnsupportedOperationException();  
  8. }  
  9.   
  10. public E remove(int index) {  
  11.     throw new UnsupportedOperationException();  
  12. }  


在创建SubList内部类的时候,
new SubList(this, 0, fromIndex, toIndex);
实际上将外部的ArrayList对象,传入了内部类作为一个数据成员,即 AbstractList parent
并且记录了偏移量和Size等信息.

  1. private final AbstractList<E> parent;  
  2. private final int parentOffset;  
  3. private final int offset;  
  4. int size;  
  5.   
  6. SubList(AbstractList<E> parent,  
  7.         int offset, int fromIndex, int toIndex) {  
  8.     this.parent = parent;  
  9.     this.parentOffset = fromIndex;  
  10.     this.offset = offset + fromIndex;  
  11.     this.size = toIndex - fromIndex;  
  12.     this.modCount = ArrayList.this.modCount;  
  13. }  

SubList的方法调用,使用了两种方式
1.因为内部类可以访问外部类的方法和属性,所以一些操作直接使用外部类的方法
2.由于内部类AbstractList parent指向外部类的对象,有一些操作调用parent的方法,通过多态性调用了外部类的方法.

代码风格似乎不太统一..

add和remove都是调用抽象类的方法,通过多态性调用了ArrayList的方法
  1. public void add(int index, E e) {  
  2.     rangeCheckForAdd(index);  
  3.     checkForComodification();  
  4.     parent.add(parentOffset + index, e);  
  5.     this.modCount = parent.modCount;  
  6.     this.size++;  
  7. }  
  8.   
  9. public E remove(int index) {  
  10.     rangeCheck(index);  
  11.     checkForComodification();  
  12.     E result = parent.remove(parentOffset + index);  
  13.     this.modCount = parent.modCount;  
  14.     this.size--;  
  15.     return result;  
  16. }  

而get和set方法,又是通过内部类可以直接访问外部类的特性.
  1. public E set(int index, E e) {  
  2.     rangeCheck(index);  
  3.     checkForComodification();  
  4.     E oldValue = ArrayList.this.elementData(offset + index);  
  5.     ArrayList.this.elementData[offset + index] = e;  
  6.     return oldValue;  
  7. }  
  8.   
  9. public E get(int index) {  
  10.     rangeCheck(index);  
  11.     checkForComodification();  
  12.     return ArrayList.this.elementData(offset + index);  
  13. }  

有点意思.

来自 “ ITPUB博客 ” ，链接：https://blog.itpub.net/29254281/viewspace-2121834/ ，如需转载，请注明出处，否则将追究法律责任。

0
0
上一篇： 内部类总结
下一篇： 理解Java线程的中断
请登录后发表评论 登录
全部评论
壹頁書

注册时间：2013-10-19

  • 博文量
    620
  • 访问量
    6339935

最新文章

支持我们 作者招募 用户协议 FAQ Contact Us

北京盛拓优讯信息技术有限公司. 版权所有  京ICP备16024965号-8 北京市公安局海淀分局网监中心备案编号：11010802021510 niuxiaotong@pcpop.com 17352615567 未成年人举报专区

广播电视节目制作经营许可证(京) 字第1234号 中国互联网协会会员

违法和不良信息举报电话:18101376593