今天給大家帶來的是初級Java基礎部分的知識：包括初識Java、變量、常量、數據類型、運算符、各種選擇結構、循環結構、數組等Java的基礎語法部分！最后還有****循環結構的進階****,步驟超詳細，
值得收藏(๑•̀ㅂ•́)و✧！！！
另附有各種案例的源代碼（可以直接用O(∩_∩)O~）！！！仔細看完它，扎實的基礎不再是空談，萬丈高樓平地起，當有了扎實的基礎知識，后面學習面向對象以及項目的開發時，壓力就減少了很多，所以
基礎知識不能被輕易的忽略！！！
一、初識Java
使用記事本開發程序的步驟（注意：整個操作過程都是英文）：
1 編寫源程序
首先新建一個文本文件，修改其后綴名為“.java" ---->然后再里面編寫我們需要的代碼
public class HelloWorld{
public static void main(string[] args){
system.out.println("Hello Java!!!");
}
}
public:公共的公開的，處處可以訪問。
class：類，類別，類似狗狗類，電腦類等。
HelloWorld:類名稱，有一個要求，必須和文件名稱保持一致
public static void main(String[] args){} ---->>> 入口方法，所有需要運行的代碼都需要放到這里來，固定寫法
static：關鍵字（計算機中已經使用的名字，我們就不能再使用）
void:返回值類型，void表示沒有返回值
main:是入口方法的方法名
易錯點：
①大括號要成對出現
②String中的”s”要大寫
③我們在每一句話之后都需要使用英文的分號結束
④System中的”s”需要大寫
⑤類名需要和文件名保持一致
所有的輸出內容需要在引號里面
2 編譯源程序
因為編寫的是我們人寫的，但是計算機是看不懂的，所以需要一個“翻譯” 編譯成一個 ".class" 結尾的文件（半機器語言）。我們在dos命令中進入到文件所在目錄，輸入命令 javac xxx.java 類編譯同時會生成一個以“class”結尾的字節碼文件
3 運行
編譯成功之后，即可運行，輸入 java xxx 即可.在控制台即可出現在打印語句中雙引號中的內容了（所有需要打印的內容都需要在雙引號中）
符號的含義：
\t：一個制表符的空格
\n：換到下一行的初識位置
注釋的作用：
解釋說明，不會被編譯運行
單行注釋： //
多行注釋： /* */
文檔注釋： /** */
1.變量
引入：人的計算是在大腦中進行的，計算機的計算是在內存中進行的，內存就好比酒店根據人員的多少開辟適當大小的空間(單人OR雙人，來存儲各種數據。
誕生：內存中的每個空間都是相互獨立的，且都有自己的地址值。
找數據：存入數據並不是目的，我們最主要的是存入了方便之后的使用。每個空間都是有其地址值，地址值是相對比較長且不好記憶的，我們可以像賓館樣給每個空間（房間）起一個名字，這個空間有自己的名稱（變量名）和類型（數據類型）
1.1 定義：
一個存儲空間的表示，其值是可以變化的。（例如買了一雙鞋，鞋盒用來孵小雞，鞋盒就是變量，鞋子和小雞是里面的值。）
通過變量名可以簡單快速的找到它存儲的數據！！！
1.2 為什么使用變量
案例：
// System.out.println("好好學習");
// System.out.println("好好學習");
// System.out.println("好好學習");
// System.out.println("好好學習");
//.....
//現在我想寫好好學習天天向上，那我需要對每一個輸出語句進行修改，很麻煩
//其實我們是可以避免這種情況的出現的，就是使用變量
String str="好好學習，天天向上";
System.out.println(str);
System.out.println(str);
System.out.println(str);
//像以上的情況，我們只需要修改一處即可，這就是變量的好處
1.3 使用步驟：
第一步：聲明變量（聲明變量的時候變量名不能重復）
即根據數據類型在內存申請空間
數據類型 變量名；int money;（int是數據類型，money是變量名）
第二步：賦值
即將數據存儲在對應的內存空間
變量名=數值； money=1000;
上面兩步可以合二為一
int money =1000; 其含義是：在內存中開辟了一個int類型的空間，給其命名為money，並為其賦值為1000；
第三步：使用
即取出數據
注意：
在聲明變量的時候變量名不能重復
當在程序中使用“+”的時候，符號左右兩側如果有一個數據是字符串則將兩個值拼接（如果后面有多個“+”則將多個值拼接），如果都是數值型則計算和
1.4 命名的規則
一個好的命名規范是一個程序員必備的素質，不遵守規范不一定會錯，但一定會被鄙視。（凡是自己起的名字都要遵守以下規范）
1. 以數字，字母，下划線和$符號組成，其中不能以數字開頭；
2.不能和java中的關鍵字重名；
3.盡量遵守見名知意和駝峰命名（有多個單詞首個單詞首字母小寫后面單詞首字母大寫）規則。
public static void main(String[] args) {
//1聲明
int money;
//2賦值
money=100;
/**
* 第一第二兩步合並
* 聲明變量的時候變量名不能重復
*/
int m = 100;
String name="張三";
int age =27;
double score=89.0;
//是否及格 使用 true : 及格 false:不及格
boolean flag =true;
//3使用
System.out.println("和"+age+score);
System.out.println("金額:："+money);
System.out.println("姓名："+name);
System.out.println("年齡："+age);
System.out.println("分數："+score);
}
1.5 常見錯誤
未聲明且賦值直接使用
標記位置序錯誤
在同一個作用域中聲明了相同名字的變量名
2.常量
2.1 為什么使用常量
在實際開發和生活中有些值是一開始定義了在后面就不能修改的，如:圓周率
2.2 定義：
一個存儲空間的表示，其值是不可以發生變化的。
final修飾常量，final修飾的值在聲明的時候就賦值且后面不能改變（在數據類型前加final 如 final int）
2.3 優點：
一旦定義后期不能修改，所以其是相對安全的
2.4 命名規則：
優點：
一旦定義后期不能修改，所以其實相對安全的
推薦做法：
常量名通常大寫；
只能被賦值一次，通常定義時即對其初始化
常量名都要大寫，如果是多個單詞組成，則使用下划線分割
public static void main(String[] args) {
// TODO Auto-generated method stub
/**
* 常量的案列演示
* 計算圓的面積
*/
final double MY_PI =3.14;
/*pi=3;*/
double r=2;
double area=MY_PI * r * r;
System.out.println("面積是："+area);
}
3.數據類型
分類：
3.1 基本數據類型：
1、數值型
1）整型（可以存放整數）：
byte(1個字節)
short(2個字節)
int(4個字節) （默認使用）
long(8個字節)
2）浮點型（表示小數）：
float(4個字節)
double(8個字節) （默認使用）
2、非數值型
1）字符型—————需要給值加上單引號，只能存一個字符
char(2個字節)：本質上是一個整數，是字符的Unicode碼值
2）布爾型————結果只有兩種 true/false
boolean
3.2 引用數據類型：
1）String：可以存儲多個字符使用雙引號引起來
2）數組
3）枚舉
4.運算符
分類：
4.1 賦值運算符：
賦值符號：= 將右邊的值賦給左邊的變量
變量名 =表達式；
表達式舉例：
4.2 算術運算符：
符號：+ - * / % ++ --
++放在變量前指先加1在使用；放在變量后指先使用在加1
--放在變量前指先減1在使用；放在變量后指先使用在減1
%指求余數
num+=2;(意思為num=num+2;)
public static void main(String [] args){
//++ --
int a=4;
int b=2;
int c=5;
/*
System.out.println((a+b));
System.out.println((a-b));
System.out.println((a*b));
System.out.println((a/b));
System.out.println((a+b));
System.out.println((a+b));*/
System.out.println(a++);//輸出結果為4
System.out.println(a);//輸出結果為5
System.out.println(++a);//輸出結果為6
System.out.println(c%b);//輸出結果為1
}
4.3 關系運算符
| 運算符 | 含義 | 舉例 | 結果 |
|---|---|---|---|
| == | 等於 | 5==6 | false |
| != | 不等於 | 5!=6 | true |
| > | 大於 | 5>6 | false |
| < | 小於 | 5<6 | true |
| >= | 大於等於 | 5>=6 | false |
| <= | 小於等於 | 5<=6 | true |
注意：
= 為賦值運算符，== 等於運算符
表達式返還給我們的結果類型都是boolean 類型
4.4 邏輯運算符：
| 運算符 | 含義 | 運算規則 |
|---|---|---|
| && | 短路與 | 兩個表達式結果都是true結果才是true |
| || | 短路或 | 只要有一個為true 結果就為true |
| ! | 取反 | 將原來表達式結果取反 |
| & | ||
| | |
| A | B | A&&B | A||B |
|---|---|---|---|
| T | T | T | T |
| T | F | F | T |
| F | T | F | T |
| F | F | F | F |
&& 一假必假
|| 一真必真
public static void main(String[] args) {
// TODO Auto-generated method stub
int a=4;
int b=2;
int c=5;
//a>b為T,b>c為F 所以a>b||b>c為T；a<c為T所以整個表達式為T
System.out.println(a>b || b>c && a<c);
}
4.5 三目（元）運算符（條件運算符）：
語法：
boolean表達式？ 表達式1:表達式2;
當boolean表達式的結果為true的時候 執行表達式1
當boolean表達式的結果為false的時候 執行表達式2
案例：
int a=5;
int b=10;
int c= a>b? 0:1;
System.out.println(c);//結果為1
int a=5;
int b=10;
String c= a>b? "正確":"錯誤";
System.out.println(c);//結果為錯誤
返回值的數據類型需要和執行的表達式的數據類型一致
運算符優先級
5.類型轉換
5.1 自動類型轉換
好比生活中有兩個水杯，一個大的一個小的，如果將裝滿水的小杯中水倒入空的大杯，是可以的，類似於這樣的場景在java中稱之為自動類型轉換
案例1：
double first=81.99;
int duo=2;
double seconde=first+duo;
案例2：
問題: 某班第一次Java考試平均分81.29，第二次比第一次多2分，計算第二次考試平均分？
double firstAvg=81.29;
double secondAvg;
int rise=2;
secondAvg=firstAvg+rise; //一個double類型和一個int類型
System.out.println(secondAvg); // 結果是double類型 83.29
規則：
①在整個表達式中，如果有double數據類型的話，則整個表達式的結果會自動的提升為double類型
②在自動類型轉換的表達式中數據類型需要兼容。如：都是數值型
③目標類型要大於原類型
5.2 強制類型轉換
好比生活中有兩個水杯，一個大的一個小的，如果將裝滿水的大杯中水倒入空的小杯，是可以的但是會溢出，類似於這樣的場景在java中稱之為自強制類型轉換
語法：
數據類型 變量名=（數據類型）（表達式）；————是先運算表達式，然后將結果轉換
如：int seconde=(int) (first+duo); 或 int seconde=(int) (first）+duo;————先將first轉換為int類型在計算，最后將結果轉換為int類型
缺點：丟失精度，尤其在財務等方面慎用！！！（double轉int 丟失的是小數點后面的所有值不是四舍五入）
案例1：
double first=81.99;
int duo=2;
int seconde=(int) (first+duo);//結果是83
案例2：
問題：
去年Apple筆記本所占市場份額是20，今年增長的市場份額是9.8，求今年所占份額？
解析：
int before = 20; //apple筆記本市場份額
double rise = 9.8; //增長的份額
編譯出錯的情況：
int now =before + rise; //不能完成自動類型轉換
更改為; int now =before+(int)rise; //強制類型轉換
5.3 boolean類型
使用場景：
當我們遇到 真 或者 假 , 是 或者 否,類似於這樣兩種情況的時候可以使用boolean類型的值
boolean 類型的值:false 和 true
如何使用：
案例問題：從控制台輸入張三同學的成績，與李四的成績（80分）比較，輸出“張三的成績比李四的成績高嗎?“ 的判斷結果
6.Scanner
引入:之前我們都是在程序中定義變量，但是如果想讓用戶從鍵盤輸入怎么辦呢?就需要使用Scanner
作用：接收用戶在鍵盤輸入的值
使用步驟：
①導包
import java.util.Scanner; / import java.util.*; (java.util是包名 Scanner是類名，
如果用*則表示取java.util包下的所有類，兩種方法都行)
ps:在Eclipse中導包的快捷鍵：Ctrl + Shift + O。初學者不建議導，熟練之后再運用快捷鍵更佳！！！
②創建Scanner 對象
Scanner tx = new Scanner (System.in);
③使用 常用方法
接收int型 int age= tx.nextInt();
接收double型 double score=tx.nextDouble();
接收String類型 String name=tx.next();
注意
第二步中新建的Scanner中用的什么名（tx）第三步中就用什么名
由於工具的原因，在編寫提示語的時候將ln去掉；如將System.out.println("請輸入年齡：");的ln去掉即為System.out.print("請輸入年齡：");
package cn.kgc.tx.ketang;
//1、導包
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args) {
// TODO Auto-generated method stub
//2、創建Scanner 對象
Scanner tx = new Scanner (System.in);
//3、使用
System.out.print("請輸入年齡：");
int age=tx.nextInt();
System.out.print("請輸入姓名：");
String name=tx.next();
System.out.print("請輸入分數：");
double score=tx.nextDouble();
System.out.print("年齡是："+age+"，姓名是："+name+"，分數是："+score);
}
}
7.包的使用
新建的包都使用小寫字母組成，不能有中文或者特殊符號
新建的包使用公司域名去掉3w其他內容倒寫，如 www.kgc.cn cn.kgc.公司定義
新建的每個類我們使用的每個單詞的首字母大寫
在每個類中都會有且只有一個 package+包的名字（且在代碼的第一行）
3.1基本選擇結構
語法：
if(布爾類型的條件){
如果條件為真，則執行
}
條件為假的時候執行大括號后面的內容
if () { // 括號里必須是布爾條件表達式
//代碼塊，只有一條語句的時候大括號可以省略，但是不建議那么做
}
流程圖
案例：
如果張浩的Java考試成績大於98分，張浩就能獲得一個MP4作為獎勵
//解析：題目中有 如果 ....就.... 其實是對應我們英文中的單詞就可以使用 if 選擇結構完成
public static void main(String[] args){
// 如果 。。。java>98
//就有獎勵
double javaScore=100;
if(javaScore >98){
//條件為真則執行這里再向下執行
System.out.println("有一個硬盤獎勵");
}
//條件結果為假的話，直接跳到這里執行
System.out.println("程序結束");
}
3.2復雜程序結構
主要是和我們的各種運算符相互結合使用
如：張浩的Java成績大於98分，而且音樂成績大於80分，老師會獎勵他；或者Java成績等於100分，音樂成績大於70分，老師也會獎勵他
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner tx=new Scanner(System.in);
System.out.print("張浩的Java成績是：");
int javaScore=tx.nextInt();
System.out.print("張浩的音樂成績是：");
int musicScore=tx.nextInt();
if((javaScore>98&&musicScore>80)||(javaScore==100&&musicScore>70)){
System.out.println("獎勵張浩一個MP5");
}
System.out.println("程序結束");
}
if-else
為什么使用if-else ?
使用傳統的if選擇結構也可能完成如果否則之類的問題，但是可能造成代碼的冗余，浪費時間。
案例1：
如果張浩Java考試成績大於98分，老師就獎勵他一個MP4，否則老師就罰他進行編碼
解析：我們可以使用兩個 if 選擇結構。如：
if (score > 98) {
System.out.println("老師說:不錯，獎勵一個MP4！");
}
if (score <= 98) {
System.out.println("老師說:懲罰進行編碼！");
}
但是這樣容易出現一個問題（可以打斷點執行看）：
程序都是從上至下執行的，如果第一個條件不滿足執行后面的程序沒問題，但是如果第一個條件已經成立，后面的不需要執行，但是這種兩個if條件寫的程序，第一個條件不管是否成立都會執行
就影響性能
如何解決呢？請看后續腦圖...
案例2：
if(zhangScore>98){
System.out.println("獎勵一個MP4");
}
//使用之前的基本選擇結構可以做，但是可能會造成代碼的冗余
//執行的效率就降低了
if(zhangScore<60){
System.out.println("俯卧撐30個");
}
所以我們使用 if-else
語法：
if(){ //布爾類型的表達式
//條件為真進入執行代碼塊1
}else{
//條件為假進入代碼塊2
}
流程圖：
案例：
if(zhangScore>98){ //如果張浩成績大於98有獎勵
System.out.println("獎勵一個MP4");
}else { //否則俯卧撐30個
System.out.println("俯卧撐30個");
}
多重if選擇結構
為什么使用多重if
在我們的之前學習過程中，都是判斷兩種情況，不是怎么樣就是怎么樣。在實際生活中是可能出現區間選擇的，如：分數的評級
成績>=80 ：良好 成績>=60 ：中等成績<60 ：差
類似這樣，單個的if無法完成，多個if又比較麻煩，那就可以使用我們即將學習的多重 if
語法：
if(){
}else if(){
}else if(){
}else{
}
流程圖：
案例：
//對學員的結業考試成績評測 成績>=80 ：良好 成績>=60 ：中等 成績<60 ：差
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner tx=new Scanner(System.in);
System.out.print("請輸入考試成績：");
int score=tx.nextInt();
if(score>=80){
System.out.println("良好");
}else if(score>=60){
System.out.println("中等");
}else {
System.out.println("差");
}
}
在我們執行的程序過程中，程序是自上而下執行的，所以條件判斷的時候，會在第一個判斷條件滿足的時候停下並執行，后面的內容就不會再執行了
所以，在條件判斷的時候，條件的語句順序不能隨便的寫，要按照一定的順序
嵌套if選擇結構
案例引入：
男：今晚我們去看電影吧？
女：好啊，不過晚於6點還有其他事就不去了
分析：女是答應去的，但是有前提條件就是不能遲於6點鍾
這里就相當於有兩個if條件,第一個條件滿足才會執行后面的內容
語法：
if(條件1){
if(條件2){
// 代碼塊1 當兩個if都滿足時才運行
}else{
//代碼塊2
}
}else{
//代碼塊3
}
流程圖：
案例：
問題：學校舉行運動會，百米賽跑跑入10秒內的學生有資格進決賽，根據性別分別進入男子組和女子組
分析：如果進入決賽 再看是男還是女，如果是男進入男子組女就進入女子組。這就使用到了嵌套if選擇結構
@Test
public void demo8(){
System.out.print("請輸入你的跑步成績：");
//輸入成績
double score=tx.nextDouble();
//對成績進行判斷
if(score<=10){
//如果成績合格在判斷性別
System.out.print("請輸入你的性別：");
String sex=tx.next();
//判斷性別
if(sex.equals("男")){
System.out.println("恭喜進入男子組決賽");
}else if(sex.equals("女")){
System.out.println("恭喜進入女子組決賽");
} else {
System.out.println("輸入錯誤");
}
}else{
System.out.println("很遺憾你沒有進入決賽");
}
}
案例2
1.輸入小明的考試成績，顯示所獲獎勵。成績==100分，爸爸給他買輛車
100分>成績>=90分，媽媽給他買MP4 ； 90分>成績>=60分，媽媽給他買本參考書 ；成績<60分，什么都不買
Scanner input = new Scanner(System.in);
int score = input.nextInt(); // 接收成績
if (score == 100) {
System.out.println("他爸爸給他買輛車");
} else if (score >= 90) {
System.out.println("他媽媽給他買MP4");
} else if (score < 90 && score >= 60) {
System.out.println("他媽媽給他買本參考書");
} else {
System.out.println("什么都不買");
}
2.
Scanner input = new Scanner(System.in);
System.out.println("請輸入是否是會員：是（y）/否（其他字符）");
String identity = input.next();
System.out.println("請輸入購物金額：");
double money = input.nextDouble();
if(identity.equals("y")){ //會員
if(money>200){
money = money * 0.75;
}else{
money = money * 0.8;
}
}else{ //非會員
if(money>100){
money = money * 0.9;
}
}
System.out.println("實際支付：" + money);
3.
/* 輸入會員積分 */
System.out.print("請輸入會員積分： ");
Scanner input = new Scanner(System.in);
int custScore = input.nextInt();
double discount;
/* 判斷折扣 */
if (custScore < 2000) {
discount = 0.9;
} else if (2000 <= custScore && custScore < 4000) {
discount = 0.8;
} else if (4000 <= custScore && custScore < 8000) {
discount = 0.7;
} else {
discount = 0.6;
}
System.out.println("該會員享受的折扣是：" + discount);
switch選擇結構
語法：
switch(表達式){ //表達式為 int、short、byte、char、枚舉、String類型
case常量1: //計算表達式的值
語句; //如果等於常量1
break;
case常量2:
語句; //如果等於常量2
break;
……
default:
語句; //如果沒有找到匹配的值
break;
}
注意：
switch后面只能跟6種類型
3種整數型：byte、short、int
兩個字符相關：char、String
一個枚舉型
字符串需要在jdk7.0之后才能使用
案例1:
韓嫣參加計算機編程大賽: 如果獲得第一名，將參加麻省理工大學組織的1個月夏令營;如果獲得第二名，將獎勵惠普筆記本電腦一部;如果獲得第三名，將獎勵移動硬盤一個;否則，不給任何獎勵
@Test
public void demo3(){
int mc=2;
if(mc==1){
System.out.println("夏令營");
}else if(mc==2){
System.out.println("電腦");
}else if(mc==3){
System.out.println("硬盤一個");
}else{
System.out.println("明年繼續努力");
}
System.out.println("程序結束");
}
以上是使用多重if選擇結構的完成，但是從代碼的結構上看，顯得代碼冗余，結構復雜，有多次的等值判斷。
為了解決上述問題，我們引出switch的選擇結構
/**
* 1.常量名不可重復
* 2.每一個case后面要有break結束語
* 3.default可以在任何位置，除了在最后break可以省略在其他位置都不可省略（題意要求的除外）
* 建議都放在最后
* 4.switch后面的表達式類型只能是int byte short char 枚舉 和jdk1.7以后的String
* 5.case后面的常量不是一定要連續的
* 6.表達式是哪個就會跳轉到相對於的case語句
*/
int mingCi=2;
switch(mingCi){
case 1:
System.out.println("參加夏令營活動");
break;
case 2:
System.out.println("獎勵筆記本一部");
break;
case 3:
System.out.println("獎勵移動硬盤一個");
break;
default:
System.out.println("沒有獎勵");
break;
}
System.out.println("程序結束");
if選擇結構和switch選擇結構的使用場景
if選擇結構我們一般都是使用在區間判斷上，而switch選擇結構一般是作用在等值判斷
案例2：
@Test
public void demo9(){
System.out.print("輸入1到7選擇周一到周日大禮包：");
String num=tx.next();
switch(num){
case "1":
System.out.println("早上8點起床寫代碼");
break;
case "2":
System.out.println("早上9點起床寫代碼");
break;
case "3":
System.out.println("早上8半點起床寫代碼");
break;
case "4":
System.out.println("早上7點半起床寫代碼");
break;
case "5":
System.out.println("早上7點起床寫代碼");
break;
case "6":
System.out.println("寫代碼寫到晚上12點");
break;
case "7":
System.out.println("早上8點起床寫代碼");
break;
default:
System.out.println("別想逃，輸別的沒有用的");
break;
}
switch常見錯誤
常見錯誤1：
比較switch和多重if選擇結構
相同點
都是用來處理多分支條件的結構
不同點
if多用於區間的判斷
switch用於等值條件的判斷
用switch能做的，用if都能做，但反過來則不行
選擇結構的總結
到目前為止我們學習過五種選擇結構：
基本if選擇結構： 處理單一或者組合條件的情況
if-else選擇結構：處理簡單的條件分支情況
多重if選擇結構：處理復雜的條件分支情況
嵌套if選擇結構：用於較為復雜的流程控制
switch:選擇結構：多重分支並且條件判斷是等值判斷的情況。
如何處理系統異常
使用hasNextInt()解決問題2
Scanner input = new Scanner(System.in);
//如果輸入的是數字
if (input.hasNextInt()) {
int num = input.nextInt();
switch (num) {
case 1:
//顯示系統主菜單；
break;
case 2:
System.out.println("謝謝您的使用！"); break;
default:
System.out.println("輸入錯誤。");break;
}
} else { //如果輸入的不是數字
System.out.println("請輸入正確的數字！");
}
為什么使用循環：
在達到同樣的效果的同時可以用較簡潔的代碼
public void demo1(){
//直接打印：易錯、代碼量多、效率低
System.out.println("好好學習第一遍");
System.out.println("好好學習第二遍");
System.out.println("好好學習第三遍");
System.out.println("好好學習第四遍");
}
使用循環即可解決
概念：
一直重復做的有開始有結束的事
循環的特征：
循環條件：開始結束的條件
循環操作：一直需要重復做的事
循環變量：能夠對循環條件的結果產生影響的量
4.1 while循環
特點：
先判斷，后執行
如果循環條件開始就不符合的時候，循環操作一遍也不會執行
語法：
while(循環條件//boolean類型表達式){
循環操作
}
流程圖：
案例1：
/*打印50份試卷
* 循環特征：
* 循環條件：開始結束的條件
* 循環操作：一直需要重復做的事
* 循環變量：能夠對循環條件的結果產生影響的量
*/
@Test
public void demo3(){
int a=1;
while (a<=50){ //循環條件
//循環操作
System.out.println("打印第"+a+"份試卷");
a++; //循環變量
}
}
案例2（while循環進階）：
分析：明確是否能用循環做？若能，明確循環結構需要的量。String類型的比較用equals()
@Test
Scanner sc = new Scanner(System.in);
System.out.println("老師我合格了么（y/n）: ");
String answer=sc.next();
while(answer.equals("n")){
System.out.println("上午閱讀教材，下午上機操作");
System.out.println("老師我合格了么？（y/n）: ");
answer=sc.next();
}
System.out.println("程序結束");
4.2 do—while循環
為什么需要使用do—while循環？
在生活中往往會有一些事情是需要我們先做然后再去判斷的。如：期末考試之前需要先學習一個學期
語法：
do{
循環操作
}while(循環條件)；//循環條件時boolean類型
流程圖：
執行特點：
先執行，后判斷。
條件為假，也至少執行一次循環操作
案例：
經過幾天的學習，老師給張浩一道測試題，
讓他先上機編寫程序完成，
然后老師檢查是否合格。如果不合格，則繼續編寫。……
@Test
public void demo1(){
String answer;
do {
//循環操作
System.out.println("先上機考試");
System.out.println("老師我合格了嗎？");
answer=tx.next();
}while ("n".equals(answer));
System.out.println("程序結束");
}
while 和do...while的區別：
不同點：
語法不同；
執行次序不同；
初始情況不滿足條件時；
while循環一次都不執行；
do-while循環不管任何情況都會執行一次。
4.3 for循環（難點）
為什么使用for循環：
有很多問題用我們之前的whie循環是可以的，也可以使用我們現在for循環，類似於運動員有的擅長跑，有的擅長短跑，但是都是長跑的。我們的循環也是一樣，只是他們都有自己擅長的領域。對比for循環的結構和while循環的結構，其實結構都是一樣
的只是每個部分所在的位置有所不同，之前所在的是多行的內容現在放到一個括號里面了。
代碼更簡潔：while循環中有的表達式在for中都有
適用場景：循環次數固定的情況下使用
語法：
for(初始化循環變量;循環條件;修改循環變量的值){
循環操作
}
易錯點：
初識化循環變量可以省略但是需要在for上面寫
循環條件和修改循環變量的值不能省略否則會死循環
初始化循環變量、循環條件、修改循環變量的值都不寫的話（分號不能省）會死循環
案例：
商場對顧客的年齡層次進行調查
計算各年齡層次的顧客比例
@Test
public void demo6(){
double num2=0; //聲明30歲以下人員數
double num3=0; //聲明30歲以上人員數
for (int i=1;i<=10;i++){
System.out.print("請輸入第"+i+"位顧客的年齡：");
int num1=tx.nextInt();
if (num1<=30){
num2++;
}else {
num3++;
}
}
System.out.println("30歲以下的比列是："+(num2/(num2+num3)));
System.out.println("30歲以上的比列是："+(num3/(num2+num3)));
}
4.4 break和continue的不解之緣
含義：
break：終止本循環，繼續向后執行
continue：終止本次循環，繼而執行下一次的循環操作
break作用：
改變程序控制流
用於do-while、while、for中時，可跳出循環而執行循環后面的語句
break通常在循環中與條件語句一起使用
continue作用:
中斷此次循環，繼續下次循環
continue通常與條件語句一起使用加速循環
案例：
break：
循環錄入某學生5門課的成績並計算平均分。如果某分數錄入為負，停止錄入並提示錄入錯誤
循環錄入成績，判斷錄入正確性。錄入錯誤，使用break語句立刻跳出循環；否則，累加求和
@Test
public void demo7(){
int sum=0; //成績總和
boolean flag=false; // false 表示輸入的分數不是負數 true表示輸入的分數是負數
for (int i=0;i<5;i++){
System.out.print("請輸入第"+(i+1)+"門課的成績：");
//循環錄入的成績
int score=tx.nextInt();
if (score<0){
flag =true;
break;
}
sum=sum+score;
}
if(flag){
System.out.println("輸入錯誤");
}else {
int avg= sum/5;
System.out.println("平均分為："+avg);
}
}
continue：
@Test
/*
* 循環錄入Java課的學生成績，統計分數大於等於80分的學生比例
*/
public void demo9(){
int sum=0; //用來累加學生人數的變量
System.out.print("班級總人數為：");
int penNo=tx.nextInt();
for (int i=1;i<=penNo;i++){
System.out.print("輸入第"+i+"位學生的成績：");
double score=tx.nextDouble();
if (score<80){
continue;
}
sum++;
}
double a=(double)sum/penNo*100;
System.out.println("80分以上的學生個數為："+sum);
System.out.println("80分以上學生占比為："+a+"%");
}
對比break和continue：
使用場合：
break常用於switch結構和循環結構中
continue一般用於循環結構中
作用（循環結構中）：
break語句終止某個循環，程序跳轉到循環塊外的下一條語句
continue跳出本次循環，進入下一次循環
Ps:補充：return 結束當前方法的執行並退出，返回到調用該方法的語句處。
4.5 調試
為什么需要調試 : 在程序的開發過程中難免會有錯誤，但是我們不好發現和定位錯誤，所以我們需要調試
怎么調試，程序的執行一閃而過我們想讓其慢點，就可以使用斷電。步驟為：
1.分析錯誤，設置斷點
2.啟動調試: debug as
3.單步運行: F6
4.觀察變量.
5.發現問題，解決問題
為什么需要使用數組：
當有多個數值的時候.需要定義多個變量，較為麻煩，使用數組的話只需要定義一個變量直接開辟一串空間
什么是數組：
數組是一個變量，存儲相同數據類型的一組數據
數組和變量的對比：
變量:聲明一個變量就是在內存中開辟一個合適大小的空間
數組:聲明一個數組就是在內存中開辟一連串的連續空間
數組基本要素：
標識符：
數組的名稱，用於區分不同的數組
數組元素：
向數組中存放的數據
元素下標：
對數組元素進行編號，從0開始，數組中的每個元素都可以通過下標來訪問
元素類型：
數組元素的數據類型
注意：
聲明一個變量就是在內存空間划出一塊合適的空間
聲明一個數組就是在內存空間划出一串連續的空間
數組長度和類型一旦定義不會改變
數組中的所有元素必須屬於相同的數據類型
如何使用數組：
1、聲明數組
數組類型 數組名 [];
數組類型[] 數組名; //常用寫法
int[] a;
int a[];
String[] name;
2、分配空間(告訴計算機分配幾個連續的空間)
數組類型[] 數組名 = new 數據類型[大小];
a=new int[5];
3、賦值（向分配的格子里放數據）
數組名[元素下標] =要賦的值;
a[0]=8;
賦值：
一、邊聲明邊賦值：賦值的時候給了幾個值，數組的長度就是多少
數組類型[] 數組名 = {x ; y ; z};
int[ ] score = {89, 79, 76};
數組類型[] 數組名 = {x ; y ; z};
int[ ] score = new int[ ]{89, 79, 76};
二、動態的從鍵盤錄入信息並賦值（需要先定義數組長度）
Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
score[i] = input.nextInt();
}
4、處理數據
a[0]=a[0]*10;
案例：
//計算5位學生的平均分：
int [ ] score = {60, 80, 90, 70, 85};
double avg;
avg = (score[0] + score[1] + score[2] + score[3] + score[4])/5;
但是如果像上面寫法的話還是會有弊端的，如：學生的個數有變動，那我們的循環次數和求平均分的時候除以的數都需要修改，我們有一個方法避免修改多處
動態的獲取數組的長度。 score.length
5、常見錯誤
編譯出錯：沒寫明數組的大小：int [] score= new int[];
編譯出錯：數組下標越界：int [] score= new int[2];
score[0]=11;
score[1]=11;
score[2]=11; //下標越界了
編譯出錯：數組的聲明和賦值在多行：
int [] score;
score={11,22,33,21};
6.、Arrays類
| 返回值類型 | 方法名稱 | 說明 |
|---|---|---|
| boolean | equals(array1,array2) | 比較array1和array2兩個數組是否相等 |
| sort(array) | 對數組array的元素進行升序排列 | |
| String | toString(array) | 將一個數組array轉換成一個字符串 |
| fill(array,val) | 把數組array所有元素都賦值為val | |
| 原數組什么類型復制的新數組也是什么類型 | copyOf(array,length) | 把數組array復制成一個長度為length的新數組，返回類型與復制的數組一致 |
| int | binarySearch(array, val) | 查詢元素值val在數組array中的下標（要求數組中元素已經按升序排列） |
案例：
@Test
public void test05(){
int[] array1 ={12,21,13};
int[] array2 ={12,21,13};
int[] array3 ={12,21,13,24};
//int binarySearch(array, val) 查詢元素值val在數組array中的下標（要求數組中元素已經按升序排列）
Arrays.sort(array3);
int i =Arrays.binarySearch(array3,13);
System.out.println(i);
//copyOf(array,length) 把數組array復制成一個長度為length的新數組，返回類型與復制的數組一致
/*int array4[] =Arrays.copyOf(array3,6);
System.out.println(Arrays.toString(array4));*/
/*//void fill(array,val) 把數組array所有元素都賦值為val
Arrays.fill (array3,22);
System.out.println(Arrays.toString(array3));
//sort(array) 對數組array的元素進行升序排列
//String toString(array) 將一個數組array轉換成一個字符串
Arrays.sort(array3);
System.out.println(Arrays.toString(array3));
// boolean equals(array1,array2); 比較 array1 和 array2 是否相等
boolean a=Arrays.equals(array1,array2);
boolean b=Arrays.equals(array1,array3);
System.out.println(a+","+b);*/
}
7、多維數組
為什么學習多維數組:如遇5個班各5名學生的信息
概念:從內存角度看只有一-維數組，java是支持多維數據的但是二維以上的數組很少使用，只要用二維數組
二維數組:其實是數組的數組
語法：
<數據類型> [ ][ ] 數Ä名; 或者 <數據類型> 數Ä名 [ ][ ];
int [ ][ ] scores; //定義二維數組
scores=new int[5][50]; //分配內存空間
或者
int [ ][ ] scores = new int[5][50];
常見問題
定義二維數組時，要定義最大維數：
int [ ][ ] scores = new int[5][]; 后面的中括號是可以省略的
int [ ][ ] scores = new int[][]; 不能省略前面的或者都省略
二維數組實際上是一個一維數組，它的每個元素又是一個一維數組
賦值
int[][] scores=new int[3][5];
score[0][0]=90;
score[2][3]=70;
方法一：
int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
方法二：
int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } };
最后再補充一點關於equals 和 == 的區別哈！！！
== 和 equals 的區別是？
==
既可以比較數值類型，也可以比較引用數據類型。當比較的是數值類型的時候比較的是值比較的是引用數據類型的是后，比較的就是地址值
equals
如果沒有對equals方法進行重寫的時候，比較的方式和==是一樣的，如果重寫的則按照重寫的方式進行比較
在使用equals 的時候我們將肯定有值的變量寫在前面，避免空指針異常的出現
案例：
@Test
public void test2(){
String i =null;//String 的默認值 為空
if (i.equals("")){
System.out.println("合格");
}
System.out.println("程序結束");
}//此時運行會報錯
@Test
public void test2(){
String i =null;
if ("".equals(i)){
System.out.println("合格");
}
System.out.println("程序結束");
}//換位后運行正常
七、循環結構進階
1、為什么使用二重循環:
重復做的事使用循環那如計算3個班級各5名學生的成績平均分就需要兩個循環
2、什么是二重循環:
簡單來說，就是循環里面套一個循環
3、方式：
語法：
while的雙重循環
while(循環條件1) {
//循環操作1
while(循環條件2) {
//循環操作2
}
}
do {
//循環操作1
do {
//循環操作2
}while(循環條件1);
}while(循環條件2);
for(循環條件1) {
//循環操作1
for(循環條件2) {
//循環操作2
}
}
while(循環條件1) {
//循環操作1
for(循環條件2) {
//循環操作2
}
}
特點：外層循環一次，內層循環一遍
4、如何使用二重循環：
案例1：
//計算三個班級的四個學生的成績平均分
Scanner sc = new Scanner(System.in);
double score=0;
double sum=0;
for(int i=0;i<3;i++){ //循環的是班級
System.out.println("請輸入第 "+(i+1)+"個班級的學生成績：");
sum=0;
for(int j=0;j<4;j++){ //循環的是班級的每個學生
System.out.println("請輸入第 "+(j+1)+"個學生的成績：");
score=sc.nextDouble();
sum+=score;
}
System.out.println("第 "+(i+1)+"個班級學生的總成績是："+sum);
System.out.println("第 "+(i+1)+"個班級學生的平均分是："+sum/4);
}
:案例2（進階）：
1.打印各種圖形（矩形、直角三角形、倒直角三角形、等腰三角形、平行四邊形、菱形、數字菱形、空心菱形）
打印四邊形的星星
1 提示：外層循環控制行數，內層循環控制列數 2 //打印矩形的星星
3 for(int i=1;i<=5;i++){ 4 for(int j=1;j<=5;j++){ 5 System.out.print("*"); 6 } 7 System.out.println(); 8 }
打印直角三角形的圖案
1 //打印直角三角形
2 Scanner sc = new Scanner(System.in); 3 System.out.println("請輸入三角形的行數："); 4 int num=sc.nextInt(); 5 for(int i=1;i<=num;i++){ 6 for(int j=1;j<=(2*i-1);j++){ 7 System.out.print("*"); 8 } 9 System.out.println(); 10 }
打印倒直角三角形
1 //打印直角三角形
2 Scanner sc = new Scanner(System.in); 3 System.out.println("請輸入三角形的行數："); 4 int num=sc.nextInt(); 5 for(int i=1;i<=num;i++){ 6 for(int j=1;j<=(num+1-i);j++){ 7 System.out.print("*"); 8 } 9 System.out.println(); 10 }
打印等腰三角形（如下圖效果）
1 //打印等腰三角形
2 Scanner sc = new Scanner(System.in); 3 System.out.print("請輸入您要打印的行數："); 4 int num=sc.nextInt(); 5 for(int i=1;i<=num;i++){ 6 for(int j=1;j<=num-i;j++){ 7 System.out.print(" "); 8 } 9 for(int k=1;k<=(2*i-1);k++){ 10 System.out.print("*"); 11 } 12 System.out.println(); 13 }
1 //輸出平行四邊形
2 for(int i = 0;i<5;i++){ 3 //循環輸出空格
4 for(int j=0;j<5-i-1;j++){ 5 System.out.print(" "); 6 } 7 //循環輸出*
8 for(int k = 0;k<=5;k++){ 9 System.out.print("*"); 10 } 11 System.out.println(); 12 }
打印菱形
1 //輸出菱形 2 //先輸出等腰三角形
3 for(int i = 1;i<=5;i++){ 4 //循環輸出空格
5 for(int j=5-i;j>0;j--){ 6 System.out.print(" "); 7 } 8 //循環輸出*
9 for(int k = 0;k<2*i-1;k++){ 10 System.out.print("*"); 11 } 12 System.out.println(); 13 } 14 //再輸出一個4行的倒三角形
15 for(int i = 1;i<=4;i++){ 16 //循環輸出空格
17 for(int j=1;j<=i;j++){ 18 System.out.print(" "); 19 } 20 //循環輸出*
21 for(int k = 0;k<2*(5-i)-1;k++){ // 2*(5-i)-1 9-2i
22 System.out.print("*"); 23 } 24 System.out.println(); 25 }
打印數字菱形
1 //輸出數字菱形 2 //先輸出等腰三角形
3 for(int i = 1;i<=5;i++){ 4 //循環輸出空格
5 for(int j=5-i;j>0;j--){ 6 System.out.print(" "); 7 } 8 //循環輸出*
9 for(int k = 0;k<2*i-1;k++){ 10 System.out.print((5-i)); 11 } 12 System.out.println(); 13 } 14 //再輸出一個4行的倒三角形
15 for(int i = 1;i<=4;i++){ 16 //循環輸出空格
17 for(int j=1;j<=i;j++){ 18 System.out.print(" "); 19 } 20 //循環輸出*
21 for(int k = 0;k<2*(5-i)-1;k++){ // 2*(5-i)-1 9-2i
22 System.out.print(i); 23 } 24 System.out.println(); 25 }
打印空心菱形 
1 //輸出空心菱形 2 //先輸出等腰三角形 3 for(int i = 1;i<=5;i++){ 4 //循環輸出空格 5 for(int j=1;j<= 5-i;j++){ 6 System.out.print(" "); 7 } 8 //循環輸出* 9 for(int k = 1;k<=2*i-1;k++){ 10 if(k==1 || k==2*i-1){ 11 System.out.print("*"); 12 }else{ 13 System.out.print(" "); 14 } 15 } 16 System.out.println(); 17 } 18 //再輸出一個4行的倒三角形 19 for(int i = 1;i<=4;i++){ 20 //循環輸出空格 21 for(int j=1;j<=i;j++){ 22 System.out.print(" "); 23 } 24 //循環輸出* 25 for(int k = 1;k<=2*(5-i)-1;k++){ // 2*(5-i)-1 9-2i 26 if(k== 1 || k==2*(5-i)-1){ 27 System.out.print("*"); 28 }else{ 29 System.out.print(" "); 30 } 31 } 32 System.out.println(); 33 }
2.//若有3個班級各4名學員參賽，計算每個班級參賽學員平均分，統計成績大於80分學員數
Scanner sc = new Scanner(System.in);
double avg=0;
double sum=0;
double score=0;
int num=0;
for(int i=1;i<=3;i++){
System.out.println("請輸入第 "+i+"個班級的成績：");
sum=0;
for(int j=1;j<=4;j++){
System.out.print("請輸入第 "+j+"個同學的成績：");
score=sc.nextDouble();
sum+=score;
if(score<80){
continue;
}
num++;
}
System.out.println("第 "+i+"個班的平均分是："+sum/4);
}
System.out.println("80分以上的學院個數為："+num);
===========================================================
3.循環和break相結合的聯系
Scanner sc = new Scanner(System.in);
String answer="";
int num=0;
for(int i=1;i<=5;i++){
System.out.println("歡迎光臨第 "+i+"家店");
for(int j=1;j<=3;j++){
System.out.print("要離開么（y/n）: ");
answer=sc.next();
if(answer.equals("y")){
System.out.println("離店結賬");
break;
}
num++;
}
}
System.out.println("一共買了 "+num+"件衣服");===========================================================
4. 在數組中添加、修改、刪除數據
1 //在數組中添加數據 2 //首先初始化數組 3 String[] arr = {"iphone4","iphone4s","iphone5",null}; 4 //初始化需要插入的位置下標 5 int index = -1; 6 System.out.print("初始數組為："); 7 for(int i = 0;i<arr.length;i++){ 8 //如果為空，則可以插入 9 if(arr[i] == null){ 10 //把需要插入的下標賦值給index 11 index = i; 12 break; //跳出for循環 13 } 14 System.out.print(arr[i]+" "); 15 } 16 //判斷index是否變化 17 //index不等於-1，說明找到可以插入的位置 18 if(index != -1){ 19 //把插入的輸入賦值給數組的null值，且下標就是index 20 System.out.print("\n請輸入您要插入的數據："); 21 String num = sc.next(); 22 arr[index] = num; 23 }else{ 24 System.out.println("數組已滿，不能插入！"); 25 } 26 //循環遍歷數組 27 System.out.print("插入后的數組為："); 28 for(String arr1:arr){ 29 System.out.print(arr1+" "); 30 } 31 }
1 //在數組中修改信息
2 String[] arr = {"ipone4","ipone4s","ipone5","ipone6"}; 3 //初始化需要修改的數組下標
4 int index = -1; 5 System.out.print("初始數組為："); 6 //循環遍歷數組
7 for(String i:arr){ 8 System.out.print(i+" "); 9 } 10 //判斷是否可以找到需要修改的數據
11 for(int i =0;i<arr.length;i++){ 12 if(arr[i].equals("ipone6")){ 13 index = i; 14 System.out.println("\n您要修改的數據的數組下標為："+index); 15 break; 16 } 17 } 18 //判斷index是否發生變化
19 if(index != -1){ 20 arr[index] = "iphone5s"; 21 }else{ 22 System.out.println("輸入的數據不存在"); 23 } 24 //循環遍歷輸出
25 System.out.print("修改后的數組為："); 26 for(String i:arr){ 27 System.out.print(i+" "); 28 } 29 }
1 //刪除數組中一個數據
2 public void test04(){ 3 //初始化數組
4 String[] arr = {"ipone4","ipone4s","ipone5","ipone7","ipone5s"}; 5 //循環遍歷數組
6 System.out.print("初始數組為："); 7 for(String i:arr){ 8 System.out.print(i+" "); 9 } 10 //初始化需要刪除的數據下標
11 int index = -1; 12 System.out.print("\n請輸入您要刪除的數據："); 13 String deleteData = sc.next(); 14 for(int i = 0;i<arr.length;i++){ 15 //如果在數組中找到了要刪除的數據
16 if(arr[i].equals(deleteData)){ 17 index = i; 18 break; 19 } 20 } 21 //判斷index的值是否改變
22 if(index != -1){ 23 //說明數組中存在輸入的數據，可以刪除 24 //把刪除后的數據整體向前移一位
25 for(int i = index;i<arr.length-1;i++){ 26 arr[i] = arr[i+1]; 27 } 28 //把最后一位置空
29 arr[arr.length-1] = null; 30 }else{ 31 System.out.println("找不到數據，不能刪除！"); 32 return; 33 } 34 //循環遍歷輸出數組
35 System.out.print("刪除后的數組為："); 36 for(String i:arr){ 37 System.out.print(i+" "); 38 } 39 }
===========================================================
5.冒泡排序、選擇排序、插入排序的代碼和對比
1 一共是比較了數組長度的-1輪，每一輪比較的次數都是比上一次少一次 2 //打印冒泡
3 int [] arr={21,77,23,32,1,99}; 4 System.out.println("排序之前："); 5 for(int i=0;i<arr.length;i++){ 6 System.out.print(arr[i]+" "); 7 } 8 System.out.println(); 9
10 for(int i=0;i<arr.length-1;i++){ 11 for(int j=0;j<arr.length-i-1;j++){ 12 if(arr[j]>arr[j+1]){ 13 int temp=arr[j]; 14 arr[j]=arr[j+1]; 15 arr[j+1]=temp; 16 } 17 } 18 } 19 System.out.println("排序之后："); 20 for(int i=0;i<arr.length;i++){ 21 System.out.print(arr[i]+" "); 22 }
1 //插入排序
2 int[] arr = {3,42,54,2,56,7,76}; 3 for(int i =1;i<arr.length;i++){ //從i=1開始比，和arr[0]比。比較的輪數就是arr.length-1，即i從到小於arr.length
4 int temp = arr[i]; //把第一個要比較的數54賦值給temp
5 int j = 0; 6 for(j = i-1;j>=0;j--){ //j就是被比較的數：42，j>=0是從i向前比較，直到數組的下標為0. 7 //判斷temp是否大於被比較的數42
8 if(arr[j] > temp){ 9 //如果temp小於被比較的數42，就要交換位置，即把arr[j]的值賦值給后面一位arr[j+1].此時不用擔心后面的數被覆蓋后找不到， 10 //因為已經賦值給了temp
11 arr[j+1] = arr[j]; //賦值之后返回單for循環，j--，此時j相當於i-2
12 }else{ 13 //如果temp大於別比較的數42，不需要交換位置 .此時break后,j不用--，即j的值沒變
14 break; 15 } 16 } 17
18 //接着判斷是否發生了交換。如果沒有交換，此時arr[j+1] == temp ; 如果交換了,j也減了1,此時arr[j+1] != temp
19 if(arr[j+1] != temp){ 20 //說明發生了交換。則把temp賦值給arr[j+1]
21 arr[j+1] = temp; 22 } 23 } 24 //遍歷輸出數組，檢測
25 for(int i:arr){ 26 System.out.print(i+" "); 27 }
1 //選擇排序 2 //int[] arr = {1,3,42,54,2,56,7,76,4};
3 int index = 0; 4 for(int i = 0;i<arr.length-1;i++){ 5 index = i; //如果第一個數是最小的，第一輪之后，把最小值下標i+1后賦值給index
6 for(int j = i+1;j<arr.length;j++){ 7 if(arr[index]>arr[j]){ 8 index = j; 9 } 10 } 11 if(index != i){ 12 arr[index] = arr[index]+arr[i]; 13 arr[i] = arr[index] - arr[i]; 14 arr[index] = arr[index] - arr[i]; 15 } 16 } 17 for(int i:arr){ 18 System.out.print(i+" "); 19 }
至此，Java基礎語法部分大致完成，下面該是Java的重難點：面向對象！！！下次會給大家帶來更為詳細的關於面向對象的博客，期待小伙伴們的收藏、支持和評論，加油！！！
喜歡前端、后端java開發的 可以到我的知乎主頁(更多詳細內容等你關注呦)：https://www.zhihu.com/people/xing-chen-you-guang-pie-pie-pie，有詳細視頻、資料、教程，文檔，值得擁有！！！希望可以一起努力，加油ヾ(◍°∇°◍)ﾉﾞ！！！
B站有上傳的更多項目視頻，從Java基礎到面向對象、Java高級API，以及SSM等框架的視頻，地址：https://www.bilibili.com/video/BV15a411w7Jh
