1. 語句

1.1 流程控制語句

在一個程序執(zhí)行的過程中，各條語句的執(zhí)行順序?qū)Τ绦虻慕Y(jié)果是有直接影響的。也就是說程序的流程對運行結(jié)果有直接的影響。所以，我們必須清楚每條語句的執(zhí)行流程。而且，很多時候我們要通過控制語句的執(zhí)行順序來實現(xiàn)我們要完成的功能。

流程控制語句分類：順序結(jié)構(gòu)、選擇結(jié)構(gòu)、循環(huán)結(jié)構(gòu)

1.2 順序結(jié)構(gòu)概述

是程序中最簡單最基本的流程控制，沒有特定的語法結(jié)構(gòu)，按照代碼的先后順序，依次執(zhí)行，程序中大多數(shù)的代碼都是這樣執(zhí)行的。

總的來說：寫在前面的先執(zhí)行，寫在后面的后執(zhí)行

1.3 選擇結(jié)構(gòu)

選擇結(jié)構(gòu)也被稱為分支結(jié)構(gòu)。選擇結(jié)構(gòu)有特定的語法規(guī)則，代碼要執(zhí)行具體的邏輯運算進行判斷，邏輯運算的結(jié)果有兩個，所以產(chǎn)生選擇，按照不同的選擇執(zhí)行不同的代碼。

Java語言提供了兩種選擇結(jié)構(gòu)語句：（1）if語句（2）switch語句

1.3.1 選擇結(jié)構(gòu)(if語句)

if語句有三種格式

if語句第一種格式：

if(關(guān)系表達式) {語句體 }

執(zhí)行流程：

• 首先判斷關(guān)系表達式看其結(jié)果是true還是false
• 如果是true就執(zhí)行語句體
• 如果是false就不執(zhí)行語句體

注意事項：

• 關(guān)系表達式無論簡單還是復(fù)雜，結(jié)果必須是boolean類型
• if語句控制的語句體如果是一條語句，大括號可以省略；如果是多條語句，就不能省略。建議永遠不要省略。
• 一般來說：有左大括號就沒有分號，有分號就沒有左大括號

if語句第二種格式：

if(關(guān)系表達式) {語句體1; }else {語句體2; }

執(zhí)行流程：

• 首先判斷關(guān)系表達式看其結(jié)果是true還是false

• 如果是true就執(zhí)行語句體1

• 如果是false就執(zhí)行語句體2

/*if語句格式2的練習(xí)：A:獲取兩個數(shù)據(jù)中較大的值B:判斷一個數(shù)據(jù)是奇數(shù)還是偶數(shù),并輸出是奇數(shù)還是偶數(shù) */ import java.util.Scanner; class IfTest { public static void main(String[] args) { //創(chuàng)建鍵盤錄入對象 Scanner sc = new Scanner(System.in); //獲取兩個數(shù)據(jù)中較大的值 System.out.println("請輸入第一個數(shù)據(jù)："); int a = sc.nextInt(); System.out.println("請輸入第二個數(shù)據(jù)："); int b = sc.nextInt(); //定義一個變量接收最大值 int max; if(a > b) { max = a; }else { max = b; } System.out.println("max:"+max); System.out.println("----------------"); //判斷一個數(shù)據(jù)是奇數(shù)還是偶數(shù) System.out.println("請輸入你要判斷的數(shù)據(jù)："); int x = sc.nextInt(); if(x%2 == 0) { System.out.println(x+"這個數(shù)據(jù)是偶數(shù)"); }else { System.out.println(x+"這個數(shù)據(jù)是奇數(shù)"); } } }

運行結(jié)果：

if語句第三種格式：

if(關(guān)系表達式1) {語句體1; }else if (關(guān)系表達式2) {語句體2; } … else {語句體n+1; }

執(zhí)行流程：

• 首先判斷關(guān)系表達式1看其結(jié)果是true還是false
• 如果是true就執(zhí)行語句體1
• 如果是false就繼續(xù)判斷關(guān)系表達式2看其結(jié)果是true還是false
• 如果是true就執(zhí)行語句體2
• 如果是false就繼續(xù)判斷關(guān)系表達式…看其結(jié)果是true還是false
  …
• 如果沒有任何關(guān)系表達式為true，就執(zhí)行語句體n+1。

/*三種if語句分別適合做什么事情呢?格式1：適合做單個判斷格式2：適合做兩個判斷格式3：適合做多個判斷需求：鍵盤錄入x的值，計算出y的并輸出。x>=3 y = 2x + 1;-1<=x<3 y = 2x;x<=-1 y = 2x – 1;分析：A:由于數(shù)據(jù)要鍵盤錄入，所以必須使用Scanner。B:由于是三種判斷，所以我們選擇if語句格式3。 */ import java.util.Scanner; class IfTest2 { public static void main(String[] args) { //創(chuàng)建鍵盤錄入對象 Scanner sc = new Scanner(System.in); System.out.println("請輸入x的值："); int x = sc.nextInt(); //定義一個y int y; //用if語句格式3進行判斷 if(x >= 3) { y = 2*x + 1; }else if(x>=-1 && x<3) { y = 2*x; }else { y = 2*x - 1; } System.out.println("y:"+y); } }

運行結(jié)果：

switch語句格式：

switch(表達式) {case 值1：語句體1;break;case 值2：語句體2;break;…default：語句體n+1;break; }

格式解釋

• switch表示這是switch語句
  
  • 表達式的取值：byte，short，int，char
  • JDK5以后可以是枚舉
  • JDK7以后可以是String
• case后面跟的是要和表達式進行比較的值
• 語句體部分可以是一條或多條語句
• break表示中斷，結(jié)束的意思，可以結(jié)束switch語句
• default語句表示所有情況都不匹配的時候，就執(zhí)行該處的內(nèi)容，和if語句的else相似。

執(zhí)行流程

• 首先計算出表達式的值
• 其次，和case依次比較，一旦有對應(yīng)的值，就會執(zhí)行相應(yīng)的語句，在執(zhí)行的過程中，遇到break就會結(jié)束。
• 最后，如果所有的case都和表達式的值不匹配，就會執(zhí)行default語句體部分，然后程序結(jié)束掉。

/*用switch語句實現(xiàn)鍵盤錄入月份，輸出對應(yīng)的季節(jié)分析：A:鍵盤錄入一個月份，用Scanner實現(xiàn)B:用switch語句實現(xiàn)即可 */ import java.util.Scanner; class SwitchTest4 { public static void main(String[] args) { //創(chuàng)建鍵盤錄入對象 Scanner sc = new Scanner(System.in); //錄入數(shù)據(jù) System.out.println("請輸入月份(1-12)："); int month = sc.nextInt(); //case穿透 switch(month) { case 1: case 2: case 12: System.out.println("冬季"); break; case 3: case 4: case 5: System.out.println("春季"); break; case 6: case 7: case 8: System.out.println("夏季"); break; case 9: case 10: case 11: System.out.println("秋季"); break; default: System.out.println("你輸入的月份有誤"); } } }

運行結(jié)果：

（3）if語句和switch語句的區(qū)別?
if語句：

• A:針對結(jié)果是boolean類型的判斷
• B:針對一個范圍的判斷
• C:針對幾個常量值的判斷

switch語句：針對幾個常量值的判斷

注意事項：

• case后面只能是常量，不能是變量，而且，多個case后面的值不能出現(xiàn)相同的
• default可以省略嗎?可以省略。一般不建議。除非判斷的值是固定的。
• break可以省略嗎?可以省略，一般不建議。否則結(jié)果可能不是你想要的
• default的位置一定要在最后嗎?可以出現(xiàn)在switch語句任意位置。
• switch語句的結(jié)束條件，遇到break執(zhí)行到程序的末尾

2. 循環(huán)結(jié)構(gòu)

循環(huán)語句可以在滿足循環(huán)條件的情況下，反復(fù)執(zhí)行某一段代碼，這段被重復(fù)執(zhí)行的代碼被稱為循環(huán)體語句，當(dāng)反復(fù)執(zhí)行這個循環(huán)體時，需要在合適的時候把循環(huán)判斷條件修改為false，從而結(jié)束循環(huán)，否則循環(huán)將一直執(zhí)行下去，形成死循環(huán)。

2.1 循環(huán)語句的組成

• 初始化語句：一條或者多條語句，這些語句完成一些初始化操作
• 判斷條件語句：這是一個boolean 表達式，這個表達式能決定是否執(zhí)行循環(huán)體
• 循環(huán)體語句：這個部分是循環(huán)體語句，也就是我們要多次做的事情
• 控制條件語句：這個部分在一次循環(huán)體結(jié)束后，下一次循環(huán)判斷條件執(zhí)行前執(zhí)行。通過用于控制循環(huán)條件中的變量，使得循環(huán)在合適的時候結(jié)束

2.2 for循環(huán)語句格式

for(初始化語句;判斷條件語句;控制條件語句) {循環(huán)體語句; }

執(zhí)行流程

• 執(zhí)行初始化語句
• 執(zhí)行判斷條件語句，看其結(jié)果是true還是false
  
  • 如果是false，循環(huán)結(jié)束
  • 如果是true，繼續(xù)執(zhí)行
• 執(zhí)行循環(huán)體語句
• 執(zhí)行控制條件語句
• 回到B繼續(xù)

注意事項

• 判斷條件語句的結(jié)果是一個boolean類型

• 循環(huán)體語句如果是一條語句，大括號可以省略；如果是多條語句，大括號不能省略。建議永遠不要省略。

• 一般來說：有左大括號就沒有分號，有分號就沒有左大括號

2.3 for語句的練習(xí)

代碼示例：在控制臺輸出所有的”水仙花數(shù)”

/*需求：在控制臺輸出所有的”水仙花數(shù)”分析：我們都不知道什么叫"水仙花數(shù)"，你讓我怎么做呢?所謂的水仙花數(shù)是指一個三位數(shù)，其各位數(shù)字的立方和等于該數(shù)本身。舉例：153就是一個水仙花數(shù)。153 = 1*1*1 + 5*5*5 + 3*3*3 = 1 + 125 + 27 = 153A:三位數(shù)其實是告訴了我們范圍。B:通過for循環(huán)我們就可以實現(xiàn)獲取每一個三位數(shù)但是麻煩是如何獲取這個三位數(shù)的個,十,百位上的數(shù)據(jù)我們?nèi)绾潍@取一個數(shù)據(jù)的個,十,百呢?假設(shè)有個一個數(shù)據(jù):153ge: 153%10 = 3shi: 153/10%10 = 5bai：153/10/10%10 = 1qian：x/10/10/10%10wan: x/10/10/10/10%10...C:讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數(shù)據(jù)比較如果相同，就把該數(shù)據(jù)在控制臺輸出。 */ class ForDemo6 { public static void main(String[] args) { //三位數(shù)其實是告訴了我們范圍。 for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; //讓ge*ge*ge+shi*shi*shi+bai*bai*bai和該數(shù)據(jù)比較 if(x == (ge*ge*ge+shi*shi*shi+bai*bai*bai)) { //如果相同，就把該數(shù)據(jù)在控制臺輸出。 System.out.println(x); } } } }

運行結(jié)果：

代碼示例：回文數(shù)

/*練習(xí)：請在控制臺輸出滿足如下條件的五位數(shù)個位等于萬位十位等于千位個位+十位+千位+萬位=百位分析：A:五位數(shù)就告訴了我們范圍。B:分解每一個五位數(shù)的個，十，百，千，萬位上的數(shù)據(jù)C:按照要求進行判斷即可 */ class ForDemo7 { public static void main(String[] args) { //五位數(shù)就告訴了我們范圍。 for(int x=10000; x<100000; x++) { //分解每一個五位數(shù)的個，十，百，千，萬位上的數(shù)據(jù) int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; int qian = x/10/10/10%10; int wan = x/10/10/10/10%10; //按照要求進行判斷即可 if((ge==wan) && (shi==qian) && (ge+shi+qian+wan==bai)) { System.out.println(x); } } } }

運行結(jié)果：

2.4 while循環(huán)語句格式

基本格式

while(判斷條件語句) {循環(huán)體語句; }

擴展格式

初始化語句; while(判斷條件語句) {循環(huán)體語句;控制條件語句; }

循環(huán)結(jié)構(gòu)(for循環(huán)和while循環(huán)的區(qū)別)

for循環(huán)語句和while循環(huán)語句可以等價轉(zhuǎn)換，但還是有些小區(qū)別的

• 使用區(qū)別：控制條件語句所控制的那個變量，在for循環(huán)結(jié)束后，就不能再被訪問到了，而while循環(huán)結(jié)束還可以繼續(xù)使用，如果你想繼續(xù)使用，就用while，否則推薦使用for。原因是for循環(huán)結(jié)束，該變量就從內(nèi)存中消失，能夠提高內(nèi)存的使用效率。
• 場景區(qū)別：for循環(huán)適合針對一個范圍判斷進行操作,while循環(huán)適合判斷次數(shù)不明確操作

/*練習(xí)：用while循環(huán)實現(xiàn)左邊：求出1-100之和右邊：統(tǒng)計水仙花數(shù)有多少個初始化語句;while(判斷條件語句) {循環(huán)體語句;控制條件語句;}for(初始化語句;判斷條件語句;控制條件語句) {循環(huán)體語句;}*/ class WhileDemo2 { public static void main(String[] args) { //求出1-100之和 //for語句版本 int sum = 0; for(int x=1; x<=100; x++) { sum+=x; } System.out.println("sum:"+sum); System.out.println("--------"); //while語句版本 int sum2 = 0; int y=1; while(y<=100) { sum2+=y; y++; } System.out.println("sum2:"+sum2); System.out.println("--------"); } }

運行結(jié)果：

/*需求：統(tǒng)計水仙花數(shù)有多少個 */ class WhileDemo3 { public static void main(String[] args) { //for循環(huán)版本 int count = 0; for(int x=100; x<1000; x++) { int ge = x%10; int shi = x/10%10; int bai = x/10/10%10; if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == x) { count++; } } System.out.println("count:"+count); System.out.println("------------"); //while循環(huán)版本 int count2 = 0; int y = 100; while(y<1000) { int ge = y%10; int shi = y/10%10; int bai = y/10/10%10; if((ge*ge*ge+shi*shi*shi+bai*bai*bai) == y) { count2++; } y++; } System.out.println("count2:"+count2); } }

運行結(jié)果：

2.4 while循環(huán)和for循環(huán)的區(qū)別?

使用區(qū)別：如果你想在循環(huán)結(jié)束后，繼續(xù)使用控制條件的那個變量，用while循環(huán)，否則用for循環(huán)。不知道用for循環(huán)。因為變量及早的從內(nèi)存中消失，可以提高內(nèi)存的使用效率。

其實還有一種場景的理解:
如果是一個范圍的，用for循環(huán)非常明確。
如果是不明確要做多少次，用while循環(huán)較為合適。舉例：吃葡萄。

class WhileDemo4 { public static void main(String[] args) { //for循環(huán)實現(xiàn) for(int x=0; x<10; x++) { System.out.println("學(xué)習(xí)Java技術(shù)哪家強,中國北京傳智播客"); } //這里不能在繼續(xù)訪問了 //System.out.println(x); //while循環(huán)實現(xiàn) int y = 0; while(y<10) { System.out.println("學(xué)習(xí)Java技術(shù)哪家強,中國北京傳智播客"); y++; } //這里是可以繼續(xù)訪問的 System.out.println(y); } }

2.5 do…while循環(huán)語句格式

基本格式

do {循環(huán)體語句; }while((判斷條件語句);

擴展格式

初始化語句; do {循環(huán)體語句;控制條件語句; } while((判斷條件語句);

注意死循環(huán)：

A:一定要注意控制條件語句控制的那個變量的問題，不要弄丟了，否則就容易死循環(huán)。
B:兩種最簡單的死循環(huán)格式

while(true){...} for(;;){...}

2.6 循環(huán)嵌套

代碼示例：九九表

/*需求：在控制臺輸出九九乘法表。首先我們寫出九九乘法表：1*1=11*2=2 2*2=41*3=3 2*3=6 3*3=91*4=4 2*4=8 3*4=12 4*4=16...1*9=9 2*9=18 3*9=27 ...我們先把這個九九乘法表看出是這樣的一個形狀：*********************************************注意：'\x' x表示任意，這種做法叫轉(zhuǎn)移字符。'\t' tab鍵的位置'\r' 回車'\n' 換行 */ class ForForDemo3 { public static void main(String[] args) { for(int x=0; x<9; x++) { for(int y=0; y<=x; y++) { System.out.print("*"); } System.out.println(); } System.out.println("--------------"); //為了使用數(shù)據(jù)，我們從1開始 for(int x=1; x<=9; x++) { for(int y=1; y<=x; y++) { System.out.print(y+"*"+x+"="+y*x+"\t"); } System.out.println(); } } }

運行結(jié)果：

2.7 跳轉(zhuǎn)控制語句

Java中的goto是保留字，目前不能使用。雖然沒有g(shù)oto語句可以增強程序的安全性，但是也帶來很多不便，比如說，我想在某個循環(huán)知道到某一步的時候就結(jié)束，現(xiàn)在就做不了這件事情。為了彌補這個缺陷，Java就提供了break，continue和return來實現(xiàn)控制語句的跳轉(zhuǎn)和中斷。

break 中斷、continue 繼續(xù)、return 返回

2.7.1 break的使用場景

• 在選擇結(jié)構(gòu)switch語句中
• 在循環(huán)語句中
• 離開使用場景的存在是沒有意義的

2.7.2 break的作用

• 跳出單層循環(huán)
• 跳出多層循環(huán)
  帶標簽的跳出
  格式：標簽名: 循環(huán)語句
  標簽名要符合Java的命名規(guī)則

/*控制跳轉(zhuǎn)語句：break:中斷continue:繼續(xù)return:返回break:中斷的意思使用場景：A:switch語句中B:循環(huán)語句中。(循環(huán)語句中加入了if判斷的情況)注意：離開上面的兩個場景，無意義。如何使用呢?A:跳出單層循環(huán)B:跳出多層循環(huán)要想實現(xiàn)這個效果，就必須知道一個東西。帶標簽的語句。格式：標簽名: 語句 */ class BreakDemo { public static void main(String[] args) { //在 switch 或 loop 外部中斷 //break; //跳出單層循環(huán) for(int x=0; x<10; x++) { if(x == 3) { break; } System.out.println("HelloWorld"); } System.out.println("over"); System.out.println("-------------"); wc:for(int x=0; x<3; x++) { nc:for(int y=0; y<4; y++) { if(y == 2) { //break nc; break wc; } System.out.print("*"); } System.out.println(); } } }

2.7.3 continue的使用場景

• 在循環(huán)語句中
• 離開使用場景的存在是沒有意義的

2.7.4 continue的作用

• 單層循環(huán)對比break，然后總結(jié)兩個的區(qū)別
  
  • break 退出當(dāng)前循環(huán)
  • continue 退出本次循環(huán)
• 也可以帶標簽的使用

/*continue:繼續(xù)使用場景：循環(huán)中。離開此場景無意義。測試，找到和break的區(qū)別：break:跳出單層循環(huán)continue:跳出一次循環(huán)，進入下一次的執(zhí)行練習(xí)題：for(int x=1; x<=10; x++) {if(x%3==0) {//在此處填寫代碼}System.out.println(“Java基礎(chǔ)班”);}我想在控制臺輸出2次:“Java基礎(chǔ)班“break;我想在控制臺輸出7次:“Java基礎(chǔ)班“continue;我想在控制臺輸出13次:“Java基礎(chǔ)班“ System.out.println(“Java基礎(chǔ)班”);*/ class ContinueDemo { public static void main(String[] args) { for(int x=0; x<10; x++) { if(x == 3) { //break; continue; } System.out.println(x); } } }

2.7.5 return關(guān)鍵字

不是為了跳轉(zhuǎn)出循環(huán)體，更常用的功能是結(jié)束一個方法，也就是退出一個方法。跳轉(zhuǎn)到上層調(diào)用的方法。這個在方法的使用那里會在詳細的講解

/*return:返回其實它的作用不是結(jié)束循環(huán)的，而是結(jié)束方法的。 */ class ReturnDemo { public static void main(String[] args) { for(int x=0; x<10; x++) { if(x == 2) { System.out.println("退出"); //break; //continue; return; } System.out.println(x); } System.out.println("over"); } }

3. 方法

3.1 方法概述

假設(shè)有一個游戲程序，程序在運行過程中，要不斷地發(fā)射炮彈(植物大戰(zhàn)僵尸)。發(fā)射炮彈的動作需要編寫100行的代碼，在每次實現(xiàn)發(fā)射炮彈的地方都需要重復(fù)地編寫這100行代碼，這樣程序會變得很臃腫，可讀性也非常差。為了解決代碼重復(fù)編寫的問題，可以將發(fā)射炮彈的代碼提取出來放在一個{}中，并為這段代碼起個名字，這樣在每次發(fā)射炮彈的地方通過這個名字來調(diào)用發(fā)射炮彈的代碼就可以了。上述過程中，所提取出來的代碼可以被看作是程序中定義的一個方法，程序在需要發(fā)射炮彈時調(diào)用該方法即可。

3.2 方法定義及格式

1、簡單的說：方法就是完成特定功能的代碼塊
在很多語言里面都有函數(shù)的定義，函數(shù)在Java中被稱為方法
2、格式：

修飾符 返回值類型 方法名(參數(shù)類型 參數(shù)名1，參數(shù)類型 參數(shù)名2…) {函數(shù)體;return 返回值;}

3.3 方法格式解釋

• 修飾符 比較多，后面會詳細介紹。目前public static
• 返回值類型 用于限定返回值的數(shù)據(jù)類型
• 方法名 一個名稱，為了方便我們調(diào)用方法
• 參數(shù)類型 限定調(diào)用方法時傳入?yún)?shù)的數(shù)據(jù)類型
• 參數(shù)名 是一個變量，接收調(diào)用方法時傳入的參數(shù)
• 方法體 完成功能的代碼
• return 結(jié)束方法以及返回方法指定類型的值
• 返回值 程序被return帶回的結(jié)果，返回給調(diào)用者

3.4 有明確返回值的方法調(diào)用

• 單獨調(diào)用，沒有意義
• 輸出調(diào)用，有意義，但是不夠好，因為我不一定非要把結(jié)果輸出
• 賦值調(diào)用，推薦方式

注意事項：

• 方法不調(diào)用不執(zhí)行
• 方法與方法是平級關(guān)系，不能嵌套定義
• 方法定義的時候參數(shù)之間用逗號隔開
• 方法調(diào)用的時候不用在傳遞數(shù)據(jù)類型
• 如果方法有明確的返回值，一定要有return帶回一個值

3.5 沒有明確返回值的函數(shù)調(diào)用

• 其實就是void類型方法的調(diào)用
• 只能單獨調(diào)用

3.6 方法調(diào)用圖解

3.7 方法重載

• 方法重載概述

  在同一個類中，允許存在一個以上的同名方法，只要它們的參數(shù)個數(shù)或者參數(shù)類型不同即可。

• 方法重載特點

  與返回值類型無關(guān)，只看方法名和參數(shù)列表
  在調(diào)用時，虛擬機通過參數(shù)列表的不同來區(qū)分同名方法

/*比較兩個數(shù)據(jù)是否相等。參數(shù)類型分別為兩個byte類型，兩個short類型，兩個int類型，兩個long類型，并在main方法中進行測試 */ class FunctionTest6 { public static void main(String[] args) { //測試 byte b1 = 3; byte b2 = 4; System.out.println("byte:"+compare(b1,b2)); //測試 short s1 = 5; short s2 = 5; System.out.println("short:"+compare(s1,s2)); //后面的兩個自己測試 } //byte類型 public static boolean compare(byte a,byte b) { System.out.println("byte"); return a == b; } //short類型 public static boolean compare(short a,short b) { System.out.println("short"); return a == b; } //int類型 public static boolean compare(int a,int b) { System.out.println("int"); return a == b; } //long類型 public static boolean compare(long a,long b) { System.out.println("long"); return a == b; } }

運行結(jié)果：

4. 數(shù)組

4.1 數(shù)組概述

需求：現(xiàn)在需要統(tǒng)計某公司員工的工資情況，例如計算平均工資、找到最高工資等。假設(shè)該公司有80名員工，用前面所學(xué)的知識，程序首先需要聲明80個變量來分別記住每位員工的工資，然后在進行操作，這樣做會顯得很麻煩。為了解決這種問題，Java就提供了數(shù)組供我們使用

那么數(shù)組到底是什么呢?有什么特點呢?通過上面的分析：我們可以得到如下兩句話：

• 數(shù)組是存儲多個變量(元素)的東西(容器)
• 這多個變量的數(shù)據(jù)類型要一致

4.2 數(shù)組概念

• 數(shù)組是存儲同一種數(shù)據(jù)類型多個元素的集合。也可以看成是一個容器
• 數(shù)組既可以存儲基本數(shù)據(jù)類型，也可以存儲引用數(shù)據(jù)類型

4.3 數(shù)組的定義格式

格式1：數(shù)據(jù)類型[] 數(shù)組名;
格式2：數(shù)據(jù)類型 數(shù)組名[];
注意：這兩種定義做完了，數(shù)組中是沒有元素值的

4.4 數(shù)組初始化概述

• Java中的數(shù)組必須先初始化,然后才能使用
• 所謂初始化：就是為數(shù)組中的數(shù)組元素分配內(nèi)存空間，并為每個數(shù)組元素賦值
• 數(shù)組的初始化方式
  
  • 動態(tài)初始化：初始化時只指定數(shù)組長度，由系統(tǒng)為數(shù)組分配初始值。
  • 靜態(tài)初始化：初始化時指定每個數(shù)組元素的初始值，由系統(tǒng)決定數(shù)組長度
• 動態(tài)初始化：初始化時只指定數(shù)組長度，由系統(tǒng)為數(shù)組分配初始值

格式：數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)據(jù)類型[數(shù)組長度];
數(shù)組長度其實就是數(shù)組中元素的個數(shù)。
舉例：int[] arr = new int[3];
解釋：定義了一個int類型的數(shù)組，這個數(shù)組中可以存放3個int類型的值。

4.5 Java中的內(nèi)存分配

Java 程序在運行時，需要在內(nèi)存中的分配空間。為了提高運算效率，就對空間進行了不同區(qū)域的劃分，因為每一片區(qū)域都有特定的處理數(shù)據(jù)方式和內(nèi)存管理方式。

• 棧 存儲局部變量
• 堆 存儲new出來的東西
• 方法區(qū) (面向?qū)ο蟛糠种v)
• 本地方法區(qū) (和系統(tǒng)相關(guān))
• 寄存器 (給CPU使用)

4.6 Java中數(shù)組的內(nèi)存圖解

圖解1：定義一個數(shù)組，輸出數(shù)組名及元素。然后給數(shù)組中的元素賦值，再次輸出數(shù)組名及元素。

圖解2：定義兩個數(shù)組，分別輸出數(shù)組名及元素。然后分別給數(shù)組中的元素賦值，分別再次輸出數(shù)組名及元素。

圖解3：定義兩個數(shù)組，先定義一個數(shù)組，賦值，輸出。然后定義第二個數(shù)組的時候把第一個數(shù)組的地址賦值給第二個數(shù)組。然后給第二個數(shù)組賦值，再次輸出兩個數(shù)組的名及元素。

4.7 數(shù)組的初始化

靜態(tài)初始化：初始化時指定每個數(shù)組元素的初始值，由系統(tǒng)決定數(shù)組長度。
格式：數(shù)據(jù)類型[] 數(shù)組名 = new 數(shù)據(jù)類型[]{元素1,元素2,…};
舉例：int[] arr = new int[]{1,2,3};
解釋：定義了一個int類型的數(shù)組，這個數(shù)組中可以存放3個int類型的值，并且值分別是1,2,3。
其實這種寫法還有一個簡化的寫法：int[] arr = {1,2,3};

4.8 數(shù)組操作常見的兩個小問題

• ArrayIndexOutOfBoundsException 數(shù)組索引越界
  訪問到了數(shù)組中的不存在的索引時發(fā)生
• NullPointerException 空指針異常
  數(shù)組引用沒有指向?qū)嶓w，卻在操作實體中的元素時。

4.9 二維數(shù)組概述

二維數(shù)組概述

我們傳智播客的Java基礎(chǔ)班每個班有很多個學(xué)生，所以，可以用數(shù)組來存儲，而我們又同時有很多個Java基礎(chǔ)班。這個也應(yīng)該用一個數(shù)組來存儲。如何來表示這樣的數(shù)據(jù)呢?Java就提供了二維數(shù)組供我們使用。由此可見：其實二維數(shù)組其實就是一個元素為一維數(shù)組的數(shù)組。

二維數(shù)組定義格式
（1）格式1

數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][n]; // m表示這個二維數(shù)組有多少個一維數(shù)組 // n表示每一個一維數(shù)組的元素個數(shù)

舉例：

int[][] arr = new int[3][2]; // 定義了一個二維數(shù)組arr // 這個二維數(shù)組有3個一維數(shù)組，名稱是arr[0],arr[1],arr[2] // 每個一維數(shù)組有2個元素，可以通過arr[m][n]來獲取 // 表示獲取第m+1個一維數(shù)組的第n+1個元素

（2）格式2

數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[m][]; // m表示這個二維數(shù)組有多少個一維數(shù)組 // 這一次沒有直接給出一維數(shù)組的元素個數(shù)，可以動態(tài)的給出。

舉例：

int[][] arr = new int[3][]; arr[0] = new int[2]; arr[1] = new int[3] arr[2] = new int[1];

（3）格式3

數(shù)據(jù)類型[][] 變量名 = new 數(shù)據(jù)類型[][]{{元素…},{元素…},{元素…}}; 簡化版格式：數(shù)據(jù)類型[][] 變量名 = {{元素…},{元素…},{元素…}}; 舉例：int[][] arr = {{1,2,3},{4,6},{6}};

4.10 數(shù)組常見操作

4.10.1 數(shù)組遍歷

/*數(shù)組遍歷：就是依次輸出數(shù)組中的每一個元素。注意：數(shù)組提供了一個屬性length，用于獲取數(shù)組的長度。格式：數(shù)組名.length */ class ArrayTest { public static void main(String[] args) { //定義數(shù)組 int[] arr = {11,22,33,44,55}; //獲取每一個元素 //如何獲取呢?我們知道數(shù)組名結(jié)合編號(索引)就可以找到數(shù)據(jù) for(int x=0; x<5; x++) { //x=0,1,2,3,4 System.out.println(arr[x]); } System.out.println("--------------------"); //從0開始我們是明確的，但是為什么到5呢，我們是數(shù)了一下數(shù)組的個數(shù) //繼續(xù)看下個數(shù)組如何遍歷 int[] arr2 = {1,2,3,4,5,6,7,8,9,10,11,2,2,3,4,5,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8,7,8,5,3,5,6,8}; //而我們在很多時候，數(shù)組的元素不能靠數(shù) //這個時候，數(shù)組就給我們提供了一個屬性：length專門用于獲取數(shù)組的長度 //格式：數(shù)組名.length 返回數(shù)組的長度 System.out.println(arr.length); System.out.println(arr2.length); System.out.println("--------------------"); //改進第一個程序 for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } System.out.println("--------------------"); //我們?nèi)绻胍獙Χ鄠€數(shù)組進行遍歷，每個數(shù)組的遍歷我們都把代碼寫一遍，麻煩不 //麻煩，所以，我們準備用方法改進。 //用方法改進后，請調(diào)用 printArray(arr); System.out.println("--------------------"); printArray(arr2); System.out.println("--------------------"); printArray2(arr); } /*遍歷數(shù)組的方法兩個明確：返回值類型：void參數(shù)列表：int[] arr*/ public static void printArray(int[] arr) { for(int x=0; x<arr.length; x++) { System.out.println(arr[x]); } } //請看改進版本 public static void printArray2(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x == arr.length-1) { //這是最后一個元素 System.out.println(arr[x]+"]"); }else { System.out.print(arr[x]+", "); } } } }

4.10.2 獲取數(shù)組最值

/*數(shù)組獲取最值(獲取數(shù)組中的最大值最小值)分析：A:定義一個數(shù)組，并對數(shù)組的元素進行靜態(tài)初始化。B:從數(shù)組中任意的找一個元素作為參照物(一般取第一個),默認它就是最大值。C:然后遍歷其他的元素，依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。D:最后參照物里面保存的就是最大值。 */ class ArrayTest2 { public static void main(String[] args) { //定義一個數(shù)組 int[] arr = {34,98,10,25,67}; //請獲取數(shù)組中的最大值 /*//從數(shù)組中任意的找一個元素作為參照物int max = arr[0];//然后遍歷其他的元素for(int x=1; x<arr.length; x++) {//依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。if(arr[x] > max) {max = arr[x];}}//最后參照物里面保存的就是最大值。System.out.println("max:"+max);*/ //把這個代碼用方法改進 //調(diào)用方法 int max = getMax(arr); System.out.println("max:"+max); //請獲取數(shù)組中的最小值 int min = getMin(arr); System.out.println("min:"+min); } /*需求：獲取數(shù)組中的最大值兩個明確：返回值類型：int參數(shù)列表：int[] arr*/ public static int getMax(int[] arr) { //從數(shù)組中任意的找一個元素作為參照物 int max = arr[0]; //然后遍歷其他的元素 for(int x=1; x<arr.length; x++) { //依次獲取和參照物進行比較，如果大就留下來，如果小，就離開。 if(arr[x] > max) { max = arr[x]; } } //最后參照物里面保存的就是最大值。 return max; } public static int getMin(int[] arr) { //從數(shù)組中任意的找一個元素作為參照物 int min = arr[0]; //然后遍歷其他的元素 for(int x=1; x<arr.length; x++) { //依次獲取和參照物進行比較，如果小就留下來，如果大，就離開。 if(arr[x] < min) { min = arr[x]; } } //最后參照物里面保存的就是最小值。 return min; } }

運行結(jié)果：

4.10.3 數(shù)組元素逆序

/*數(shù)組元素逆序 (就是把元素對調(diào))分析：A:定義一個數(shù)組，并進行靜態(tài)初始化。B:思路把0索引和arr.length-1的數(shù)據(jù)交換把1索引和arr.length-2的數(shù)據(jù)交換...只要做到arr.length/2的時候即可。 */ class ArrayTest3 { public static void main(String[] args) { //定義一個數(shù)組，并進行靜態(tài)初始化。 int[] arr = {12,98,50,34,76}; //逆序前 System.out.println("逆序前："); printArray(arr); //逆序后 System.out.println("逆序后："); //reverse(arr); reverse2(arr); printArray(arr); } /*需求：數(shù)組逆序兩個明確：返回值類型：void (有人會想到應(yīng)該返回的是逆序后的數(shù)組，但是沒必要，因為這兩個數(shù)組其實是同一個數(shù)組)參數(shù)列表：int[] arr*/ public static void reverse(int[] arr) { /*//第一次交換int temp = arr[0];arr[0] = arr[arr.length-1-0];arr[arr.length-1-0] = temp;//第二次交換int temp = arr[1];arr[1] = arr[arr.length-1-1];arr[arr.length-1-1] = temp;//第三次交換int temp = arr[2];arr[2] = arr[arr.length-1-2];arr[arr.length-1-2] = temp;*/ //用循環(huán)改進 for(int x=0; x<arr.length/2; x++) { int temp = arr[x]; arr[x] = arr[arr.length-1-x]; arr[arr.length-1-x] = temp; } } public static void reverse2(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; } } //遍歷數(shù)組 public static void printArray(int[] arr) { System.out.print("["); for(int x=0; x<arr.length; x++) { if(x == arr.length-1) { //這是最后一個元素 System.out.println(arr[x]+"]"); }else { System.out.print(arr[x]+", "); } } } }

運行結(jié)果：

4.10.4 數(shù)組基本查找

/*需求：數(shù)組元素查找(查找指定元素第一次在數(shù)組中出現(xiàn)的索引)分析：A:定義一個數(shù)組，并靜態(tài)初始化。B:寫一個功能實現(xiàn)遍歷數(shù)組，依次獲取數(shù)組中的每一個元素，和已知的數(shù)據(jù)進行比較如果相等，就返回當(dāng)前的索引值。 */ class ArrayTest5 { public static void main(String[] args) { //定義一個數(shù)組，并靜態(tài)初始化 int[] arr = {200,250,38,888,444}; //需求：我要查找250在這個數(shù)組中第一次出現(xiàn)的索引 int index = getIndex(arr,250); System.out.println("250在數(shù)組中第一次出現(xiàn)的索引是："+index); int index2 = getIndex2(arr,250); System.out.println("250在數(shù)組中第一次出現(xiàn)的索引是："+index2); int index3 = getIndex2(arr,2500); System.out.println("2500在數(shù)組中第一次出現(xiàn)的索引是："+index3); } /*需求：查找指定數(shù)據(jù)在數(shù)組中第一次出現(xiàn)的索引兩個明確：返回值類型：int參數(shù)列表：int[] arr,int value*/ public static int getIndex(int[] arr,int value) { //遍歷數(shù)組，依次獲取數(shù)組中的每一個元素，和已知的數(shù)據(jù)進行比較 for(int x=0; x<arr.length; x++) { if(arr[x] == value) { //如果相等，就返回當(dāng)前的索引值。 return x; } } //目前的代碼有一個小問題 //就是假如我要查找的數(shù)據(jù)在數(shù)組中不存在，那就找不到，找不到，你就對應(yīng)的返回嗎? //所以報錯。 //只要是判斷，就可能是false，所以大家要細心。 //如果找不到數(shù)據(jù)，我們一般返回一個負數(shù)即可，而且是返回-1 return -1; } public static int getIndex2(int[] arr,int value) { //定義一個索引 int index = -1; //有就修改索引值 for(int x=0; x<arr.length; x++) { if(arr[x] == value) { index = x; break; } } //返回index return index; } }

運行結(jié)果：

總結(jié)

以上是生活随笔為你收集整理的Java语法基础-2的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。