java陣列定義及方法
阿新 • • 發佈：2021-10-26
陣列的描述
在陣列中每個元素都具有相同的資料型別，是有序資料的集合。通俗的說陣列就相當於一個容器。陣列分為一維陣列、二維陣列和多維陣列。
陣列的特點：
- 陣列型別是從抽象基類Array派生的引用型別。
- 數值陣列元素的預設值為 0，而引用元素的預設值為 null。
- 陣列中存放元素的型別必須與建立陣列時宣告的型別相一致。
- 陣列的型別可以是任意資料型別，包括基本資料型別和引用資料型別，如String[]、int[] 、float[]…
- 陣列的索引是從0開始的，如果陣列有n個元素，那麼它的最大索引為n-1，（陣列索引的取值範圍[0,n-1]）。
陣列的建立及賦值
一維陣列的建立及賦值
一維陣列記憶體格式（如下圖）：
動態建立陣列（如下）：
/* 資料型別[] 陣列名; //（建議使用）
* 陣列名 = new 陣列型別[陣列長度];
*/
String[] str;
str = new String[10];
str[2] = "Hello";
/* 或
* 資料型別 陣列名[];
* 陣列名 = new 陣列型別[陣列長度];
*/
String str1[];
str1 = new String[10];
// 陣列名[索引下標] = 元素值;
str1[2] = "Hello";
/*
* 元素型別[] 陣列名 = new 元素型別[陣列長度]; (建議使用這一種)
* 元素型別 陣列名[] = new 元素型別[陣列長度];
*/
String[] str2 = new String[20]; //（建議使用）
String str2[] = new String[20];
str2[2] = "Hello";
靜態建立陣列（如下）：
// 元素型別[] 陣列名 = {元素1, 元素2, 元素3，…};
int sum = {1,2,3,4,5,6};
//元素型別[] 陣列名 = new 元素型別[]{元素1, 元素2, 元素3，…};
String[] str2 = new String[]{"a","b","1","2"};
二維陣列的建立及賦值
二維陣列記憶體格式（如下圖）：
動態建立二維陣列（如下）：
陣列型別[][] 陣列名 = new 陣列元素型別[行數][列數]
注意：二維陣列中宣告列數時可以省略，但行數必須寫。
/* 資料型別[][] 陣列名; //（建議使用）
* 陣列名 = new 陣列元素型別[行數][]}
*/
String[][] str;
str = new String[5][];
str[0][1] = new String("Hello");
/* 或
* 資料型別 陣列名[][];
* 陣列名 = new 陣列元素型別[行數][列數]}
*/
String str1[][];
str1 = new String[2][3];
str1[0][1] = new String("Hello");
/*
* 元素型別[][] 陣列名 = new 元素型別[陣列長度1][陣列長度2]; (建議使用)
* 元素型別[] 陣列名[] = new 元素型別[陣列長度1][陣列長度2];
* 元素型別 陣列名[][] = new 元素型別[陣列長度1][陣列長度2];
* (陣列長度1和陣列長度2都必須是正整數；陣列長度1為行數，陣列長度2為列數；陣列長度1必須宣告長度)
*/
String[][] str2 = new String[2][3]; // 可以認為建立一個兩行三列的陣列
String[] str2[] = new String[2][3];
String str2[][] = new String[2][3];
str2[0][1] = new String("Hello");
靜態建立二維陣列（如下）：
//資料型別[][] 陣列名 = {{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str = {{"a","1"},{"b","2"}};
//資料型別[][] 陣列名 = new 資料型別[][]{{元素1,元素2...},{元素1,元素2...},{元素1,元素2...}};
String[][] str2 = new String[][]{{"a","1"},{"b","2"}};
陣列的遍歷
一維陣列遍歷
使用for迴圈遍歷獲取陣列元素
int[] arr = {11, 22, 33, 44, 55, 66, 77};
// for迴圈遍歷陣列
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
使用for-each迴圈遍歷獲取陣列元素
優點：語法簡潔，相對執行效率較高
缺點：遍歷過程中，無法獲得陣列|集合索引
int[] arr = {11, 22, 33, 44, 55, 66, 77};
// 增強for迴圈遍歷陣列
for (int value : arr) {
System.out.println(value);
}
二維陣列遍歷
// 使用巢狀迴圈（兩層for迴圈）遍歷
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++){
sum +=arr[i][j];
System.out.print(arr[i][j] + "\t");
}
}
陣列資料結構的優勢和劣勢
優勢：陣列能夠實現快速定址，所以執行“修改”和“查詢”的效率非常高！
快速定址公式：首地址 + 索引值 * 儲存元素佔用的位元組數。
劣勢：陣列實現“插入”和“刪除”的效率非常低！
插入：
a)插入元素之前，先判斷陣列是否還能存得下插入的元素，如果存不下那麼需要執行擴容操作。
原因：陣列一旦建立完畢，那麼陣列的空間長度就不能發生變化了！
b)插入元素時，為了保證陣列是一塊連續的內容空間，那麼我們需要對插入位置之後的元素做位移操作。
位移操作：向後移動一位
刪除：
a)刪除元素時，為了保證陣列是一塊連續的內容空間，那麼我們需要對刪除位置之後的元素做位移操作。
位移操作：向前移動一位
陣列中常見的方法
import java.util.Arrays;
public class ArraysUtil {
public static void main(String[] args) {
int[] arr = { 5, 12, 90, 18, 77, 76, 45, 28, 59, 72 };
// 字串輸出
//toString(arr);
// 升序排序
//sort(arr);
// 判斷陣列是否相等
//equals();
// 二分法查詢
//binarySearch();
// 陣列複製
//copyOf(arr);
//copyOfRange(arr);
/* System類中的arraycopy方法
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
作用：就是用於實現陣列元素的拷貝工作。
建議：如果需要實現對陣列元素的拷貝工作，建議使用System類中的arraycopy方法，而不要去用Arrays工具類中的copyOf()和copyOfRange()方法
方法引數分析：
src：需要被拷貝的陣列(源陣列)
srcPos：從源陣列中的那個位置開始拷貝，傳遞是一個索引值
dest：目標陣列，也就是把拷貝的元素放入目標陣列中
destPos：把拷貝的元素放在目標陣列中的哪個位置，傳遞是一個索引值
length：拷貝陣列的元素個數*/
// 複製陣列建議使用這種
int[] dest = new int[5];
System.arraycopy(arr, 2, dest, 0, 5);
System.out.println(Arrays.toString(dest));
/*native關鍵字介紹：
使用關鍵字“native”修飾的方法，我們稱之為本地方法。
本地方法特點：只有方法的宣告，沒有方法的實現(沒有方法體)。
為什麼會有本地方法的出現呢？？？
java雖然很強大，但是也有侷限性。java不能直接操作硬體！
java中提供的本地方法，本質上就是通過本地方法來呼叫別的語言（例如：C語言）來操作硬體。*/
}
/**
* 範圍複製陣列
* @param arr 傳入的陣列
*/
public static void copyOfRange(int[] arr) {
/*int[] copyOfRange = Arrays.copyOfRange(arr, 2, 8);
for (int i : copyOfRange) {
System.out.print(i + " ");
}*/
int[] copyOfRangeArrays = copyOfRangeArrays(arr, 2, 8);
for (int i : copyOfRangeArrays) {
System.out.print(i + " ");
}
}
/**
* 手寫實現範圍複製陣列
* @param arr 傳入的陣列
* @param from 取值的初始索引
* @param to 取值的結束索引
* @return 返回的新陣列
*/
public static int[] copyOfRangeArrays(int[] arr,int from,int to) {
// 0.判斷form和to是否合法
if (to < from || to < 0 || from < 0 || to >= arr.length) {
System.out.println("傳入的to或from不合法！");
throw new RuntimeException();
}
int length = to - from;
int[] arr2 = new int[length];
// 方案一：
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[from + i];
}
/*// 方案二：
for(int i = from; i < to; i++) {
arr2[i - from] = arr[i];
}*/
/*// 方法三：
for(int i = from, j = 0; i < to; i++, j++) {
arr2[j] = arr[i];
}*/
arr = arr2;
return arr;
}
/**
* 賦值陣列
* @param arr 傳入的陣列
*/
public static void copyOf(int[] arr) {
/*int[] arr2 = new int[4];
int[] copyOf = Arrays.copyOf(arr, 4);
arr2 = copyOf;
for (int i : arr2) {
System.out.print(i + " ");
}*/
int[] copyOfArrays = copyOfArrays(arr,4);
for (int i : copyOfArrays) {
System.out.print(i + " ");
}
}
/**
* 手寫實現copy陣列方法
* @param arr 傳入的陣列
* @param length 擷取的長度
* @return 返回擷取的陣列
*/
public static int[] copyOfArrays(int[] arr,int length) {
int[] arr2 = new int[length];
for (int i = 0; i < arr2.length; i++) {
arr2[i] = arr[i];
}
arr = arr2;
return arr;
}
/**
* 二分法查詢 （陣列必須有序）
* @param arr 傳入的陣列
*/
public static void binarySearch() {
int[] arr = {1,2,3,4,5,6,7,8,9};
/*int binarySearch = Arrays.binarySearch(arr, 6);
System.out.println(binarySearch);*/
int binarySearch = binarySearch(arr, 6);
System.out.println(binarySearch);
}
/**
* 手寫實現二分法查詢
* @param arr 傳入的陣列
* @param value 傳入的值
* @return 返回陣列中查詢值的索引
*/
public static int binarySearch(int[] arr,int value){
int min = 0,max = arr.length - 1,mid = 0;
for (int i = 0; i < arr.length; i++) {
mid = (min + max) / 2;
if (value > arr[mid]) {
min = mid + 1;
}else if(value < arr[mid]){
max = mid - 1;
}else {
return mid;
}
if (max < min) {
return -1;
}
}
return mid;
}
/**
* sort方法
* @param arr 傳入的陣列
*/
private static void sort(int[] arr) {
// Arrays.sort(arr);
int[] sortArrays = sortArrays(arr);
for (int i : sortArrays) {
System.out.print(i + " ");
}
}
/**
* 手寫實現sort方法（冒泡法）
* @param arr 傳入的陣列
* @return 返回排序後（升序）的陣列
*/
public static int[] sortArrays(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
// 假設陣列是有序的
boolean flag= true;
for (int j = 0; j < arr.length - 1 - i; j++) {
if (arr[j] > arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
flag = false; // 推翻假設
}
}
if (flag) { // 如果有序直接跳出迴圈
break;
}
}
return arr;
}
/**
* toString方法
* @param arr 傳入的陣列
*/
public static void toString(int[] arr) {
// System.out.println(Arrays.toString(arr));
System.out.println(toStringArrys(arr));
}
/**
* 手寫實現tostring方法
* @param arr 傳入的陣列
* @return 返回的字串
*/
private static String toStringArrys(int[] arr) {
String str = "";
System.out.print("[");
for (int i = 0; i < arr.length; i++) {
if (i != arr.length - 1) {
str += arr[i] + ",";
} else {
str += arr[i] + "]";
}
}
return str;
}