技術標籤：筆記JAVA字串類java

目錄

• 前言
• 一、Arrays是什麼？
• 二、使用步驟
• • 常用方法

前言

該類包含用於運算元組的各種方法（例如排序和搜尋）。 此類還包含一個靜態工廠，允許將陣列視為列表。 如果指定的陣列引用為null，則此類中的方法都丟擲NullPointerException ，除非另有說明。 包含在此類的方法中的檔案包括的實施方式的簡要描述。 這些描述應被視為實施說明 ，而不是規範的一部分 。 只要遵守規範本身，實現者就可以隨意替換其他演算法。
（例如， sort(Object[])使用的演算法不一定是sort(Object[]) ，但它必須是穩定的 。）

一、Arrays是什麼？

Arrays類位於 java.util 包中，主要包含了運算元組的各種方法，其實我們知道其他的一些集合例如List、Set這些集合類還是提供了很多方法的，但是陣列它是不屬於集合體系下的，它是通過[]進行標識的，它沒有提供給使用者可操作的任何方法，只提供了一個length 屬性.

二、使用步驟

常用方法

原始碼說:

asList(T... a) 
binarySearch( Object[] a, Object key)
copyOf(Object[] original, int newLength) 
copyOfRange(Object[] original, int
 
 from, int to) 
deepEquals(Object[] a1, Object[] a2)
deepHashCode(Object a[]) 
deepToString(Object[] a) 
deepToString(Object[] a, StringBuilder buf, Set<Object[]> dejaVu) {
equals(Object[] a, Object[] a2)
fill(Object[] a, Object val)
hashCode(char a[])
legacyMergeSort(Object[] a) 
parallelPrefix
 
(Object[] array, Object op)
parallelSetAll(Object[] array, IntToObjectFunction generator) 
parallelSort(Object[] a) 
setAll(Object[] array, IntToObjectFunction generator)
sort(Object[] a)
spliterator(Object[] array) 
spliterator(Object[] array, int startInclusive, int endExclusive)
stream(Object[] array)
stream(Object[] array, int startInclusive, int endExclusive) 
swap(Object[] x, int a, int b)
toString(Object[] a)

程式碼示例:
asList()方法:將陣列或者是可變引數轉化為List

public static void asList(){
        String [] arr={"n","a","n"};
        List<String> list = Arrays.asList(arr);
        List<String> list1 = Arrays.asList("b","a","o");
        System.out.println(list);
        System.out.println(list1);
        /**
         * [n, a, n]
         * [b, a, o]
         */
    }

對陣列進行升序排序:

public static void sort(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.sort(arr);
        for (int i : arr){
            System.out.print(i+" ");
        }
        //-4 3 4 5 8 9
    }

sort​(int[] a, int fromIndex, int toIndex)按升序對陣列的指定範圍進行排序。

public static void sort1(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.sort(arr,0,3);
        for (int i : arr){
            System.out.print(i+" ");
            //4 5 9 8 3 -4 
        }
    }

Arrays.sort(nums, new Comparator() ) 使用Comparator 指定排序方向 主要看重寫的compared方法規定的方法

public void sort() {
    Integer[] nums = {2, 5, 0, 4, 6, -10};
    Arrays.sort(nums, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1.compareTo(o2);
        }
    });
    for (int i : nums) {
        System.out.print(i + " ");
    }
}
// 輸出結果
-10 0 2 4 5 6 

fill​(int[] a, int val) 將指定的int值分配給指定的int陣列的每個元素,將陣列內的元素全部替換成val

 public static void fill(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.fill(arr,2);
        for (int i : arr){
            System.out.print(i+" ");
            //2 2 2 2 2 2 
        }
    }

fill​(int[] a, int fromIndex, int toIndex, int val)將指定的int值分配給指定的int陣列的指定範圍的每個元素。

public static void fill1(){
        int [] arr ={9,5,4,8,3,-4};
        Arrays.fill(arr,2,5,200);
        for (int i : arr){
            System.out.print(i+" ");
            //9 5 200 200 200 -4 
        }
    }

toString​(int[] a)返回指定陣列內容的字串表示形式。

 public static void tostring(){
        int [] arr ={9,5,4,8,3,-4};
        //[[email protected]
        System.out.println(arr);
        //[9, 5, 4, 8, 3, -4]
        System.out.println(Arrays.toString(arr));
    }

deepToString(Object[][] arrays)返回多維陣列的字串形式

@Test
public void deepToString() {
    int[][] nums = {{2, 5, 0, 4, 6, -10},{2, 5, 0, 4, 6, -10}};
    System.out.println(nums);
    System.out.println(Arrays.deepToString(nums));
}
// 輸出結果
[[I@587c290d
[[2, 5, 0, 4, 6, -10], [2, 5, 0, 4, 6, -10]]

binarySearch(Object[] a, Object key)
採用二分查詢方式，查詢某個特定的key，如果找到返回下標，找不到則返回-1，需要注意的是二分查詢要求輸入是有序的

 public static void binarysearch(){
        //無序輸出
        int a =Arrays.binarySearch(new int[] {1,2,3,9,5}, 4);

        int b=Arrays.binarySearch(new int[] {1,2,3,4,5}, 4);
        System.out.println(a);//-4
        
        
        System.out.println(b);//3
    }

copyOf​(int[] original, int newLength)使用零複製指定的陣列，截斷或填充（如有必要），以使副本具有指定的長度。

public void copyOfRange() {
    int[] ints = Arrays.copyOfRange(new int[]{9, 8, 7,6,5,4,3,2,1}, 0, 5);
    System.out.println(Arrays.toString(ints));
}
// 輸出結果
[9, 8, 7, 6, 5]

parallelPrefix使用平行計算，並對陣列做計算的功能，由於是一個函式式介面，可以作lambda表示式

public void parallelPrefix() {
    int[] ints = {1, 2, 3, 4, 5};
    //K表示陣列第一個值，也就是0號索引，V代表K的下一個索引值，兩個索引的值相加
    Arrays.parallelPrefix(ints,(K,V)-> K+V);
    //輸出為[1, 3, 6, 10, 15]：流程是1和2相加為3，3和3相加為6，6和4相加為10...以此往後類推
    System.out.println(Arrays.toString(ints));

    int[] Ints = {5,4,3,2,1,0};
    //從1號索引到5號索引之間開始相加數值
    Arrays.parallelPrefix(Ints,1,5,(K,V) -> K + V);
    System.out.println(Arrays.toString(Ints)); //輸出為[5, 4, 7, 9, 10, 0]

}

parallelSort使用並行排序+合併排序演算法對陣列進行排序

public void parallelSort() {
    int[] ints = {2, 3, 4, 5, 1};
    Arrays.parallelSort(ints);
    //輸出為：[1, 2, 3, 4, 5]
    System.out.println(Arrays.toString(ints));
    
    int[] Ints = {2, 3, 4, 5, 1,6,8,7};
    //從1到7號索引之間進行排序
    Arrays.parallelSort(Ints,1,7);
    //輸出為：[2, 1, 3, 4, 5, 6, 8, 7]
    System.out.println(Arrays.toString(Ints));
}