今天給大家帶來的是初級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：

  常見錯誤2：
  常見錯誤3：

　　

比較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方法進行重寫的時候，比較的方式和==是一樣的，如果重寫的則按照重寫的方式進行比較

在使用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 =https://www.cnblogs.com/sunlll666/p/ 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的重難點：面向物件！！！下次會給大家帶來更為詳細的關于面向物件的博客，期待小伙伴們的收藏、支持和評論，加油！！！

 

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/155296.html

標籤：Java

上一篇：吃貨聯盟 源代碼 Java初級小專案

下一篇：【JAVA SE基礎篇】44.手工實作簡易HashMap和HashSet