三，流程控制
1，接收使用者輸入

首先，建立Scanner工具類對應的實體物件input，用於操作輸入，需要注意以下兩點：

在這裡插入圖片描述

更具體的輸入，需要使用上一步建立的實體input帶有的函式，比如：

input.nextInt(); // 返回值為int
input.nextFloat(); // 返回值為float
input.nextByte(); // 返回值為byte
…

然而上述函式要求輸入必須與預定型別一致。為了方便接受各種不同型別的輸入，可以使用函式：

input.next(); // 返回值為String
input.nextLine(); // 返回值為String

注意：

next與nextLine儘量不要同時使用，以下面的例子為例：

package com.kaikeba.demo;
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.println("請輸入next接受的內容：");
String s1 = input.next();
System.out.println(s1);
System.out.println("請輸入nextLine接受的內容：");
String s2 = input.nextLine();
System.out.println(s2);
System.out.println("------我是分界線------");
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

原先設想的是可以在控制檯輸入兩次資料，一次給next函式，另一次給nextLine函式。然而執行時會發現，next接收資料後，敲下回車，可以正常顯示，等到nextLine函式接受資料時，卻不能繼續在控制檯進行輸入。

原因是：敲下回車後，next函式接受了資料，nextLine函式接收了後面的換行字元；所以s2中存放的是換行字元；
2，程式的執行結構

1996 年，電腦科學家 Bohm 和 Jacopini 證明了：任何簡單或複雜的演算法都可以由順序結構、分支結構和迴圈結構這三種基本 結構組合而成。

它們的共同點是都包含一個入口和一個出口，它們的每個程式碼都有機會被執行，不會出現死迴圈。

順序結構 ：順序結構是一種基本的控制結構，它按照語句出現的順序執行操作 ；
分支結構 ：分支結構又被稱為選擇結構，根據條件成立與否來執行操作；
迴圈結構 ：迴圈結構是一種重複結構，如果條件成立，它會重複執行某一迴圈體，直到出現不滿足的條件為止；

3，分支執行結構
3.1 if條件語句

if 條件結構是根據條件判斷之後再做處理

if(條件語句){…}
if (條件語句){…}else{…}
if (條件語句){…}else if(條件語句){…}
if (條件語句){…}else if(條件語句){…}else{…}
例子：使用者輸入學生成績，判斷成績是否及格，判斷條件為 優良： > 90、良好：81-90、中：60-80、不及格：<60

import java.util.Scanner;
public class Demo4{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("請輸入成績：");
int score s= input.nextInt(); // 91 優 81-90 良 60-80 中 60 差
if(score >= 91){
System.out.println("您的成績是優秀！繼續加油哦！");
}else if(score >= 81 & score < 91){
System.out.println("您的成績是良好！還要努力哦！");
}else if(score >= 60 & score <= 80){
System.out.println("您的成績是中等！還要加倍努力哦！");
}else{
System.out.println("您的成績是差！準備補考費吧！");
}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.2 switch語句

switch(表示式){

case 取值 1: 語句塊 1;break;

case 取值 n: 語句塊 n;break;

default: 語句塊 n+1;break;

}

switch 語句有關規則

表示式的返回值必須是下述幾種型別之一：int, byte, char, short,String；
case 子句中的取值必須是常量，且所有 case 子句中的取值應是不同的；
default 子句是可選的；
break 語句用來在執行完一個 case 分支後使程式跳出 switch 語句塊；
如果 case 後面沒有寫 break 則直接往下面執行！
Case 後面的執行體可寫{ }也可以不寫{ }

例題：多分支月份輸出天數（充分利用語句特性）

import java.util.Scanner;
public class Demo6{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("請輸入月份：");
int month = input.nextInt();
switch(month){
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
System.out.println(month + "月共有 31 天");
break;
case 4:
case 6:
case 9:
case 11:
System.out.println(month + "月共有 30 天");
break;
case 2:
System.out.println(month + "月共有 28 天");
break;
default :
System.out.println("友情提示，您輸入有誤！");
break;
}
}
}

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
28
29
30
31

4，迴圈執行結構

迴圈語句功能

在迴圈條件滿足的情況下，反覆執行特定程式碼 迴圈語句分類
for 迴圈
while 迴圈
do/while 迴圈

4.1 while迴圈

符合條件，迴圈繼續執行；否則，迴圈退出

特點：先判斷，再執行

while(條件表示式){
//語句塊；
}

int sum = 0;
int score = 0;
int avg = 0;
int studentNum = 20;
while(i<=studentNum){
System.out.print("請輸入第" + i + "位同學的成績：");
score = input.nextInt();
sum = sum + score;
i++;
}
avg = sum / stuNum ;

1
2
3
4
5
6
7
8
9
10
11

4.2 do-while 迴圈

先執行一遍迴圈操作，符合條件，迴圈繼續執行；否則，迴圈退出 （保證函式體內的程式碼至少執行一次）

特點：先執行，再判斷

do {
迴圈操作
}while ( 條件表示式 );

在這裡插入圖片描述
4.3 for迴圈

for(初始化引數;判斷條件 ;更新迴圈變數){
迴圈體;
}

public class ForLoop {
public static void main(String [] args){
int result = 0;
for(int i=1; i<=100; i++) {
result += i;
}
System.out.println("result=" + result);
}

}

1
2
3
4
5
6
7
8
9
10
11

4.4 break、continue與多重迴圈的跳出

break：跳出包含break的最近的一個迴圈體；

continue：跳過此次迴圈體中continue語句後的程式碼，並執行下一次迴圈；

多重迴圈的跳出使用別名的方法，舉例如下：
在這裡插入圖片描述
4.5 判斷使用者輸入型別

在這裡插入圖片描述
四，陣列
1，陣列
1.1 陣列概念

陣列是相同資料型別的多個數據的容器。

這些元素按線性順序排列。所謂線性順序是指除第一個元素外，每一個元素都有唯一的前驅元素；除最後一個元素外，每一個元素都有唯一的後繼元素。（“簡單理解就是：一個跟一個順序排列”）。
1.2 陣列建立格式

格式 1. 資料型別[] 陣列名稱 = new 資料型別[陣列長度];

格式 2. 資料型別[] 陣列名稱 = {陣列內容 1,陣列內容 2,陣列內容 3…陣列內容 n};

格式 3. 資料型別[] 陣列名;

格式 3 屬於只建立了陣列引用名， 並未在記憶體建立陣列空間。

格式 4. 資料型別[] 陣列名稱 = new 資料型別[]{內容 1,內容 2,內容 3…內容 n};

package com.kaikeba.demo;
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
/*
* 建立陣列的格式
*/
// 常用格式1：建立陣列同時指定陣列內容
// 資料型別[] 陣列名 = {資料1，資料2，資料3，......};
int[] tem1 = {1, 2, 3, 4};

	// 常用格式2：建立陣列，指定長度，不指定內容
	// 資料型別[] 陣列名 = new 資料型別[陣列長度（int）型別]
	int[] tem2 = new int[10];
	
	// 不常用格式1：建立陣列 不初始化
	// 資料型別[] 陣列名
	int[] tem3;
	
	// 不常用格式2：建立陣列並指定內容
	// 資料型別[] 陣列名 = new 資料型別[]{資料1，資料2，資料3，......}
	int[] tem4 = new int[] {1, 2, 3, 4};
}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

1.3 陣列相關操作

1，通過下標操作資料的方式

給陣列某個下標賦值：

tem1[2] = 66;

1

從下標取值：

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

1

2，獲得陣列長度

陣列名.length

System.out.println(tem2.length);

1

2，陣列常見問題
2.1 下標越界

在這裡插入圖片描述
2.2 空指標問題

名稱與值未繫結；
在這裡插入圖片描述
3，陣列應用
3.1 尋找陣列最大最小值

建立變數，儲存最大值，遍歷陣列更新最大值；

建議：將變數初始化為陣列的第一個元素；
在這裡插入圖片描述
3.2 常用演算法

氣泡排序：

原理：

比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
針對所有的元素重複以上的步驟，除了最後一個。
持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較
名字來由：

是因為最小（或最大）的元素會經由交換慢慢“浮”到數列的頂端（降序或升序），就如同水中的氣泡最終會上浮到 頂端一樣，故名“氣泡排序”。

package com.kaikeba.demo1;

public class Demo4 {

/**
 * 氣泡排序
 * @param args
 */
public static void main(String[] args) {
	int[] nums = {20,15,18,13,30,60};
	int temp;
	//外層迴圈控制的是， 比較的輪數。
	//外層迴圈次數： length-1
	for(int i=0;i<nums.length-1;i++) {
		//內層迴圈控制的是，每輪比較的次數
		//第i輪（i從0開始計算）， 比較次數為：length-i-1
		for(int j=0;j<nums.length-i-1;j++) {
			if(nums[j]>nums[j+1]) {
				//兩兩相比， 滿足移動條件
				temp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = temp;
			}
		}
	}
//排序已經完成。 下面是遍歷列印檢視的過程
	for(int i=0;i<nums.length;i++) {
		System.out.println(nums[i]);
	}
}

}

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
28
29
30
31
32

二分查詢

概述

二分查詢也稱折半查詢（Binary Search），它是一種效率較高的查詢方法。但是，二分查詢要求陣列資料必須採用順序儲存結構有序排列。

原理

首先，假設陣列中元素是按升序排列，將陣列中間位置的資料與查詢資料比較，如果兩者相等，則查詢成功；否則利用
中間位置記錄將陣列分成前、後兩個子陣列，如果中間位置資料大於查詢資料，則進一步查詢前子陣列，否則進一步查 找後子陣列。
重複以上過程，直到找到滿足條件的資料，則表示查詢成功， 直到子陣列不存在為止，表示查詢不成功。