初識Java之陣列操作篇
陣列是Java語言中最為重要的資料型別之一。陣列能夠解決不同開發場景下的複雜資料的處理，可以對資料進行快速儲存，靈活讀取，擁有高效的增刪改查，排序的功能。說到這裡我們就想到了Python裡面的序列了，裡面的相關資料型別有元組、字典、集合等，對於Java來說陣列操作起來可能的比較的麻煩，但是不要擔心，我們一步一步來!
Java 語言中提供的陣列是用來儲存固定大小的同類型元素
至於什麼是陣列，我這裡就不多說了，陣列的構成其實和我們的Python有些相似的，每個鍵對應每個值。
宣告陣列變數
dataType[] arrayRefVar;
- 1
一般都是資料型別 [] 變數名構成一個數組
如果是多維陣列的話，我們就會使用多箇中括號來進行定義；在建立陣列的時候我們需要指定陣列的長度，不然就會無法訪問。
注意陣列的長度和陣列的索引是不一樣的，如果陣列的長度為5，那麼索引應該為0-4，這個是需要注意的。
建立陣列
arrayRefVar = new dataType[arraySize];
- 1
一、使用 dataType[arraySize] 建立了一個數組。
二、把新建立的陣列的引用賦值給變數 arrayRefVar。
- 1
- 2
dataType[] arrayRefVar = new dataType[arraySize];
- 1
也可以通過這樣一條語句來完成
例外，建立陣列的時候也可以不用表明長度這個用的比較多
// 這裡就沒有為a這個陣列定義它的長度，我們直接在後面定義陣列的資料，自動會為我們分配空間！！
int [] a=new int[]{12,1,13,69};
- 1
- 2
也可以後面直接跟著{}
double[] myList = {1.9, 2.9, 3.4, 3.5};
- 1
這個是因為我們用new更加的有利於我們程式的健康，new可以自動回收垃圾，對我們電腦程式執行釋放相關記憶體！！！
package 陣列;
public class 陣列原理 {
public static void main(String[] args) {
// 陣列大小
int size = 10;
// 定義陣列
double[] myList = new double[size];
myList[0] = 5.6;
myList[1] = 4.5;
myList[2] = 3.3;
myList[3] = 13.2;
myList[4] = 4.0;
myList[5] = 34.33;
myList[6] = 34.0;
myList[7] = 45.45;
myList[8] = 99.993;
myList[9] = 11123;
// 計算所有元素的總和
double total = 0;
for (int i = 0; i < size; i++) {
total += myList[i];
}
System.out.println("總和為： " + total);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
處理陣列
一般處理陣列我們用foreach ，和我們Python裡面的for迴圈是差不多的，但是要注意的是foreach裡面的條件只能是唯一的，這個也是Java條件迴圈的一大注意事項。
public class TestArray {
public static void main(String[] args) {
double[] myList = {1.9, 2.9, 3.4, 3.5};
// 列印所有陣列元素
for (int i = 0; i < myList.length; i++) {
System.out.println(myList[i] + " ");
}
// 計算所有元素的總和
double total = 0;
for (int i = 0; i < myList.length; i++) {
total += myList[i];
}
System.out.println("Total is " + total);
// 查詢最大元素
double max = myList[0];
for (int i = 1; i < myList.length; i++) {
if (myList[i] > max) max = myList[i];
}
System.out.println("Max is " + max);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
for(type element: array)
{
System.out.println(element);
}
- 1
- 2
- 3
- 4
陣列作為函式的引數
陣列也可以向方法那樣，可以傳遞引數，進行呼叫然後再去輸出，這樣就可以使得程式結構變得更加明顯。比如我們看看下面的完整的程式碼：
package 陣列;
public class 陣列練習 {
public static void printLn(int [] num) {
for(int i=0;i<num.length;i++) {
// System.out.println(num.length);
// System.out.println(num);
}
for(int x:num){
System.out.println(x);
}
}
public static void main(String[] args) {
printLn(new int[]{12,26,56,96});
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
這裡我們通過呼叫之前我們寫好的一個方法，我們後面又建立了一個主方法進行呼叫，就達到了效果，這裡我們利用foreach迴圈實現的，所以我們看看，結果，那麼我們想一想，如果我們不去使用這個迴圈，直接列印那麼會出現如何的效果。
這裡列印了四個雜湊碼，我們看不懂得那種！！！！！這個是規則也是語法
陣列也可以作為方法（函式）的返回值，我們看看一下的程式碼
public static int[] reverse(int[] list) {
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
上面就是一個倒序的功能程式，下面我們看看它在實際的程式裡面是如何起作用的！！！
package 陣列;
public class 陣列返回值 {
public static int[] reverse(int[] list) {
// 這是一個倒序功能！！！！！！
int[] result = new int[list.length];
for (int i = 0, j = result.length - 1; i < list.length; i++, j--) {
result[j] = list[i];
}
return result;
}
public static void main(String[] args) {
int a[]=reverse(new int []{1,2,3,4,6,7,8,9,10});
System.out.println("陣列的長度為："+a.length);
for(int x:a){
System.out.println(x);
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
我們介紹了這麼多的程式了，我們都發現在同一個程式裡面不能有多個類，但是可以宣告多個public 進行方法呼叫和編寫，這個和我們的Python程式語言結構有異曲同工之妙。
多維陣列
多維陣列，就像我們線性代數裡面的矩陣一樣，有多個維數的資料。
多維陣列可以看成是陣列的陣列，比如二維陣列就是一個特殊的一維陣列，其每一個元素都是一個一維陣列
String str[][] = new String[3][4];
- 1
- 2
- 3
type[][] typeName = new type[typeLength1][typeLength2];
- 1
- 2
- 3
package 陣列;
public class 多維陣列 {
public static void main(String[] args) {
// 這裡是為陣列分配空間！
String [][]x=new String[3][3];
int [][]x=new int[1][3];
// x[0]=new String[1];
// x[0]=new String[2];
// 0，1出的資料為“OK！”
String a=x[0][1]=new String("ok!");
System.out.println(a);
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
從最高維開始，分別為每一維分配空間，我們可以看做兩行的0列的
String s[][] = new String[2][];
s[0] = new String[2];
s[1] = new String[3];
s[0][0] = new String("Good");
s[0][1] = new String("Luck");
s[1][0] = new String("to");
s[1][1] = new String("you");
s[1][2] = new String("!");
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
s[0]=new String[2] 和 s[1]=new String[3] 是為最高維分配引用空間，也就是為最高維限制其能儲存資料的最長的長度，然後再為其每個陣列元素單獨分配空間 s0=new String(“Good”) 等操作。
Arrays 類
反正我對於多維陣列的理解就是我們要變相的把它們看做是一個行列式，[行][列],這樣去理解比較的好
陣列的常見操作
陣列的長度，我們用length來進行操作，你還知道Python裡面的長度嗎（len）。
如何向數組裡面面新增元素，我們利用fill方法。
Arrays.toString的作用
Arrays.toString（）的作用是用來很方便地輸出陣列，而不用一個一個地輸出陣列中的元素。
這個方法是是用來將陣列轉換成String型別輸出的，入參可以是long，float，double，int，boolean，byte，object
型的陣列。
這個就解決我們之前需要利用for迴圈遍歷的方法了！
格式： 首先要匯入import java.util.Arrays;
Arrays.toString(資料名)）
- 1
非常方便！！！！！！！！！！！！！！！！！！！！！
Arrays.fill(intArry,0,3,20);
- 1
這個是按照序列進行新增的，從0索引開始到3索引結束，用20填充，其餘的用0填充（預設）
陣列在建立之後不可以修改長度，就像我們的元組一樣，所以我們可以利用一些演算法進行修改，但是沒有特定的函式來提供修改的許可權。
排序
升序排序
Arrays.sort(a);
System.out.println("排序後"+Arrays.toString(a));
- 1
- 2
- 3
和我們的Python是不是一樣的
複製
int[] b=Arrays.copyOf(a,8);
System.out.println("複製後"+Arrays.toString(b));
- 1
- 2
第一個引數是複製的內容，第二個是複製的長度
比較
System.out.println(Arrays.equals(a,b));
- 1
比較a b 這兩個陣列是否是一樣的