由ArrayList构造函数源码引出的问题

来源:互联网 发布:阿里云的图标含义 编辑:程序博客网 时间:2024/06/05 08:14

由ArrayList构造函数源码引出的问题

  ArrayList应该用得很多了。最近看了看其源码,发现有很多细节,如果要我们自己来实现,估计会考虑不到。当然,这些细节跟jdk本身一些实现的bug有关,如果不去深挖,定然是不能发现。本文从ArrayList的一个构造函数开始剖析。

  该构造函数源代码如下:

复制代码
1 public ArrayList(Collection<? extends E> c) {2         elementData = c.toArray();3         size = elementData.length;4         // c.toArray might (incorrectly) not return Object[] (see 6260652)5         if (elementData.getClass() != Object[].class)6             elementData = Arrays.copyOf(elementData, size, Object[].class);7     }
复制代码

  与上述源代码相关的elementData的申明如下:

1 private transient Object[] elementData;

  注意到,这是一个Object类型的数组。 

我的疑问在于,第四行注释是什么意思?原来,它表明这里涉及到jdk的一个bug,代号6260652。经过查找,在http://bugs.java.com/bugdatabase/view_bug.do?bug_id=6260652中有描述这个bug。它是这么描述的:Arrays.asList(x).toArray().getClass() should be Object[].class。原来,bug由来于Arrays这个工具类。查看源代码:

1 public static <T> List<T> asList(T... a) {2         return new ArrayList<>(a);3     }

  这边的ArrayList并非我们常用的java.util.ArrayList,而是Arrays的内部类。它继承自AbstractList,自然实现了Collection接口,代码如下:

复制代码
 1 private static class ArrayList<E> extends AbstractList<E> 2         implements RandomAccess, java.io.Serializable 3  { 4         private static final long serialVersionUID = -2764017481108945198L; 5         private final E[] a; 6  7         ArrayList(E[] array) { 8             if (array==null) 9                 throw new NullPointerException();10             a = array;11         }12 13         public int size() {14             return a.length;15         }16         。。。。。。17  }18     
复制代码

  可以发现,这里的a不是 Object[],而是E[]。a称为该ArrayList的backed array。同时构造函数也是直接用array给a赋值。这就是问题的所在。举个例子:

1     String[] s=new String[]{"hello","world"};2     List<String> list=Arrays.asList(s);3     Object[] a=list.toArray();4     System.out.println(a.getClass().getName());        

  上述代码输出的是"[Ljava.lang.String"。说明是String[]。而另一段代码(如下)输出的则是"[Ljava.lang.Object"。

1   ArrayList<String> s=new ArrayList<String>();2   System.out.println(s.toArray().getClass().getName());

  出于可靠性考虑,需要保证java.util.ArrayList的backed array类型都是Object[]的。故而,文章第一段代码处需要做一个判断,如果参数的toArray得到的类型不是Object[],则做另外的处理。如果不做该处理,会有问题吗?假如有如下代码:

1   List<Object> l = new ArrayList<Object>(Arrays.asList("foo", "bar"));2    l.set(0, new Object());

  如果不做处理,则会出现ArrayStoreException。因为l中的array类型是String[],不能随意存入Object类型的数据。通过该处理,就把Array.asList的问题在这个地方消除了。

  另一个问题:

  由此也更容易理解另一个问题,就是ArrayList的toArray。该函数有两种实现方式:

复制代码
 1   public Object[] toArray() { 2         return Arrays.copyOf(elementData, size); 3     } 4  5   public <T> T[] toArray(T[] a) { 6         if (a.length < size) 7             // Make a new array of a's runtime type, but my contents: 8             return (T[]) Arrays.copyOf(elementData, size, a.getClass()); 9         System.arraycopy(elementData, 0, a, 0, size);10         if (a.length > size)11             a[size] = null;12         return a;13     }
复制代码

  通常我们使用第二种,如果我们有一个ArrayList<String> s,要把它转换成String[],我们要这样写:

String[] sa=s.toArray(new String[0]);

  第二中返回的是泛型的数组,第一种则是Object[]。如果使用第一种,我们就不便对数组的值进行更改了,因为数组元素的类型是Object,而不是String。如果强制转成String[],则会出现ClassCastException。

  总结:ArrayList中的elementData是Object[],由此带来的问题,也应当在使用的时候注意。

 

 

 

private transient Object[] elementData;

分类: Java
标签: Java
好文要顶 关注我 收藏该文  
zhizhizhiyuan
关注 - 4
粉丝 - 6
+加关注
0
0
« 上一篇:Linux驱动之内存映射
» 下一篇:单件模式

posted on 2014-04-13 16:14 zhizhizhiyuan 阅读(145) 评论(1) 编辑 收藏

评论

#1楼 2017-10-22 21:24 N3verL4nd  

good

附: Arrays与ArrayList源码
package java.util;


import java.io.Serializable;
import java.lang.reflect.Array;
import java.security.AccessController;
import sun.security.action.GetBooleanAction;


public class Arrays
{
  private static final int INSERTIONSORT_THRESHOLD = 7;


  public static void sort(int[] paramArrayOfInt)
  {
    DualPivotQuicksort.sort(paramArrayOfInt);
  }


  public static void sort(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfInt, paramInt1, paramInt2 - 1);
  }


  public static void sort(long[] paramArrayOfLong)
  {
    DualPivotQuicksort.sort(paramArrayOfLong);
  }


  public static void sort(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfLong, paramInt1, paramInt2 - 1);
  }


  public static void sort(short[] paramArrayOfShort)
  {
    DualPivotQuicksort.sort(paramArrayOfShort);
  }


  public static void sort(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfShort, paramInt1, paramInt2 - 1);
  }


  public static void sort(char[] paramArrayOfChar)
  {
    DualPivotQuicksort.sort(paramArrayOfChar);
  }


  public static void sort(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfChar, paramInt1, paramInt2 - 1);
  }


  public static void sort(byte[] paramArrayOfByte)
  {
    DualPivotQuicksort.sort(paramArrayOfByte);
  }


  public static void sort(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfByte, paramInt1, paramInt2 - 1);
  }


  public static void sort(float[] paramArrayOfFloat)
  {
    DualPivotQuicksort.sort(paramArrayOfFloat);
  }


  public static void sort(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfFloat, paramInt1, paramInt2 - 1);
  }


  public static void sort(double[] paramArrayOfDouble)
  {
    DualPivotQuicksort.sort(paramArrayOfDouble);
  }


  public static void sort(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    DualPivotQuicksort.sort(paramArrayOfDouble, paramInt1, paramInt2 - 1);
  }


  public static void sort(Object[] paramArrayOfObject)
  {
    if (LegacyMergeSort.userRequested)
      legacyMergeSort(paramArrayOfObject);
    else
      ComparableTimSort.sort(paramArrayOfObject);
  }


  private static void legacyMergeSort(Object[] paramArrayOfObject)
  {
    Object[] arrayOfObject = (Object[])paramArrayOfObject.clone();
    mergeSort(arrayOfObject, paramArrayOfObject, 0, paramArrayOfObject.length, 0);
  }


  public static void sort(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    if (LegacyMergeSort.userRequested)
      legacyMergeSort(paramArrayOfObject, paramInt1, paramInt2);
    else
      ComparableTimSort.sort(paramArrayOfObject, paramInt1, paramInt2);
  }


  private static void legacyMergeSort(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    Object[] arrayOfObject = copyOfRange(paramArrayOfObject, paramInt1, paramInt2);
    mergeSort(arrayOfObject, paramArrayOfObject, paramInt1, paramInt2, -paramInt1);
  }


  private static void mergeSort(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramInt2 - paramInt1;
    if (i < 7)
    {
      for (j = paramInt1; j < paramInt2; j++)
        for (k = j; (k > paramInt1) && (((Comparable)paramArrayOfObject2[(k - 1)]).compareTo(paramArrayOfObject2[k]) > 0); k--)
          swap(paramArrayOfObject2, k, k - 1);
      return;
    }
    int j = paramInt1;
    int k = paramInt2;
    paramInt1 += paramInt3;
    paramInt2 += paramInt3;
    int m = paramInt1 + paramInt2 >>> 1;
    mergeSort(paramArrayOfObject2, paramArrayOfObject1, paramInt1, m, -paramInt3);
    mergeSort(paramArrayOfObject2, paramArrayOfObject1, m, paramInt2, -paramInt3);
    if (((Comparable)paramArrayOfObject1[(m - 1)]).compareTo(paramArrayOfObject1[m]) <= 0)
    {
      System.arraycopy(paramArrayOfObject1, paramInt1, paramArrayOfObject2, j, i);
      return;
    }
    int n = j;
    int i1 = paramInt1;
    int i2 = m;
    while (n < k)
    {
      if ((i2 >= paramInt2) || ((i1 < m) && (((Comparable)paramArrayOfObject1[i1]).compareTo(paramArrayOfObject1[i2]) <= 0)))
        paramArrayOfObject2[n] = paramArrayOfObject1[(i1++)];
      else
        paramArrayOfObject2[n] = paramArrayOfObject1[(i2++)];
      n++;
    }
  }


  private static void swap(Object[] paramArrayOfObject, int paramInt1, int paramInt2)
  {
    Object localObject = paramArrayOfObject[paramInt1];
    paramArrayOfObject[paramInt1] = paramArrayOfObject[paramInt2];
    paramArrayOfObject[paramInt2] = localObject;
  }


  public static <T> void sort(T[] paramArrayOfT, Comparator<? super T> paramComparator)
  {
    if (LegacyMergeSort.userRequested)
      legacyMergeSort(paramArrayOfT, paramComparator);
    else
      TimSort.sort(paramArrayOfT, paramComparator);
  }


  private static <T> void legacyMergeSort(T[] paramArrayOfT, Comparator<? super T> paramComparator)
  {
    Object[] arrayOfObject = (Object[])paramArrayOfT.clone();
    if (paramComparator == null)
      mergeSort(arrayOfObject, paramArrayOfT, 0, paramArrayOfT.length, 0);
    else
      mergeSort(arrayOfObject, paramArrayOfT, 0, paramArrayOfT.length, 0, paramComparator);
  }


  public static <T> void sort(T[] paramArrayOfT, int paramInt1, int paramInt2, Comparator<? super T> paramComparator)
  {
    if (LegacyMergeSort.userRequested)
      legacyMergeSort(paramArrayOfT, paramInt1, paramInt2, paramComparator);
    else
      TimSort.sort(paramArrayOfT, paramInt1, paramInt2, paramComparator);
  }


  private static <T> void legacyMergeSort(T[] paramArrayOfT, int paramInt1, int paramInt2, Comparator<? super T> paramComparator)
  {
    rangeCheck(paramArrayOfT.length, paramInt1, paramInt2);
    Object[] arrayOfObject = copyOfRange(paramArrayOfT, paramInt1, paramInt2);
    if (paramComparator == null)
      mergeSort(arrayOfObject, paramArrayOfT, paramInt1, paramInt2, -paramInt1);
    else
      mergeSort(arrayOfObject, paramArrayOfT, paramInt1, paramInt2, -paramInt1, paramComparator);
  }


  private static void mergeSort(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2, int paramInt1, int paramInt2, int paramInt3, Comparator paramComparator)
  {
    int i = paramInt2 - paramInt1;
    if (i < 7)
    {
      for (j = paramInt1; j < paramInt2; j++)
        for (k = j; (k > paramInt1) && (paramComparator.compare(paramArrayOfObject2[(k - 1)], paramArrayOfObject2[k]) > 0); k--)
          swap(paramArrayOfObject2, k, k - 1);
      return;
    }
    int j = paramInt1;
    int k = paramInt2;
    paramInt1 += paramInt3;
    paramInt2 += paramInt3;
    int m = paramInt1 + paramInt2 >>> 1;
    mergeSort(paramArrayOfObject2, paramArrayOfObject1, paramInt1, m, -paramInt3, paramComparator);
    mergeSort(paramArrayOfObject2, paramArrayOfObject1, m, paramInt2, -paramInt3, paramComparator);
    if (paramComparator.compare(paramArrayOfObject1[(m - 1)], paramArrayOfObject1[m]) <= 0)
    {
      System.arraycopy(paramArrayOfObject1, paramInt1, paramArrayOfObject2, j, i);
      return;
    }
    int n = j;
    int i1 = paramInt1;
    int i2 = m;
    while (n < k)
    {
      if ((i2 >= paramInt2) || ((i1 < m) && (paramComparator.compare(paramArrayOfObject1[i1], paramArrayOfObject1[i2]) <= 0)))
        paramArrayOfObject2[n] = paramArrayOfObject1[(i1++)];
      else
        paramArrayOfObject2[n] = paramArrayOfObject1[(i2++)];
      n++;
    }
  }


  private static void rangeCheck(int paramInt1, int paramInt2, int paramInt3)
  {
    if (paramInt2 > paramInt3)
      throw new IllegalArgumentException("fromIndex(" + paramInt2 + ") > toIndex(" + paramInt3 + ")");
    if (paramInt2 < 0)
      throw new ArrayIndexOutOfBoundsException(paramInt2);
    if (paramInt3 > paramInt1)
      throw new ArrayIndexOutOfBoundsException(paramInt3);
  }


  public static int binarySearch(long[] paramArrayOfLong, long paramLong)
  {
    return binarySearch0(paramArrayOfLong, 0, paramArrayOfLong.length, paramLong);
  }


  public static int binarySearch(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfLong, paramInt1, paramInt2, paramLong);
  }


  private static int binarySearch0(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      long l = paramArrayOfLong[k];
      if (l < paramLong)
        i = k + 1;
      else if (l > paramLong)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static int binarySearch(int[] paramArrayOfInt, int paramInt)
  {
    return binarySearch0(paramArrayOfInt, 0, paramArrayOfInt.length, paramInt);
  }


  public static int binarySearch(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfInt, paramInt1, paramInt2, paramInt3);
  }


  private static int binarySearch0(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      int m = paramArrayOfInt[k];
      if (m < paramInt3)
        i = k + 1;
      else if (m > paramInt3)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static int binarySearch(short[] paramArrayOfShort, short paramShort)
  {
    return binarySearch0(paramArrayOfShort, 0, paramArrayOfShort.length, paramShort);
  }


  public static int binarySearch(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfShort, paramInt1, paramInt2, paramShort);
  }


  private static int binarySearch0(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      short s = paramArrayOfShort[k];
      if (s < paramShort)
        i = k + 1;
      else if (s > paramShort)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static int binarySearch(char[] paramArrayOfChar, char paramChar)
  {
    return binarySearch0(paramArrayOfChar, 0, paramArrayOfChar.length, paramChar);
  }


  public static int binarySearch(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfChar, paramInt1, paramInt2, paramChar);
  }


  private static int binarySearch0(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      char c = paramArrayOfChar[k];
      if (c < paramChar)
        i = k + 1;
      else if (c > paramChar)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static int binarySearch(byte[] paramArrayOfByte, byte paramByte)
  {
    return binarySearch0(paramArrayOfByte, 0, paramArrayOfByte.length, paramByte);
  }


  public static int binarySearch(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfByte, paramInt1, paramInt2, paramByte);
  }


  private static int binarySearch0(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      byte b = paramArrayOfByte[k];
      if (b < paramByte)
        i = k + 1;
      else if (b > paramByte)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static int binarySearch(double[] paramArrayOfDouble, double paramDouble)
  {
    return binarySearch0(paramArrayOfDouble, 0, paramArrayOfDouble.length, paramDouble);
  }


  public static int binarySearch(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfDouble, paramInt1, paramInt2, paramDouble);
  }


  private static int binarySearch0(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      double d = paramArrayOfDouble[k];
      if (d < paramDouble)
      {
        i = k + 1;
      }
      else if (d > paramDouble)
      {
        j = k - 1;
      }
      else
      {
        long l1 = Double.doubleToLongBits(d);
        long l2 = Double.doubleToLongBits(paramDouble);
        if (l1 == l2)
          return k;
        if (l1 < l2)
          i = k + 1;
        else
          j = k - 1;
      }
    }
    return -(i + 1);
  }


  public static int binarySearch(float[] paramArrayOfFloat, float paramFloat)
  {
    return binarySearch0(paramArrayOfFloat, 0, paramArrayOfFloat.length, paramFloat);
  }


  public static int binarySearch(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfFloat, paramInt1, paramInt2, paramFloat);
  }


  private static int binarySearch0(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      float f = paramArrayOfFloat[k];
      if (f < paramFloat)
      {
        i = k + 1;
      }
      else if (f > paramFloat)
      {
        j = k - 1;
      }
      else
      {
        int m = Float.floatToIntBits(f);
        int n = Float.floatToIntBits(paramFloat);
        if (m == n)
          return k;
        if (m < n)
          i = k + 1;
        else
          j = k - 1;
      }
    }
    return -(i + 1);
  }


  public static int binarySearch(Object[] paramArrayOfObject, Object paramObject)
  {
    return binarySearch0(paramArrayOfObject, 0, paramArrayOfObject.length, paramObject);
  }


  public static int binarySearch(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfObject, paramInt1, paramInt2, paramObject);
  }


  private static int binarySearch0(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      Comparable localComparable = (Comparable)paramArrayOfObject[k];
      int m = localComparable.compareTo(paramObject);
      if (m < 0)
        i = k + 1;
      else if (m > 0)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static <T> int binarySearch(T[] paramArrayOfT, T paramT, Comparator<? super T> paramComparator)
  {
    return binarySearch0(paramArrayOfT, 0, paramArrayOfT.length, paramT, paramComparator);
  }


  public static <T> int binarySearch(T[] paramArrayOfT, int paramInt1, int paramInt2, T paramT, Comparator<? super T> paramComparator)
  {
    rangeCheck(paramArrayOfT.length, paramInt1, paramInt2);
    return binarySearch0(paramArrayOfT, paramInt1, paramInt2, paramT, paramComparator);
  }


  private static <T> int binarySearch0(T[] paramArrayOfT, int paramInt1, int paramInt2, T paramT, Comparator<? super T> paramComparator)
  {
    if (paramComparator == null)
      return binarySearch0(paramArrayOfT, paramInt1, paramInt2, paramT);
    int i = paramInt1;
    int j = paramInt2 - 1;
    while (i <= j)
    {
      int k = i + j >>> 1;
      T ? = paramArrayOfT[k];
      int m = paramComparator.compare(?, paramT);
      if (m < 0)
        i = k + 1;
      else if (m > 0)
        j = k - 1;
      else
        return k;
    }
    return -(i + 1);
  }


  public static boolean equals(long[] paramArrayOfLong1, long[] paramArrayOfLong2)
  {
    if (paramArrayOfLong1 == paramArrayOfLong2)
      return true;
    if ((paramArrayOfLong1 == null) || (paramArrayOfLong2 == null))
      return false;
    int i = paramArrayOfLong1.length;
    if (paramArrayOfLong2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfLong1[j] != paramArrayOfLong2[j])
        return false;
    return true;
  }


  public static boolean equals(int[] paramArrayOfInt1, int[] paramArrayOfInt2)
  {
    if (paramArrayOfInt1 == paramArrayOfInt2)
      return true;
    if ((paramArrayOfInt1 == null) || (paramArrayOfInt2 == null))
      return false;
    int i = paramArrayOfInt1.length;
    if (paramArrayOfInt2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfInt1[j] != paramArrayOfInt2[j])
        return false;
    return true;
  }


  public static boolean equals(short[] paramArrayOfShort1, short[] paramArrayOfShort2)
  {
    if (paramArrayOfShort1 == paramArrayOfShort2)
      return true;
    if ((paramArrayOfShort1 == null) || (paramArrayOfShort2 == null))
      return false;
    int i = paramArrayOfShort1.length;
    if (paramArrayOfShort2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfShort1[j] != paramArrayOfShort2[j])
        return false;
    return true;
  }


  public static boolean equals(char[] paramArrayOfChar1, char[] paramArrayOfChar2)
  {
    if (paramArrayOfChar1 == paramArrayOfChar2)
      return true;
    if ((paramArrayOfChar1 == null) || (paramArrayOfChar2 == null))
      return false;
    int i = paramArrayOfChar1.length;
    if (paramArrayOfChar2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfChar1[j] != paramArrayOfChar2[j])
        return false;
    return true;
  }


  public static boolean equals(byte[] paramArrayOfByte1, byte[] paramArrayOfByte2)
  {
    if (paramArrayOfByte1 == paramArrayOfByte2)
      return true;
    if ((paramArrayOfByte1 == null) || (paramArrayOfByte2 == null))
      return false;
    int i = paramArrayOfByte1.length;
    if (paramArrayOfByte2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfByte1[j] != paramArrayOfByte2[j])
        return false;
    return true;
  }


  public static boolean equals(boolean[] paramArrayOfBoolean1, boolean[] paramArrayOfBoolean2)
  {
    if (paramArrayOfBoolean1 == paramArrayOfBoolean2)
      return true;
    if ((paramArrayOfBoolean1 == null) || (paramArrayOfBoolean2 == null))
      return false;
    int i = paramArrayOfBoolean1.length;
    if (paramArrayOfBoolean2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (paramArrayOfBoolean1[j] != paramArrayOfBoolean2[j])
        return false;
    return true;
  }


  public static boolean equals(double[] paramArrayOfDouble1, double[] paramArrayOfDouble2)
  {
    if (paramArrayOfDouble1 == paramArrayOfDouble2)
      return true;
    if ((paramArrayOfDouble1 == null) || (paramArrayOfDouble2 == null))
      return false;
    int i = paramArrayOfDouble1.length;
    if (paramArrayOfDouble2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (Double.doubleToLongBits(paramArrayOfDouble1[j]) != Double.doubleToLongBits(paramArrayOfDouble2[j]))
        return false;
    return true;
  }


  public static boolean equals(float[] paramArrayOfFloat1, float[] paramArrayOfFloat2)
  {
    if (paramArrayOfFloat1 == paramArrayOfFloat2)
      return true;
    if ((paramArrayOfFloat1 == null) || (paramArrayOfFloat2 == null))
      return false;
    int i = paramArrayOfFloat1.length;
    if (paramArrayOfFloat2.length != i)
      return false;
    for (int j = 0; j < i; j++)
      if (Float.floatToIntBits(paramArrayOfFloat1[j]) != Float.floatToIntBits(paramArrayOfFloat2[j]))
        return false;
    return true;
  }


  public static boolean equals(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2)
  {
    if (paramArrayOfObject1 == paramArrayOfObject2)
      return true;
    if ((paramArrayOfObject1 == null) || (paramArrayOfObject2 == null))
      return false;
    int i = paramArrayOfObject1.length;
    if (paramArrayOfObject2.length != i)
      return false;
    for (int j = 0; j < i; j++)
    {
      Object localObject1 = paramArrayOfObject1[j];
      Object localObject2 = paramArrayOfObject2[j];
      if (localObject1 == null ? localObject2 != null : !localObject1.equals(localObject2))
        return false;
    }
    return true;
  }


  public static void fill(long[] paramArrayOfLong, long paramLong)
  {
    int i = 0;
    int j = paramArrayOfLong.length;
    while (i < j)
    {
      paramArrayOfLong[i] = paramLong;
      i++;
    }
  }


  public static void fill(long[] paramArrayOfLong, int paramInt1, int paramInt2, long paramLong)
  {
    rangeCheck(paramArrayOfLong.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfLong[i] = paramLong;
  }


  public static void fill(int[] paramArrayOfInt, int paramInt)
  {
    int i = 0;
    int j = paramArrayOfInt.length;
    while (i < j)
    {
      paramArrayOfInt[i] = paramInt;
      i++;
    }
  }


  public static void fill(int[] paramArrayOfInt, int paramInt1, int paramInt2, int paramInt3)
  {
    rangeCheck(paramArrayOfInt.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfInt[i] = paramInt3;
  }


  public static void fill(short[] paramArrayOfShort, short paramShort)
  {
    int i = 0;
    int j = paramArrayOfShort.length;
    while (i < j)
    {
      paramArrayOfShort[i] = paramShort;
      i++;
    }
  }


  public static void fill(short[] paramArrayOfShort, int paramInt1, int paramInt2, short paramShort)
  {
    rangeCheck(paramArrayOfShort.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfShort[i] = paramShort;
  }


  public static void fill(char[] paramArrayOfChar, char paramChar)
  {
    int i = 0;
    int j = paramArrayOfChar.length;
    while (i < j)
    {
      paramArrayOfChar[i] = paramChar;
      i++;
    }
  }


  public static void fill(char[] paramArrayOfChar, int paramInt1, int paramInt2, char paramChar)
  {
    rangeCheck(paramArrayOfChar.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfChar[i] = paramChar;
  }


  public static void fill(byte[] paramArrayOfByte, byte paramByte)
  {
    int i = 0;
    int j = paramArrayOfByte.length;
    while (i < j)
    {
      paramArrayOfByte[i] = paramByte;
      i++;
    }
  }


  public static void fill(byte[] paramArrayOfByte, int paramInt1, int paramInt2, byte paramByte)
  {
    rangeCheck(paramArrayOfByte.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfByte[i] = paramByte;
  }


  public static void fill(boolean[] paramArrayOfBoolean, boolean paramBoolean)
  {
    int i = 0;
    int j = paramArrayOfBoolean.length;
    while (i < j)
    {
      paramArrayOfBoolean[i] = paramBoolean;
      i++;
    }
  }


  public static void fill(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2, boolean paramBoolean)
  {
    rangeCheck(paramArrayOfBoolean.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfBoolean[i] = paramBoolean;
  }


  public static void fill(double[] paramArrayOfDouble, double paramDouble)
  {
    int i = 0;
    int j = paramArrayOfDouble.length;
    while (i < j)
    {
      paramArrayOfDouble[i] = paramDouble;
      i++;
    }
  }


  public static void fill(double[] paramArrayOfDouble, int paramInt1, int paramInt2, double paramDouble)
  {
    rangeCheck(paramArrayOfDouble.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfDouble[i] = paramDouble;
  }


  public static void fill(float[] paramArrayOfFloat, float paramFloat)
  {
    int i = 0;
    int j = paramArrayOfFloat.length;
    while (i < j)
    {
      paramArrayOfFloat[i] = paramFloat;
      i++;
    }
  }


  public static void fill(float[] paramArrayOfFloat, int paramInt1, int paramInt2, float paramFloat)
  {
    rangeCheck(paramArrayOfFloat.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfFloat[i] = paramFloat;
  }


  public static void fill(Object[] paramArrayOfObject, Object paramObject)
  {
    int i = 0;
    int j = paramArrayOfObject.length;
    while (i < j)
    {
      paramArrayOfObject[i] = paramObject;
      i++;
    }
  }


  public static void fill(Object[] paramArrayOfObject, int paramInt1, int paramInt2, Object paramObject)
  {
    rangeCheck(paramArrayOfObject.length, paramInt1, paramInt2);
    for (int i = paramInt1; i < paramInt2; i++)
      paramArrayOfObject[i] = paramObject;
  }


  public static <T> T[] copyOf(T[] paramArrayOfT, int paramInt)
  {
    return (Object[])copyOf(paramArrayOfT, paramInt, paramArrayOfT.getClass());
  }


  public static <T, U> T[] copyOf(U[] paramArrayOfU, int paramInt, Class<? extends T[]> paramClass)
  {
    Object[] arrayOfObject = paramClass == [Ljava.lang.Object.class ? (Object[])new Object[paramInt] : (Object[])(Object[])Array.newInstance(paramClass.getComponentType(), paramInt);
    System.arraycopy(paramArrayOfU, 0, arrayOfObject, 0, Math.min(paramArrayOfU.length, paramInt));
    return arrayOfObject;
  }


  public static byte[] copyOf(byte[] paramArrayOfByte, int paramInt)
  {
    byte[] arrayOfByte = new byte[paramInt];
    System.arraycopy(paramArrayOfByte, 0, arrayOfByte, 0, Math.min(paramArrayOfByte.length, paramInt));
    return arrayOfByte;
  }


  public static short[] copyOf(short[] paramArrayOfShort, int paramInt)
  {
    short[] arrayOfShort = new short[paramInt];
    System.arraycopy(paramArrayOfShort, 0, arrayOfShort, 0, Math.min(paramArrayOfShort.length, paramInt));
    return arrayOfShort;
  }


  public static int[] copyOf(int[] paramArrayOfInt, int paramInt)
  {
    int[] arrayOfInt = new int[paramInt];
    System.arraycopy(paramArrayOfInt, 0, arrayOfInt, 0, Math.min(paramArrayOfInt.length, paramInt));
    return arrayOfInt;
  }


  public static long[] copyOf(long[] paramArrayOfLong, int paramInt)
  {
    long[] arrayOfLong = new long[paramInt];
    System.arraycopy(paramArrayOfLong, 0, arrayOfLong, 0, Math.min(paramArrayOfLong.length, paramInt));
    return arrayOfLong;
  }


  public static char[] copyOf(char[] paramArrayOfChar, int paramInt)
  {
    char[] arrayOfChar = new char[paramInt];
    System.arraycopy(paramArrayOfChar, 0, arrayOfChar, 0, Math.min(paramArrayOfChar.length, paramInt));
    return arrayOfChar;
  }


  public static float[] copyOf(float[] paramArrayOfFloat, int paramInt)
  {
    float[] arrayOfFloat = new float[paramInt];
    System.arraycopy(paramArrayOfFloat, 0, arrayOfFloat, 0, Math.min(paramArrayOfFloat.length, paramInt));
    return arrayOfFloat;
  }


  public static double[] copyOf(double[] paramArrayOfDouble, int paramInt)
  {
    double[] arrayOfDouble = new double[paramInt];
    System.arraycopy(paramArrayOfDouble, 0, arrayOfDouble, 0, Math.min(paramArrayOfDouble.length, paramInt));
    return arrayOfDouble;
  }


  public static boolean[] copyOf(boolean[] paramArrayOfBoolean, int paramInt)
  {
    boolean[] arrayOfBoolean = new boolean[paramInt];
    System.arraycopy(paramArrayOfBoolean, 0, arrayOfBoolean, 0, Math.min(paramArrayOfBoolean.length, paramInt));
    return arrayOfBoolean;
  }


  public static <T> T[] copyOfRange(T[] paramArrayOfT, int paramInt1, int paramInt2)
  {
    return copyOfRange(paramArrayOfT, paramInt1, paramInt2, paramArrayOfT.getClass());
  }


  public static <T, U> T[] copyOfRange(U[] paramArrayOfU, int paramInt1, int paramInt2, Class<? extends T[]> paramClass)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    Object[] arrayOfObject = paramClass == [Ljava.lang.Object.class ? (Object[])new Object[i] : (Object[])(Object[])Array.newInstance(paramClass.getComponentType(), i);
    System.arraycopy(paramArrayOfU, paramInt1, arrayOfObject, 0, Math.min(paramArrayOfU.length - paramInt1, i));
    return arrayOfObject;
  }


  public static byte[] copyOfRange(byte[] paramArrayOfByte, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    byte[] arrayOfByte = new byte[i];
    System.arraycopy(paramArrayOfByte, paramInt1, arrayOfByte, 0, Math.min(paramArrayOfByte.length - paramInt1, i));
    return arrayOfByte;
  }


  public static short[] copyOfRange(short[] paramArrayOfShort, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    short[] arrayOfShort = new short[i];
    System.arraycopy(paramArrayOfShort, paramInt1, arrayOfShort, 0, Math.min(paramArrayOfShort.length - paramInt1, i));
    return arrayOfShort;
  }


  public static int[] copyOfRange(int[] paramArrayOfInt, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    int[] arrayOfInt = new int[i];
    System.arraycopy(paramArrayOfInt, paramInt1, arrayOfInt, 0, Math.min(paramArrayOfInt.length - paramInt1, i));
    return arrayOfInt;
  }


  public static long[] copyOfRange(long[] paramArrayOfLong, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    long[] arrayOfLong = new long[i];
    System.arraycopy(paramArrayOfLong, paramInt1, arrayOfLong, 0, Math.min(paramArrayOfLong.length - paramInt1, i));
    return arrayOfLong;
  }


  public static char[] copyOfRange(char[] paramArrayOfChar, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    char[] arrayOfChar = new char[i];
    System.arraycopy(paramArrayOfChar, paramInt1, arrayOfChar, 0, Math.min(paramArrayOfChar.length - paramInt1, i));
    return arrayOfChar;
  }


  public static float[] copyOfRange(float[] paramArrayOfFloat, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    float[] arrayOfFloat = new float[i];
    System.arraycopy(paramArrayOfFloat, paramInt1, arrayOfFloat, 0, Math.min(paramArrayOfFloat.length - paramInt1, i));
    return arrayOfFloat;
  }


  public static double[] copyOfRange(double[] paramArrayOfDouble, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    double[] arrayOfDouble = new double[i];
    System.arraycopy(paramArrayOfDouble, paramInt1, arrayOfDouble, 0, Math.min(paramArrayOfDouble.length - paramInt1, i));
    return arrayOfDouble;
  }


  public static boolean[] copyOfRange(boolean[] paramArrayOfBoolean, int paramInt1, int paramInt2)
  {
    int i = paramInt2 - paramInt1;
    if (i < 0)
      throw new IllegalArgumentException(paramInt1 + " > " + paramInt2);
    boolean[] arrayOfBoolean = new boolean[i];
    System.arraycopy(paramArrayOfBoolean, paramInt1, arrayOfBoolean, 0, Math.min(paramArrayOfBoolean.length - paramInt1, i));
    return arrayOfBoolean;
  }


  @SafeVarargs
  public static <T> List<T> asList(T[] paramArrayOfT)
  {
    return new ArrayList(paramArrayOfT);
  }


  public static int hashCode(long[] paramArrayOfLong)
  {
    if (paramArrayOfLong == null)
      return 0;
    int i = 1;
    for (long l : paramArrayOfLong)
    {
      int m = (int)(l ^ l >>> 32);
      i = 31 * i + m;
    }
    return i;
  }


  public static int hashCode(int[] paramArrayOfInt)
  {
    if (paramArrayOfInt == null)
      return 0;
    int i = 1;
    for (int m : paramArrayOfInt)
      i = 31 * i + m;
    return i;
  }


  public static int hashCode(short[] paramArrayOfShort)
  {
    if (paramArrayOfShort == null)
      return 0;
    int i = 1;
    for (int m : paramArrayOfShort)
      i = 31 * i + m;
    return i;
  }


  public static int hashCode(char[] paramArrayOfChar)
  {
    if (paramArrayOfChar == null)
      return 0;
    int i = 1;
    for (int m : paramArrayOfChar)
      i = 31 * i + m;
    return i;
  }


  public static int hashCode(byte[] paramArrayOfByte)
  {
    if (paramArrayOfByte == null)
      return 0;
    int i = 1;
    for (int m : paramArrayOfByte)
      i = 31 * i + m;
    return i;
  }


  public static int hashCode(boolean[] paramArrayOfBoolean)
  {
    if (paramArrayOfBoolean == null)
      return 0;
    int i = 1;
    for (int m : paramArrayOfBoolean)
      i = 31 * i + (m != 0 ? 1231 : 1237);
    return i;
  }


  public static int hashCode(float[] paramArrayOfFloat)
  {
    if (paramArrayOfFloat == null)
      return 0;
    int i = 1;
    for (float f : paramArrayOfFloat)
      i = 31 * i + Float.floatToIntBits(f);
    return i;
  }


  public static int hashCode(double[] paramArrayOfDouble)
  {
    if (paramArrayOfDouble == null)
      return 0;
    int i = 1;
    for (double d : paramArrayOfDouble)
    {
      long l = Double.doubleToLongBits(d);
      i = 31 * i + (int)(l ^ l >>> 32);
    }
    return i;
  }


  public static int hashCode(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null)
      return 0;
    int i = 1;
    for (Object localObject : paramArrayOfObject)
      i = 31 * i + (localObject == null ? 0 : localObject.hashCode());
    return i;
  }


  public static int deepHashCode(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null)
      return 0;
    int i = 1;
    for (Object localObject : paramArrayOfObject)
    {
      int m = 0;
      if ((localObject instanceof Object[]))
        m = deepHashCode((Object[])(Object[])localObject);
      else if ((localObject instanceof byte[]))
        m = hashCode((byte[])(byte[])localObject);
      else if ((localObject instanceof short[]))
        m = hashCode((short[])(short[])localObject);
      else if ((localObject instanceof int[]))
        m = hashCode((int[])(int[])localObject);
      else if ((localObject instanceof long[]))
        m = hashCode((long[])(long[])localObject);
      else if ((localObject instanceof char[]))
        m = hashCode((char[])(char[])localObject);
      else if ((localObject instanceof float[]))
        m = hashCode((float[])(float[])localObject);
      else if ((localObject instanceof double[]))
        m = hashCode((double[])(double[])localObject);
      else if ((localObject instanceof boolean[]))
        m = hashCode((boolean[])(boolean[])localObject);
      else if (localObject != null)
        m = localObject.hashCode();
      i = 31 * i + m;
    }
    return i;
  }


  public static boolean deepEquals(Object[] paramArrayOfObject1, Object[] paramArrayOfObject2)
  {
    if (paramArrayOfObject1 == paramArrayOfObject2)
      return true;
    if ((paramArrayOfObject1 == null) || (paramArrayOfObject2 == null))
      return false;
    int i = paramArrayOfObject1.length;
    if (paramArrayOfObject2.length != i)
      return false;
    for (int j = 0; j < i; j++)
    {
      Object localObject1 = paramArrayOfObject1[j];
      Object localObject2 = paramArrayOfObject2[j];
      if (localObject1 == localObject2)
        continue;
      if (localObject1 == null)
        return false;
      boolean bool = deepEquals0(localObject1, localObject2);
      if (!bool)
        return false;
    }
    return true;
  }


  static boolean deepEquals0(Object paramObject1, Object paramObject2)
  {
    assert (paramObject1 != null);
    boolean bool;
    if (((paramObject1 instanceof Object[])) && ((paramObject2 instanceof Object[])))
      bool = deepEquals((Object[])(Object[])paramObject1, (Object[])(Object[])paramObject2);
    else if (((paramObject1 instanceof byte[])) && ((paramObject2 instanceof byte[])))
      bool = equals((byte[])(byte[])paramObject1, (byte[])(byte[])paramObject2);
    else if (((paramObject1 instanceof short[])) && ((paramObject2 instanceof short[])))
      bool = equals((short[])(short[])paramObject1, (short[])(short[])paramObject2);
    else if (((paramObject1 instanceof int[])) && ((paramObject2 instanceof int[])))
      bool = equals((int[])(int[])paramObject1, (int[])(int[])paramObject2);
    else if (((paramObject1 instanceof long[])) && ((paramObject2 instanceof long[])))
      bool = equals((long[])(long[])paramObject1, (long[])(long[])paramObject2);
    else if (((paramObject1 instanceof char[])) && ((paramObject2 instanceof char[])))
      bool = equals((char[])(char[])paramObject1, (char[])(char[])paramObject2);
    else if (((paramObject1 instanceof float[])) && ((paramObject2 instanceof float[])))
      bool = equals((float[])(float[])paramObject1, (float[])(float[])paramObject2);
    else if (((paramObject1 instanceof double[])) && ((paramObject2 instanceof double[])))
      bool = equals((double[])(double[])paramObject1, (double[])(double[])paramObject2);
    else if (((paramObject1 instanceof boolean[])) && ((paramObject2 instanceof boolean[])))
      bool = equals((boolean[])(boolean[])paramObject1, (boolean[])(boolean[])paramObject2);
    else
      bool = paramObject1.equals(paramObject2);
    return bool;
  }


  public static String toString(long[] paramArrayOfLong)
  {
    if (paramArrayOfLong == null)
      return "null";
    int i = paramArrayOfLong.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfLong[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(int[] paramArrayOfInt)
  {
    if (paramArrayOfInt == null)
      return "null";
    int i = paramArrayOfInt.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfInt[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(short[] paramArrayOfShort)
  {
    if (paramArrayOfShort == null)
      return "null";
    int i = paramArrayOfShort.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfShort[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(char[] paramArrayOfChar)
  {
    if (paramArrayOfChar == null)
      return "null";
    int i = paramArrayOfChar.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfChar[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(byte[] paramArrayOfByte)
  {
    if (paramArrayOfByte == null)
      return "null";
    int i = paramArrayOfByte.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfByte[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(boolean[] paramArrayOfBoolean)
  {
    if (paramArrayOfBoolean == null)
      return "null";
    int i = paramArrayOfBoolean.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfBoolean[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(float[] paramArrayOfFloat)
  {
    if (paramArrayOfFloat == null)
      return "null";
    int i = paramArrayOfFloat.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfFloat[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(double[] paramArrayOfDouble)
  {
    if (paramArrayOfDouble == null)
      return "null";
    int i = paramArrayOfDouble.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(paramArrayOfDouble[j]);
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String toString(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null)
      return "null";
    int i = paramArrayOfObject.length - 1;
    if (i == -1)
      return "[]";
    StringBuilder localStringBuilder = new StringBuilder();
    localStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      localStringBuilder.append(String.valueOf(paramArrayOfObject[j]));
      if (j == i)
        return ']';
      localStringBuilder.append(", ");
    }
  }


  public static String deepToString(Object[] paramArrayOfObject)
  {
    if (paramArrayOfObject == null)
      return "null";
    int i = 20 * paramArrayOfObject.length;
    if ((paramArrayOfObject.length != 0) && (i <= 0))
      i = 2147483647;
    StringBuilder localStringBuilder = new StringBuilder(i);
    deepToString(paramArrayOfObject, localStringBuilder, new HashSet());
    return localStringBuilder.toString();
  }


  private static void deepToString(Object[] paramArrayOfObject, StringBuilder paramStringBuilder, Set<Object[]> paramSet)
  {
    if (paramArrayOfObject == null)
    {
      paramStringBuilder.append("null");
      return;
    }
    int i = paramArrayOfObject.length - 1;
    if (i == -1)
    {
      paramStringBuilder.append("[]");
      return;
    }
    paramSet.add(paramArrayOfObject);
    paramStringBuilder.append('[');
    for (int j = 0; ; j++)
    {
      Object localObject = paramArrayOfObject[j];
      if (localObject == null)
      {
        paramStringBuilder.append("null");
      }
      else
      {
        Class localClass = localObject.getClass();
        if (localClass.isArray())
        {
          if (localClass == [B.class)
            paramStringBuilder.append(toString((byte[])(byte[])localObject));
          else if (localClass == [S.class)
            paramStringBuilder.append(toString((short[])(short[])localObject));
          else if (localClass == [I.class)
            paramStringBuilder.append(toString((int[])(int[])localObject));
          else if (localClass == [J.class)
            paramStringBuilder.append(toString((long[])(long[])localObject));
          else if (localClass == [C.class)
            paramStringBuilder.append(toString((char[])(char[])localObject));
          else if (localClass == [F.class)
            paramStringBuilder.append(toString((float[])(float[])localObject));
          else if (localClass == [D.class)
            paramStringBuilder.append(toString((double[])(double[])localObject));
          else if (localClass == [Z.class)
            paramStringBuilder.append(toString((boolean[])(boolean[])localObject));
          else if (paramSet.contains(localObject))
            paramStringBuilder.append("[...]");
          else
            deepToString((Object[])(Object[])localObject, paramStringBuilder, paramSet);
        }
        else
          paramStringBuilder.append(localObject.toString());
      }
      if (j == i)
        break;
      paramStringBuilder.append(", ");
    }
    paramStringBuilder.append(']');
    paramSet.remove(paramArrayOfObject);
  }


  private static class ArrayList<E> extends AbstractList<E>
    implements RandomAccess, Serializable
  {
    private static final long serialVersionUID = -2764017481108945198L;
    private final E[] a;


    ArrayList(E[] paramArrayOfE)
    {
      if (paramArrayOfE == null)
        throw new NullPointerException();
      this.a = paramArrayOfE;
    }


    public int size()
    {
      return this.a.length;
    }


    public Object[] toArray()
    {
      return (Object[])this.a.clone();
    }


    public <T> T[] toArray(T[] paramArrayOfT)
    {
      int i = size();
      if (paramArrayOfT.length < i)
        return Arrays.copyOf(this.a, i, paramArrayOfT.getClass());
      System.arraycopy(this.a, 0, paramArrayOfT, 0, i);
      if (paramArrayOfT.length > i)
        paramArrayOfT[i] = null;
      return paramArrayOfT;
    }


    public E get(int paramInt)
    {
      return this.a[paramInt];
    }


    public E set(int paramInt, E paramE)
    {
      Object localObject = this.a[paramInt];
      this.a[paramInt] = paramE;
      return localObject;
    }


    public int indexOf(Object paramObject)
    {
      int i;
      if (paramObject == null)
        for (i = 0; i < this.a.length; i++)
          if (this.a[i] == null)
            return i;
      else
        for (i = 0; i < this.a.length; i++)
          if (paramObject.equals(this.a[i]))
            return i;
      return -1;
    }


    public boolean contains(Object paramObject)
    {
      return indexOf(paramObject) != -1;
    }
  }


  static final class LegacyMergeSort
  {
    private static final boolean userRequested = ((Boolean)AccessController.doPrivileged(new GetBooleanAction("java.util.Arrays.useLegacyMergeSort"))).booleanValue();
  }
}


ArrayList.java

package java.util;


import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class ArrayList<E> extends AbstractList<E>
  implements List<E>, RandomAccess, Cloneable, Serializable
{
  private static final long serialVersionUID = 8683452581122892189L;
  private static final int DEFAULT_CAPACITY = 10;
  private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
  private transient Object[] elementData;
  private int size;
  private static final int MAX_ARRAY_SIZE = 2147483639;


  public ArrayList(int paramInt)
  {
    if (paramInt < 0)
      throw new IllegalArgumentException("Illegal Capacity: " + paramInt);
    this.elementData = new Object[paramInt];
  }


  public ArrayList()
  {
    this.elementData = EMPTY_ELEMENTDATA;
  }


  public ArrayList(Collection<? extends E> paramCollection)
  {
    this.elementData = paramCollection.toArray();
    this.size = this.elementData.length;
    if (this.elementData.getClass() != [Ljava.lang.Object.class)
      this.elementData = Arrays.copyOf(this.elementData, this.size, [Ljava.lang.Object.class);
  }


  public void trimToSize()
  {
    this.modCount += 1;
    if (this.size < this.elementData.length)
      this.elementData = Arrays.copyOf(this.elementData, this.size);
  }


  public void ensureCapacity(int paramInt)
  {
    int i = this.elementData != EMPTY_ELEMENTDATA ? 0 : 10;
    if (paramInt > i)
      ensureExplicitCapacity(paramInt);
  }


  private void ensureCapacityInternal(int paramInt)
  {
    if (this.elementData == EMPTY_ELEMENTDATA)
      paramInt = Math.max(10, paramInt);
    ensureExplicitCapacity(paramInt);
  }


  private void ensureExplicitCapacity(int paramInt)
  {
    this.modCount += 1;
    if (paramInt - this.elementData.length > 0)
      grow(paramInt);
  }


  private void grow(int paramInt)
  {
    int i = this.elementData.length;
    int j = i + (i >> 1);
    if (j - paramInt < 0)
      j = paramInt;
    if (j - 2147483639 > 0)
      j = hugeCapacity(paramInt);
    this.elementData = Arrays.copyOf(this.elementData, j);
  }


  private static int hugeCapacity(int paramInt)
  {
    if (paramInt < 0)
      throw new OutOfMemoryError();
    return paramInt > 2147483639 ? 2147483647 : 2147483639;
  }


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


  public boolean isEmpty()
  {
    return this.size == 0;
  }


  public boolean contains(Object paramObject)
  {
    return indexOf(paramObject) >= 0;
  }


  public int indexOf(Object paramObject)
  {
    int i;
    if (paramObject == null)
      for (i = 0; i < this.size; i++)
        if (this.elementData[i] == null)
          return i;
    else
      for (i = 0; i < this.size; i++)
        if (paramObject.equals(this.elementData[i]))
          return i;
    return -1;
  }


  public int lastIndexOf(Object paramObject)
  {
    int i;
    if (paramObject == null)
      for (i = this.size - 1; i >= 0; i--)
        if (this.elementData[i] == null)
          return i;
    else
      for (i = this.size - 1; i >= 0; i--)
        if (paramObject.equals(this.elementData[i]))
          return i;
    return -1;
  }


  public Object clone()
  {
    try
    {
      ArrayList localArrayList = (ArrayList)super.clone();
      localArrayList.elementData = Arrays.copyOf(this.elementData, this.size);
      localArrayList.modCount = 0;
      return localArrayList;
    }
    catch (CloneNotSupportedException localCloneNotSupportedException)
    {
    }
    throw new InternalError();
  }


  public Object[] toArray()
  {
    return Arrays.copyOf(this.elementData, this.size);
  }


  public <T> T[] toArray(T[] paramArrayOfT)
  {
    if (paramArrayOfT.length < this.size)
      return (Object[])Arrays.copyOf(this.elementData, this.size, paramArrayOfT.getClass());
    System.arraycopy(this.elementData, 0, paramArrayOfT, 0, this.size);
    if (paramArrayOfT.length > this.size)
      paramArrayOfT[this.size] = null;
    return paramArrayOfT;
  }


  E elementData(int paramInt)
  {
    return this.elementData[paramInt];
  }


  public E get(int paramInt)
  {
    rangeCheck(paramInt);
    return elementData(paramInt);
  }


  public E set(int paramInt, E paramE)
  {
    rangeCheck(paramInt);
    Object localObject = elementData(paramInt);
    this.elementData[paramInt] = paramE;
    return localObject;
  }


  public boolean add(E paramE)
  {
    ensureCapacityInternal(this.size + 1);
    this.elementData[(this.size++)] = paramE;
    return true;
  }


  public void add(int paramInt, E paramE)
  {
    rangeCheckForAdd(paramInt);
    ensureCapacityInternal(this.size + 1);
    System.arraycopy(this.elementData, paramInt, this.elementData, paramInt + 1, this.size - paramInt);
    this.elementData[paramInt] = paramE;
    this.size += 1;
  }


  public E remove(int paramInt)
  {
    rangeCheck(paramInt);
    this.modCount += 1;
    Object localObject = elementData(paramInt);
    int i = this.size - paramInt - 1;
    if (i > 0)
      System.arraycopy(this.elementData, paramInt + 1, this.elementData, paramInt, i);
    this.elementData[(--this.size)] = null;
    return localObject;
  }


  public boolean remove(Object paramObject)
  {
    int i;
    if (paramObject == null)
      for (i = 0; i < this.size; i++)
      {
        if (this.elementData[i] != null)
          continue;
        fastRemove(i);
        return true;
      }
    else
      for (i = 0; i < this.size; i++)
      {
        if (!paramObject.equals(this.elementData[i]))
          continue;
        fastRemove(i);
        return true;
      }
    return false;
  }


  private void fastRemove(int paramInt)
  {
    this.modCount += 1;
    int i = this.size - paramInt - 1;
    if (i > 0)
      System.arraycopy(this.elementData, paramInt + 1, this.elementData, paramInt, i);
    this.elementData[(--this.size)] = null;
  }


  public void clear()
  {
    this.modCount += 1;
    for (int i = 0; i < this.size; i++)
      this.elementData[i] = null;
    this.size = 0;
  }


  public boolean addAll(Collection<? extends E> paramCollection)
  {
    Object[] arrayOfObject = paramCollection.toArray();
    int i = arrayOfObject.length;
    ensureCapacityInternal(this.size + i);
    System.arraycopy(arrayOfObject, 0, this.elementData, this.size, i);
    this.size += i;
    return i != 0;
  }


  public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
  {
    rangeCheckForAdd(paramInt);
    Object[] arrayOfObject = paramCollection.toArray();
    int i = arrayOfObject.length;
    ensureCapacityInternal(this.size + i);
    int j = this.size - paramInt;
    if (j > 0)
      System.arraycopy(this.elementData, paramInt, this.elementData, paramInt + i, j);
    System.arraycopy(arrayOfObject, 0, this.elementData, paramInt, i);
    this.size += i;
    return i != 0;
  }


  protected void removeRange(int paramInt1, int paramInt2)
  {
    this.modCount += 1;
    int i = this.size - paramInt2;
    System.arraycopy(this.elementData, paramInt2, this.elementData, paramInt1, i);
    int j = this.size - (paramInt2 - paramInt1);
    for (int k = j; k < this.size; k++)
      this.elementData[k] = null;
    this.size = j;
  }


  private void rangeCheck(int paramInt)
  {
    if (paramInt >= this.size)
      throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
  }


  private void rangeCheckForAdd(int paramInt)
  {
    if ((paramInt > this.size) || (paramInt < 0))
      throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
  }


  private String outOfBoundsMsg(int paramInt)
  {
    return "Index: " + paramInt + ", Size: " + this.size;
  }


  public boolean removeAll(Collection<?> paramCollection)
  {
    return batchRemove(paramCollection, false);
  }


  public boolean retainAll(Collection<?> paramCollection)
  {
    return batchRemove(paramCollection, true);
  }


  private boolean batchRemove(Collection<?> paramCollection, boolean paramBoolean)
  {
    Object[] arrayOfObject = this.elementData;
    int i = 0;
    int j = 0;
    int k = 0;
    try
    {
      while (i < this.size)
      {
        if (paramCollection.contains(arrayOfObject[i]) == paramBoolean)
          arrayOfObject[(j++)] = arrayOfObject[i];
        i++;
      }
      if (i != this.size)
      {
        System.arraycopy(arrayOfObject, i, arrayOfObject, j, this.size - i);
        j += this.size - i;
      }
      if (j != this.size)
      {
        for (int m = j; m < this.size; m++)
          arrayOfObject[m] = null;
        this.modCount += this.size - j;
        this.size = j;
        k = 1;
      }
    }
    finally
    {
      if (i != this.size)
      {
        System.arraycopy(arrayOfObject, i, arrayOfObject, j, this.size - i);
        j += this.size - i;
      }
      if (j != this.size)
      {
        for (int n = j; n < this.size; n++)
          arrayOfObject[n] = null;
        this.modCount += this.size - j;
        this.size = j;
        k = 1;
      }
    }
    return k;
  }


  private void writeObject(ObjectOutputStream paramObjectOutputStream)
    throws IOException
  {
    int i = this.modCount;
    paramObjectOutputStream.defaultWriteObject();
    paramObjectOutputStream.writeInt(this.size);
    for (int j = 0; j < this.size; j++)
      paramObjectOutputStream.writeObject(this.elementData[j]);
    if (this.modCount != i)
      throw new ConcurrentModificationException();
  }


  private void readObject(ObjectInputStream paramObjectInputStream)
    throws IOException, ClassNotFoundException
  {
    this.elementData = EMPTY_ELEMENTDATA;
    paramObjectInputStream.defaultReadObject();
    paramObjectInputStream.readInt();
    if (this.size > 0)
    {
      ensureCapacityInternal(this.size);
      Object[] arrayOfObject = this.elementData;
      for (int i = 0; i < this.size; i++)
        arrayOfObject[i] = paramObjectInputStream.readObject();
    }
  }


  public ListIterator<E> listIterator(int paramInt)
  {
    if ((paramInt < 0) || (paramInt > this.size))
      throw new IndexOutOfBoundsException("Index: " + paramInt);
    return new ListItr(paramInt);
  }


  public ListIterator<E> listIterator()
  {
    return new ListItr(0);
  }


  public Iterator<E> iterator()
  {
    return new Itr(null);
  }


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


  static void subListRangeCheck(int paramInt1, int paramInt2, int paramInt3)
  {
    if (paramInt1 < 0)
      throw new IndexOutOfBoundsException("fromIndex = " + paramInt1);
    if (paramInt2 > paramInt3)
      throw new IndexOutOfBoundsException("toIndex = " + paramInt2);
    if (paramInt1 > paramInt2)
      throw new IllegalArgumentException("fromIndex(" + paramInt1 + ") > toIndex(" + paramInt2 + ")");
  }


  private class Itr
    implements Iterator<E>
  {
    int cursor;
    int lastRet = -1;
    int expectedModCount = ArrayList.this.modCount;


    private Itr()
    {
    }


    public boolean hasNext()
    {
      return this.cursor != ArrayList.this.size;
    }


    public E next()
    {
      checkForComodification();
      int i = this.cursor;
      if (i >= ArrayList.this.size)
        throw new NoSuchElementException();
      Object[] arrayOfObject = ArrayList.this.elementData;
      if (i >= arrayOfObject.length)
        throw new ConcurrentModificationException();
      this.cursor = (i + 1);
      return arrayOfObject[(this.lastRet = i)];
    }


    public void remove()
    {
      if (this.lastRet < 0)
        throw new IllegalStateException();
      checkForComodification();
      try
      {
        ArrayList.this.remove(this.lastRet);
        this.cursor = this.lastRet;
        this.lastRet = -1;
        this.expectedModCount = ArrayList.this.modCount;
      }
      catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
      {
        throw new ConcurrentModificationException();
      }
    }


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


  private class ListItr extends ArrayList<E>.Itr
    implements ListIterator<E>
  {
    ListItr(int arg2)
    {
      super(null);
      int i;
      this.cursor = i;
    }


    public boolean hasPrevious()
    {
      return this.cursor != 0;
    }


    public int nextIndex()
    {
      return this.cursor;
    }


    public int previousIndex()
    {
      return this.cursor - 1;
    }


    public E previous()
    {
      checkForComodification();
      int i = this.cursor - 1;
      if (i < 0)
        throw new NoSuchElementException();
      Object[] arrayOfObject = ArrayList.this.elementData;
      if (i >= arrayOfObject.length)
        throw new ConcurrentModificationException();
      this.cursor = i;
      return arrayOfObject[(this.lastRet = i)];
    }


    public void set(E paramE)
    {
      if (this.lastRet < 0)
        throw new IllegalStateException();
      checkForComodification();
      try
      {
        ArrayList.this.set(this.lastRet, paramE);
      }
      catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
      {
        throw new ConcurrentModificationException();
      }
    }


    public void add(E paramE)
    {
      checkForComodification();
      try
      {
        int i = this.cursor;
        ArrayList.this.add(i, paramE);
        this.cursor = (i + 1);
        this.lastRet = -1;
        this.expectedModCount = ArrayList.this.modCount;
      }
      catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
      {
        throw new ConcurrentModificationException();
      }
    }
  }


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


    SubList(int paramInt1, int paramInt2, int arg4)
    {
      this.parent = paramInt1;
      int i;
      this.parentOffset = i;
      this.offset = (paramInt2 + i);
      int j;
      this.size = (j - i);
      this.modCount = ArrayList.this.modCount;
    }


    public E set(int paramInt, E paramE)
    {
      rangeCheck(paramInt);
      checkForComodification();
      Object localObject = ArrayList.this.elementData(this.offset + paramInt);
      ArrayList.this.elementData[(this.offset + paramInt)] = paramE;
      return localObject;
    }


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


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


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


    public E remove(int paramInt)
    {
      rangeCheck(paramInt);
      checkForComodification();
      Object localObject = this.parent.remove(this.parentOffset + paramInt);
      this.modCount = this.parent.modCount;
      this.size -= 1;
      return localObject;
    }


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


    public boolean addAll(Collection<? extends E> paramCollection)
    {
      return addAll(this.size, paramCollection);
    }


    public boolean addAll(int paramInt, Collection<? extends E> paramCollection)
    {
      rangeCheckForAdd(paramInt);
      int i = paramCollection.size();
      if (i == 0)
        return false;
      checkForComodification();
      this.parent.addAll(this.parentOffset + paramInt, paramCollection);
      this.modCount = this.parent.modCount;
      this.size += i;
      return true;
    }


    public Iterator<E> iterator()
    {
      return listIterator();
    }


    public ListIterator<E> listIterator(int paramInt)
    {
      checkForComodification();
      rangeCheckForAdd(paramInt);
      int i = this.offset;
      return new ListIterator(paramInt, i)
      {
        int cursor = this.val$index;
        int lastRet = -1;
        int expectedModCount = ArrayList.this.modCount;


        public boolean hasNext()
        {
          return this.cursor != ArrayList.SubList.this.size;
        }


        public E next()
        {
          checkForComodification();
          int i = this.cursor;
          if (i >= ArrayList.SubList.this.size)
            throw new NoSuchElementException();
          Object[] arrayOfObject = ArrayList.this.elementData;
          if (this.val$offset + i >= arrayOfObject.length)
            throw new ConcurrentModificationException();
          this.cursor = (i + 1);
          return arrayOfObject[(this.val$offset + (this.lastRet = i))];
        }


        public boolean hasPrevious()
        {
          return this.cursor != 0;
        }


        public E previous()
        {
          checkForComodification();
          int i = this.cursor - 1;
          if (i < 0)
            throw new NoSuchElementException();
          Object[] arrayOfObject = ArrayList.this.elementData;
          if (this.val$offset + i >= arrayOfObject.length)
            throw new ConcurrentModificationException();
          this.cursor = i;
          return arrayOfObject[(this.val$offset + (this.lastRet = i))];
        }


        public int nextIndex()
        {
          return this.cursor;
        }


        public int previousIndex()
        {
          return this.cursor - 1;
        }


        public void remove()
        {
          if (this.lastRet < 0)
            throw new IllegalStateException();
          checkForComodification();
          try
          {
            ArrayList.SubList.this.remove(this.lastRet);
            this.cursor = this.lastRet;
            this.lastRet = -1;
            this.expectedModCount = ArrayList.this.modCount;
          }
          catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
          {
            throw new ConcurrentModificationException();
          }
        }


        public void set(E paramE)
        {
          if (this.lastRet < 0)
            throw new IllegalStateException();
          checkForComodification();
          try
          {
            ArrayList.this.set(this.val$offset + this.lastRet, paramE);
          }
          catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
          {
            throw new ConcurrentModificationException();
          }
        }


        public void add(E paramE)
        {
          checkForComodification();
          try
          {
            int i = this.cursor;
            ArrayList.SubList.this.add(i, paramE);
            this.cursor = (i + 1);
            this.lastRet = -1;
            this.expectedModCount = ArrayList.this.modCount;
          }
          catch (IndexOutOfBoundsException localIndexOutOfBoundsException)
          {
            throw new ConcurrentModificationException();
          }
        }


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


    public List<E> subList(int paramInt1, int paramInt2)
    {
      ArrayList.subListRangeCheck(paramInt1, paramInt2, this.size);
      return new SubList(ArrayList.this, this, this.offset, paramInt1, paramInt2);
    }


    private void rangeCheck(int paramInt)
    {
      if ((paramInt < 0) || (paramInt >= this.size))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
    }


    private void rangeCheckForAdd(int paramInt)
    {
      if ((paramInt < 0) || (paramInt > this.size))
        throw new IndexOutOfBoundsException(outOfBoundsMsg(paramInt));
    }


    private String outOfBoundsMsg(int paramInt)
    {
      return "Index: " + paramInt + ", Size: " + this.size;
    }


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










原创粉丝点击
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防,我是瞎子 手上起白皮屑怎么办 手背起皮干燥怎么办 不会读的英语怎么办 中学生不准时回家怎么办 汽车轮胎锈住了怎么办 新轮胎不好装怎么办 学it找不到工作怎么办 血液里有微生物怎么办 机械硬盘不显示怎么办 六安建筑机械租赁公司怎么办 别墅楼梯太陡怎么办 不锈钢楼梯太陡怎么办 真皮白色鞋脏了怎么办 白色牛皮包脏了怎么办 白色羊皮鞋脏了怎么办 白色真皮染色了怎么办 白色漆皮鞋脏了怎么办 对鉴定结果不服怎么办 洗衣机入水口堵塞怎么办 华科办临时饭卡怎么办 血浆乳酸测定高怎么办 olay大红瓶过敏怎么办 饥一顿饱一顿怎么办 朝鲜人向去韩国怎么办? 我是超级大方脸怎么办 被精神病砍断四根筋怎么办 40小时不睡觉怎么办 边防转业军人安置不好怎么办 转业军人孩子读书怎么办玉环 军官证丢了怎么办 飞行学员停飞了怎么办 丹东港债券违约怎么办 对村党支部贿选怎么办 马自达2油耗高怎么办 马自达1.5油耗高怎么办 马自达5停产配件怎么办 期货账户休眠了怎么办 低于二本线怎么办 听力测试不过关怎么办 安装的天正过期怎么办 天正t20v4过期了怎么办