Java.util.Arrays 與陣列拷貝

阿新 • • 發佈：2018-11-06

Java.util.Arrays

java.util.Arrays類中提供了許多實用的方法，可用於陣列的複製、排序等操作處理。
以下是常用的方法和屬性：

Arrays.sort() 序列排序:
原始碼：

public static void sort(int[] a, int fromIndex, int toIndex) {
    rangeCheck(a.length, fromIndex, toIndex);
     DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
  										//雙軸快速排序比一般的快速排序更快,優化後的快速排序
    }

sort(陣列名，起始下標，結束下標） //填充指定索引範圍，按照升序進行陣列排序，如果指定範圍，則排序範圍從起始索引（包括）到結束索引（不包括）。如果起始索引==結束索引，則排序範圍為空。如果指定下標索引越界，則會丟擲異常ArrayIndexOutOfBoundsException。這裡底層用到rangeCheck（）方法即範圍檢查，rangeCheck（）方法具體如何實現如下：

private static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
        if (fromIndex > toIndex) {
            throw new IllegalArgumentException(
                    "fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
        }
        if (fromIndex < 0) {
            throw new ArrayIndexOutOfBoundsException(fromIndex);
        }
        if (toIndex > arrayLength) {
            throw new ArrayIndexOutOfBoundsException(toIndex);
        }
    }

舉例：

package kkee;
import java.util.Arrays;
/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/18 20:53
 */
public class Arraysort {
    public static void main(String[] args) {
        int[] array1 = {1,4,2,5,7,3,8,6};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));
    }
}

[1, 2, 3, 4, 5, 6, 7, 8]

Arrays.binarySearch() 二分查詢：
使用二分查詢來搜尋指定型別的陣列，以查詢指定的鍵值。原始碼：

   public static int binarySearch(int[] a, int key) {
        return binarySearch0(a, 0, a.length, key);
    }
 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;	//無符號右移 = mid=low+(high-low)/2
        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.
}

binarySearch(陣列名，鍵值) / binarySearch(陣列名，起始索引，結束索引，鍵值) //在指定索引範圍內搜尋，鍵值即我們要查詢的數字，如果搜尋鍵包含在陣列中，則返回其索引，即在陣列中的下標；否則返回（—（插入點）—1）。插入點為第一個大於鍵值的元素索引。如果指定下標索引越界，則會丟擲異常ArrayIndexOutOfBoundsException。

Arrays.equals() :
判斷兩個陣列是否相等，結果為true或者false。原始碼：

  public static boolean equals(int[] a, int[] a2) {
        if (a==a2)
            return true;		//判斷陣列是否相同；若相同，則結果為true
        if (a==null || a2==null)
            return false;		//判斷兩個陣列是否為空

        int length = a.length;		//宣告陣列長度
        if (a2.length != length)		//判斷兩個陣列長度是否相等
            return false;

        for (int i=0; i<length; i++)
            if (a[i] != a2[i])   //判斷陣列中元素是否相同
                return false;
                
        return true;

如果兩個陣列以相同順序包含相同的元素，則兩個陣列是相等的。注：如果兩個陣列引用均為null，則認為他們是相等的。

舉例：

public class Arraysort {
    public static void main(String[] args) {
        int[] array1 = {1,4,2,5,7,3,8,6};
        int[] array2 = {1,2,3,4,5};
        int[] array3 = {1,4,2,5,7,3,8,6};
        int[] array4 = {1,2,3,4,5,6,7,8};
        boolean b1 = Arrays.equals(array1,array2);
        boolean b2 = Arrays.equals(array1,array3);
        boolean b3 = Arrays.equals(array1,array4);
        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
	}
}

false
true
false

Arrays.fill():
使用指定值填充陣列。原始碼：

 public static void fill(int[] a, int val) {
        for (int i = 0, len = a.length; i < len; i++)
            a[i] = val;
    }
   public static void fill(int[] a, int fromIndex, int toIndex, int val) {
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i = fromIndex; i < toIndex; i++)
            a[i] = val;
    }

fill(陣列名，值)/fill(陣列名，起始索引，結束索引，鍵值，值)//填充指定索引範圍，如果指定範圍，則填充從起始索引（包括）到結束索引（不包括）。注：如果起始索引==結束索引，則填充範圍為空。如果指定下標索引越界，則會丟擲異常ArrayIndexOutOfBoundsException。

舉例：

public class Arraysort {
    public static void main(String[] args) {
        int[] array1 = {1,4,2,5,7,3,8,6};
        int[] array2 = {1,2,3,4,5};
        int[] array3 = {1,4,2,5,7,3,8,6};
        int[] array4 = {1,2,3,4,5,6,7,8};
        Arrays.fill(array4 , 5); //用一個數填充整個陣列，未定義起始索引和結束索引則預設整個
       System.out.println(Arrays.toString(array4));
        Arrays.fill(array4 , 0 ,5,0); //從array[0]開始到aaray[5]用0填充，剩餘不變
        System.out.println(Arrays.toString(array4));
        Arrays.fill(array4 , 0 ,10,0); //下標索引越界，執行時異常
        System.out.println(Arrays.toString(array4));

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Array index out of range: 10
[5, 5, 5, 5, 5, 5, 5, 5]
[0, 0, 0, 0, 0, 5, 5, 5]
	at java.util.Arrays.rangeCheck(Arrays.java:120)
	at java.util.Arrays.fill(Arrays.java:2903)
	at kkee.Arraysort.main(Arraysort.java:21)

Arrays.toString():
返回指定陣列的字串表示形式。原始碼：

public static String toString(int[] a) {
        if (a == null)   //若陣列為空，則返回null
            return "null";
        int iMax = a.length - 1;   
        if (iMax == -1)
            return "[]";

        StringBuilder b = new StringBuilder();
        b.append('[');  //append()是往動態字串陣列新增  新增[
        for (int i = 0; ; i++) {
            b.append(a[i]); //新增陣列的元素 按下標輸出
            if (i == iMax)  // 如果i==iMax即陣列中元素新增結束
                return b.append(']').toString(); //新增]
            b.append(", ");
        }
    }

前面的例子中已經使用過，可以檢視結果。

陣列拷貝

陣列拷貝即為陣列複製。首先，可以分為淺拷貝和深拷貝。
淺拷貝是指拷貝物件時僅僅拷貝物件本身（包括物件中的基本變數），而不拷貝物件包含的引用指向的物件。深拷貝不僅拷貝物件本身，而且拷貝物件包含的引用指向的所有物件。舉例來說更加清楚：物件A1中包含對B1的引用，B1中包含對C1的引用。淺拷貝A1得到A2，A2 中依然包含對B1的引用，B1中依然包含對C1的引用。深拷貝則是對淺拷貝的遞迴，深拷貝A1得到A2，A2中包含對B2（B1的copy）的引用，B2 中包含對C2（C1的copy）的引用。
淺拷貝是按位拷貝物件，它會建立一個新物件，這個物件有著原始物件屬性值的一份精確拷貝。如果屬性是基本型別，拷貝的就是基本型別的值；如果屬性是記憶體地址（引用型別），拷貝的就是記憶體地址，因此如果其中一個物件改變了這個地址，就會影響到另一個物件。
深拷貝會拷貝所有的屬性,並拷貝屬性指向的動態分配的記憶體。當物件和它所引用的物件一起拷貝時即發生深拷貝。深拷貝相比於淺拷貝速度較慢並且花銷較大。
目前在Java中資料拷貝提供瞭如下方式：

for 迴圈（淺拷貝）
陣列名.clone() 克隆拷貝（淺拷貝）
System.arraycopy() （淺拷貝）
Arrays.copyOf() （淺拷貝）

for 迴圈實現陣列拷貝

package kkee;
import java.util.Arrays;
public class Arraysort {
    public static void main(String[] args) {
        int[] array1 = {1, 4, 2, 5, 7, 3, 8, 6};
        int[] array2 = {1, 2, 3, 4, 5};
        int[] array3 = {1, 4, 2, 5, 7, 3, 8, 6};
        int[] array4 = {1, 2, 3, 4, 5, 6, 7, 8};
        int[] barry = new int[array1.length];

        for (int i = 0; i < array1.length; i++) {
            barry[i] = array1[i];
        }
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(barry));
        barry[1] = 10;
        System.out.println(Arrays.toString(barry));
        System.out.println(Arrays.toString(array1));
    }
}

[1, 4, 2, 5, 7, 3, 8, 6]
[1, 4, 2, 5, 7, 3, 8, 6]
[1, 10, 2, 5, 7, 3, 8, 6]
[1, 4, 2, 5, 7, 3, 8, 6]

class TestArray {
    private int val = 10;
    public void setVal(int val) { this.val = val; }
    public int getVal() { return this.val; }
}
public class Arraysort {

    public static void main(String[] args) {
        TestArray[] barry1 = new TestArray[4];
        barry1[0] = new TestArray();
        barry1[1] = new TestArray();
        barry1[2] = new TestArray();
        barry1[3] = new TestArray();
        TestArray[] barry2 = new TestArray[4];
        for (int i = 0; i < barry1.length; i++) {
            barry2[i] = barry1[i];
        }
        for (int i = 0; i < barry1.length; i++) {
            System.out.print(barry1[i].getVal() + " ");
        }
        System.out.println();
        for (int i = 0; i < barry2.length; i++) {
            System.out.print(barry2[i].getVal() + " ");
        }
        System.out.println();
        barry2[0].setVal(100000);
        System.out.println("===============");

        for (int i = 0; i < barry1.length; i++) {
            System.out.print(barry1[i].getVal() + " ");
        }
        System.out.println();
        for (int i = 0; i < barry2.length; i++) {
            System.out.print(barry2[i].getVal() + " ");
        }
    }

}

10 10 10 10 
10 10 10 10 
===============
100000 10 10 10 
100000 10 10 10

由上可得，for迴圈是淺拷貝，產生一個新的物件，兩個引用指向同一個物件，程式碼靈活，但效率低，速度相對較慢。

克隆拷貝 Object.clone()

在Java語言中，陣列是引用型別。如果有兩個陣列變數a1和a2，則語句“a2 = a1;”將陣列變數a1的引用傳遞給另一個數組a2；如果陣列a2發生變化，則陣列a1也發生變化。對於引用型別來說，它是淺拷貝；對簡單型別來說，它是深拷貝。
引用型別：

package kkee;
import java.util.Arrays;
public class Arraysort {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] barry = array.clone();
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(barry));
        barry[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(barry));
    }
}

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1000, 2, 3, 4, 5, 6, 7, 8, 9]

class TestArray {
    private int val = 10;
    public void setVal(int val) { this.val = val; }
    public int getVal() { return this.val; }
}
public class Arraysort {
    public static void main(String[] args) {
        TestArray[] t1 = new TestArray[4];
        t1[0] = new TestArray();
        t1[1] = new TestArray();
        t1[2] = new TestArray();
        t1[3] = new TestArray();
        TestArray[] t2 = t1.clone();//t2[0]
        for(int i = 0;i < t1.length;i++) {
            System.out.print(t1[i].getVal()+" ");
        }
        System.out.println();
        for(int i = 0;i < t2.length;i++) {
            System.out.print(t2[i].getVal()+" ");
        }
        System.out.println();
        t2[0].setVal(100000);
        System.out.println("===============");

        for(int i = 0;i < t1.length;i++) {
            System.out.print(t1[i].getVal()+" ");
        }
        System.out.println();
        for(int i = 0;i < t2.length;i++) {
            System.out.print(t2[i].getVal()+" ");
        }
    }

10 10 10 10 
10 10 10 10 
===============
100000 10 10 10 
100000 10 10 10

檢視clone()的原始碼可知：

 protected native Object clone() throws CloneNotSupportedException;

它的關鍵字是native（本地方法）,返回型別是Object,所以賦值時要發生強制轉換，並且也是由底層的C/C++語言實現的，還要注意的是，這裡修飾符是protected，也就是說，我們建立了一個Object類以後，是不能直接呼叫這個clone（）方法的，因為protected關鍵字只允許同一個包內的類和它的子類呼叫，所以我們宣告一個object類時，肯定不是同一個包內，所以就不能去呼叫它。
要呼叫這個方法，就需要我們寫一個類，然後宣告實現cloneable介面就好了，不需要去顯示地宣告繼承於object，因為java中的類如果不顯示說明父類的話，預設父類就是object。然後我們繼承這個方法：

@Override
public Object clone() throws CloneNotSupportedException {
// TODO Auto-generated method stub
return super.clone();
}
這裡需要是，為了能夠在不同包內去呼叫這個方法，我們需要把這個許可權升級為public。現在我們就可以呼叫這個類的clone()方法去拷貝我們的類了。總得來說clone()就是淺拷貝。

System.arraycopy()

System.arraycopy(src,srcPos,dest,destPos,length)是System類提供的一個靜態方法，可以用它來實現陣列之間的賦值。檢視原始碼：

public static native void arraycopy(Object src, int srcPos, Object dest, int desPos, int length)
//引數含義：（原陣列， 原陣列的開始位置， 目標陣列， 目標陣列的開始位置， 拷貝個數）

它是淺拷貝，也就是說對於非基本型別而言，它拷貝的是物件的引用，而不是去新建一個新的物件。通過它的程式碼我們可以看到，這個方法不是用java語言寫的，而是底層用c或者c++實現的，因而速度會比較快。

public class Arraysort {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] brray = new int[array.length];
        System.arraycopy(array,0,brray,0,array.length);
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
        brray[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
   }
 }

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1000, 2, 3, 4, 5, 6, 7, 8, 9]

class TestArray {
    private int val = 10;
    public void setVal(int val) { this.val = val; }
    public int getVal() { return this.val; }
}
public class Arraysort {
 public static void main(String[] args) {
        TestArray[] t1 = new TestArray[4];
        t1[0] = new TestArray();
        t1[1] = new TestArray();
        t1[2] = new TestArray();
        t1[3] = new TestArray();
        TestArray[] t2 = new TestArray[4];

        System.arraycopy(t1,0,t2,0,t1.length);

        for(int i = 0;i < t1.length;i++) {
            System.out.print(t1[i].getVal()+" ");
        }
        System.out.println();
        for(int i = 0;i < t2.length;i++) {
            System.out.print(t2[i].getVal()+" ");
        }
        System.out.println();
        t2[0].setVal(100000);
        System.out.println("===============");

        for(int i = 0;i < t1.length;i++) {
            System.out.print(t1[i].getVal()+" ");
        }
        System.out.println();
        for(int i = 0;i < t2.length;i++) {
            System.out.print(t2[i].getVal()+" ");
        }
    }

10 10 10 10 
10 10 10 10 
===============
100000 10 10 10 
100000 10 10 10

Arrays.copyOf()

Arrays.copyOf底層其實也是用的System.arraycopy ，所以效率自然低於System.arraycpoy()，所以它也是淺拷貝。
原始碼如下：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked") //源陣列，拷貝的個數
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    System.arraycopy(original, 0, copy, 0,
                     Math.min(original.length, newLength));
    return copy;
}

public class Arraysort {
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6,7,8,9};
        int[] brray = Arrays.copyOf(array,array.length);

        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
        brray[0] = 1000;
        System.out.println("=================");
        System.out.println(Arrays.toString(array));
        System.out.println(Arrays.toString(brray));
    }
    }

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
=================
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1000, 2, 3, 4, 5, 6, 7, 8, 9]

Arrays.copyOfRange():

複製陣列的指定範圍內容。原始碼：

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));
        return copy;
    }

copyOfRange（陣列名，起始索引，結束索引）從起始索引（包括）到結束索引（不包括）。結果為相同資料型別的陣列。

練習：

{1,2,3,4,5,6}陣列將奇數放在偶數前面，大小順序不要求。

package kkee;
import java.util.Arrays;
/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/19 1:16
 */

public class EvenoddChange {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6};
        for (int i = 0; i < array.length; i++) {
            int temp; //設定臨時變數
            for (int j = array.length - 1; j > 0; j--) {
                //將後面的奇數放在偶數前
                if (array[j] % 2 == 1 && array[j - 1] % 2 == 0) {
                    temp = array[j];
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(array));
    }
}

[1, 3, 5, 2, 4, 6]

一個數組是有序的，給定一個key:數字有兩個數字的和加起來等於key，
找到這兩個數字的下標，例 {1,2,3,4,5,6} 7

public class NewArray {
    public static void findIndex(int[] array,int key){
        for(int i = 0; i < array.length ; i++){
            for(int j = 1; j < array.length; j++){
                int sum = 0;
                sum = array[i] + array[j];
                if(sum == key){
                    System.out.println("所加和等於key對應陣列下標及元素: " + i + ": " + array[i]+ "   " + "   " + "" + j + ": " + array[j] );
                }
            }
        }
    }
    public static void main(String[] args) {
        int[] array = {1,2,3,4,5,6};
        int key = 7;
        findIndex(array, key);
    }
}

所加和等於key對應陣列下標及元素: 0: 1      5: 6
所加和等於key對應陣列下標及元素: 1: 2      4: 5
所加和等於key對應陣列下標及元素: 2: 3      3: 4
所加和等於key對應陣列下標及元素: 3: 4      2: 3
所加和等於key對應陣列下標及元素: 4: 5      1: 2

一個整形陣列，除了兩個數字只出現一次外，其他數字都是兩次，找到這兩個數字。{1,3,1,2,3,4}
解題思路：運用異或的方法：
1^1= 0
1^0= 1
0^1= 1
(1)對於出現兩次的元素，使用“異或”操作後結果肯定為0，那麼我們就可以遍歷一遍陣列，對所有元素使用異或操作，那麼得到的結果就是兩個出現一次的元素的異或結果。
(2)因為這兩個元素不相等，所以異或的結果肯定不是0，也就是可以再異或的結果中找到1位不為0的位，例如異或結果的最後一位不為0。
(3)這樣我們就可以最後一位將原陣列元素分為兩組，一組該位全為1，另一組該位全為0。
(4)再次遍歷原陣列，最後一位為0的一起異或，最後一位為1的一起異或，兩組異或的結果分別對應著兩個結果。

package kkee;
import java.util.Arrays;
/**
 * @Package: kkee
 * @Author:kkz
 * @Description:
 * @Date:Created in 2018/10/19 10:12
 */
public class ValueGroup {
    public static void main(String[] args) {
        int[] array = {1, 3, 1, 2, 3, 4};
        int[] value = findNums(array);
        System.out.println(Arrays.toString(value));
    }
    public static int[] findNums(int[] arr) {
        if(arr.length < 2)
            return arr;//判斷陣列長度是否滿足題目要求，至少有3個數組元素
        int[] result = new int[2];  //要返回的結果，即只出現一次的兩個數字
        int res = arr[0];  //第一次對所有元素進行亦或操作結果
        for(int i=1; i<arr.length; i++) {
            res ^= arr[i];
        }
        int bitIndex = 0;
        for(int i=0; i<32; i++) {  //找出異或結果為1的位。
            if((res>>i & 1) == 1) {
                bitIndex = i;
                break;
            }
        }
        for(int i=0; i<arr.length; i++) { //根據bitIndex為1，將元素分為兩組
            if((arr[i] >> bitIndex & 1) == 1)
                result[0] ^= arr[i];   //對應位為1，亦或得到的結果
            else
                result[1] ^= arr[i];   //對應位為0，亦或得到的結果
        }
        return result;
    }
}

[2, 4]

如何排序陣列並插入某個元素？

package kkee;
import java.util.Arrays;
import java.util.Scanner;
public class NewArray {
    public static void main(String[] args) {
        int[] array = {9, 2, 4, 5};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
        Scanner input = new Scanner(System.in);
        int[] barry = new int[array.length + 1]; //宣告並初始化一個新的陣列，插入一個數，長度加1
        for (int i = 0;i < array.length;i ++){
            barry[i] = array[i];
        } //將原陣列的元素賦給新陣列
        System.out.print("插入新的元素：");
        int value = input.nextInt();
        int index = array.length; //插入的陣列在新陣列的下標
        barry[index] = value;
        Arrays.sort(barry);
        System.out.println("插入後的陣列："+Arrays.toString(barry));

[2, 4, 5, 9]
插入新的元素：8
插入後的陣列：[2, 4, 5, 8, 9]

如何搜尋陣列中的最小值和最大元素？

package kkee;
public class NewArray {
    public static void main(String[] args) {
        int[] array = {9, 2, 4, 5};
         // 查詢最大元素
        int max = array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max)
                max = array[i];
        }
        //查詢最小元素
        int min = array[0];
        for (int i = 0;i < array.length; i++){
            if(array[i] < min)
                min = array[i];
        }
        System.out.println("Max is " + max);
        System.out.println("Min is " + min);
        }
  }

Max is 9
Min is 2

如何合併兩個陣列（合併到一個新的陣列）？

package kkee;
import java.util.Arrays;
public class NewArray {
    public static void main(String[] args) {
        int[] array = {9, 2, 4, 5};
        int[] carry = {2, 3, 4, 5, 6, 7};
        int[] darry = new int[10];
        System.arraycopy(array, 0, darry, 0,array.length);
        System.arraycopy(carry, 0, darry, array.length,carry.length);
        System.out.println("darry =" + Arrays.toString(darry));
    }
}

darry =[9, 2, 4, 5, 2, 3, 4, 5, 6, 7]

如何填充陣列（一次填充，部分填充）？

package kkee;
import java.util.Arrays;
public class NewArray {
    public static void main(String[] args) {
        int[] array = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
        Arrays.fill(array,1,3,1);  //起始索引包括，結束索引不包括  部分填充
        System.out.println(Arrays.toString(array));
        Arrays.fill(array, 2);  //一次填充
        System.out.println(Arrays.toString(array));
        Arrays.fill(array, 0, 5, 3);
        System.out.println(Arrays.toString(array));
    }
}

[1, 1, 1, 2, 3, 3, 4, 4, 5, 5]
[2, 2, 2, 2, 2, 2, 2, 2, 2, 2]
[3, 3, 3, 3, 3, 2, 2, 2, 2, 2]

如何刪除陣列指定元素？

package kkee;
import java.util.Arrays;
import java.util.Scanner;
public class NewArray {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        int[] array = new int[]{1,2,4,5,9,8,0};
        System.out.println(Arrays.toString(array));
        System.out.println("輸入要刪除第幾個元素：");
        int n = sc.nextInt();
        array[n-1] = array[array.length-1];//把最後一個元素替代指定刪除的元素
        array = Arrays.copyOf(array, array.length-1);//陣列長度減一，再賦給原來的陣列
        System.out.println(Arrays.toString(array));
    }
}

[1, 2, 4, 5, 9, 8, 0]
輸入要刪除第幾個元素：
3
[1, 2, 0, 5, 9, 8]

如何從陣列中查詢常見的元素？陣列有的可以查並返回下標，沒有的返回-1。

public class OrderArray {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 11, 15, 17};
        System.out.println("所查詢元素在陣列中的下標為：" + binarySearch(arr, 15, 0, 10));
        System.out.println("所查詢元素在陣列中的下標為：" + binarySearch(arr, 25, 0, 10));
    }
    public static int binarySearch(int[] arr, int key,int start,int end) {
        start = 0;
        end = arr.length - 1;
        while (start <= end) {
            int middle = start + (end - start) / 2;
            if (arr[middle] == key) {
                return middle;
            } else if (arr[middle] < key) {
                start = middle + 1;
            } else {
                end = middle - 1;
            }
        }
        return -1;
    }
}

所查詢元素在陣列中的下標為：9
所查詢元素在陣列中的下標為：-1

Java.util.Arrays 與陣列拷貝

Java.util.Arrays

陣列拷貝

for 迴圈實現陣列拷貝

克隆拷貝 Object.clone()

System.arraycopy()

Arrays.copyOf()

Arrays.copyOfRange():

練習：

Java.util.Arrays 與陣列拷貝

java：陣列操作工具類 java.util.Arrays包主要方法詳解

陣列排序 java.util.Arrays類的sort方法

java.util.ArrayList與java.util.Arrays$ArrayList區別

Java中陣列操作 java.util.Arrays 類常用方法的使用

要想陣列用的 6，怎能不懂 java.util.Arrays

java.util.Date與java.sql.Date

at java.util.Arrays.copyOfRange(Arrays.java:3209)導致的java.lang.OutOfMemoryError: Java heap space 錯誤的解決辦法

Java常用工具類：java.util.Arrays

java.util.Date 與 java.sql.Date 與 String 的轉換

java:IO流(位元組陣列拷貝之available()方法---不推薦使用)

mybatis報錯：java.lang.IllegalArgumentException: invalid comparison: java.util.Arrays$ArrayList and java.lang.String

java.lang.System下的arraycopy和java.util.Arrays.copyOf方法

【呼叫javacv進行人臉識別總是出現無法找到 java.util.Arrays.copyOf】

resultMap type型別 java.util.HashMap與pojo類的區別

Java：集合與陣列轉換

java中list與陣列轉換

Java.util.Arrays.deepToString(Object[])

java.util.Arrays類詳解（原始碼總結）

關於java.util.Arrays中的方法分析

Java.util.Arrays 與 陣列拷貝

Java.util.Arrays

陣列拷貝

for 迴圈實現陣列拷貝

克隆拷貝 Object.clone()

System.arraycopy()

Arrays.copyOf()

Arrays.copyOfRange():

練習：

相關推薦

Java.util.Arrays 與陣列拷貝