【03-流程控制與數組】，03-流程數組
![]()
流程控制與數組
順序結構
•順序結構就是程序從上到下一行一行地執行，中間沒有任何判斷和跳轉。
•如果main方法多行代碼之間沒有任何流程控制，則程序總是從上向下依次執行，排在前面的代碼先執行，排在後
面的代碼後執行。
分支結構
•Java提供了兩種常見的分支控制結構：
–if語句：使用布爾表達式或布爾值作為分支條件來進行分支控制。
–switch語句：用於對多個整型值進行匹配，從而實現分支控制。
if條件語句
•if條件語句的3種形式：
• ▲ if (logic expression) { statements…}
• ▲ if (logic expression) { statements…}
• else { statements…}
• ▲ if (logic expression) { statements…}
• else if (logic expression) { statements…}
• …//可以有0個或多個else if 語句
• else { statements…} //最後的else語句也可以省略
•注意：if、else、else if 後條件執行體要麼是一個花括號括起來的語句塊，則這個語句塊整體作為條件執行體；
要麼是以分號為結束符的一行語句，甚至可能是一個空語句（空語句就是一個分號）。
If語句常見的錯誤
•如果if、else、else if後的執行體只有一行語句時，則可以省略花括號，但我們最好不要省略花括號，因為保留花
括號會有更好的可讀性，且還可以減少發生錯誤的可能。
•對於if 語句，還有一個很容易出現的邏輯錯誤，這個邏輯錯誤並不屬於語法問題，但引起錯誤的可能性更大。如
後面程序TestIfError.java我們想打印的是中年人，但打印出來的結果是青年人。
• 對於任何的if else 語句，表面上看起來else後沒有任何條件，或者else if後只有一個條件，但這不是真相：因為
else的含義是“否則”，else本身就是一個條件！else 的隱含條件就是對前面條件取反。
switch分支語句
•可以省略case後代碼塊的花括號
◆使用break;語句，防止case穿透
◆default可以省略，但不推薦省略
◆switch語句中控制表達式的類型只能是byte、short、char、int、String（JDK7新增）和枚舉
Switch語句容易導致的錯誤
•switch語句後的expression表達式的數據類型只能是byte、short、char、int、String類型和枚舉；
•小心省略了case後代碼塊的break;時所引入的陷阱。
循環結構
•Java支持3種基本的循環語句：
–while 循環語句
–do while 循環語句
– for 循環語句
while & do while 循環語句
★ while 循環的語法格式如下：
[init_statements]
while (test_expression)
{ statements;
[iteration_statements]
}
★ 執行過程：先判斷邏輯表達式的值，若為true
則執行其後面的語句，然後再次判斷條件並反復
執行，直到條件不成立為止。
★ do while 循環的語法格式如下：
[init_statements]
do
{ statements;
[iteration_statements]
}while (test_expression);
※注意：do while 循環的循環條件必須有一個分
號，這個分號表明循環結束。
★ 執行過程：先執行語句，再判斷邏輯表達式的
值，若為true，再執行語句，否則結束循環
控制循環條件
•使用循環時，一定要保證循環條件有變成false的時候，如果循環條件永遠為true，那就是死循環。使用while循
環時還有一個陷阱，while循環條件後緊跟一個分號。
•do while 循環語句裡，即使test_expression循環條件的值開始是假，do while循環也會執行循環體。因此，
do while循環的循環體至少執行一次。
本文原創作者：pipi-changing
本文原創出處：http://www.cnblogs.com/pipi-changing/
for 循環語句
•for ([inint_statements] ; [test_expression] ; [iteration_statements]){ statements }
•★ 執行過程：首先計算表達式1，即init_statements，接著執行表達式2，即test_expression，若表達式2的
值為true，則執行語句（statements），接著執行表達式3，即iteration_statements，再判斷表達式2的值；
依次重復下去，直到表達式的值=false，則結束for循環。因此，for循環的循環條件（表達式2）比循環體（語
句）要多執行一次。
•注意：for循環的循環迭代語句並沒有與循環體放在一起，因此即使在執行循環體時遇到continue語句結束本次
循環，循環迭代語句一樣會得到執行。
for循環指定多個初始化語句
•for 循環允許同時指定多個初始化語句，循環條件也可以是一個包含邏輯運算符的表達式。但只能有一個聲明語
句，因此如果需要在初始化表達式中聲明多個變量，那麼這些變量應該有相同的數據類型。
•初學者使用for循環時也容易犯一個錯誤，他們以為只要在for後的括號內控制了循環循環迭代語句就萬無一失，
但實際情況則不是這樣的。
for循環的分號
•for 循環圓括號中只有兩個分號是必須的，初始化語句、循環條件、迭代語句部分都可以省略，如果省略了循環
條件，則這個循環條件默認是true，將會產生一個死循環。
•使用for循環時，還可以把初始化條件定義在循環體之外，把循環迭代語句放在循環體內，這種做法將非常類似前
面的while循環。
嵌套循環
•各種基本類型的循環都可以作為外層循環，各種基本類型的循環也可以作為內層循環。
•假設外層循環的循環次數為n次，內層循環的循環次數為m次，那麼內層循環的循環體實際上需要執行n*m次。
•實際上，嵌套循環不僅可以是兩層嵌套，還可以是三層嵌套，四層嵌套……
break語句
•break用於完全結束一個循環，跳出循環體。不管是哪種循環，一旦在循環體中遇到break，系統將完全結束循
環，開始執行循環之後的代碼。
•break不僅可以結束其所在的循環，還可結束其外層循環。此時需要在break後緊跟一個標簽，這個標簽用於標
識一個外層循環。Java中的標簽就是一個緊跟著英文冒號（:）的標識符。且它必須放在循環語句之前才有作用。
continue 語句
•continue的功能和break有點類似，區別是continue只是中止本次循環，接著開始下一次循環。而break則是
完全中止循環。
return語句
• return關鍵字並不是專門用於跳出循環的，return的功能是結束一個方法。
•一旦在循環體內執行到一個return語句，return語句將會結束該方法，循環自然也隨之結束。與continue和
break不同的是，return直接結束整個方法，不管這個return處於多少層循環之內。
數組類型
•在任何已有類型後加上方括號[ ]，又變成一種新類型，這種類型統稱為數組類型，所有的數組類型又稱為引用類
型，所以又稱引用類型。
•Java的數組要求所有數組元素具有相同的數據類型。因此，在一個數組中，數組元素的類型是唯一的，即一個數
組裡只能存儲一種數據類型的數據，而不能存儲多種數據類型的數據。
•一旦數組的初始化完成，數組在內存中所占的空間將被固定下來，因此數組的長度將不可改變。即使把某個數組
元素的數據清空，但它所占的空間依然被保留，依然屬於該數組，數組的長度依然不變。
•Java的數組既可以存儲基本類型的數據，也可以存儲引用類型的數據。
•值得指出的是：數組也是一種數據類型，它本身是一種引用類型。
定義數組
•Java語言支持兩種語法格式來定義數組：
–type[ ] arrayName;
–type arrayName[ ];
•對於這兩種語法格式，一般推薦使用第一種格式。因為第一種格式不僅具有更好的語意，也具有更好的可讀性。
•數組是一種引用類型的變量，因此使用它定義一個變量時，僅僅表示定義了一個引用變量（也就是定義了一個指
針），這個引用變量還未指向任何有效的內存，因此定義數組時不能指定數組的長度。
•※注意：定義數組時不能指定數組的長度。
數組的初始化
•靜態初始化：初始化時由程序員顯式指定每個數組的初始值，由系統決定需要的數組長度。
•動態初始化：初始化時程序員指定數組長度，由系統為數組元素分配初始值
動態初始化
•arrayName = new type[ length];
在上面的語法中，需要指定一個int整型的length參數，這個參數指定了數組的長度，也就是可以容納數組元素的
個數。
使用數組
•數組最常用的用法就是訪問數組元素，包括對數組元素賦值和訪問數組元素的值，訪問數組元素是通過在數組引用變
量後緊跟一個方括號（[ ]），方括號裡是數組元素的索引值。
•Java語言的數組索引是從0開始的，也就是說，第一個數組元素的索引值為0，最後一個數組元素的索引為數組長度
減1。
•如果訪問數組元素進指定的索引小於0，或者大於等於數組的長度，編譯程序不會出現任何錯誤，但運行時出現異
常：java.lang.ArrayIndexOutOfBoundsException:2（數組索引越界異常），在這個異常提示信息後有一個int
整數，這個整數就是程序員試圖訪問的數組索引。
•所有數組都提供了一個length屬性，通過這個屬性可以訪問到數組的長度，一旦獲得了數組的長度後，就可以通過循
環來遍歷該數組的每個數組元素。
JDK1.5 提供了foreach循環
•從JDK1.5 之後，Java提供了一種更簡單的循環：foreach循環，這種循環遍歷數組和集合更加簡潔。使用
foreach循環遍歷數組和集合元素時，無須獲得數組和集合長度，無須根據索引來訪問數組元素和集合元素，
foreach循環自動遍歷數組和集合的每個元素。
•當使用foreach循環來迭代輸出數組元素或集合時，通常不要對循環變量進行賦值，雖然這種賦值在語法上是允
許的，但沒有太大的意義，而且極容易引起錯誤。
深入數組
•數組元素和數組變量在內存裡是分開存放的。
實際的數組元素是存儲在堆（heap）內存中；數組引用變量是一個引用類型的變量，被存儲在棧（stack）內存
中。
•如果堆內存中數組不再有任何引用變量指向自己，則這個數組將成為垃圾，該數組所占的內存將會被系統的垃圾
回收機制回收。因此，為了讓垃圾回收機制回收一個數組所占的內存空間，則可以將該數組變量賦為null，也就切
斷了數組引用變量和實際數組之間的引用關系，實際數組也就成了垃圾。
數組長度不可變
•只要類型相互兼容，可以讓一個數組變量指向另一個實際的數組，這種操作會產生數組的長度可變的錯覺。
•但由於數組變量整體賦值導致的數組的長度可以改變，只是一個假相。
基本類型數組的初始化
•對於基本類型數組而言，數組元素的值直接存儲在對應的數組元素中，因此，初始化數組時，先為該數組分配內
存空間，然後直接將數組元素的值存入對應數組元素中，
![]()
public class TestPrimitiveArray
{
public static void main(String[] args)
{
// 定義一個int[ ]類型的數組變量
int[] iArr;
// 動態初始化數組，數組長度為5
iArr = new int[5];
// 采用循環方式為每個數組元素賦值
for (int i = 0; i < iArr.length; i++)
{
iArr[i] = i + 10;
System.out.println(iArr[i]);
}
}
}
TestPrimitiveArray
引用類型數組的初始化
引用類型數組的數組元素是引用，因此情況變得更加復雜：每個數組元素裡存儲的還是引用，它指向另一塊內存，
這塊內存裡存儲了有效數據。
沒有多維數組
•Java語言提供了多維數組的語法，但多維數組實質上還是一維數組。
Java語言裡的數組類型是引用類型，因此，數組變量其實是一個引用，這個引用指向真實的數組內存。數組元素
的類型也可以是引用，如果數組元素的引用再次指向真實的數組內存，這種情形看上去很像多維數組。
•定義二維數組的語法：
•type[ ] [ ] arrName;
![]()
public class TestTwoDimension {
public static void main(String[] args) {
// 定義一個二維數組
int[][] a;
// 把a當成一維數組進行初始化，初始化a是一個長度為3的整數
// a數組的數組元素又是引用類型
a = new int[3][];
// 把a數組當成一維數組，遍歷a數組的每個元素
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
// 初始化a數組的第一個元素
a[0] = new int[2];
// 訪問a數組的第一個元素所指數組的第二個元素
a[0][1] = 6;
// a數組的第一個元素是一個一維數組，遍歷這個一維數組
for (int i = 0; i < a[0].length; i++) {
System.out.println(a[0][i]);
}
}
// null
// null
// null
// 0
// 6
}
TestTwoDimension
我們可以得到一個結論：
二維數組是一維數組，其數組元素是一維數組；三維數組也是一維數組，其數組元素是二維數組；四維數組還是一維數
組，其數組元素是三維數組……從這個角度來看，Java語言裡沒有多維數組。
Java 8增強的Arrays工具類
•Arrays類裡包含的一些static修飾的方法可以直接操作數組。
•Java 8增強了Arrays類的功能，Java 8為Arrays類增加了一些工具方法，這些工具方法可以充分利用多CPU並
行的能力來提高設值、排序的性能。
代碼區：
![]()
public class IfCorrectTest {
public static void main(String[] args) {
int age = 45;
if (age > 60) {
System.out.println("老年人");
} else if (age > 40) {
System.out.println("中年人");
} else if (age > 20) {
System.out.println("青年人");
}
}
// 中年人
}
IfCorrectTest
![]()
public class IfCorrectTest2 {
public static void main(String[] args) {
int age = 45;
if (age > 60) {
System.out.println("老年人");
}
// 在原本的if條件中增加了else的隱含條件
if (age > 40 && !(age > 60)) {
System.out.println("中年人");
}
// 在原本的if條件中增加了else的隱含條件
if (age > 20 && !(age > 60) && !(age > 40 && !(age > 60))) {
System.out.println("青年人");
}
}
// 中年人
}
IfCorrectTest2
![]()
public class IfErrorTest {
public static void main(String[] args) {
int age = 45;
if (age > 20) {
System.out.println("青年人");
} else if (age > 40) {
System.out.println("中年人");
} else if (age > 60) {
System.out.println("老年人");
}
}
// 青年人
}
IfErrorTest
![]()
public class IfErrorTest2 {
public static void main(String[] args) {
int age = 45;
if (age > 20) {
System.out.println("青年人");
}
// 在原本的if條件中增加了else的隱含條件
if (age > 40 && !(age > 20)) {
System.out.println("中年人");
}
// 在原本的if條件中增加了else的隱含條件
if (age > 60 && !(age > 20) && !(age > 40 && !(age > 20))) {
System.out.println("老年人");
}
}
// 青年人
}
IfErrorTest2
![]()
public class IfTest {
public static void main(String[] args) {
int age = 30;
if (age > 20)
// 只有當age > 20時，下面花括號括起來的語句塊才會執行
// 花括號括起來的語句是一個整體，要麼一起執行，要麼一起不會執行
{
System.out.println("年齡已經大於20歲了");
System.out.println("20歲以上的人應該學會承擔責任...");
}
// 定義變量a ，並為其賦值
int a = 5;
if (a > 4)
// 如果a>4，執行下面的執行體，只有一行代碼作為代碼塊
System.out.println("a大於4");
else
// 否則，執行下面的執行體，只有一行代碼作為代碼塊
System.out.println("a不大於4");
// 定義變量b ，並為其賦值
int b = 5;
if (b > 4)
// 如果b>4，執行下面的執行體，只有一行代碼作為代碼塊
System.out.println("b大於4");
else
// 否則，執行下面的執行體，只有一行代碼作為代碼塊
b--;
// 對於下面代碼而言，它已經不再是條件執行體的一部分，因此總會執行。
System.out.println("b不大於4");
// 定義變量c ，並為其賦值
int c = 5;
if (c > 4)
// 如果b>4，執行下面的執行體，將只有c--;一行代碼為條件體
c--;
// 下面是一行普通代碼，不屬於條件體
System.out.println("c大於4");
// 此處的else將沒有if語句，因此編譯出錯。
// else
// 否則，執行下面的執行體，只有一行代碼作為代碼塊
System.out.println("c不大於4");
}
// 年齡已經大於20歲了
// 20歲以上的人應該學會承擔責任...
// a大於4
// b大於4
// b不大於4
// c大於4
// c不大於4
}
IfTest
![]()
public class StringSwitchTest {
public static void main(String[] args) {
// 聲明變量season
String season = "夏天";
// 執行swicth分支語句
switch (season) {
case "春天":
System.out.println("春暖花開.");
break;
case "夏天":
System.out.println("夏日炎炎.");
break;
case "秋天":
System.out.println("秋高氣爽.");
break;
case "冬天":
System.out.println("冬雪皚皚.");
break;
default:
System.out.println("季節輸入錯誤");
}
}
// 夏日炎炎.
}
StringSwitchTest
![]()
public class SwitchTest {
public static void main(String[] args) {
// 聲明變量score，並為其賦值為'C'
char score = 'C';
// 執行swicth分支語句
switch (score) {
case 'A':
System.out.println("優秀");
break;
case 'B':
System.out.println("良好");
break;
case 'C':
System.out.println("中");
break;
case 'D':
System.out.println("及格");
break;
case 'F':
System.out.println("不及格");
break;
default:
System.out.println("成績輸入錯誤");
}
}
// 中
}
SwitchTest
![]()
public class WhileTest {
public static void main(String[] args) {
// // 循環的初始化條件
// int count = 0;
// // 當count小於10時，執行循環體
// while (count < 10)
// {
// System.out.println(count);
// // 迭代語句
// count++;
// }
// System.out.println("循環結束!");
// // 下面是一個死循環
// int count = 0;
// while (count < 10)
// {
// System.out.println("不停執行的死循環 " + count);
// count--;
// }
// System.out.println("永遠無法跳出的循環體");
int count = 0;
// while後緊跟一個分號，表明循環體是一個分號（空語句）
while (count < 10)
;
// 下面的代碼塊與while循環已經沒有任何關系
{
System.out.println("------" + count);
count++;
}
}
}
WhileTest
![]()
public class DoWhileTest {
public static void main(String[] args) {
// 定義變量count
int count = 1;
// 執行do while循環
do {
System.out.println(count);
// 循環迭代語句
count++;
// 循環條件緊跟while關鍵字
} while (count < 10);
System.out.println("循環結束!");
// 定義變量count2
int count2 = 20;
// 執行do while循環
do
// 這行代碼把循環體和迭代部分合並成了一行代碼
System.out.println(count2++);
while (count2 < 10);
System.out.println("循環結束!");
}
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 循環結束!
// 20
// 循環結束!
}
DoWhileTest
![]()
public class ForErrorTest {
public static void main(String[] args) {
// 循環的初始化條件,循環條件，循環迭代語句都在下面一行
for (int count = 0; count < 10; count++) {
System.out.println(count);
// 再次修改了循環變量
count *= 0.1;
}
System.out.println("循環結束!");
}
}
ForErrorTest
![]()
public class ForInsteadWhile {
public static void main(String[] args) {
// 把for循環的初始化條件提出來獨立定義
int count = 0;
// for循環裡只放循環條件
for (; count < 10;) {
System.out.println(count);
// 把循環迭代部分放在循環體之後定義
count++;
}
System.out.println("循環結束!");
// 此處將還可以訪問count變量
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 循環結束!
}
ForInsteadWhile
![]()
public class ForTest {
public static void main(String[] args) {
// 循環的初始化條件,循環條件，循環迭代語句都在下面一行
for (int count = 0; count < 10; count++) {
System.out.println(count);
}
System.out.println("循環結束!");
}
// 0
// 1
// 2
// 3
// 4
// 5
// 6
// 7
// 8
// 9
// 循環結束!
}
ForTest
![]()
public class ForTest2 {
public static void main(String[] args) {
// 同時定義了三個初始化變量，使用&&來組合多個boolean表達式
for (int b = 0, s = 0, p = 0; b < 10 && s < 4 && p < 10; p++) {
System.out.println(b++);
System.out.println(++s + p);
}
}
// 0
// 1
// 1
// 3
// 2
// 5
// 3
// 7
}
ForTest2
![]()
public class NestedLoopTest {
public static void main(String[] args) {
// 外層循環
for (int i = 0; i < 5; i++) {
// 內層循環
for (int j = 0; j < 3; j++) {
System.out.println("i的值為:" + i + " j的值為:" + j);
}
}
}
// i的值為:0 j的值為:0
// i的值為:0 j的值為:1
// i的值為:0 j的值為:2
// i的值為:1 j的值為:0
// i的值為:1 j的值為:1
// i的值為:1 j的值為:2
// i的值為:2 j的值為:0
// i的值為:2 j的值為:1
// i的值為:2 j的值為:2
// i的值為:3 j的值為:0
// i的值為:3 j的值為:1
// i的值為:3 j的值為:2
// i的值為:4 j的值為:0
// i的值為:4 j的值為:1
// i的值為:4 j的值為:2
}
NestedLoopTest
![]()
public class WhileTest {
public static void main(String[] args) {
// // 循環的初始化條件
// int count = 0;
// // 當count小於10時，執行循環體
// while (count < 10)
// {
// System.out.println(count);
// // 迭代語句
// count++;
// }
// System.out.println("循環結束!");
// // 下面是一個死循環
// int count = 0;
// while (count < 10)
// {
// System.out.println("不停執行的死循環 " + count);
// count--;
// }
// System.out.println("永遠無法跳出的循環體");
int count = 0;
// while後緊跟一個分號，表明循環體是一個分號（空語句）
while (count < 10)
;
// 下面的代碼塊與while循環已經沒有任何關系
{
System.out.println("------" + count);
count++;
}
}
}
WhileTest
![]()
public class BreakTest {
public static void main(String[] args) {
// 一個簡單的for循環
for (int i = 0; i < 10; i++) {
System.out.println("i的值是" + i);
if (i == 2) {
// 執行該語句時將結束循環
break;
}
}
}
// i的值是0
// i的值是1
// i的值是2
}
BreakTest
![]()
public class BreakTest2 {
public static void main(String[] args) {
// 外層循環，outer作為標識符
outer: for (int i = 0; i < 5; i++) {
// 內層循環
for (int j = 0; j < 3; j++) {
System.out.println("i的值為:" + i + " j的值為:" + j);
if (j == 1) {
// 跳出outer標簽所標識的循環。
break outer;
}
}
}
}
// i的值為:0 j的值為:0
// i的值為:0 j的值為:1
}
BreakTest2
![]()
public class ContinueTest {
public static void main(String[] args) {
// 一個簡單的for循環
for (int i = 0; i < 3; i++) {
System.out.println("i的值是" + i);
if (i == 1) {
// 忽略本次循環的剩下語句
continue;
}
System.out.println("continue後的輸出語句");
}
}
// i的值是0
// continue後的輸出語句
// i的值是1
// i的值是2
// continue後的輸出語句
}
ContinueTest
![]()
public class ContinueTest2 {
public static void main(String[] args) {
// 外層循環
outer: for (int i = 0; i < 5; i++) {
// 內層循環
for (int j = 0; j < 3; j++) {
System.out.println("i的值為:" + i + " j的值為:" + j);
if (j == 1) {
// 忽略outer標簽所指定的循環中本次循環所剩下語句。
continue outer;
}
}
}
}
// i的值為:0 j的值為:0
// i的值為:0 j的值為:1
// i的值為:1 j的值為:0
// i的值為:1 j的值為:1
// i的值為:2 j的值為:0
// i的值為:2 j的值為:1
// i的值為:3 j的值為:0
// i的值為:3 j的值為:1
// i的值為:4 j的值為:0
// i的值為:4 j的值為:1
}
ContinueTest2
![]()
public class ReturnTest {
public static void main(String[] args) {
// 一個簡單的for循環
for (int i = 0; i < 3; i++) {
System.out.println("i的值是" + i);
if (i == 1) {
return;
}
System.out.println("return後的輸出語句");
}
}
// i的值是0
// return後的輸出語句
// i的值是1
}
ReturnTest
![]()
public class ArrayTest {
public static void main(String[] args) {
// 定義一個int數組類型的變量，變量名為intArr.
int[] intArr;
// 使用靜態初始化，初始化數組時只指定數組元素的初始值，不指定數組長度。
intArr = new int[] { 5, 6, 8, 20 };
// 定義一個Object數組類型的變量，變量名為objArr.
Object[] objArr;
// 使用靜態初始化，初始化數組時數組元素的類型是
// 定義數組時所指定的數組元素類型的子類
objArr = new String[] { "Java", "李" };
Object[] objArr2;
// 使用靜態初始化
objArr2 = new Object[] { "Java", "李" };
// 數組的定義和初始化同時完成，使用簡化的靜態初始化寫法
int[] a = { 5, 6, 7, 9 };
// 數組的定義和初始化同時完成，使用動態初始化語法
int[] prices = new int[5];
// 數組的定義和初始化同時完成，初始化數組時元素的類型是定義數組時元素類型的子類
Object[] books = new String[4];
// 輸出objArr數組的第二個元素，將輸出字符串"李"
System.out.println(objArr[1]);
// 為objArr2的第一個數組元素賦值
objArr2[0] = "Spring";
// 訪問數組元素指定的索引等於數組長度，所以下面代碼將在運行時出現異常
// System.out.println(objArr2[2]);
// 使用循環輸出prices數組的每個數組元素的值
for (int i = 0; i < prices.length; i++) {
System.out.println(prices[i]);
}
// 對動態初始化後的數組元素進行賦值
books[0] = "Java講義";
books[1] = "輕量級Java EE企業應用實戰";
// 使用循環輸出books數組的每個數組元素的值
for (int i = 0; i < books.length; i++) {
System.out.println(books[i]);
}
}
// 李
// 0
// 0
// 0
// 0
// 0
// Java講義
// 輕量級Java EE企業應用實戰
// null
// null
}
ArrayTest
![]()
public class ForEachErrorTest {
public static void main(String[] args) {
String[] books = { "輕量級Java EE企業應用實戰", "瘋狂Java講義", "瘋狂Android講義" };
// 使用foreach循環來遍歷數組元素，其中book將會自動迭代每個數組元素
for (String book : books) {
book = "瘋狂Ajax講義";
System.out.println(book);
}
System.out.println(books[0]);
}
// 瘋狂Ajax講義
// 瘋狂Ajax講義
// 瘋狂Ajax講義
// 輕量級Java EE企業應用實戰
}
ForEachErrorTest
![]()
public class ForEachTest {
public static void main(String[] args) {
String[] books = { "輕量級Java EE企業應用實戰", "瘋狂Java講義", "瘋狂Android講義" };
// 使用foreach循環來遍歷數組元素，
// 其中book將會自動迭代每個數組元素
for (String book : books) {
System.out.println(book);
}
}
// 輕量級Java EE企業應用實戰
// 瘋狂Java講義
// 瘋狂Android講義
}
ForEachTest
![]()
public class ArrayInRam {
public static void main(String[] args) {
// 定義並初始化數組，使用靜態初始化
int[] a = { 5, 7, 20 };
// 定義並初始化數組，使用動態初始化
int[] b = new int[4];
// 輸出b數組的長度
System.out.println("b數組的長度為：" + b.length);
// 循環輸出a數組的元素
for (int i = 0, len = a.length; i < len; i++) {
System.out.println(a[i]);
}
// 循環輸出b數組的元素
for (int i = 0, len = b.length; i < len; i++) {
System.out.println(b[i]);
}
// 因為a是int[]類型，b也是int[]類型，所以可以將a的值賦給b。
// 也就是讓b引用指向a引用指向的數組
b = a;
// 再次輸出b數組的長度
System.out.println("b數組的長度為：" + b.length);
}
// b數組的長度為：4
// 5
// 7
// 20
// 0
// 0
// 0
// 0
// b數組的長度為：3
}
ArrayInRam
![]()
public class ArraysTest {
public static void main(String[] args) {
// 定義一個a數組
int[] a = new int[] { 3, 4, 5, 6 };
// 定義一個a2數組
int[] a2 = new int[] { 3, 4, 5, 6 };
// a數組和a2數組的長度相等，每個元素依次相等，將輸出true
System.out.println("a數組和a2數組是否相等：" + Arrays.equals(a, a2));
// 通過復制a數組，生成一個新的b數組
int[] b = Arrays.copyOf(a, 6);
System.out.println("a數組和b數組是否相等：" + Arrays.equals(a, b));
// 輸出b數組的元素，將輸出[3, 4, 5, 6, 0, 0]
System.out.println("b數組的元素為：" + Arrays.toString(b));
// 將b數組的第3個元素（包括）到第5個元素（不包括）賦為1
Arrays.fill(b, 2, 4, 1);
// 輸出b數組的元素，將輸出[3, 4, 1, 1, 0, 0]
System.out.println("b數組的元素為：" + Arrays.toString(b));
// 對b數組進行排序
Arrays.sort(b);
// 輸出b數組的元素，將輸出[0, 0, 1, 1, 3, 4]
System.out.println("b數組的元素為：" + Arrays.toString(b));
}
// a數組和a2數組是否相等：true
// a數組和b數組是否相等：false
// b數組的元素為：[3, 4, 5, 6, 0, 0]
// b數組的元素為：[3, 4, 1, 1, 0, 0]
// b數組的元素為：[0, 0, 1, 1, 3, 4]
}
ArraysTest
![]()
public class ArraysTest2 {
public static void main(String[] args) {
int[] arr1 = new int[] { 3, -4, 25, 16, 30, 18 };
// 對數組arr1進行並發排序
Arrays.parallelSort(arr1);
System.out.println(Arrays.toString(arr1));
int[] arr2 = new int[] { 3, -4, 25, 16, 30, 18 };
Arrays.parallelPrefix(arr2, new IntBinaryOperator() {
// left代表數組中前一個所索引處的元素，計算第一個元素時，left為1
// right代表數組中當前索引處的元素
public int applyAsInt(int left, int right) {
return left * right;
}
});
System.out.println(Arrays.toString(arr2));
int[] arr3 = new int[5];
Arrays.parallelSetAll(arr3, new IntUnaryOperator() {
// operand代表正在計算的元素索引
public int applyAsInt(int operand) {
return operand * 5;
}
});
System.out.println(Arrays.toString(arr3));
}
}
ArraysTest2
![]()
public class Gobang {
// 定義棋盤的大小
private static int BOARD_SIZE = 15;
// 定義一個二維數組來充當棋盤
private String[][] board;
public void initBoard() {
// 初始化棋盤數組
board = new String[BOARD_SIZE][BOARD_SIZE];
// 把每個元素賦為"╋"，用於在控制台畫出棋盤
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
board[i][j] = "╋";
}
}
}
// 在控制台輸出棋盤的方法
public void printBoard() {
// 打印每個數組元素
for (int i = 0; i < BOARD_SIZE; i++) {
for (int j = 0; j < BOARD_SIZE; j++) {
// 打印數組元素後不換行
System.out.print(board[i][j]);
}
// 每打印完一行數組元素後輸出一個換行符
System.out.print("\n");
}
}
public static void main(String[] args) throws Exception {
Gobang gb = new Gobang();
gb.initBoard();
gb.printBoard();
// 這是用於獲取鍵盤輸入的方法
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String inputStr = null;
// br.readLine()：每當在鍵盤上輸入一行內容按回車，用戶剛輸入的內容將被br讀取到。
while ((inputStr = br.readLine()) != null) {
// 將用戶輸入的字符串以逗號（,）作為分隔符，分隔成2個字符串
String[] posStrArr = inputStr.split(",");
// 將2個字符串轉換成用戶下棋的座標
int xPos = Integer.parseInt(posStrArr[0]);
int yPos = Integer.parseInt(posStrArr[1]);
// 把對應的數組元素賦為"●"。
gb.board[yPos - 1][xPos - 1] = "●";
/*
* 電腦隨機生成2個整數，作為電腦下棋的座標，賦給board數組。 還涉及 1.座標的有效性，只能是數字，不能超出棋盤范圍
* 2.如果下的棋的點，不能重復下棋。 3.每次下棋後，需要掃描誰贏了
*/
gb.printBoard();
System.out.println("請輸入您下棋的座標，應以x,y的格式：");
}
}
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
// ╋╋╋╋╋╋╋╋╋╋╋╋╋╋╋
}
Gobang
![]()
public class Num2Rmb {
private String[] hanArr = { "零", "壹", "貳", "三", "肆", "伍", "陸", "柒", "捌",
"玖" };
private String[] unitArr = { "十", "百", "千" };
/**
* 把一個浮點數分解成整數部分和小數部分字符串
*
* @param num
* 需要被分解的浮點數
* @return 分解出來的整數部分和小數部分。第一個數組元素是整數部分，第二個數組元素是小數部分。
*/
private String[] divide(double num) {
// 將一個浮點數強制類型轉換為long，即得到它的整數部分
long zheng = (long) num;
// 浮點數減去整數部分，得到小數部分，小數部分乘以100後再取整得到2位小數
long xiao = Math.round((num - zheng) * 100);
// 下面用了2種方法把整數轉換為字符串
return new String[] { zheng + "", String.valueOf(xiao) };
}
/**
* 把一個四位的數字字符串變成漢字字符串
*
* @param numStr
* 需要被轉換的四位的數字字符串
* @return 四位的數字字符串被轉換成的漢字字符串。
*/
private String toHanStr(String numStr) {
String result = "";
int numLen = numStr.length();
// 依次遍歷數字字符串的每一位數字
for (int i = 0; i < numLen; i++) {
// 把char型數字轉換成的int型數字，因為它們的ASCII碼值恰好相差48
// 因此把char型數字減去48得到int型數字，例如'4'被轉換成4。
int num = numStr.charAt(i) - 48;
// 如果不是最後一位數字，而且數字不是零，則需要添加單位（千、百、十）
if (i != numLen - 1 && num != 0) {
result += hanArr[num] + unitArr[numLen - 2 - i];
}
// 否則不要添加單位
else {
result += hanArr[num];
}
}
return result;
}
public static void main(String[] args) {
Num2Rmb nr = new Num2Rmb();
// 測試把一個浮點數分解成整數部分和小數部分
System.out.println(Arrays.toString(nr.divide(236711125.123)));
// 測試把一個四位的數字字符串變成漢字字符串
System.out.println(nr.toHanStr("609"));
}
// [236711125, 12]
// 陸百零玖
}
Num2Rmb
![]()
public class Num2Rmb {
private String[] hanArr = { "零", "壹", "貳", "三", "肆", "伍", "陸", "柒", "捌",
"玖" };
private String[] unitArr = { "十", "百", "千" };
/**
* 把一個浮點數分解成整數部分和小數部分字符串
*
* @param num
* 需要被分解的浮點數
* @return 分解出來的整數部分和小數部分。第一個數組元素是整數部分，第二個數組元素是小數部分。
*/
private String[] divide(double num) {
// 將一個浮點數強制類型轉換為long，即得到它的整數部分
long zheng = (long) num;
// 浮點數減去整數部分，得到小數部分，小數部分乘以100後再取整得到2位小數
long xiao = Math.round((num - zheng) * 100);
// 下面用了2種方法把整數轉換為字符串
return new String[] { zheng + "", String.valueOf(xiao) };
}
/**
* 把一個四位的數字字符串變成漢字字符串
*
* @param numStr
* 需要被轉換的四位的數字字符串
* @return 四位的數字字符串被轉換成的漢字字符串。
*/
private String toHanStr(String numStr) {
String result = "";
int numLen = numStr.length();
// 依次遍歷數字字符串的每一位數字
for (int i = 0; i < numLen; i++) {
// 把char型數字轉換成的int型數字，因為它們的ASCII碼值恰好相差48
// 因此把char型數字減去48得到int型數字，例如'4'被轉換成4。
int num = numStr.charAt(i) - 48;
// 如果不是最後一位數字，而且數字不是零，則需要添加單位（千、百、十）
if (i != numLen - 1 && num != 0) {
result += hanArr[num] + unitArr[numLen - 2 - i];
}
// 否則不要添加單位
else {
result += hanArr[num];
}
}
return result;
}
public static void main(String[] args) {
Num2Rmb nr = new Num2Rmb();
// 測試把一個浮點數分解成整數部分和小數部分
System.out.println(Arrays.toString(nr.divide(236711125.123)));
// 測試把一個四位的數字字符串變成漢字字符串
System.out.println(nr.toHanStr("609"));
}
// [236711125, 12]
// 陸百零玖
}
Num2Rmb
![]()
public class PrimitiveArrayTest {
public static void main(String[] args) {
// 定義一個int[]類型的數組變量
int[] iArr;
// 動態初始化數組，數組長度為5
iArr = new int[5];
// 采用循環方式為每個數組元素賦值。
for (int i = 0; i < iArr.length; i++) {
iArr[i] = i + 10;
}
}
}
PrimitiveArrayTest
![]()
class Person {
public int age; // 年齡
public double height; // 身高
// 定義一個info方法
public void info() {
System.out.println("我的年齡是：" + age + "，我的身高是：" + height);
}
// 我的年齡是：16，我的身高是：161.0
// 我的年齡是：16，我的身高是：161.0
}
public class ReferenceArrayTest {
public static void main(String[] args) {
// 定義一個students數組變量，其類型是Person[]
Person[] students;
// 執行動態初始化
students = new Person[2];
// 創建一個Person實例，並將這個Person實例賦給zhang變量
Person zhang = new Person();
// 為zhang所引用的Person對象的age、height賦值
zhang.age = 15;
zhang.height = 158;
// 創建一個Person實例，並將這個Person實例賦給lee變量
Person lee = new Person();
// 為lee所引用的Person對象的age、height賦值
lee.age = 16;
lee.height = 161;
// 將zhang變量的值賦給第一個數組元素
students[0] = zhang;
// 將lee變量的值賦給第二個數組元素
students[1] = lee;
// 下面兩行代碼的結果完全一樣，因為lee
// 和students[1]指向的是同一個Person實例。
lee.info();
students[1].info();
}
}
Person
![]()
public class TwoDimensionTest {
public static void main(String[] args) {
// 定義一個二維數組
int[][] a;
// 把a當成一維數組進行初始化，初始化a是一個長度為4的數組
// a數組的數組元素又是引用類型
a = new int[4][];
// 把a數組當成一維數組，遍歷a數組的每個數組元素
for (int i = 0, len = a.length; i < len; i++) {
System.out.println(a[i]);
}
// 初始化a數組的第一個元素
a[0] = new int[2];
// 訪問a數組的第一個元素所指數組的第二個元素
a[0][1] = 6;
// a數組的第一個元素是一個一維數組，遍歷這個一維數組
for (int i = 0, len = a[0].length; i < len; i++) {
System.out.println(a[0][i]);
}
// 同時初始化二維數組的2個維數
int[][] b = new int[3][4];
// 使用靜態初始化的語法來初始化一個二維數組
String[][] str1 = new String[][] { new String[3],
new String[] { "hello" } };
// 使用簡化的靜態初始化語法來初始化二維數組
String[][] str2 = { new String[3], new String[] { "hello" } };
System.out.println(str1[1][0]);
System.out.println(str2[1][0]);
}
// null
// null
// null
// null
// 0
// 6
// hello
// hello
}
TwoDimensionTest
