Java基礎語法（練習）

Java基礎語法

今日內容介紹

u 循環練習

u 數組方法練習

第1章 循環練習

1.1 編寫程序求 1+3+5+7+……+99 的和值。

題目分析：

通過觀察發現，本題目要實現的奇數（范圍1-100之間）的累加和。

1. 為了記錄累加和的值，我們需要定義一個存儲累加和的變量
2. 我們要獲取到1-100范圍內的數
3. 判斷當前數是否為奇數，是奇數，完成累加和操作
4. 累加完畢后，最終顯示下累加和的值

解題步驟：

1. 定義一個用來記錄累加和的變量
2. 使用for循環語句，完成1-100之間每個數的獲取
3. 使用if條件語句，判斷當前數是否是奇數，是奇數，進行累加和操作
4. 使用輸出語句，打印累加和變量的值

 

代碼如下：

public class Test01 {

public static void main(String[] args) {

int sum = 0;

for (int i = 0; i < 100; i++) {

if (i%2==1) {

sum += i;

}

}

System.out.println("累加和的值 " + sum);

}

}

 

1.2 輸出所有的水仙花數，所謂水仙花數是指一個數3位數，其每位數字立方和等於其本身，如153 = 1*1*1 + 3*3*3 + 5*5*5

題目分析：

通過觀察發現，本題目要實現打印符合要求的數字（即水仙花數）。

1. 明確什么樣的數就是水仙花數。水仙花數是指一個3位數（100-999之間），其每位數字立方之和等於該3位數本身。如153 = 1*1*1 + 3*3*3 + 5*5*5，

即 3位數本身 = 百位數立方 + 十位數立方 + 個位數立方;

1. 獲取水仙花范圍內的所有3位數（100-999之間的每個3位數）
2. 判斷該3位數是否滿足水仙花數，滿足，打印該3位數

解題步驟：

1. 使用for循環，得到100-999之間的每個3位數
2. 獲取3位數中百位數字、十位數字、個位數字
3. 使用if條件語句，判斷該3位數是否滿足水仙花數，滿足，使用輸出語句，打印該3位數

代碼如下：

public class Test02 {

public static void main(String[] args) {

for (int i = 100; i < 1000; i++) {

int bai = i/100%10;

int shi = i/10%10;

int ge = i%10;

 

if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {

System.out.println(i);

}

}

}

}

 

1.3 ASCII編碼表

  American Standard Code for Information Interchange，美國標准信息交換代碼.

  在計算機中，所有的數據在存儲和運算時都要使用二進制數表示, a、b、c、d這樣的52個字母（包括大寫）、以及0、1等數字還有一些常用的符號, 在計算機中存儲時也要使用二進制數來表示，而具體用哪些二進制數字表示哪個符號，當然每個人都可以約定自己的一套（這就叫編碼），而大家如果要想互相通信而不造成混亂，那么大家就必須使用相同的編碼規則，於是美國有關的標准化組織就出台了ASCII編碼，統一規定了上述常用符號用哪些二進制數來表示。

 

 

 

  數字0-9對應ASCII編碼十進制為48-57, 字母a-z對應ASCII編碼十進制為97-122，字母A-Z對應ASCII編碼十進制為65-90

1.4 利用for循環打印ABCDEFG...XYZ，26個大寫字母與26個小寫字母

題目分析：

通過觀察發現，本題目要實現打印26個大寫字母、26個小寫字母

1. 一共26個大小寫字母，那么，可以考慮循環26次。在每次循環中，完成指定字母的大小寫打印
2. 找出ABCDEFG…XYZ這些字母之間的變化規律

通過ASCII表發現，后面的字母比它前面的字母，ASCII值大1

下一個字母 = 上一個字母 + 1

如： A B C D

65 66 67 68

3. 在每次循環中打印上一個字母大小寫，並指定下一個字母

解題步驟：

1. 定義初始化大寫變量，值為’A’； 初始化小寫變量，值為’a’
2. 使用for循環，進行26次循環
3. 在每次循環中，打印大寫字母、小寫字母。

每次打印完成后，更新大寫字母值、小寫字母值

代碼如下：

public class Test04 {

public static void main(String[] args) {

char da = 'A';

char xiao = 'a';

for (int i = 0; i < 26; i++) {

System.out.println("大寫字母 "+da+" ,小寫字母 "+xiao);

da++; //更新大寫字母值

xiao++; //更新小寫字母值

}

}

}

1.5 利用for循環打印 9*9 表?

如：

  1*1=1

1*2=2  2*2=4

1*3=3  2*3=6  3*3=9

 

題目分析：

通過觀察發現，如果把1*1=1這樣的內容 看做一顆*的話，那么打印結果就成了如下效果：

*

**

***

…

這樣，就是打印9行星，每行打印星的個數與當前行數相等。

再觀察“1*3=3 2*3=6 3*3=9”得出它們如下的變化規律：

每行第n次 +"*"+ 行號 +"="+ 每行第n次 * 行號

如: 1 +"*"+  2    +"="+   1*2; // 相當於1*2=2

        2 +"*"+  2    +"="+   2*2; // 相當於2*2=4

 

解題步驟：

1. 定義一個外層for循環，初始值從1開始，循環9次。用來控制打印的行數
2. 在外層for循環內部，定義一個for循環，初始值從1開始，循環次數與當前行數相等。用來完成每行打印指定次數的乘法公式 如1*1=1
3. 在內層for循環中，完成每行指定次數的乘法公式打印 如1*1=1

System.out.print(k +"*"+ j +"="+ j*k +"\t");

// 變量k代表：每行中的第n次

// 變量j代表：行號

1. 在外循環中，當每行指定次數的乘法公式打印完畢后，通過System.out.println()切換到下一行。這樣，再次打印乘法公式時，就在下一行輸出打印了

代碼如下：

public class Test05 {

public static void main(String[] args) {

for (int j = 1; j < 10; j++) {

for (int k = 1; k <= j; k++) {

System.out.print(k +"*"+ j +"="+ j*k +"\t");

}

System.out.println();

}

}

}

 

第2章 數組方法練習

2.1 定義打印數組元素方法,按照給定的格式打印[11, 33, 44, 22, 55]

題目分析：

通過觀察發現，本題目要實現按照指定格式，打印數組元素操作

1. 通過循環，我們可以完成數組中元素的獲取，數組名[索引]
2. 觀察發現，每個數組元素之間加入了一個逗號”,”進行分隔；並且，整個數組的前后有一對中括號”[]”包裹數組所有元素。

解題步驟：

1. 使用輸出語句完成打印 左邊的中括號”[”
2. 使用循環，輸出數組元素值。輸出元素值分為兩種情況，如下：

a) 最后一個數組元素，加上一個右邊的中括號”]”

b) 非最后一個數組元素，加上一個逗號”,”

代碼如下：

//打印數組

public static void printArray(int[] arr) {

System.out.print("[");

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

if (i == arr.length - 1) {

System.out.println(arr[i]+"]");

} else {

System.out.print(arr[i]+", ");

}

}

}

2.2 數組元素逆序

圖解：

 

 

題目分析：

通過觀察發現，本題目要實現原數組元素倒序存放操作。即原數組存儲元素為{11,22,33,44}，逆序后為原數組存儲元素變為{44,33,22,11}。

1. 通過圖解發現，想完成數組元素逆序，其實就是把數組中索引為start與end的元素進行互換。
2. 每次互換后，start索引位置后移，end索引位置前移，再進行互換
3. 直到start位置超越了end位置，互換結束，此時，數組元素逆序完成。

解題步驟：

1. 定義兩個索引變量start值為0，變量end值為數組長度減去1（即數組最后一個元素索引）
2. 使用循環，完成數組索引start位置元素與end位置元素值互換。
3. 在循環換過程中，每次互換結束后，start位置后移1，end位置前移1
4. 在循環換過程中，最先判斷start位置是否超越了end位置，若已超越，則跳出循環

代碼如下：

//數組元素逆序

public static void receive(int[] arr){

for (int start = 0, end = arr.length-1; start < end; start++,end--) {

int temp = arr[start];

arr[start] = arr[end];

arr[end] = temp;

}

}

 

2.3 數組元素選擇排序

圖解：

 

 

題目分析：

通過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序

1. 提到數組排序，就要進行元素值大小的比較，通過上圖發現，我們想完成排序要經過若干次的比較才能夠完成。
2. 上圖中用每圈要比較的第一個元素與該元素后面的數組元素依次比較到數組的最后一個元素，把小的值放在第一個數組元素中，數組循環一圈后，則把最小元素值互換到了第一個元素中。
3. 數組再循環一圈后，把第二小的元素值互換到了第二個元素中。按照這種方式，數組循環多圈以后，就完成了數組元素的排序。這種排序方式我們稱為選擇排序。

解題步驟：

1. 使用for循環（外層循環），指定數組要循環的圈數（通過圖解可知，數組循環的圈數為數組長度 - 1）
2. 在每一圈中，通過for循環（內層循環）完成數組要比較的第一個元素與該元素后面的數組元素依次比較到數組的最后一個元素，把小的值放在第一個數組元素中
3. 在每一圈中，要參與比較的第一個元素由第幾圈循環來決定。如上圖所示

a) 進行第一圈元素比較時，要比較的第一個元素為數組第一個元素，即索引為0的元素

b) 進行第二圈元素比較時，要比較的第一個元素為數組第二個元素，即索引為1的元素

c) 依次類推，得出結論：進行第n圈元素比較時，要比較的第一個元素為數組第n個元素，即數組索引為n-1的元素

代碼如下：

//選擇排序

public static void selectSort(int[] arr) {

//功能

//外層循環用來控制數組循環的圈數

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

//內層循環用來完成元素值比較，把小的元素值互換到要比較的第一個元素中

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

if (arr[i] > arr[j]) {

int temp = arr[i];

arr[i] = arr[j];

arr[j] = temp;

}

}

}

}

2.4 數組元素冒泡排序

圖解：數組元素{13,46,22,65,3}

 

 

題目分析：

通過觀察發現，本題目要實現把數組元素{13,46,22,65,3}進行排序

1. 提到數組排序，就要進行元素值大小的比較，通過上圖發現，我們想完成排序要經過若干次的比較才能夠完成。
2. 上圖中相鄰的元素值依次比較，把大的值放后面的元素中，數組循環一圈后，則把最大元素值互換到了最后一個元素中。數組再循環一圈后，把第二大的元素值互換到了倒數第二個元素中。按照這種方式，數組循環多圈以后，就完成了數組元素的排序。這種排序方式我們稱為冒泡排序。

解題步驟：

1. 使用for循環（外層循環），指定數組要循環的圈數（通過圖解可知，數組循環的圈數為數組長度 - 1）
2. 在每一圈中，通過for循環（內層循環）完成相鄰的元素值依次比較，把大的值放后面的元素中
3. 每圈內層循環的次數，由第幾圈循環來決定。如上圖所示

a) 進行第一圈元素比較時，內層循環次數為數組長度 - 1

b) 進行第二圈元素比較時，內層循環次數為數組長度 - 2

c) 依次類推，得出結論：進行第n圈元素比較時，內層循環次數為數組長度 - n

代碼如下：

//冒泡排序

public static void bubbleSort(int[] arr) {

//功能

//外層循環用來控制數組循環的圈數

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

//j < arr.length-1 為了避免角標越界

//j < arr.length-1-i 為了比較效率,避免重復比較

//內層循環用來完成元素值比較，把大的元素值互換到后面

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;

}

}

}

}

 

2.5 數組元素普通查找

圖解：

 

 

題目分析：

通過觀察發現，本題目要實現查找指定數值第一次在數組中存儲的位置（索引），返回該位置（索引）。

1. 我們可以通過遍歷數組，得到每個數組元素的值
2. 在遍歷數組過程中，使用當前數組元素值與要查找的數值進行對比

a) 數值相等，返回當前數組元素值的索引

b) 整個循環結束后，比對結果數值沒有相等的情況，說明該數組中沒有存儲要查找的數值，此時，返回一個索引值-1，來表示沒有查詢到對應的位置。（使用 -1來表示沒有查詢到，是因為數組的索引沒有負數）

解題步驟：

1. 使用for循環，遍歷數組，得到每個數組元素值
2. 在每次循環中，使用if條件語句進行當前數組元素值與要查找的數值進行對比，若比較結果相等，直接返回當前數組元素的索引值
3. 若整個循環結束后，比對結果數值沒有相等的情況，說明該數組中沒有存儲要查找的數值，此時，返回一個索引值-1

代碼如下：

//普通查找

public static int getArrayIndex(int[] arr, int number) {

//把數組中的元素依次與指定的數值 進行比較

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

if (arr[i] == number) {

//找到了

return i;

}

}

return -1;

}

 

2.6 數組元素二分查找（折半查找）

圖解：

 

 

題目分析：

通過觀察發現，本題目要實現查找指定數值在元素有序的數組中存儲的位置（索引），返回該位置（索引）。

1. 我們使用數組最中間位置的元素值與要查找的指定數值進行比較，若相等，返回中間元素值的索引
2. 最中間位置的元素值與要查找的指定數值進行比較，若不相等，則根據比較的結果，縮小查詢范圍為上次數組查詢范圍的一半；

再根據新的查詢范圍，更新最中間元素位置，然后使用中間元素值與要查找的指定數值進行比較

1. 比較結果相等，返回中間元素值的索引
2. 比較結果不相等，繼續縮小查詢范圍為上次數組查詢范圍的一半，更新最中間元素位置，繼續比較，依次類推。
   1. 當查詢范圍縮小到小於0個元素時，則指定數值沒有查詢到，返回索引值-1。

解題步驟：

1. 定義3個用來記錄索引值的變量，變量min記錄當前范圍最小索引值，初始值為0；變量max記錄當前范圍最大索引值，初始值為數組長度-1；變量mid記錄當前當前范圍最中間元素的索引值，初始值為(min+max) / 2
2. 使用循環，判斷當前范圍下，最中間元素值與指定查找的數值是否相等
3. 若相等，結束循環，返回當前范圍最中間元素的索引值mid
4. 若不相等，根據比較結果，縮小查詢范圍為上一次查詢范圍的一般
5. 中間元素值 比 要查詢的數值大，說明要查詢的數值在當前范圍的最小索引位置與中間索引位置之間，此時，更新查詢范圍為:

范圍最大索引值 = 上一次中間索引位置 -1；

1. 中間元素值 比 要查詢的數值小，說明要查詢的數值在當前范圍的最大索引位置與中間索引位置之間，此時，更新查詢范圍為:

范圍最小索引值 = 上一次中間索引位置 +1；

1. 在新的查詢范圍中，更新中間元素值的位置，再次使用最中間元素值與指定查找的數值是否相等。

                  中間索引值 = (范圍最小索引值 +范圍最大索引值) / 2;

1. 每次查詢范圍縮小一半后，使用if語句判斷，查詢范圍是否小於0個元素，若小於0個元素，則說明指定數值沒有查詢到，返回索引值-1。

    

代碼如下：

//二分查找法(折半查找法)

public static int halfSearch(int[] arr, int number) {

//定義3個變量，用來記錄min, min, mid的位置

int min = 0;

int max = arr.length-1;

int mid = 0;

while (min <= max) {

           mid = (min+max)/2;

//沒找了， 更新范圍，繼續比較

//更新范圍

if (arr[mid] > number) {

//在左邊

max = mid-1;

} else if(arr[i] < number){

//在右邊

min = mid+1;

}

else{

              return mid ;

          }

 

return -1;

}