第4天 Java基礎語法

今日內容介紹

u?流程控制語句（switch）

u?數組

第1章?流程控制語句

1.1?選擇結構switch

switch 條件語句也是一種很常用的選擇語句，它和if條件語句不同，它只能針對某個表達式的值作出判斷，從而決定程序執行哪一段代碼。例如，在程序中使用數字1~7來表示星期一到星期天，如果想根據某個輸入的數字來輸出對應中文格式的星期值，可以通過下面的一段偽代碼來描述：

用于表示星期的數字

如果等于1，則輸出星期一

如果等于2，則輸出星期二

如果等于3，則輸出星期三

如果等于4，則輸出星期四

如果等于5，則輸出星期五

如果等于6，則輸出星期六

如果等于7，則輸出星期天

對于上面一段偽代碼的描述，大家可能會立刻想到用剛學過得if…else if…else語句來實現，但是由于判斷條件比較多，實現起來代碼過長，不便于閱讀。Java中提供了一種switch語句來實現這種需求，在switch語句中使用switch關鍵字來描述一個表達式，使用case關鍵字來描述和表達式結果比較的目標值，當表達式的值和某個目標值匹配時，會執行對應case下的語句。具體實現代碼如下：

switch(用于表示星期的數字) {

????case 1 :

????????輸出星期一;

????????break;

????case 2 :

????????輸出星期二;

????????break;

????case 3 :

????????輸出星期三

????????break;

????case 4 :

????????輸出星期四;

????????break;

????case 5 :

????????輸出星期五;

????????break;

????case 6:

????????輸出星期六;

????????break;

????case 7:

????????輸出星期天;

????????break;

}

?

l?上面改寫后的偽代碼便描述了switch語句的基本語法格式，具體如下：

switch (表達式){

case 目標值1:

執行語句1

break;

case 目標值2:

執行語句2

break;

．．．．．．

case 目標值n:

執行語句n

break;

default:

執行語句n+1

break;

}

在上面的格式中，switch語句將表達式的值與每個case中的目標值進行匹配，如果找到了匹配的值，會執行對應case后的語句，如果沒找到任何匹配的值，就會執行default后的語句。switch語句中的break關鍵字將在后面的做具體介紹，此處，我們只需要知道break的作用是跳出switch語句即可。

需要注意的是，在switch語句中的表達式只能是byte、short、char、int類型的值，如果傳入其它類型的值，程序會報錯。但上述說法并不嚴謹，實際上在JDK5.0中引入的新特性enum枚舉也可以作為switch語句表達式的值，在JDK7.0中也引入了新特性，switch語句可以接收一個String類型的值。

1.2?選擇結構switch練習

接下來通過一個案例演示根據數字來輸出中文格式的星期，如下所示。SwitchDemo01.java

public?class?SwitchDemo01 {

public?static?void?main(String[] args) {

int?week = 5;

switch?(week) {

case?1:

System.out.println("星期一");

break;

case?2:

System.out.println("星期二");

break;

case?3:

System.out.println("星期三");

break;

case?4:

System.out.println("星期四");

break;

case?5:

System.out.println("星期五");

break;

case?6:

System.out.println("星期六");

break;

case?7:

System.out.println("星期天");

break;

default:

System.out.println("輸入的數字不正確...");

break;

}

}

}

運行結果如圖所示。

?

?

圖1-1?運行結果

上述代碼中，由于變量week的值為5，整個switch語句判斷的結果滿足第17行的條件，因此打印“星期五”，例程中的default語句用于處理和前面的case都不匹配的值，將第3行代碼替換為int week = 8，再次運行程序，輸出結果如下圖所示。

?

?

圖1-2?運行結果

在使用switch語句的過程中，如果多個case條件后面的執行語句是一樣的，則該執行語句只需書寫一次即可，這是一種簡寫的方式。例如，要判斷一周中的某一天是否為工作日，同樣使用數字1~7來表示星期一到星期天，當輸入的數字為1、2、3、4、5時就視為工作日，否則就視為休息日。接下來通過一個案例來實現上面描述的情況，如下所示。SwitchDemo02.java

public?class?SwitchDemo02 {

public?static?void?main(String[] args) {

int?week = 2;

switch?(week) {

case?1:

case?2:

case?3:

case?4:

case?5:

// 當 week 滿足值 1、2、3、4、5 中任意一個時，處理方式相同

System.out.println("今天是工作日");

break;

case?6:

case?7:

// 當 week 滿足值 6、7 中任意一個時，處理方式相同

System.out.println("今天是休息日");

break;

}

}

}

運行結果如下圖所示。

?

?

圖1-3?運行結果

上述代碼中，當變量week值為1、2、3、4、5中任意一個值時，處理方式相同，都會打印“今天是工作日”。同理，當變量week值為6、7中任意一個值時，打印“今天是休息日”。

第2章?數組

在生活中，我們可能會碰到如下的場景。

現在需要統計某公司員工的工資情況，例如計算平均工資、最高工資等。假設該公司有50名員工，用前面所學的知識完成，那么程序首先需要聲明50個變量來分別記住每位員工的工資，這樣做會顯得很麻煩。

其實在Java中，我們可以使用一個數組來記住這50名員工的工資。數組是指一組數據的集合，數組中的每個數據被稱作元素。在數組中可以存放任意類型的元素，但同一個數組里存放的元素類型必須一致。

2.1?數組的定義

在Java中，可以使用以下格式來定義一個數組。如下

數據類型[] 數組名 = new 數據類型[元素個數或數組長度];

int[] x = new int[100];

上述語句就相當于在內存中定義了100個int類型的變量，第一個變量的名稱為x[0]，第二個變量的名稱為x[1]，以此類推，第100個變量的名稱為x[99]，這些變量的初始值都是0。為了更好地理解數組的這種定義方式，可以將上面的一句代碼分成兩句來寫，具體如下：

int[] x; ??????????// 聲明一個int[]類型的變量

x = new int[100]; // 創建一個長度為100的數組

接下來，通過兩張內存圖來詳細地說明數組在創建過程中內存的分配情況。

第一行代碼?int[] x; 聲明了一個變量x，該變量的類型為int[]，即一個int類型的數組。變量x會占用一塊內存單元，它沒有被分配初始值。內存中的狀態如下圖所示。

?

?

圖1-4?內存狀態圖

第二行代碼?x = new int[100]; 創建了一個數組，將數組的地址賦值給變量x。在程序運行期間可以使用變量x來引用數組，這時內存中的狀態會發生變化，如下圖所示。

?

?

圖1-5?內存狀態圖

在上圖中描述了變量x引用數組的情況。該數組中有100個元素，初始值都為0。數組中的每個元素都有一個索引(也可稱為角標)，要想訪問數組中的元素可以通過“x[0]、x[1]、……、x[98]、x[99]”的形式。需要注意的是，數組中最小的索引是0，最大的索引是“數組的長度-1”。在Java中，為了方便我們獲得數組的長度，提供了一個length屬性，在程序中可以通過“數組名.length”的方式來獲得數組的長度，即元素的個數。

接下來，通過一個案例來演示如何定義數組以及訪問數組中的元素，如下所示。ArrayDemo01.java

1?public?class?ArrayDemo01 {

1? public?static?void?main(String[] args) {

2? int[] arr; // 聲明變量

3? arr = new?int[3]; // 創建數組對象

4? System.out.println("arr[0]="?+ arr[0]); // 訪問數組中的第一個元素

5? System.out.println("arr[1]="?+ arr[1]); // 訪問數組中的第二個元素

6? System.out.println("arr[2]="?+ arr[2]); // 訪問數組中的第三個元素

7? System.out.println("數組的長度是："?+ arr.length); // 打印數組長度

8? }

9?}

運行結果如下圖所示。

?

?

圖1-6?運行結果

在上述代碼中聲明了一個int[]類型變量arr，并將數組在內存中的地址賦值給它。在5~7行代碼中通過角標來訪問數組中的元素，在第8行代碼中通過length屬性訪問數組中元素的個數。從打印結果可以看出，數組中的三個元素初始值都為0，這是因為當數組被成功創建后，數組中元素會被自動賦予一個默認值，根據元素類型的不同，默認初始化的值也是不一樣的。具體如下表所示。

表2-1?元素默認值

數據類型	默認初始化值
byte、short、int、long	0
float、double	0.0
char	一個空字符（空格），即’\u0000’
boolean	false
引用數據類型	null，表示變量不引用任何對象

如果在使用數組時，不想使用這些默認初始值，也可以顯式地為這些元素賦值。接下來通過一個程序來學習如何為數組的元素賦值，如下所示。ArrayDemo02.java

1?public?class?ArrayDemo02 {

10? public?static?void?main(String[] args) {

11? int[] arr = new?int[4]; // 定義可以存儲4個整數的數組

12? arr[0] = 1; // 為第1個元素賦值1

13? arr[1] = 2; // 為第2個元素賦值2

14? // 下面的代碼是打印數組中每個元素的值

15? System.out.println("arr[0]="?+ arr[0]);

16? System.out.println("arr[1]="?+ arr[1]);

17? System.out.println("arr[2]="?+ arr[2]);

18? System.out.println("arr[3]="?+ arr[3]);

19? }

20?}

運行結果如下圖所示。

?

?

圖1-7?運行結果

在上述代碼中，第3行代碼定義了一個數組，此時數組中每個元素都為默認初始值0。第2、3行代碼通過賦值語句將數組中的元素arr[0]和arr[1]分別賦值為1和2，而元素arr[2]和arr[3]沒有賦值，其值仍為0，因此打印結果中四個元素的值依次為1、2、0、0。

在定義數組時只指定數組的長度，由系統自動為元素賦初值的方式稱作動態初始化。

在初始化數組時還有一種方式叫做靜態初始化，就是在定義數組的同時就為數組的每個元素賦值。數組的靜態初始化有兩種方式，具體格式如下：

1、類型[] 數組名?= new 類型[]{元素，元素，……};

2、類型[] 數組名?= {元素，元素，元素，……}; ???

上面的兩種方式都可以實現數組的靜態初始化，但是為了簡便，建議采用第二種方式。接下來通過一段代碼來演示數組靜態初始化的效果，如下所示。ArrayDemo03.java

1?public?class?ArrayDemo03 {

2? public?static?void?main(String[] args) {

3? int[] arr = { 1, 2, 3, 4 }; // 靜態初始化

4? // 下面的代碼是依次訪問數組中的元素

5? System.out.println("arr[0] = "?+ arr[0]);

6? System.out.println("arr[1] = "?+ arr[1]);

7? System.out.println("arr[2] = "?+ arr[2]);

8? System.out.println("arr[3] = "?+ arr[3]);

9? }

10?}

運行結果如下圖所示。

?

?

圖1-8?運行結果

上述代碼中采用靜態初始化的方式為數組每個元素賦予初值，分別是1、2、3、4。需要注意的是，第3行代碼千萬不可寫成int[] arr = new int[4]{1,2,3,4};，這樣寫編譯器會報錯。原因在于編譯器會認為數組限定的元素個數[4]與實際存儲的元素{1,2,3,4}個數有可能不一致，存在一定的安全隱患。

2.2?數組遍歷

在操作數組時，經常需要依次訪問數組中的每個元素，這種操作稱作數組的遍歷。接下來通過一個案例來學習如何使用for循環來遍歷數組，如下所示。ArrayDemo04.java

public?class?ArrayDemo04?{

public?static?void?main(String[] args) {

int[] arr = { 1, 2, 3, 4, 5 }; // 定義數組

// 使用for循環遍歷數組的元素

for?(int?i = 0; i < arr.length; i++) {

System.out.println(arr[i]); // 通過索引訪問元素

}

}

}

運行結果如下圖所示。

?

?

圖1-9?運行結果

上述代碼中，定義一個長度為5的數組arr，數組的角標為0~4。由于for循環中定義的變量i的值在循環過程中為0~4，因此可以作為索引，依次去訪問數組中的元素，并將元素的值打印出來。

2.3?數組的常見問題

數組在編寫程序時應用非常廣泛，靈活地使用數組對實際開發很重要。接下來，本節將針對數組的常見操作進行詳細地講解，如數組的遍歷、最值的獲取、數組的排序等。

2.3.1?數組最值

在操作數組時，經常需要獲取數組中元素的最值。接下來通過一個案例來演示如何獲取數組中元素的最大值，如下所示。ArrayDemo05.java

public?class?ArrayDemo05?{

public?static?void?main(String[] args) {

int[] arr = { 4, 1, 6, 3, 9, 8 }; // 定義一個數組

int?max = arr[0]; // 定義變量max用于記住最大數，首先假設第一個元素為最大值

// 下面通過一個for循環遍歷數組中的元素

for?(int?x = 1; x < arr.length; x++) {

if?(arr[x] > max) { // 比較 arr[x]的值是否大于max

max = arr[x]; // 條件成立，將arr[x]的值賦給max

}

}

System.out.println("max="?+ max); // 打印最大值

}

}

運行結果如下圖所示。

?

?

圖1-10?運行結果

上述代碼中，定義了一個臨時變量max，用于記住數組的最大值。通過for 循環獲取數組中的最大值，賦值給max變量。

首先假設數組中第一個元素arr[0]為最大值，然后使用for循環對數組進行遍歷，在遍歷的過程中只要遇到比max值還大的元素，就將該元素賦值給max。這樣一來，變量max就能夠在循環結束時記住數組中的最大值。需要注意的是，在for循環中的變量i是從1開始的，這樣寫的原因是程序已經假設第一個元素為最大值，for循環中只需要從第二個元素開始比較，從而提高程序的運行效率。

2.3.2?數組異常

2.3.2.1?數組越界異常

每個數組的索引都有一個范圍，即0~length-1。在訪問數組的元素時，索引不能超出這個范圍，否則程序會報錯，如下所示。ArrayDemo06.java

1?public?class?ArrayDemo06?{

2? public?static?void?main(String[] args) {

3? int[] arr = new?int[4]; // 定義一個長度為4的數組

4? System.out.println("arr[0]="?+ arr[4]); // 通過角標4訪問數組元素

5? }

6?}

運行結果如下圖所示。

?

?

上圖運行結果中所提示的錯誤信息是數組越界異常ArrayIndexOutOfBoundsException，出現這個異常的原因是數組的長度為4，其索引范圍為0~3，而上述代碼中的第4行代碼使用索引4來訪問元素時超出了數組的索引范圍。

所謂異常指程序中出現的錯誤，它會報告出錯的異常類型、出錯的行號以及出錯的原因，關于異常在后面的章節會有詳細地講解。

2.3.2.2?空指針異常

在使用變量引用一個數組時，變量必須指向一個有效的數組對象，如果該變量的值為null，則意味著沒有指向任何數組，此時通過該變量訪問數組的元素會出現空指針異常，接下來通過一個案例來演示這種異常，如下所示。ArrayDemo07.java

1?public?class?ArrayDemo07?{

2? public?static?void?main(String[] args) {

3? int[] arr = new?int[3]; // 定義一個長度為3的數組

4? arr[0] = 5; // 為數組的第一個元素賦值

5? System.out.println("arr[0]="?+ arr[0]); // 訪問數組的元素

6? arr = null; // 將變量arr置為null

7? System.out.println("arr[0]="?+ arr[0]); // 訪問數組的元素

8? }

9?}

運行結果如下圖所示。

?

?

圖1-11?運行結果

通過上圖所示的運行結果可以看出，上述代碼中第4、5行代碼都能通過變量arr正常地操作數組。第6行代碼將變量置為null，當第7行代碼再次訪問數組時就出現了空指針異常NullPointerException。

?

2.4?二維數組

在程序中可以通過一個數組來保存某個班級學生的考試成績，試想一下，如果要統計一個學校各個班級學生的考試成績，又該如何實現呢？這時就需要用到多維數組，多維數組可以簡單地理解為在數組中嵌套數組。在程序中比較常見的就是二維數組，接下來針對二維數組進行詳細地講解。

2.4.1?二維數組的定義格式

二維數組的定義有很多方式，接下來針對幾種常見的方式進行詳細地講解，具體如下：

第一種方式：

int[][] arr = new int[3][4];

上面的代碼相當于定義了一個3*4的二維數組，即二維數組的長度為3，二維數組中的每個元素又是一個長度為4的數組，接下來通過一個圖來表示這種情況，如下圖所示。

?

?

圖1-12?二維數組

第二種方式：

int[][] arr = new int[3][];

第二種方式和第一種類似，只是數組中每個元素的長度不確定，接下來通過一個圖來表示這種情況，如下圖所示。

?

?

圖1-13?二維數組

第三種方式：

int[][] arr = {{1,2},{3,4,5,6},{7,8,9}};

上面的二維數組中定義了三個元素，這三個元素都是數組，分別為{1,2}、{3,4,5,6}、{7,8,9}，接下來通過一個圖來表示這種情況，如圖2-54所示。

?

?

圖1-14?二維數組

對二維數組中元素的訪問也是通過角標的方式，如需訪問二維數組中第一個元素數組的第二個元素，具體代碼如下：

arr[0][1];

2.4.2?二維數組元素的訪問

操作二維數組時，經常需要獲取數組中元素的值。接下來通過一個案例來演示如何獲取數組中元素值，如下所示。ArrayDemo08.java

class ArrayDemo08?{

public static void main(String[] args){

?

//定義二維數組的方式

int[][] arr = new int[3][4];

?

System.out.println( arr );

System.out.println("二維數組的長度: " + arr.length);

//獲取二維數組的3個元素

System.out.println( arr[0] );

System.out.println( arr[1] );

System.out.println( arr[2] );

?

System.out.println("打印第一個一維數組的元素值");

System.out.println( arr[0][0] );

System.out.println( arr[0][1] );//訪問的為二維數組中第1個一維數組的第2個元素

System.out.println( arr[0][2] );

System.out.println( arr[0][3] );

?

System.out.println("打印第二個一維數組的元素值");

System.out.println( arr[1][0] );

System.out.println( arr[1][1] );

System.out.println( arr[1][2] );

System.out.println( arr[1][3] );

?

System.out.println("打印第三個一維數組的元素值");

System.out.println( arr[2][0] );

System.out.println( arr[2][1] );

System.out.println( arr[2][2] );

System.out.println( arr[2][3] );

}

}

運行結果如下圖所示：

?

?

圖1-15?運行結果

?

2.4.3?二維數組元素遍歷與數組元素累加和

學習完了數組元素的訪問，我們來學習下數組的遍歷及數組的元素累加和操作。

class ArrayDemo09?{

public static void main(String[] args){

//一維數組的求累加和并遍歷

int[] arr = {10,20,30,40,50};

int sum = 0;

for (int i=0; i<arr.length; i++) {

??????????????//System.out.println(arr[i]);

sum += arr[i];

}

System.out.println("sum= " + sum);

System.out.println("---------------------");

?

//二維數組的求累加和并遍歷

int[][] arr2 = { {1,2},{3,4,5},{6,7,8,9,10} };

int sum2 = 0;

for (int i=0; i<arr2.length; i++) {

for (int j=0; j<arr2[i].length; j++) {

?????????????????//System.out.println(arr2[i][j])

sum2 += arr2[i][j];

}

}

System.out.println("sum2= "+ sum2);

}

}

運行結果如下圖所示：

?

?

圖1-16?運行結果

2.4.4?公司銷售總和練習

接下來通過一個案例來熟悉二維數組的使用。

例如要統計一個公司三個銷售小組中每個小組的總銷售額以及整個公司的銷售額。如下所示

l?第一小組銷售額為{11, 12}萬元

l?第二小組銷售額為{21, 22, 23}萬元

l?第三小組銷售額為{31, 32, 33, 34}萬元。

ArrayDemo08.java

1?public?class?ArrayDemo10?{

2? public?static?void?main(String[] args) {

3? int[][] arr = new?int[3][]; // 定義一個長度為3的二維數組

4? arr[0] = new?int[] { 11, 12 }; // 為數組的元素賦值

5? arr[1] = new?int[] { 21, 22, 23 };

6? arr[2] = new?int[] { 31, 32, 33, 34 };

7?

8? int?sum = 0; // 定義變量記錄總銷售額

9? for?(int?i = 0; i < arr.length; i++) { // 遍歷數組元素

10? int?groupSum = 0; // 定義變量記錄小組銷售總額

11? for?(int?j = 0; j < arr[i].length; j++) { // 遍歷小組內每個人的銷售額

12? groupSum = groupSum + arr[i][j];

13? }

14? sum = sum + groupSum; // 累加小組銷售額

15? System.out.println("第"?+ (i + 1) + "小組銷售額為："?+ groupSum + " 萬元");

16? }

17? System.out.println("總銷售額為: "?+ sum + " 萬元");

18? }

19?}

運行結果如下圖所示。

?

?

圖1-17?運行結果

在上述代碼中，第3行代碼定義了一個長度為3的二維數組，并在4~6行代碼中為數組的每個元素賦值。例程中還定義了兩個變量sum和groupSum，其中sum用來記錄公司的總銷售額，groupSum用來記錄每個銷售小組的銷售額。當通過嵌套for循環統計銷售額時，外層循環對三個銷售小組進行遍歷，內層循環對每個小組員工的銷售額進行遍歷，內層循環每循環一次就相當于將一個小組員工的銷售總額統計完畢，賦值給groupSum，然后把groupSum的值與sum的值相加賦值給sum。當外層循環結束時，三個銷售小組的銷售總額groupSum都累加到sum中，即統計出了整個公司的銷售總額。

?

第3章?隨機點名器案例

3.1?案例介紹

隨機點名器，即在全班同學中隨機的打印出一名同學名字。

要做的隨機點名器，它具備以下3個內容：

l?存儲所有同學姓名

l?總覽全班同學姓名

l?隨機點名其中一人，打印到控制臺

在編寫案例前，我們先來學習下本案例中所涉及到的知識點：

l?數組

3.2?案例需求分析

在全班同學中隨機的打印出一名同學名字。

我們對本案例進行分析，得出如下分析結果：

1.存儲全班同學名字

2.打印全班同學每一個人的名字

3.在班級總人數范圍內，隨機產生一個隨機數，查找該隨機數所對應的同學名字

在存儲同學姓名時，如果對每一個同學都定義一個變量進行姓名存儲，則會出現過多孤立的變量，很難一次性將全部數據持有。此時，我們可以使用數組解決多個數據的存儲問題。

3.3?實現代碼步驟

編寫CallName.java文件，完成程序的編寫。

l?main方法中進行步驟1、2、3的代碼實現

public?static?void?main(String[] args) {

System.out.println("--------隨機點名器--------");

// 創建一個存儲多個同學名字的容器（數組）

String[] students = new?String[3];

?

//1.存儲全班同學名字

//2.打印全班同學每一個人的名字

//3.獲取隨機點名到的學生姓名，并打印

}

?

l?1.存儲所有同學姓名

/**

?* 1.存儲全班同學名字

?* 創建一個存儲多個同學名字的容器（數組）

?* ?鍵盤輸入每個同學的名字，存儲到容器中（數組）

?*/

//鍵盤輸入多個同學名字存儲到容器中

Scanner sc = new?Scanner(System.in);

for?(int?i = 0; i < students.length; i++) {

System.out.println("存儲第"+i+"個名稱：");

students[i] = sc.next();

}

?

l?2.打印全班同學每一個人的名字

/**

?* 2打印全班同學每一個人的名字

?*/

//遍歷數組，得到每個同學名字

for?(int?i = 0; i < students.length; i++) {

String name = students[i];

//打印同學名字

System.out.println("第"+i+"個學生名稱："?+ name);

}

?

l?3.獲取隨機點名到的學生姓名，并打印

/**

?* 3.在班級總人數范圍內，隨機產生一個隨機數

?*/

//根據數組長度，獲取隨機索引

int?index = new?Random().nextInt(students.length);

//通過隨機索引從數組中獲取名稱

String name = students[index];

//返回隨機點到的名稱

上述代碼中，通過隨機數類Random產生一個從0到數組長度的隨機索引。使用該索引獲取students數組中對應的值，便得到了全班同學的隨機姓名。

?

第4章?總結

4.1?知識點總結

l?數組

l?它是一個用來存儲同一個數據類型多個元素的一個容器（數組長度是固定的，數組中存儲的元素的數據類型要求一致）

l?格式：

格式1：

數據類型[] 數組名 = new 數據類型[數組長度];

?

格式2:

數據類型[] 數組名 = new 數據類型[]{元素值1,元素值2,..};

?

格式3：

數據類型[] 數組名 = {元素值1,元素值2,..};

l?數組操作的常見問題：

NullPointerException: 空指針異常

ArrayIndexOutOfBoundsException: 數組越界異常

l?二維數組：

l?它是一個包含多個一維數組的數組

l?特點：二維數組中的每個元素都是一個一維數組

l?格式：

格式1：

數據類型[][] 數組名 = new 數據類型[m][n];

m: 代表二維數組中一維數組的個數

n: 代表每個一維數組中元素的個數

格式2：

數據類型[][] 數組名 = new 數據類型[m][];

m: 代表二維數組中一維數組的個數

每一個一維數組通過賦值來確定數組長度

格式3：

數據類型[][] 數組名 = {{元素值1，元素值2,..},{元素值1，元素值2,..},..};

?

轉載于:https://www.cnblogs.com/jmsjh/p/7739873.html

總結

以上是生活随笔為你收集整理的Java基础语法（数组）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。