您好,登錄后才能下訂單哦!
本篇內容主要講解“Java核心類庫Arrays的常用方法介紹”,感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷,實用性強。下面就讓小編來帶大家學習“Java核心類庫Arrays的常用方法介紹”吧!
Java常用類庫Arrays
一、常用方法
1.1 toString
1.2 Sort
1.2.1 sort(T[] a, int fromIndex, int toIndex)
1.2.2 Sort(T[] a)
1.2.3 其它
1.3 copyOf
1.4 mismatch
1.5 binarySearch
1.5.1 binarySearch(T[] a, int fromIndex, int toIndex, T key)
1.5.2 binarySearch(T[] a, T key)
1.5.3 其它
1.6 equals
1.6.1 equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex)
1.6.2 equals(T[] a, T[] a2)
1.6.3 其它
1.7 fills
1.7.1 fill(T[] a, int fromIndex, int toIndex, T val)
1.7.2 fill(T[] a, T val)
二、其他方法
類Arrays包含用于操作數組的各種方法(例如排序和搜索)
如果指定的數組引用為null,則此類中的方法都拋出NullPointerException ,除非另有說明
返回指定數組內容的字符串形式
舉例
int[] a1 = {1,2,3,4,5}; System.out.println(Arrays.toString(a1));//[1, 2, 3, 4, 5]
源碼
public static String toString(int[] 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(", "); } }
其它
Modifier and Type | Field | Description |
---|---|---|
static String | deepToString(Object[] a) | 返回指定數組的“深層內容”的字符串表示形式 |
排序(默認升序)
指定區間進行排序
舉例
int[] a1 = {9,1,3,7,2,5}; System.out.println(Arrays.toString(a1));//[9, 1, 3, 7, 2, 5] Arrays.sort(a1,0,3);//[0,3),對9,1,3進行排序 System.out.println(Arrays.toString(a1));//[0[1, 3, 9, 7, 2, 5]
源碼
public static void sort(int[] a, int fromIndex, int toIndex) { rangeCheck(a.length, fromIndex, toIndex); DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0); }
對整個數組進行排序
舉例
int[] a1 = {0,7,8,2,4,1}; System.out.println(Arrays.toString(a1));//[0, 7, 8, 2, 4, 1] Arrays.sort(a1); System.out.println(Arrays.toString(a1));//[0, 1, 2, 4, 7, 8]
源碼
public static void sort(int[] a) { DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0); }
Modifier and Type | Field | Description |
---|---|---|
static void | sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c) | 根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。 |
static void | sort(T[] a, Comparator<? super T> c) | 根據指定比較器引發的順序對指定的對象數組進行排序。 |
static void | parallelSort(T[] a) | 將指定的數組按升序排序。 |
static void | parallelSort(T[] a, int fromIndex, int toIndex) | 將指定的數組范圍按數字升序排序。 |
static <T extends Comparable<? super T>>void | parallelSort(T[] a) | 根據元素的natural ordering對指定的對象數組按升序排序。 |
static <T extends Comparable<? super T>>void | parallelSort(T[] a, int fromIndex, int toIndex) | 根據元素的natural ordering ,將指定對象數組的指定范圍按升序排序。 |
static void | parallelSort(T[] a, int fromIndex, int toIndex, Comparator<? super T> cmp) | 根據指定比較器引發的順序對指定對象數組的指定范圍進行排序。 |
static void | parallelSort(T[] a, Comparator<? super T> cmp) | 根據指定比較器引發的順序對指定的對象數組進行排序。 |
復制(常用于數組擴容)
舉例
int[] a = {1,2,3}; System.out.println(a.length);//output:3 a = Arrays.copyOf(a,15); System.out.println(a.length);//output:15
源碼
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; }
其它
Modifier and Type | Field | Description |
---|---|---|
static T[] | copyOf(T[] original, int newLength) | 使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度 |
static <T,U>T[] | copyOf(U[] original, int newLength, 類<? extends T[]> newType) | 使用空值復制指定的數組,截斷或填充(如有必要),以使副本具有指定的長度 |
舉例
int[] a1 = {0,1,2,3,4,5}; int[] a2 = {0,1,2,3,4,5};//與a1相同 int[] a3 = {0,1,2,3,0,5};//從索引4開始與a1不同 System.out.println(Arrays.mismatch(a1,a2));//output:-1 System.out.println(Arrays.mismatch(a1,a3));//output:4
源碼
public static int mismatch(int[] a, int[] b) { int length = Math.min(a.length, b.length); // Check null array refs if (a == b) return -1; int i = ArraysSupport.mismatch(a, b, length); return (i < 0 && a.length != b.length) ? length : i; }
其它
Modifier and Type | Field | Description |
---|---|---|
static int | mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 查找并返回指定范圍內兩個 Object數組之間第一個不匹配的相對索引,否則如果未找到不匹配則返回-1。 |
static int | mismatch(T[] a, T[] b, Comparator<? super T> cmp) | 查找并返回兩個 Object數組之間第一個不匹配的索引,否則如果未找到不匹配則返回-1。 |
二分查找,搜索,返回下標
限定了搜索的范圍[fromIndex, toIndex)
舉例
int[] a = {1,2,3,4,5}; int x1 = Arrays.binarySearch(a,2,3,4);//在a數組下標[2,3)中查找值為4的下標 System.out.println(x1);//output:<0的隨機數
源碼
public static int binarySearch(int[] a, int fromIndex, int toIndex,int key) { rangeCheck(a.length, fromIndex, toIndex); return binarySearch0(a, fromIndex, toIndex, key); } 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. }
與上述相同,只是沒有限定范圍,fromIndex=0, toIndex=length
舉例
int[] a = {1,2,3,4,5}; int x1 = Arrays.binarySearch(a,3);//在a數組中查找值為3的下標 int x2 = Arrays.binarySearch(a,-6);//在a數組中查找值為6的下標 System.out.println(x1);//output:2 System.out.println(x2);//output:<0的隨機數
源碼
public static int binarySearch(int[] a, int key) { return binarySearch0(a, 0, a.length, key); } 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. }
Modifier and Type | Field | Description |
---|---|---|
static int | binarySearch(T[] a, int fromIndex, int toIndex, T key, Comparator<? super T> c) | 使用二進制搜索算法搜索指定對象的指定數組范圍 |
static int | binarySearch(T[] a, T key, Comparator<? super T> c) | 使用二進制搜索算法在指定的數組中搜索指定的對象 |
如果兩個指定數組在指定范圍內相等 ,則返回true
舉例
int[] a1 = {1,2,3,4,5}; int[] a2 = {1,2,0,0,4,5}; System.out.println(Arrays.equals(a1,0,2,a2,0,2));//true System.out.println(Arrays.equals(a1,3,5,a2,4,6));//true
源碼
public static boolean equals(int[] a, int aFromIndex, int aToIndex,int[] b, int bFromIndex, int bToIndex) { rangeCheck(a.length, aFromIndex, aToIndex); rangeCheck(b.length, bFromIndex, bToIndex); int aLength = aToIndex - aFromIndex; int bLength = bToIndex - bFromIndex; if (aLength != bLength) return false; return ArraysSupport.mismatch(a, aFromIndex, b, bFromIndex,aLength) < 0; }
如果兩個指定數組相等,則返回 true
舉例
int[] a1 = {1,2,3,4,5}; int[] a2 = {1,2,3,4,5}; int[] a3 = {1,2,0,4,5}; System.out.println(Arrays.equals(a1,a2));//true System.out.println(Arrays.equals(a1,a3));//false
源碼
public static boolean equals(int[] a, int[] a2) { if (a==a2) return true; if (a==null || a2==null) return false; int length = a.length; if (a2.length != length) return false; return ArraysSupport.mismatch(a, a2, length) < 0; }
Modifier and Type | Field | Description |
---|---|---|
static boolean | deepEquals(Object[] a1, Object[] a2) | 如果兩個指定的數組彼此 深度相等 ,則返回 true |
static boolean | equals(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 如果在指定范圍內指定的兩個Object數組彼此 相等 ,則返回true |
static boolean | equals(T[] a, T[] a2, Comparator<? super T> cmp) | 如果兩個指定的Objects數組彼此 相等 ,則返回 true |
將指定的T值分配給指定的T類型數組的指定范圍的每個元素
舉例
int[] a1 = new int[10]; Arrays.fill(a1,1,4,8); char[] a2 = new char[10]; Arrays.fill(a2,0,3,'s'); System.out.println(Arrays.toString(a1));//[0, 8, 8, 8, 0, 0, 0, 0, 0, 0] System.out.println(Arrays.toString(a2));//[s, s, s, , , , , , , ]
源碼
public static void fill(char[] a, int fromIndex, int toIndex, char val) { rangeCheck(a.length, fromIndex, toIndex); for (int i = fromIndex; i < toIndex; i++) a[i] = val; }
將指定的T值分配給指定的T類型數組的每個元素
舉例
int[] a1 = new int[10]; Arrays.fill(a1,8); char[] a2 = new char[10]; Arrays.fill(a2,'s'); System.out.println(Arrays.toString(a1));//[8, 8, 8, 8, 8, 8, 8, 8, 8, 8] System.out.println(Arrays.toString(a2));//[s, s, s, s, s, s, s, s, s, s]
源碼
public static void fill(int[] a, int val) { for (int i = 0, len = a.length; i < len; i++) a[i] = val; }
Modifier and Type | Field | Description |
---|---|---|
static List | asList(T… a) | 返回由指定數組支持的固定大小的列表。 |
static int | compare(T[] a, T[] b) | 字典順序比較兩個T陣列 |
static int | compare(T[] a, int aFromIndex, int aToIndex,T[] b, int bFromIndex, int bToIndex) | 在指定范圍內按字典順序比較兩個T陣列 |
static <T extends Comparable<? super T>>int | compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) | 在指定范圍內按字典順序比較兩個 Object陣列。 |
static int | compare(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex, Comparator<? super T> cmp) | 在指定范圍內按字典順序比較兩個 Object陣列。 |
static <T extends Comparable<? super T>>int | compare(T[] a, T[] b) | 按 Object順序比較兩個 Object陣列,在可比元素中。 |
static int | compare(T[] a, T[] b, Comparator<? super T> cmp) | 使用指定的比較器按字典順序比較兩個 Object陣列 |
static int | compareUnsigned(T[] a, T[] b) | byte字典順序比較兩個T陣列,數字處理元素為無符號 |
static int | compareUnsigned(T[] a, int aFromIndex, int aToIndex, T[] b, int bFromIndex, int bToIndex) | 在指定范圍內按字典順序比較兩個 T陣列,將元素數字處理為無符號 |
static T[] | copyOfRange(T[] original, int from, int to) | 將指定數組的指定范圍復制到新數組中 |
static T[] | copyOfRange(T[] original, int from, int to) | 將指定數組的指定范圍復制到新數組中 |
static <T,U>T[] | copyOfRange(U[] original, int from, int to, 類<? extends T[]> newType) | 將指定數組的指定范圍復制到新數組中 |
static int | hashCode(T[] a) | 根據指定數組的內容返回哈希碼 |
static int | deepHashCode(Object[] a) | 返回基于指定數組的“深層內容”的哈希碼 |
static void | parallelPrefix(T[] array, int fromIndex, int toIndex,TBinaryOperator op) | 對于給定的數組子范圍執行parallelPrefix(T[],TBinaryOperator) |
static void | parallelPrefix(dT[] array,TBinaryOperator op) | 使用提供的函數并行地累積給定數組的每個元素 |
static void | parallelPrefix(T[] array, int fromIndex, int toIndex, BinaryOperator op) | 對于給定的數組子范圍執行 parallelPrefix(Object[], BinaryOperator) |
static void | parallelPrefix(T[] array, BinaryOperator op) | 使用提供的函數并行地累積給定數組的每個元素 |
static void | parallelSetAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素 |
static void | parallelSetAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素 |
static void | parallelSetAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素 |
static void | parallelSetAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函數并行設置指定數組的所有元素以計算每個元素 |
static void | setAll(double[] array, IntToDoubleFunction generator) | 使用提供的生成器函數設置指定數組的所有元素以計算每個元素 |
static void | setAll(int[] array, IntUnaryOperator generator) | 使用提供的生成器函數設置指定數組的所有元素以計算每個元素 |
static void | setAll(long[] array, IntToLongFunction generator) | 使用提供的生成器函數設置指定數組的所有元素以計算每個元素 |
static void | setAll(T[] array, IntFunction<? extends T> generator) | 使用提供的生成器函數設置指定數組的所有元素以計算每個元素 |
static | Spliterator.OfDouble spliterator(double[] array) | 返回覆蓋所有指定數組的Spliterator.OfDouble |
static | Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive) | 返回覆蓋指定數組的指定范圍的Spliterator.OfDouble |
static | Spliterator.OfInt spliterator(int[] array) | 返回覆蓋所有指定數組的Spliterator.OfInt |
static | Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) | 返回覆蓋指定數組的指定范圍的Spliterator.OfInt |
static | Spliterator.OfLong spliterator(long[] array) | 返回覆蓋所有指定數組的Spliterator.OfLong |
static | Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive) | 返回覆蓋指定數組的指定范圍的Spliterator.OfLong |
static Spliterator | spliterator(T[] array) | 返回覆蓋所有指定數組的Spliterator |
static Spliterator | spliterator(T[] array, int startInclusive, int endExclusive) | 返回覆蓋指定數組的指定范圍的Spliterator |
static DoubleStream | stream(double[] array) | 返回以指定數組作為源的順序DoubleStream |
static DoubleStream | stream(double[] array, int startInclusive, int endExclusive) | 返回指定數組的指定范圍作為其源的順序DoubleStream |
static IntStream | stream(int[] array) | 返回以指定數組作為源的順序IntStream |
static IntStream | stream(int[] array, int startInclusive, int endExclusive) | 返回指定數組的指定范圍作為其源的順序IntStream |
static LongStream | stream(long[] array) | 返回以指定數組作為源的順序LongStream |
static LongStream | stream(long[] array, int startInclusive, int endExclusive) | 返回指定數組的指定范圍作為其源的順序LongStream |
static Stream | stream(T[] array) | 返回以指定數組作為源的順序Stream |
static Stream | stream(T[] array, int startInclusive, int endExclusive) | 返回指定數組的指定范圍作為其源的順序Stream |
到此,相信大家對“Java核心類庫Arrays的常用方法介紹”有了更深的了解,不妨來實際操作一番吧!這里是億速云網站,更多相關內容可以進入相關頻道進行查詢,關注我們,繼續學習!
免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。