SubList到底怎么转化为ArrayList？

SubList

你们好，今天 Tony 给你们讲个SubList转化的坑。

这个错误真的会被忽略，你们好好的看看，这个错误咱们生产环境还真的遇到过。

集合类型相信你们都很熟悉，在 Java 中 ArrayList 使用的场景很是广泛。咱们今天主要看的是 ArrayList 中的 subList 方法。

首先咱们来看看源码



Returns a view of the portion of this list between the specified {@code fromIndex}, inclusive, and {@code toIndex}, exclusive.

”

在 jdk 的源码中清楚的写明了返回的是一个new SubList,方法的注释上面写的是返回一个 View，能够理解为视图。

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}

接下来咱们再细品SubList，源码

private class SubList extends AbstractList<E> implements RandomAccess {
      private final AbstractList<E> parent;
      private final int parentOffset;
      private final int offset;
      int size;

      SubList(AbstractList<E> parent,
              int offset, int fromIndex, int toIndex) {
          this.parent = parent;
          this.parentOffset = fromIndex;
          this.offset = offset + fromIndex;
          this.size = toIndex - fromIndex;
          this.modCount = ArrayList.this.modCount;
  }
}

SubList 是 ArrayList 中的一个内部类，继承了 AbstractList，实现了 RandomAccess，从上面的代码中能够看到，在 SubList 这个构造方法中仍是直接引用的父类中的元素，只是单纯的将截取的索引从新赋值了一下。

使用场景

public static void main(String[] args) {
    List<String> names = new ArrayList<String>() {{
        add("兔子");add("托尼");add("`啊");
    }};
    List<String> subList = names.subList(0, 3);
    System.out.println(subList);
}

上面的代码输出结果

[兔子, 托尼, 啊]

在什么状况下会报错呢？接下来再看个例子，把上面的代码简单修改下，让数据返回 ArrayList

public static void main(String[] args) {
      List<String> names = new ArrayList<String>() {{
        add("兔子");add("托尼");add("啊");
      }};
      ArrayList<String> subList = (ArrayList)names.subList(0, 3);
      System.out.println(subList);
  }

上面的代码直接抛出异常了

Exception in thread "main" java.lang.ClassCastException: java.util.ArrayList$SubList cannot be cast to java.util.ArrayList

为何不能直接转换为 ArrayList 呢？上面的源码已经显示了，SubList 只是一个内部类，它继承 AbstractList 和 ArrayList 根本都没有关系，因此直接转化会报 Cast 异常。

ModificationException

SubList 一样具备集合原始的方法好比添加、删除等。我截取部分源码。

public E set(int index, E e) {
      rangeCheck(index);
      checkForComodification();
      E oldValue = ArrayList.this.elementData(offset + index);
      ArrayList.this.elementData[offset + index] = e;
      return oldValue;
  }

  public E get(int index) {
      rangeCheck(index);
      checkForComodification();
      return ArrayList.this.elementData(offset + index);
  }

  public int size() {
      checkForComodification();
      return this.size;
  }

  public void add(int index, E e) {
      rangeCheckForAdd(index);
      checkForComodification();
      parent.add(parentOffset + index, e);
      this.modCount = parent.modCount;
      this.size++;
  }

  public E remove(int index) {
      rangeCheck(index);
      checkForComodification();
      E result = parent.remove(parentOffset + index);
      this.modCount = parent.modCount;
      this.size--;
      return result;
  }

  protected void removeRange(int fromIndex, int toIndex) {
      checkForComodification();
      parent.removeRange(parentOffset + fromIndex,
                         parentOffset + toIndex);
      this.modCount = parent.modCount;
      this.size -= toIndex - fromIndex;
  }

上面的源码中每个方法都包含有一个checkForComodification 方法。 这个方法是有什么做用呢？

private void checkForComodification() {
if (ArrayList.this.modCount != this.modCount)
    throw new ConcurrentModificationException();
}

源码中写的很清楚，判断原始类型，能够理解为父类型原始的 ArrayList 和当前的 SubList 方法中的元素个数作比较，若是不同就报异常。 一、 对 subList 视图作数据的删除

public static void main(String[] args) {
    List<String> namesList = new ArrayList<String>() {{
        add("兔子");
        add("托尼");
        add("啊");
    }};
    System.out.println("namesList原始的：== ==>" + namesList);
    List<String> subList = namesList.subList(0, 2);
    System.out.println("subList截取的：== ==>" + subList);
    //删除SubList第2个元素
    subList.remove(1);
    System.out.println("subList删除的：== ==>" + subList);
    System.out.println("namesList删除的：== ==>" + namesList);
}

上面的代码运行正常输出结果

namesList原始的：== ==>[兔子, 托尼, 啊]
subList截取的：== ==>[兔子, 托尼]
subList删除的：== ==>[兔子]
namesList删除的：== ==>[兔子, 啊]

二、 对 ArrayList 作数据的删除

public static void main(String[] args) {
    List<String> namesList = new ArrayList<String>() {{
        add("兔子");
        add("托尼");
        add("啊");
    }};
    System.out.println("namesList原始的：== ==>" + namesList);
    List<String> subList = namesList.subList(0, 2);
    System.out.println("subList截取的：== ==>" + subList);
    //删除ArraList第2个元素
    namesList.remove(1);
    System.out.println("subList删除的：== ==>" + subList);
    System.out.println("namesList删除的：== ==>" + namesList);
}

输出结果报异常了

namesList原始的：== ==>[兔子, 托尼, 啊]
subList截取的：== ==>[兔子, 托尼]
Exception in thread "main" java.util.ConcurrentModificationException
    at java.util.ArrayList$SubList.checkForComodification(ArrayList.java:1231)
    at java.util.ArrayList$SubList.listIterator(ArrayList.java:1091)
    at java.util.AbstractList.listIterator(AbstractList.java:299)
    at java.util.ArrayList$SubList.iterator(ArrayList.java:1087)
    at java.util.AbstractCollection.toString(AbstractCollection.java:454)
    at java.lang.String.valueOf(String.java:2994)
    at java.lang.StringBuilder.append(StringBuilder.java:131)

当咱们对父元素 ArrayList 中对数据进行删除操做的时候，咱们会发现 SubList 会报一个 ConcurrentModificationException 异常，这个异常是对数据比较发现元素被更改过，能够理解为脏数据吗？

总结

一、 SubList 和 ArrayList 之间没有任何关系

二、千万不要将 SubList 转化为 ArrayList 会报转换异常

三、对 SubList 视图元素修改会影响原始父 ArrayList 中的数据。

四、对 ArrayList 数据删除添加等修改，SubList 会报 Modification 异常

其实咱们能够理解下，SubList 理解为一个视图，其实就是一个内部类，它的实现就是在原始的 ArrayList 中改变了截取的索引位置。

对视图的操做结果会反映到原始的 ArrayList 中，若是对原始的 ArrayList 作数据的添加删除操做，很差意思此刻的 SubList 已经报异常了。

通俗一点，能够修改儿子，不能修改父亲。

结果

SubList 转化为 ArrayList 能够用 Guava 中的封装方法

Lists.newArrayList(subList)

下次见！