由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;
posted on 2014-04-13 16:14 zhizhizhiyuan 阅读(145) 评论(1) 编辑 收藏
250
到【灌水乐园】发言
评论
#1楼 2017-10-22 21:24 N3verL4nd
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();
}
}
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();
}
}
}