Markdown版本笔记	我的GitHub首页	我的博客	我的微信	我的邮箱
MyAndroidBlogs	baiqiantao	baiqiantao	bqt20094	baiqiantao@sina.com

目录
数组和集合的区别
常用操作
数组常用操作
定义数组
List转数组
遍历数组
集合常用操作
数组转 List
遍历List、Set
遍历Map
空数组、空集合的处理
转换
打印
遍历
Arrays 数组工具类的 API
asList 方法
实现原理
使用注意事项
sort 方法
binarySearch 方法
源码分析
二分查找
copyOf、copyOfRange 方法
相关的几个方法
源码分析
测试代码
equals 和 deepEquals
fill 方法
toString deepToString 方法
hashCode deepHashCode 方法

String[] array = null;
array = new String[5];//设置大小并初始化
array[0] = "呵呵";

String[] array = new String[] { "a", "b", "c", "d", "e" };
String[] array2 = { "a", "b", "c", "d", "e" };

String[] array = new String[] {};
String[] array = new String[0];

String[] array = new String[];
String[] array = new String();
String[] array = new String[]();
String[] array = new String()[];

List<String> list = Arrays.asList("a", "b", "c");
String[] array = (String[]) list.toArray();
String[] array2 = list.toArray(new String[list.size()]);

System.out.println(Arrays.toString(arr));//直接打印数组本身的话不会打印数组中的内容

for (int i = 0, j = arr.length; i < j; i++) {//普通forSystem.out.println(i + " - " + arr[i]);
}

for (String string : arr) {//增强forSystem.out.println(string);
}

List<String> mList = Arrays.asList("包青天a","包青天b","包青天c");//可变参数
List<String> mList = Arrays.asList();//结果不是null，而是长度为0的集合。return new ArrayList<>(list);String[] array = { "包青天a", "包青天b", "包青天c" };
List<String> mList = Arrays.asList(array);//直接传一个数组和直接传内容是一样的
List<String[]> mList = Arrays.asList(array, array);//以可变参数的形式传多个数组的话，集合中的元素就不是String而是String[]了

System.out.println(mList); //和数组不一样，直接打印集合其实就是打印集合中的元素

for (int i = 0, j = mList.size(); i < j; i++) {System.out.println(i + " - " + mList.get(i));
}

for (String string : mList) {System.out.println(string);
}

Iterator<String> it = mList.iterator();
while (it.hasNext()) {System.out.println(it.next());
}

ListIterator<String> it = mList.listIterator(); //可以双向遍历
while (it.hasNext()) {System.out.println(it.next());//执行完后指针移到了最后，这有这样才能使用hasPrevious遍历
}while (it.hasPrevious()) {System.out.println(it.previous());
}

System.out.println(map);

for (String key : map.keySet()) {String value = map.get(key);System.out.println(key + "---" + value);
}

for (Map.Entry<String, String> entry : map.entrySet()) {System.out.println(entry);
}

Iterator<String> iterator = map.keySet().iterator();
while (iterator.hasNext()) {String key = iterator.next();String value = map.get(key);System.out.println(key + ":" + value);
}

Iterator<Map.Entry<String, String>> iterator2 = map.entrySet().iterator();
while (iterator2.hasNext()) {System.out.println(iterator2.next());
}

System.out.println(Arrays.asList().size()); //0String[] array = null;
System.out.println(Arrays.asList(array).size()); // NullPointerExceptionSystem.out.println(Arrays.asList(null).size()); // NullPointerException
System.out.println(Arrays.asList(null, null).size()); //2System.out.println(new ArrayList<>().toArray().length); //0

String[] arr = null;
System.out.println(Arrays.toString(arr));//调用 Arrays.toString 不会异常，打印 nullList<String> mList = null;
System.out.println(mList); //null
System.out.println(new ArrayList<String>()); //[]

String[] arr = null;
for (String string : arr) { //这里就会报 NullPointerException ，不管是数组还是集合都一样，遍历前必须判空System.out.println(string);
}
String[] arr = null;
for (int i = 0, j = arr == null ? 0 : arr.length; i < j; i++) { //加上这么一个判断就很安全了，不管是数组还是集合都一样System.out.println(i + " - " + arr[i]);
}

public static <T> List<T> asList(T... a) {return new ArrayList<>(a);//注意，这里的ArrayList不是我们通常用的ArrayList，而是Arrays类中定义的一个内部类
}private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable {private final E[] a;ArrayList(E[] array) {a = Objects.requireNonNull(array);//如果 array 为 null 抛出 NullPointerException，否则直接将 array 的引用赋给 a//因为 a 和 array 这两个数组引用的是同一块内存地址，且后续对此 ArrayList 的操作实际都是对 a 的操作，所以也会影响到原始数组}
}//因为此 ArrayList 没有重新 AbstractList 中的 add、remove、clear等方法，所以不能调用这几个方法，否则都是直接抛出异常
public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {public void add(int index, E element) {throw new UnsupportedOperationException();}
}

String[] array = new String[] { "a", "b", };
List<String> mList = Arrays.asList(array); //如下问题和通过 Arrays.asList("a", "b") 方式来生成集合是完全一样的//1、不可以将 List 强转为 ArrayList .从上述源码分析可知，这两个 ArrayList 并不是同一个类，所以不能强转
ArrayList<String> list2 = (ArrayList<String>) list;//ClassCastException: java.util.Arrays$ArrayList cannot be cast to java.util.ArrayList//2、对返回列表的更改会“直接写”到数组，所以当修改转换后的集合中的元素时，原始数组中的元素也会更改
mList.set(0, "包青天");
System.out.println(Arrays.toString(array));//[包青天, b]//3、因为数组的长度不能改变，所以对转换而来的集合的长度改变的操作都是不合法的，会报 java.lang.UnsupportedOperationException
mList.add("111"); // Arrays.asList("a", "b").add("111"); 也同样会报异常
mList.remove(0);//
list.clear();

String[] array = new String[] { "c", "a", "b", "ab", "aa", "a" };
Arrays.sort(array);//集合中不能有 null ，否则会报NullPointerException，这种情况下需要自定义比较器
System.out.println(Arrays.toString(array));//[a, a, aa, ab, b, c]array = new String[] { "c", "a", "b", "ab", "aa", "a" };
Arrays.sort(array, 0, 3);//只对 0-2 这三个元素排序
System.out.println(Arrays.toString(array));//[a, b, c, ab, aa, a]

public static int binarySearch(byte[] a, byte key) {return binarySearch0(a, 0, a.length, key);
}public static int binarySearch(byte[] a, int fromIndex, int toIndex, byte key) {rangeCheck(a.length, fromIndex, toIndex);//检查 fromIndex 和 toIndex 的值是否合法，不合法抛出相应的异常return binarySearch0(a, fromIndex, toIndex, key);
}private static int binarySearch0(byte[] a, int fromIndex, int toIndex, byte key) {int low = fromIndex;//最小位置int high = toIndex - 1;//最大位置while (low <= high) {int mid = (low + high) >>> 1;//中间位置byte midVal = a[mid];//中间位置的值if (midVal < key) {//若中间位置的值小于要查询的值，向右边继续找low = mid + 1;//最小位置=中间位置+1，最大位置不变} else if (midVal > key) {//若中间位置的值大于要查询的值，向左边继续找high = mid - 1;//最大位置=中间位置-1，最小位置不变} else {return mid; //否则这就是要找到的值}}return -(low + 1);  //如果没找到返回的值
}

String[] array = new String[] { "c", "a", "b", "ab", "aa", "a" };
Arrays.sort(array);
System.out.println(Arrays.toString(array));//[a, a, aa, ab, b, c]
System.out.println(Arrays.binarySearch(array, "b"));//4
System.out.println(Arrays.binarySearch(array, "a"));//0
System.out.println(Arrays.binarySearch(array, "ac"));//-5【-(4+1)】

public static long[] copyOf(long[] original, int newLength) {long[] copy = new long[newLength];//先定义一个指定长度的数组//再通过 System.arraycopy() 方法将原始数组中的内容复制到上面定义的数组，然后直接返回System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));// 从源数组 original 的 0 位置开始复制，复制到 copy 的 0 位置，当复制 length 个后结束复制return copy;
}

public static <T> T[] copyOf(T[] original, int newLength) {return (T[]) copyOf(original, newLength, original.getClass());
}//定义数组不能用泛型，所以这里需要传一个参数 newType 告诉我们要构造的数组的类型，这种方式可以学习一下！
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {@SuppressWarnings("unchecked") //因为我们直接强转的，所以这里有一个 unchecked 的 SuppressWarningsT[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength] //直接构造 Object数组: (T[]) Array.newInstance(newType.getComponentType(), newLength); //通过反射方式构造指定类型的数组System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); //和上面一样// 从源数组 original 的 0 位置开始复制，复制到 copy 的 0 位置，当复制 length 个后结束复制return copy;
}

public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {int newLength = to - from;if (newLength < 0) throw new IllegalArgumentException(from + " > " + to);@SuppressWarnings("unchecked")T[] copy = ((Object)newType == (Object)Object[].class) ? (T[]) new Object[newLength]: (T[]) Array.newInstance(newType.getComponentType(), newLength);System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength));// 从源数组 original 的 from 位置开始复制，复制到 copy 的 0 位置，当复制 length 个后结束复制return copy;
}

String[] array = new String[] { "c", "a", };
String[] array2 = Arrays.copyOf(array, 1);
String[] array3 = Arrays.copyOf(array, 3);
String[] array4 = Arrays.copyOfRange(array, 0, 1);
System.out.println(Arrays.toString(array2) + "  " + Arrays.toString(array3) + "  " + Arrays.toString(array4));//[c]  [c, a, null]  [c]

Object[] array = new Object[] { 1, 2 };
Integer[] array2 = Arrays.copyOf(array, 3, Integer[].class); //不能用于 int[] 等基本类型的数组，因为泛型不支持基本类型
System.out.println(Arrays.toString(array2));//[1, 2, null]

String[] b = { "b" };
String[] b2 = { "b" };
String[] qt = { "qt" };
String[][] name1 = { b, qt };
String[][] name2 = { b, qt };
System.out.println(Arrays.equals(name1, name2) + "  " + Arrays.deepEquals(name1, name2));// true true
System.out.println(Arrays.equals(b2, b) + "  " + Arrays.deepEquals(b2, b));// true  trueString[][] name3 = { { "b" }, { "qt" } };
String[][] name4 = { { "b" }, { "qt" } };
System.out.println(Arrays.equals(name3, name4) + "  " + Arrays.deepEquals(name3, name4));// false  trueString[][] name5 = { b };
String[][] name6 = { b2 };
System.out.println(Arrays.equals(name5, name6) + "  " + Arrays.deepEquals(name5, name6));// false  true

String[] b = { "b", "t", "t" };
Arrays.fill(b, "包");
System.out.println(Arrays.toString(b));//[包, 包, 包]
Arrays.fill(b, 1, 2, "青");// toIndex 不能用 1 ，因为 fromIndex==toIndex 时填充范围为空
Arrays.fill(b, 2, b.length, "天");//toIndex 不能大于 b.length，否则报 ArrayIndexOutOfBoundsException
System.out.println(Arrays.toString(b));//[包, 青, 天]

String[][] name = { { "b" }, { "qt" } };
System.out.println(Arrays.toString(name) + "  " + Arrays.deepToString(name));
//[[Ljava.lang.String;@15db9742, [Ljava.lang.String;@6d06d69c]  [[b], [qt]]

String[][] name = { { "b" }, { "qt" } };
System.out.println(Arrays.hashCode(name) + "  " + Arrays.deepHashCode(name));//312355675  8610