Java.util.Arrays 與 陣列拷貝
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