欧美日韩国产在线,欧美日韩永久精品婷婷,99热五区

Java程序開(kāi)發(fā)-- Hello World

將Java代碼編寫(xiě)到擴(kuò)展名為.java的文件中
通過(guò)javac命令對(duì)該Java文件進(jìn)行編譯
通過(guò)java命令對(duì)生成的class文件進(jìn)行運(yùn)行

java程序運(yùn)行流程.png

class Demo {
    public static void main(String[] args){
        System.out.println("Hello World!");
    }
}

main()為主程序入口地址，只有一個(gè)
該函數(shù)被Java虛擬機(jī)JVM調(diào)用
有了該函數(shù)能保證一個(gè)類的獨(dú)立運(yùn)行

編譯：javac(編譯工具) ，實(shí)際上對(duì)java源文件進(jìn)行語(yǔ)法檢查

javac Demo.java ======= >>>>>> Demo.class

運(yùn)行：java(運(yùn)行工具)，對(duì)應(yīng)底層就是JVM，啟動(dòng)虛擬機(jī)，將文件加載進(jìn)內(nèi)存

java Demo.class(或Demo) ====== >>>>> Hello World!

Java語(yǔ)言基礎(chǔ)組成

關(guān)鍵字

java關(guān)鍵字.png

標(biāo)識(shí)符

在程序中自定義的一些名稱
由26個(gè)英文字母大小寫(xiě)、數(shù)字：0-9、符號(hào)：_和$組成
定義合法標(biāo)識(shí)符規(guī)則：

$\color{red}{1. 數(shù)字不可以開(kāi)頭}$

$\color{red}{2. 不可以使用關(guān)鍵字}$
Java中嚴(yán)格區(qū)分大小寫(xiě)
注意：起名時(shí)，為了提高閱讀性，盡量要有意義

注釋

用于注解說(shuō)明程序的文字就是注釋
提高了代碼的閱讀性
Java中的注釋格式
1. 單行注釋
  - 格式：// 注釋文字
2. 多行注釋
  - 格式：/*注釋文字*/
3. 文檔注釋
  - 格式：/** 注釋文字 */

常量和變量

1.常量

常量表示不能改變的數(shù)值

Java中常量的分類：
1. 整數(shù)常量，所有整數(shù)
2. 小數(shù)常量，所有小數(shù)
3. 布爾常量，特有，只有兩個(gè)數(shù)值：true，false
4. 字符常量，將一個(gè)數(shù)字、字母用單引號(hào)(' ')標(biāo)識(shí)
5. 字符串常量，將一個(gè)或多個(gè)字符用雙引號(hào)(" ")標(biāo)識(shí)
6. null常量，只有一個(gè)數(shù)值：null
整數(shù)：四種形式
1. 二進(jìn)制： 0 - 1 ，滿 2 進(jìn) 1
2. 八進(jìn)制： 0 - 7 ，滿 8 進(jìn) 1 用0開(kāi)頭表示
3. 十進(jìn)制： 0 - 9 ，滿 10 進(jìn) 1
4. 十六進(jìn)制： 0 - 9， A - F，滿 16 進(jìn) 1 用0x開(kāi)頭表示

2.變量

概念：內(nèi)存中的一個(gè)存儲(chǔ)區(qū)域，該區(qū)域有自己的名稱（變量名）和類型（數(shù)據(jù)類型），該區(qū)域的數(shù)據(jù)可以在同一類型范圍內(nèi)不斷變化，可以重復(fù)使用，可以暫時(shí)理解為數(shù)學(xué)中的未知數(shù)x。

使用注意：變量的作用域范圍（一對(duì){}之間有效），變量初始值

定義變量的格式：

數(shù)據(jù)類型變量名 = 初始化值；
注：格式是固定的

Java語(yǔ)言是強(qiáng)類型語(yǔ)言，對(duì)于每一種數(shù)據(jù)都定義了明確的具體數(shù)據(jù)類型，在內(nèi)存總分配了不同大小的內(nèi)存空間

java數(shù)據(jù)類型.png

class VarDemo{
    public static void main(String[] args){
        // 數(shù)據(jù)類型     變量名 = 初始化值
        byte a = 1;     // 128  ~  (-127)
        short b = 2;
        int c = 100000;
        long d = 123456789;
        long d = 12345678910123l;   // 如果超過(guò)整數(shù)范圍后面加一個(gè)字符l
        
        float f = 2.3f;     // 加個(gè)f聲明為單精度
        double e = 3.14;    // 默認(rèn)為雙精度
        
        char ch = 'a';      // '12' : err   
        char ch1 = '1'；     // err 非法字符 把；改為; 
        boolean g = true;
        g = false;
    }
}

3.數(shù)據(jù)類型轉(zhuǎn)換

自動(dòng)類型轉(zhuǎn)換(也叫隱式類型轉(zhuǎn)換)
強(qiáng)制類型轉(zhuǎn)換(也叫顯式類型轉(zhuǎn)換)
類型轉(zhuǎn)換的原理
表達(dá)式的數(shù)據(jù)類型自動(dòng)提升
- 所有的byte型、short型和char型的值將被提升到int
- 如果一個(gè)操作數(shù)是long型，計(jì)算結(jié)果就是long
- 如果一個(gè)操作數(shù)是float型，計(jì)算結(jié)果就是float
- 如果一個(gè)操作數(shù)是double型，計(jì)算結(jié)果就是double型

class VarDemo1{
    public static void main(String[] args){
        int a = 3;
        byte b = 5
        a = a + b;      // ok b變量將被自動(dòng)提升為int
        
        byte c = 3;
        c = c + 5;          // err 
        c = (byte)(c + 5);  // 強(qiáng)制類型轉(zhuǎn)換 int 轉(zhuǎn) byte
        
        byte aa = 4;
        byte bb = 3;
        byte cc = 5;
        
        aa = bb + cc;       // err  丟失精度  
        // 原因：aa bb 為變量 ，無(wú)法進(jìn)行檢查結(jié)果是否超過(guò)byte精度，所以報(bào)錯(cuò)  aa可能為127  bb可能為127  相加會(huì)超過(guò)精度
        int x = bb + cc;
        
        int d1 = Integer.MAX_VALUE; // 2147483647 (2^31 - 1)
        int d2 = 3;
        int d3 = d1 + d2;       // ok
    }
}

運(yùn)算符

算術(shù)運(yùn)算符： +、-、*、/、%、+(連接符)、++、--

class Demo{
    public static void main(String[] args){
        System.out.println(3+2);    // 5
        System.out.println(3-2);    // 1
        System.out.println(3*2);    // 6
        System.out.println(3/2);    // 1
        System.out.println(5%2);    // 1
        System.out.println(-5%2);   // -1
        System.out.println(5%-2);   // 1
        System.out.println(3+"2");  // 32
        int a = 1,b;
        a++;    // a = a + 1;
        System.out.println(a);      // 2
        ++a;
        System.out.println(a);      // 3
        b = a++;    // 后置++會(huì)在內(nèi)存中開(kāi)辟臨時(shí)變量存儲(chǔ)
        System.out.println(a+""+b);  // a = 4 b = 3
        b = ++a;
        System.out.println(a+""+b);  // a = 5 b = 5
        int i = 3;
        i = i++;
        System.out.println(i);      // 3
        // tmp = i => 3;  i++  i => 4;  i = tmp => 3
    }
}

賦值運(yùn)算符：=、+=、-=、*=、/=、%=

class Demo{
    public static void main(String[] args){
        int a,b,c;
        a = b = c = 4;
        a += 2;     // a = a + 2
        b -= 3;     // b = b - 3
        
        short s = 3;
        s += 4;     // 7  ok
        s = s + 4;  // err 類型提升，精度丟失
        s = (short)(s + 4); // ok
    }
}

比較運(yùn)算符：>、<、>=、<=、==、!=、instanceof

class Demo{
    public static void main(String[] args){
        /*
         * 比較運(yùn)算符，運(yùn)算結(jié)果必須是true或者false
         */
        System.out.println(3 = 2);  // err = 賦值
        System.out.println(3 == 2); // ok   false
        System.out.println(3!=2);   // ok   true
    }
}

$\color{blue}{比較運(yùn)算符結(jié)果都是boolean型，要么是true，要么是false}$

$\color{blue}{比較運(yùn)算符”==“ 不要誤寫(xiě)成”=“}$

邏輯運(yùn)算符：&、|、^、!、&&、||
1. &：與，一假即假（可以進(jìn)行位運(yùn)算）
2. |：或，一真即真（可以進(jìn)行位運(yùn)算）
3. ^：異或，相同為假，不同為真
4. !：非，真假相反
5. &&：雙與結(jié)果和&相同，優(yōu)先短路（左邊一假，右邊不運(yùn)算）
6. ||：雙或結(jié)果和|相同，優(yōu)先短路（左邊一真，右邊不運(yùn)算）

class Demo{
    public static void main(String[] args){
        // 2 < x < 5
        /*
         * 用于連接兩個(gè)boolean表達(dá)式
         */
        int x = 3;
        System.out.println(x > 2 & x < 5);  // true
    }
}

位運(yùn)算符：<<、>>、>>>、&、|、^、~
1. <<：右移
2. >>：左移
3. >>>：無(wú)符號(hào)右移
4. &：與
5. |：或
6. ^：異或
7. ~：取反

class Demo{
    public static void main(String[] args){
        int a = 3;
        a = a << 2;     // 12   3*2*2=12
        int b = 3;
        b = b >> 1;     // 1    3/2=1
        b = 3 >> 1;     // 1    3/2=1
        b = 6 & 3;      // 2
        b = 6 | 3;      // 7
        b = 6 ^ 3;      // 5
        b = ~6;         // -7
        System.out.println(x > 2 & x < 5);  // true
        
        // 不使用第三個(gè)變量交換數(shù)據(jù)
        // 方法1： 不建議使用 可能超出范圍，精度問(wèn)題
        int aa = 5,bb = 3;
        a = a + b;
        b = a - b;
        a = a - b;
        
        // 方法2：  a = 3 b = 5
        a = a ^ b;      // a = 3 ^ 5
        b = a ^ b;      // b = (3 ^ 5) ^ 5    b = 3
        a = a ^ b;      // a = (3 ^ 5) ^ 3    a = 5
    }
}

<<：相當(dāng)于乘與2的倍數(shù)

>>：相當(dāng)于除與2的倍數(shù)

移n位，就是對(duì)乘以或者除以2的n次冪

三元運(yùn)算符：（）：（）？（）
- 格式：(條件表達(dá)式) ? 表達(dá)式1 : 表達(dá)式2；
  1. true：執(zhí)行表達(dá)式1
  2. false：執(zhí)行表達(dá)式2

class Demo{
    public static void main(String[] args){
        int a = 3, b = 4;
        int max = a > b ? a : b;
    }
}

語(yǔ)句

程序流程控制

判斷結(jié)構(gòu)

class Demo{
    public static void main(String[] args){
        /**
         *  1、if (條件表達(dá)式){ 執(zhí)行語(yǔ)句 }
         *  2、if (條件表達(dá)式){ 執(zhí)行語(yǔ)句 }else{ 執(zhí)行語(yǔ)句 }
         *  3、if (條件表達(dá)式){ 執(zhí)行語(yǔ)句 }else if(條件表達(dá)式){ 執(zhí)行語(yǔ)句 } ... else{ 執(zhí)行語(yǔ)句 }
         */
        int a = 3;
        
        // 格式1：
        if (a > 1){
            System.out.println("a > 1");
        }
        
        // 格式2：
        int b;
        if (a > 3){
            b = 10;
            System.out.println("a > 3" + b);
        }else{
            b = 20;
            System.out.println("a <= 3" + b);
        }
        // 等價(jià)于 三目運(yùn)算符，是if else 的簡(jiǎn)化 
        // 三目運(yùn)算符有局限性，是運(yùn)算符，必須有結(jié)果，而if else 可以沒(méi)有結(jié)果，有結(jié)果可以優(yōu)化為三元運(yùn)算符
        b = a > 3 ? 10 : 20;
        
        // 格式3：
        if (a < 1){
            System.out.println("a < 1");
        }else if (a < 10){
            System.out.println("a < 10");
        }else if (a < 100){
            System.out.println("a < 100");
        }else{
            System.out.println("其他情況");
        }
        
        // 語(yǔ)句的嵌套
        int aa = 1; bb = 3;
        if(aa == 1){
            if(bb == 3){
                System.out.println("aabb");
            }else{
                System.out.println("aa");
            }
        }else{
            if(bb == 3){
                System.out.println("bb");
            }else{
                System.out.println("");
            }
        }
        
        if(false);      // if語(yǔ)句結(jié)束
        {
            System.out.println("hello zimo");    
        }
        if(false){
            System.out.println("hello zimo");
        }
        
        // 局部代碼塊，可以定義局部變量的生命周期
        {
            int aaa = 10;
            System.out.println(aaa);
        }
        System.out.println(aaa);    // err aaa已經(jīng)被釋放了
    }
}

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

class Demo{
    public static void main(String[] args){
        /*
         *  switch(表達(dá)式){
         *      case 1：
         *          執(zhí)行語(yǔ)句; 
         *          break;
         *      case 2:
         *          執(zhí)行語(yǔ)句; 
         *          break;
         *      ......
         *      default:
         *          執(zhí)行語(yǔ)句;
         *          break;
         *  }
         */
        
        int type = 3;
        switch(type){
            case 1:
                System.out.println("1");
                break;
            case 2:
                System.out.println("2");
                break;
            case 3:
                System.out.println("3");
                break;
            default:
                break;
        }
    }
}

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

class Demo{
    public static void main(String[] args){
        /* 
         *  while、do-while、for
         *
         *  while(條件表達(dá)式){
         *      執(zhí)行語(yǔ)句;
         *  }
         *  
         *  條件是否滿足，循環(huán)體至少執(zhí)行一次
         *  do{
         *      執(zhí)行語(yǔ)句;
         *  }while(條件表達(dá)式);
         *
         *  for(初始化表達(dá)式; 循環(huán)條件表達(dá)式; 循環(huán)后操作的表達(dá)式){
         *      執(zhí)行語(yǔ)句;
         *  }
         */
        int x = 1;
        // 方式1：
        while(x < 3){
            System.out.println("x = " + x++);
        }
        // 方式2：
        do{
            System.out.println("x = " + x++);
        }while(x < 3);
        // 方式3：
        for(int i = 1; i < 3; i++){
            System.out.println("i = " + i);
        }
        
        int x = 1;
        for(System.out.println("a"); x < 3; System.out.println("d")){
            System.out.println("c");
        }
        ///  a d c d c
        
        for(int a =0,b = 1; b < 20;b++){}
        
        // 無(wú)限循環(huán)  死循環(huán)
        for(;;){}
        while(true){}
        do{}while(true);
    }
}

if和switch的應(yīng)用場(chǎng)景：

if：
1. 對(duì)具體的值進(jìn)行判斷
2. 對(duì)區(qū)間判斷
3. 對(duì)運(yùn)行結(jié)果是boolean類型的表達(dá)式進(jìn)行判斷
switch：
1. 對(duì)具體的值進(jìn)行判斷
2. 值的個(gè)數(shù)通常是固定的

$\color{blue}{對(duì)于幾個(gè)固定的值判斷，建議使用switch語(yǔ)句，因?yàn)閟witch語(yǔ)句會(huì)將具體的答案都加載進(jìn)內(nèi)存，效率相對(duì)高一點(diǎn)。}$

for 和 while 的特點(diǎn)：

for和while可以互換
格式上的不同，在使用上有些小區(qū)別
- 如果需要通過(guò)變量來(lái)對(duì)循環(huán)進(jìn)行控制，該變量只作為循環(huán)增量存在時(shí)，區(qū)別就體現(xiàn)了，for循環(huán)使用完就會(huì)自動(dòng)釋放

函數(shù)

函數(shù)的定義
- 函數(shù)就是定義在類中的具有特定功能的一段獨(dú)立小程序。
- 函數(shù)也稱方法

定義函數(shù)的格式：
    修飾符 返回值類型 函數(shù)名(參數(shù)類型 形式參數(shù)1,參數(shù)類型 形式參數(shù)2,...){
        執(zhí)行語(yǔ)句1;
        執(zhí)行語(yǔ)句2;
        ...
        執(zhí)行語(yǔ)句n;
        return 返回值;
    }

// 返回值類型：函數(shù)運(yùn)行后的結(jié)果的數(shù)據(jù)類型
// 參數(shù)類型：是形式參數(shù)的數(shù)據(jù)類型
// 形式參數(shù)：是一個(gè)變量，用于存儲(chǔ)調(diào)用函數(shù)時(shí)傳遞給函數(shù)的實(shí)際參數(shù)
// return：用于結(jié)束函數(shù)
// 返回值：該函數(shù)運(yùn)算后的結(jié)果，該結(jié)果會(huì)返回給調(diào)用者
/*
 * 特殊情況：功能沒(méi)有具體返回值
 *      1、直接結(jié)束：return;
 *      2、返回值類型為：void
 * 總結(jié)：
 *      沒(méi)有返回值類型時(shí)，返回值類型用void 表示，return語(yǔ)句也可以省略不寫(xiě)
 */
class Demo{
    public static int add(int a, int b){
        return a + b;
    }
    public static void main(String[] args){
        add(4+5);
    }
}

函數(shù)的特點(diǎn)
- 定義函數(shù)可以將功能代碼進(jìn)行封裝
- 便于對(duì)該功能進(jìn)行復(fù)用
- 函數(shù)只有被調(diào)用才會(huì)被執(zhí)行
- 函數(shù)的出現(xiàn)提高了代碼的復(fù)用性
- 對(duì)于函數(shù)沒(méi)有具體返回值的情況，返回值類型用關(guān)鍵字void表示，那么該函數(shù)中的return語(yǔ)句如果再最后一行可以省略不寫(xiě)
- 注意事項(xiàng)
  1. $\color{red}{函數(shù)中智能調(diào)用函數(shù)，不可以在函數(shù)內(nèi)部定義函數(shù)}$
  2. 定義函數(shù)時(shí)，函數(shù)的結(jié)果應(yīng)該返回給調(diào)用者，交由調(diào)用者處理。
函數(shù)的應(yīng)用
1. 明確一：功能的結(jié)果是什么？
  - 明確函數(shù)的返回類型
2. 明確二：實(shí)現(xiàn)過(guò)程中是否需要未知內(nèi)容參數(shù)參與運(yùn)算？
  - 明確參數(shù)列表
函數(shù)的重載
1. 重載的概念：在同一個(gè)類中，允許存在一個(gè)以上的同名函數(shù)，只要它們的參數(shù)個(gè)數(shù)或者參數(shù)類型不同即可
2. 重載的特點(diǎn)：與返回值類型無(wú)關(guān)，只看參數(shù)列表
3. 重載的好處：方便于閱讀，優(yōu)化了程序設(shè)計(jì)
4. 重載示例：
  - int add(int x, int y) { return x + y; } 返回兩個(gè)整數(shù)和
  - int add(int x, int y, int z) { return x + y + z; } 返回三個(gè)整數(shù)和
  - double add(doule x, double y) { return x + y; }` 返回兩小數(shù)和
函數(shù)的功能一樣，僅僅是參與運(yùn)算的未知內(nèi)容不同時(shí)，可以定義多函數(shù)，卻使用統(tǒng)一函數(shù)名稱，這樣方便閱讀，虛擬機(jī)通過(guò)參數(shù)列表不同來(lái)區(qū)分同名函數(shù)
```
/*
 *    函數(shù)的重載：
 *    1.同一個(gè)類中
 *    2.同名函數(shù)
 *    3.參數(shù)個(gè)數(shù)不同，或者參數(shù)類型不同
 *    4.函數(shù)重載和返回值類型無(wú)關(guān)
 *    5.java是嚴(yán)謹(jǐn)性語(yǔ)言，如果函數(shù)出現(xiàn)調(diào)用的不確定性，編譯失敗
 */
class Demo{
    public static double add(double a, double b){
        return a + b;
    }
    public static int add(int a, int b){
        return a + b;
    }
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    public static void main(String[] args){
        
    }
}
```

數(shù)組

數(shù)組的定義
1. 數(shù)組的概念：同一種類型數(shù)據(jù)的集合。 $\color{red}{其實(shí)數(shù)組就是一個(gè)容器}$
2. 數(shù)組的好處：可以自動(dòng)給數(shù)組中的元素從開(kāi)始編號(hào)，方便操作這些元素。
3. 定義格式：
  1. 元素類型[] 數(shù)組名 = new 元素類型[元素個(gè)數(shù)或者數(shù)組長(zhǎng)度];
    1. 例如：int[] arr = new int[5];
  2. 元素類型[] 數(shù)組名 = new 元素類型[] {元素1,元素2,......};
    1. int[] arr = new int[]{1,3,5,7};
    2. int[] arr = {1,3,5,7};
數(shù)組的內(nèi)存分配及特點(diǎn)

大致內(nèi)存分區(qū)：寄存器、本地方法區(qū)、方法區(qū)、棧內(nèi)存、堆內(nèi)存
- 棧內(nèi)存：
  1. 存儲(chǔ)的都是局部變量
  2. 變量所屬作用域結(jié)束，該變量自動(dòng)釋放
- 堆內(nèi)存
  1. 存儲(chǔ)的是數(shù)組和對(duì)象(其實(shí)數(shù)據(jù)就是對(duì)象)凡是new建立的都在堆中
  2. 特點(diǎn)：
    - 每個(gè)實(shí)體都有首地址值
    - 堆內(nèi)存中的每一個(gè)變量都有默認(rèn)初始化值，根據(jù)類型不同而不同，整數(shù)：0、小數(shù)：0.0，0.0f、布爾：false、字符：'\u0000'
    - 堆的內(nèi)存自動(dòng)回收機(jī)制

內(nèi)存分析.png

數(shù)組操作常見(jiàn)問(wèn)題

class Demo{
    public static void main(String[] args){
        // 方式1：
        int[] arr = new int[3];
        // 方式2：
        int[] arr1 = new int[]{1,3,4,6,7,9};         // 動(dòng)態(tài)分配并初始化
        int[] arr2 = {1,2,3,4,5};                   // 靜態(tài)初始化方式
            
        // 問(wèn)題1：當(dāng)訪問(wèn)到數(shù)組中不存在的角標(biāo)時(shí)，就會(huì)發(fā)生異常。ArrayIndexOutOfBoundsException
        System.out.println(arr[3]);     // err 運(yùn)行時(shí)錯(cuò)誤： 數(shù)組腳標(biāo)異常，數(shù)組越界
        
        // 問(wèn)題2：當(dāng)引用型變量沒(méi)有任何實(shí)體指向時(shí)，還在用其操作實(shí)體，就會(huì)發(fā)生異常。NullPointException
        arr = null;
        System.out.println(arr[0]);     // 空指針異常
    }
}

數(shù)組常見(jiàn)操作

class Demo{
    public static void main(String[] args){
        /*
         *  對(duì)數(shù)組操作最基本的動(dòng)作就是存和取
         *  核心思想：就是對(duì)角標(biāo)的操作
         */
        
        ///////////        【數(shù)組遍歷】      ///////////
        int[] arr = {1,2,3,4,5,6};
        for(int i = 0; i < arr.length; i++){
            System.out.println(arr[i]);
        }
        
        // 獲取最值（最大值，最小值）
        int Max = arr[0],Min = arr[0];               // 初始化為 數(shù)組數(shù)據(jù)
        int maxIndex = 0， minIndex = 0;             // 初始化為 數(shù)組腳標(biāo)
        for(int i = 1; i < arr.length; i++){
            if(arr[i] > Max){
                Max = arr[i];
                maxIndex = i;
            }
            if(arr[i] < Min){
                Min = arr[i];
                minIndex = i;
            }
        }
        System.out.println("Max = "+Max+",Min = "+Min); 
        System.out.println("Max = "+arr[maxIndex]+",Min = "+arr[minIndex]); 
        
        /////////// 【數(shù)組排序】（選擇排序、冒泡排序）///////////
        int[] array = {12,40,4,56,1};
        
        // 選擇排序
        for(int i = 0; i < array.length; i++){
            for(int j = i + 1; j < array.length; j++){
                if(array[i] > array[j]){
                    int tmp = array[i];
                    array[i] = array[j];
                    array[j] = tmp;
                }
            }
        }
        
        // 選擇排序優(yōu)化
        for(int i = 0; i < array.length; i++){
            int num = array[i], index = i;
            for(int j = i + 1; j < array.length; j++){
                if(num > array[j]){
                    // 記錄最值 不交換
                    num = array[j];
                    index = j;
                }
            }
            if(index != i){
                // 每輪只進(jìn)行一次換位
                int tmp = array[i];
                array[i] = array[index];
                array[index] = tmp;
            }
        }
        
        // 冒泡排序
        for(int i =0; i < array.length - 1; i++){
            for(int j = 0; j < array.lenth - 1 - x; y++){
                if(array[j] > array[j+1]){
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
        /*   冒泡另一種寫(xiě)法
            for(int x = arr.length - 1; x > 0; x--)
                for(int y = 0; y < x; y++)
        */
        // 封裝交換算法
        {
            void swap(int[] arr, int x, int y){
                int tmp = array[x];
                array[x] = array[y];
                array[y] = tmp;
            }
        }
        ///////////      【數(shù)組查找】      ///////////
        int[] arr = {1,3,5,7,9}, findValue = 5;

        // 查找
        for(int i = 0; i < arr; i++){
            if(arr[i] == findValue){
                return i;
            }
        }
        
        // java提供的二分查找      如果存在返回：插入點(diǎn)下標(biāo)  不存在返回：-腳標(biāo)-1
        Arrays.binarySearch(arr,9);
        
        // 折半/二分查找（前提數(shù)組必須有序）
        int[] arr1 = {10,23,35,47,59};
        int min = 0,max,mid;
        max = arr1.length - 1;
        mid = (min + max) / 2;
        // 11111111
        {
            while(arr[mid]!=findValue){
                if(findValue > arr[mid]){
                    min = mid + 1;
                }else if(findValue < arr[mid]){
                    max = mid - 1;
                }
                if(max < min){
                    return -1;
                }
                mid = (max + min) / 2;
            }
        }
        // 22222222  
        {
            while(min <= max){
                mid = (max + min) >> 1;
                if(findValue > arr[mid]){
                    min = mid + 1;
                }else if(findValue < arr[mid]){
                    max = mid - 1;
                }else{
                    return mid;
                }
            }
            return -1
        }
        
        // 二進(jìn)制轉(zhuǎn)十六進(jìn)制
        {
            // 1、傳統(tǒng)轉(zhuǎn)換   輸出結(jié)果反，且多了0
            public static void toHex(int num){
                for(int i = 0; i < 8; i++){
                    int temp = num & 15;
                    if(temp > 9){
                        System.out.println((char)(temp-10 + 'A'));
                    }else{
                        System.out.println(temp);
                    }
                    num = num >>> 4;
                }
                
            }
            
            // 2、數(shù)組查表法
            public static void toHex1(int num){
                if(num == 0){
                    System.out.println(num);
                    return;
                }
                // 對(duì)應(yīng)關(guān)系表
                char[] chs = {'0','1','2','3',
                              '4','5','6','7',
                              '8','9','A','B',
                              'C','D','E','F'
                             };
                /*
                for(int i = 0; i < 8; i++){
                    int temp = num & 15;
                    System.out.println(chs[temp]);
                    num = num >>> 4;
                }*/
                char[] arr = new char[8];
                int pos = arr.length;
                while(num != 0){
                    int temp = num & 15;            // 轉(zhuǎn)十六進(jìn)制 與上 1111 每次取出四位
                    arr[--pos] = chs[temp];
                    num = num >>> 4;
                }
                for (int i = pos; i < arr.length; i++){
                    System.out.println(arr[i]);
                }
            }
            
            // 通用進(jìn)制轉(zhuǎn)換  num 轉(zhuǎn)換的值十進(jìn)制數(shù)   base 轉(zhuǎn)換的進(jìn)制（2，8，16） offset 位運(yùn)算偏移多少
            public static void trans(int num， int base, int offset){
                if(num == 0){
                    System.out.println(num);
                    return;
                }
                /*switch(base){
                    case 2:
                        offset = 1;
                        break;
                    case 8:
                        offset = 3;
                        break;
                    case 16:
                        offset = 4;
                        break;
                }*/
                base -= 1;      // 方便位運(yùn)算
                // 對(duì)應(yīng)關(guān)系表
                char[] chs = {'0','1','2','3',
                              '4','5','6','7',
                              '8','9','A','B',
                              'C','D','E','F'
                             };
                char[] arr = new char[32];
                int pos = arr.length;
                while(num != 0){
                    int temp = num & base;
                    arr[--pos] = chs[temp];
                    num = num >>> offset;
                }
                for (int i = pos; i < arr.length; i++){
                    System.out.println(arr[i]);
                }
        }
    }
}

數(shù)組排序.png

數(shù)組查找.png

數(shù)組中的數(shù)組

二維數(shù)組 [ ] [ ]

格式1：int[][] arr = new int[3][2];

定義了名稱為arr的二維數(shù)組
二維數(shù)組中有三個(gè)一維數(shù)組
每個(gè)一維數(shù)組有兩個(gè)元素
一維數(shù)組名稱分別為arr[0], arr[1], arr[2]
給第一個(gè)一維數(shù)組1角標(biāo)位置賦值為78可表示為：arr[0] [1] = 78;

格式2：int[][] arr = new int[3][];

二維數(shù)組中有三個(gè)一維數(shù)組
每個(gè)一維數(shù)組都是默認(rèn)初始化值null
可以對(duì)三個(gè)一維數(shù)組分別進(jìn)行初始化
1. arr[0] = new int[3];
2. arr[1] = new int[1];
3. arr[2] = new int[2];

class Demo{
    public static void main(String[] args){
        int[][] arr = new int[3][2];
        
        int[][] arr1 = new int[3][];
        // 分別對(duì)二維數(shù)組中的內(nèi)一個(gè)小數(shù)組進(jìn)行初始化
        arr1[0] = new int[2];
        arr1[1] = new int[1];
        arr1[2] = new int[3];
        
        int[][] arr2 = {{1,3,85},{5,9,1,7},{53,14}};
        int sum = 0;
        for(int i = 0; i < arr2.length; i++){
            for(int j = 0; j < arr2[i].length; j++){
                sum += arr2[i][j];
            }
        }
    }
}

二維數(shù)組內(nèi)存分析.png

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av

Java基礎(chǔ)語(yǔ)法

Java基礎(chǔ)語(yǔ)法

Java程序開(kāi)發(fā)-- Hello World

Java語(yǔ)言基礎(chǔ)組成

關(guān)鍵字

標(biāo)識(shí)符

注釋

常量和變量

1.常量

2.變量

3.數(shù)據(jù)類型轉(zhuǎn)換

運(yùn)算符

語(yǔ)句

函數(shù)

數(shù)組

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九 欧美,1769亚洲,黄色成人av

Java基礎(chǔ)語(yǔ)法

Java程序開(kāi)發(fā)-- Hello World

Java語(yǔ)言基礎(chǔ)組成

關(guān)鍵字

標(biāo)識(shí)符

注釋

常量和變量

1.常量

2.變量

3.數(shù)據(jù)類型轉(zhuǎn)換

運(yùn)算符

語(yǔ)句

函數(shù)

數(shù)組

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容

色偷偷精品伊人,欧洲久久精品,欧美综合婷婷骚逼,国产AV主播,国产最新探花在线,九色在线视频一区,伊人大交九欧美,1769亚洲,黄色成人av