前言
2022/10/25
路漫漫其修远兮,吾将上下而求索
本文是根据jdk学习所做笔记
仅供学习交流使用，转载注明出处
推荐
JDK API 1.6 中文版
说明
以下内容是结合很多资料进行编写的
源码为jdk1.8的
斜体样式 为自己的思考
下划线为自己所画的重点
Arrays类
基本信息
java.util
类 Arrays
java.lang.Object
继承者 java.util.Arrays
public class Arraysextends Object此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。
除非特别注明，否则如果指定数组引用为 null，则此类中的方法都会抛出 NullPointerException。
此类中所含方法的文档都包括对实现 的简短描述。应该将这些描述视为实现注意事项，而不应将它们视为规范 的一部分。实现者应该可以随意替代其他算法，只要遵循规范本身即可。（例如，sort(Object[]) 使用的算法不必是一个合并排序算法，但它必须是稳定的。）
此类是 Java Collections Framework 的成员。
从以下版本开始：
1.2
成员
binarySearch
public static int binarySearch(int[] a,
int key)
使用二分搜索法来搜索指定的 int 型数组，以获得指定的值。必须在进行此调用之前对数组进行排序（通过 sort(int[]) 方法）。如果没有对数组进行排序，则结果是不确定的。如果数组包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：
a - 要搜索的数组
key - 要搜索的值
返回：
如果它包含在数组中，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即第一个大于此键的元素索引，如果数组中的所有元素都小于指定的键，则为 a.length。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
public static int binarySearch(int[] a, int key) { return binarySearch0(a, 0, a.length, key); }
binarySearch
public static int binarySearch(int[] a,
int fromIndex,
int toIndex,
int key)
使用二分搜索法来搜索指定的 int 型数组的范围，以获得指定的值。必须在进行此调用之前对范围进行排序（通过 sort(int[], int, int) 方法）。如果没有对范围进行排序，则结果是不确定的。如果范围包含多个带有指定值的元素，则无法保证找到的是哪一个。
参数：
a - 要搜索的数组
fromIndex - 要搜索的第一个元素的索引（包括）
toIndex - 要搜索的最后一个元素的索引（不包括）
key - 要搜索的值
返回：
如果它包含在数组的指定范围内，则返回搜索键的索引；否则返回 (-(插入点) - 1)。插入点 被定义为将键插入数组的那一点：即范围中第一个大于此键的元素索引，如果范围中的所有元素都小于指定的键，则为 toIndex。注意，这保证了当且仅当此键被找到时，返回的值将 >= 0。
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
从以下版本开始：
1.6
public static int binarySearch(int[] a, int fromIndex, int toIndex, int key) { rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); }
binarySearch0
// Like public version, but without range checks. private static int binarySearch0(int[] a, int fromIndex, int toIndex, int key) { int low = fromIndex; int high = toIndex - 1; while (low <= high) { int mid = (low + high) >>> 1; int midVal = a[mid]; if (midVal < key) low = mid + 1; else if (midVal > key) high = mid - 1; else return mid; // key found } return -(low + 1); // key not found. }
copyOf
public static int[] copyOf(int[] original,
int newLength)
复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。对于在原数组和副本中都有效的所有索引，这两个数组将包含相同的值。对于在副本中有效而在原数组无效的所有索引，副本将包含 0。当且仅当指定长度大于原数组的长度时，这些索引存在。
参数：
original - 要复制的数组
newLength - 要返回的副本的长度
返回：
原数组的副本，截取或用 0 填充以获得指定的长度
抛出：
NegativeArraySizeException - 如果 newLength 为负
NullPointerException - 如果 original 为 null
从以下版本开始：
1.6
public static int[] copyOf(int[] original, int newLength) { int[] copy = new int[newLength]; System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }
System
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
copyOfRange
public static int[] copyOfRange(int[] original,
int from,
int to)
将指定数组的指定范围复制到一个新数组。该范围的初始索引 (from) 必须位于 0 和 original.length（包括）之间。original[from] 处的值放入副本的初始元素中（除非 from = = original.length 或 from == to）。原数组中后续元素的值放入副本的后续元素。该范围的最后索引 (to)（必须大于等于 from）可以大于 original.length，在这种情况下，0 被放入索引大于等于 original.length - from 的副本的所有元素中。返回数组的长度为 to - from。
参数：
original - 将要从其复制一个范围的数组
from - 要复制的范围的初始索引（包括）
to - 要复制的范围的最后索引（不包括）。（此索引可以位于数组范围之外）。
返回：
包含取自原数组指定范围的新数组，截取或用 0 填充以获得所需长度
抛出：
ArrayIndexOutOfBoundsException - 如果 from < 0 或 from > original.length()
IllegalArgumentException - 如果 from > to
NullPointerException - 如果 original 为 null
从以下版本开始：
1.6
public static int[] copyOfRange(int[] original, int from, int to) { int newLength = to - from; if (newLength < 0) throw new IllegalArgumentException(from + " > " + to); int[] copy = new int[newLength]; System.arraycopy(original, from, copy, 0, Math.min(original.length - from, newLength)); return copy; }
sort
public static void sort(int[] a,
int fromIndex,
int toIndex)
对指定 int 型数组的指定范围按数字升序进行排序。排序的范围从索引 fromIndex（包括）一直到索引 toIndex（不包括）。（如果 fromIndex==toIndex，则排序范围为空。）
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
参数：
a - 要排序的数组
fromIndex - 要排序的第一个元素的索引（包括）
toIndex - 要排序的最后一个元素的索引（不包括）
抛出：
IllegalArgumentException - 如果 fromIndex > toIndex
ArrayIndexOutOfBoundsException - 如果 fromIndex < 0 或 toIndex > a.length
public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); }
asList
public static List asList(T… a)
返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直接写”到数组。）此方法同 Collection.toArray() 一起，充当了基于数组的 API 与基于 collection 的 API 之间的桥梁。返回的列表是可序列化的，并且实现了 RandomAccess。
此方法还提供了一个创建固定长度的列表的便捷方法，该列表被初始化为包含多个元素：
List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
参数：
a - 支持列表的数组。
返回：
指定数组的列表视图。
@SafeVarargs @SuppressWarnings("varargs") public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }
ArrayList 内部类
private static class ArrayList<E> extends AbstractList<E> implements RandomAccess, java.io.Serializable { private static final long serialVersionUID = -2764017481108945198L; private final E[] a; ArrayList(E[] array) { a = Objects.requireNonNull(array); } @Override public int size() { return a.length; } @Override public Object[] toArray() { return a.clone(); } @Override @SuppressWarnings("unchecked") public <T> T[] toArray(T[] a) { int size = size(); if (a.length < size) return Arrays.copyOf(this.a, size, (Class<? extends T[]>) a.getClass()); System.arraycopy(this.a, 0, a, 0, size); if (a.length > size) a[size] = null; return a; } @Override public E get(int index) { return a[index]; } @Override public E set(int index, E element) { E oldValue = a[index]; a[index] = element; return oldValue; } @Override public int indexOf(Object o) { E[] a = this.a; if (o == null) { for (int i = 0; i < a.length; i++) if (a[i] == null) return i; } else { for (int i = 0; i < a.length; i++) if (o.equals(a[i])) return i; } return -1; } @Override public boolean contains(Object o) { return indexOf(o) != -1; } @Override public Spliterator<E> spliterator() { return Spliterators.spliterator(a, Spliterator.ORDERED); } @Override public void forEach(Consumer<? super E> action) { Objects.requireNonNull(action); for (E e : a) { action.accept(e); } } @Override public void replaceAll(UnaryOperator<E> operator) { Objects.requireNonNull(operator); E[] a = this.a; for (int i = 0; i < a.length; i++) { a[i] = operator.apply(a[i]); } } @Override public void sort(Comparator<? super E> c) { Arrays.sort(a, c); } }
hashCode
public static int hashCode(int[] a)
基于指定数组的内容返回哈希码。对于任何两个满足 Arrays.equals(a, b) 的非 null int 型数组 a 和 b，也可以说 Arrays.hashCode(a) == Arrays.hashCode(b)。
此方法返回的值与在 List 上调用 hashCode 方法获得的值相同，该 List 包含以相同顺序表示 a 数组元素的 Integer 实例的序列。如果 a 为 null，则此方法返回 0。
参数：
a - 要计算其哈希值的数组
返回：
a 数组基于内容的哈希码
从以下版本开始：
1.5
public static int hashCode(int a[]) { if (a == null) return 0; int result = 1; for (int element : a) result = 31 * result + element; return result; }
toString
public static String toString(int[] a)
返回指定数组内容的字符串表示形式。字符串表示形式由数组的元素列表组成，括在方括号（“[]”）中。相邻元素用字符 ", "（逗号加空格）分隔。这些元素通过 String.valueOf(int) 转换为字符串。如果 a 为 null，则返回 “null”。
参数：
a - 返回其字符串表示形式的数组
返回：
a 的字符串表示形式
从以下版本开始：
1.5
public static String toString(long[] a) { if (a == null) return "null"; int iMax = a.length - 1; if (iMax == -1) return "[]"; StringBuilder b = new StringBuilder(); b.append('['); for (int i = 0; ; i++) { b.append(a[i]); if (i == iMax) return b.append(']').toString(); b.append(", "); } }
另外
DualPivotQuicksort.sort
双轴快排
该排序算法是一个经过调优的快速排序法，改编自 Jon L. Bentley 和 M. Douglas McIlroy 合著的 Engineering a Sort Function", Software-Practice and Experience Vol. 23(11) P. 1249-1265 (November 1993)。此算法在许多数据集上提供 n*log(n) 性能，这导致其他快速排序会降低二次型性能。
/** * Sorts the specified range of the array using the given * workspace array slice if possible for merging * * @param a the array to be sorted * @param left the index of the first element, inclusive, to be sorted //留下要排序的第一个元素的索引 * @param right the index of the last element, inclusive, to be sorted //要排序的最后一个元素的索引 * @param work a workspace array (slice) * @param workBase origin of usable space in work array * @param workLen usable size of work array */ static void sort(long[] a, int left, int right, long[] work, int workBase, int workLen) { // Use Quicksort on small arrays if (right - left < QUICKSORT_THRESHOLD) { sort(a, left, right, true); return; } /* * Index run[i] is the start of i-th run * (ascending or descending sequence). */ int[] run = new int[MAX_RUN_COUNT + 1]; int count = 0; run[0] = left; // Check if the array is nearly sorted for (int k = left; k < right; run[count] = k) { if (a[k] < a[k + 1]) { // ascending while (++k <= right && a[k - 1] <= a[k]); } else if (a[k] > a[k + 1]) { // descending while (++k <= right && a[k - 1] >= a[k]); for (int lo = run[count] - 1, hi = k; ++lo < --hi; ) { long t = a[lo]; a[lo] = a[hi]; a[hi] = t; } } else { // equal for (int m = MAX_RUN_LENGTH; ++k <= right && a[k - 1] == a[k]; ) { if (--m == 0) { sort(a, left, right, true); return; } } } /* * The array is not highly structured, * use Quicksort instead of merge sort. */ if (++count == MAX_RUN_COUNT) { sort(a, left, right, true); return; } } // Check special cases // Implementation note: variable "right" is increased by 1. if (run[count] == right++) { // The last run contains one element run[++count] = right; } else if (count == 1) { // The array is already sorted return; } // Determine alternation base for merge byte odd = 0; for (int n = 1; (n <<= 1) < count; odd ^= 1); // Use or create temporary array b for merging long[] b; // temp array; alternates with a int ao, bo; // array offsets from 'left' int blen = right - left; // space needed for b if (work == null || workLen < blen || workBase + blen > work.length) { work = new long[blen]; workBase = 0; } if (odd == 0) { System.arraycopy(a, left, work, workBase, blen); b = a; bo = 0; a = work; ao = workBase - left; } else { b = work; ao = 0; bo = workBase - left; } // Merging for (int last; count > 1; count = last) { for (int k = (last = 0) + 2; k <= count; k += 2) { int hi = run[k], mi = run[k - 1]; for (int i = run[k - 2], p = i, q = mi; i < hi; ++i) { if (q >= hi || p < mi && a[p + ao] <= a[q + ao]) { b[i + bo] = a[p++ + ao]; } else { b[i + bo] = a[q++ + ao]; } } run[++last] = hi; } if ((count & 1) != 0) { for (int i = right, lo = run[count - 1]; --i >= lo; b[i + bo] = a[i + ao] ); run[++last] = right; } long[] t = a; a = b; b = t; int o = ao; ao = bo; bo = o; } }
测试
package testutil; import java.util.Arrays; import java.util.List; import java.util.stream.Stream; /** * @author CSDN@日星月云 * @date 2022/10/25 19:58 */ public class TestArrays { public static void main(String[] args) { int[] a =new int[]{ 1,2,3,4,5,9,8,7,6,0 }; //copyOf int[] b = Arrays.copyOf(a, a.length); System.out.println(Arrays.toString(b));//[1, 2, 3, 4, 5, 9, 8, 7, 6, 0] //copyOfRange int[] c = Arrays.copyOfRange(b, 0, 5); System.out.println(Arrays.toString(c));//[1, 2, 3, 4, 5] List<Integer> ints = Arrays.asList(1,2,3,4,5); ints.forEach(System.out::print);//12345 System.out.println(); //先排序 Arrays.sort(a); System.out.println(Arrays.toString(a));//[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] //二分查找先排序 // return mid System.out.println(Arrays.binarySearch(a, 5));//5 //return -(low + 1); System.out.println(Arrays.binarySearch(a, 11));//-11 System.out.println(Arrays.binarySearch(a, -1));//-1 } }
总结
关键词：
- asList
- binarySearch0
- 二分查找
- sort
- copyOf
最后
开源=为爱发电
