摘要：解題步驟使用輸出語句完成打印左邊的中括號(hào)使用循環(huán)，輸出數(shù)組元素值。按照這種方式，數(shù)組循環(huán)多圈以后，就完成了數(shù)組元素的排序。

* A: 奇數(shù)求和練習(xí)
    * a: 題目分析
        * 為了記錄累加和的值，我們需要定義一個(gè)存儲(chǔ)累加和的變量
        * 我們要獲取到1-100范圍內(nèi)的數(shù)
        * 判斷當(dāng)前數(shù)是否為奇數(shù)，是奇數(shù)，完成累加和操作
        * 累加完畢后，最終顯示下累加和的值

    * b: 解題步驟
        * 定義一個(gè)用來記錄累加和的變量
        * 使用for循環(huán)語句，完成1-100之間每個(gè)數(shù)的獲取
        * 使用if條件語句，判斷當(dāng)前數(shù)是否是奇數(shù)，是奇數(shù)，進(jìn)行累加和操作
        * 使用輸出語句，打印累加和變量的值

    * c: 案例代碼
        public class Test01 {
            public static void main(String[] args) {
                int sum = 0;
                for (int i = 0; i < 100; i++) {
                    if (i%2==1) {
                        sum += i;
                    }
                }
                System.out.println("累加和的值 " + sum);
            }
        }

* A: 水仙花練習(xí)功能實(shí)現(xiàn)
    * a: 題目分析
        * 明確什么樣的數(shù)就是水仙花數(shù)。水仙花數(shù)是指一個(gè)3位數(shù)（100-999之間），其每位數(shù)字立方之和等于該3位數(shù)本身。
            如153 = 1*1*1 + 3*3*3 + 5*5*5，即 3位數(shù)本身 = 百位數(shù)立方 + 十位數(shù)立方 + 個(gè)位數(shù)立方;
        * 獲取水仙花范圍內(nèi)的所有3位數(shù)（100-999之間的每個(gè)3位數(shù)）
        * 判斷該3位數(shù)是否滿足水仙花數(shù)，滿足，打印該3位數(shù)
        
    * b: 解題步驟
        * 使用for循環(huán)，得到100-999之間的每個(gè)3位數(shù)
        * 獲取3位數(shù)中百位數(shù)字、十位數(shù)字、個(gè)位數(shù)字
        * 使用if條件語句，判斷該3位數(shù)是否滿足水仙花數(shù)，滿足，使用輸出語句，打印該3位數(shù)
        
    * c: 案例代碼
        public class Test02 {
            public static void main(String[] args) {
                for (int i = 100; i < 1000; i++) {
                    int bai = i/100%10;
                    int shi = i/10%10;
                    int ge = i%10;
                    
                    if (i == bai*bai*bai + shi*shi*shi + ge*ge*ge) {
                        System.out.println(i);
                    }
                }
            }
        }            
        

* A: ASCII編碼表
    * a: 英文全稱
        * American Standard Code for Information Interchange，美國(guó)標(biāo)準(zhǔn)信息交換代碼
    * b: ASCII編碼表由來
        * 計(jì)算機(jī)中，所有的數(shù)據(jù)在存儲(chǔ)和運(yùn)算時(shí)都要使用二進(jìn)制數(shù)表示
        * a、b、c、d這樣的52個(gè)字母（包括大寫）、以及0、1等數(shù)字還有一些常用的符號(hào), 在計(jì)算機(jī)中存儲(chǔ)時(shí)也要使用二進(jìn)制數(shù)來表示
        * 具體用哪些二進(jìn)制數(shù)字表示哪個(gè)符號(hào)，當(dāng)然每個(gè)人都可以約定自己的一套（這就叫編碼）
        * 大家如果要想互相通信而不造成混亂，那么大家就必須使用相同的編碼規(guī)則，于是美國(guó)有關(guān)的標(biāo)準(zhǔn)化組織就出臺(tái)了ASCII編碼，
            統(tǒng)一規(guī)定了上述常用符號(hào)用哪些二進(jìn)制數(shù)來表示。
    * c: 中文編碼表
        * GB2312
        * UNICODE
    * d: 字符中重要的ASCII碼對(duì)應(yīng)關(guān)系
        * a : 97
        * A : 65
        * 0 : 48
        

* A: char類型的存儲(chǔ)
    * a: 取值范圍
        * short:占兩個(gè)字節(jié),是有符號(hào)數(shù)據(jù),取值范圍-32768-32767
        * char: 占兩個(gè)字節(jié),是無符號(hào)數(shù)據(jù),取值范圍0-65536
        
    * b: 類型轉(zhuǎn)換
        * char類型的數(shù)據(jù)參加運(yùn)算時(shí)要線程程int數(shù)據(jù)類型
        
    * c: 案例代碼
        /*
            ASCII編碼表演示
            字符Java 數(shù)據(jù)類型,char
            整數(shù)Java 數(shù)據(jù)類型,int
            
            int 類型和 char 數(shù)據(jù)類型轉(zhuǎn)換
            char  兩個(gè)字節(jié), int 四個(gè)字節(jié)
            
            char轉(zhuǎn)成int類型的時(shí)候,類型自動(dòng)提示,char數(shù)據(jù)類型,會(huì)查詢編碼表,得到整數(shù)
            int轉(zhuǎn)成char類型的時(shí)候,強(qiáng)制轉(zhuǎn)換,會(huì)查詢編碼表
            
            char存儲(chǔ)漢字,查詢Unicode編碼表
            
            char可以和int計(jì)算,提示為int類型, 內(nèi)存中兩個(gè)字節(jié)
            char取值范圍是0-65535, 無符號(hào)的數(shù)據(jù)類型
        */
        public class ASCIIDemo{
            public static void main(String[] args){
                char c = "a";
                int i = c + 1;
                System.out.println(i);
                
                int j = 90;
                char h = (char)j;
                System.out.println(h);
                
                System.out.println( (char)6 );
                
                char k = "你";
                System.out.println(k);
                
                
                char m = -1;
            }
        }    

* A: 輸出所有英文字母
    * a: 題目分析
        * 一共26個(gè)大小寫字母，那么，可以考慮循環(huán)26次。在每次循環(huán)中，完成指定字母的大小寫打印
        * 找出ABCDEFG…XYZ這些字母之間的變化規(guī)律
            通過ASCII表發(fā)現(xiàn)，后面的字母比它前面的字母，ASCII值大1
            下一個(gè)字母 = 上一個(gè)字母 + 1
            如： A    B    C    D
                65    66    67    68
        * 在每次循環(huán)中打印上一個(gè)字母大小寫，并指定下一個(gè)字母

    * b: 解題步驟
        * 定義初始化大寫變量，值為’A’； 初始化小寫變量，值為’a’
        * 使用for循環(huán)，進(jìn)行26次循環(huán)
        * 在每次循環(huán)中，打印大寫字母、小寫字母。
            每次打印完成后，更新大寫字母值、小寫字母值

    * c: 案例代碼
        public class Test04 {
            public static void main(String[] args) {
                char da = "A";
                char xiao = "a";
                for (int i = 0; i < 26; i++) {
                    System.out.println("大寫字母 "+da+" ,小寫字母 "+xiao);
                    da++; //更新大寫字母值
                    xiao++; //更新小寫字母值
                }
            }
        }
        

* A: 99乘法表的分析
    * a: 打印格式
        1*1=1
        1*2=2  2*2=4
        1*3=3  2*3=6  3*3=9
    * b: 題目分析
        通過觀察發(fā)現(xiàn)，如果把1*1=1這樣的內(nèi)容 看做一顆*的話，那么打印結(jié)果就成了如下效果：
        *
        **
        ***
        ****
        …
        這樣，就是打印9行星，每行打印星的個(gè)數(shù)與當(dāng)前行數(shù)相等。
        再觀察“1*3=3 2*3=6 3*3=9”得出它們?nèi)缦碌淖兓?guī)律：
                每行第n次 +"*"+ 行號(hào) +"="+ 每行第n次 * 行號(hào)
            如:    1    +"*"+  2    +"="+   1*2; // 相當(dāng)于1*2=2
                2    +"*"+  2    +"="+   2*2; // 相當(dāng)于2*2=4    

    * c: 解題步驟
        * 定義一個(gè)外層for循環(huán)，初始值從1開始，循環(huán)9次。用來控制打印的行數(shù)
        * 在外層for循環(huán)內(nèi)部，定義一個(gè)for循環(huán)，初始值從1開始，循環(huán)次數(shù)與當(dāng)前行數(shù)相等。用來完成每行打印指定次數(shù)的乘法公式 如1*1=1
        * 在內(nèi)層for循環(huán)中，完成每行指定次數(shù)的乘法公式打印 如1*1=1
            System.out.print(k +"*"+ j +"="+ j*k +"	");
            // 變量k代表：每行中的第n次
            // 變量j代表：行號(hào)
        * 在外循環(huán)中，當(dāng)每行指定次數(shù)的乘法公式打印完畢后，通過System.out.println()切換到下一行。
            這樣，再次打印乘法公式時(shí)，就在下一行輸出打印了

* A: 99乘法表的功能實(shí)現(xiàn)
    * a: 案例代碼
        /*
            利用嵌套for循環(huán),實(shí)現(xiàn)99乘法表示
            實(shí)現(xiàn)步驟:
              1. 定義外循環(huán)控制行數(shù)
              2. 內(nèi)循環(huán)控制個(gè)數(shù),個(gè)數(shù),每次都在遞增
              3. 循環(huán)中輸出,乘法表的格式   1*3=3
        */
        
        public class Test05 {
            public static void main(String[] args) {
                for (int j = 1; j < 10; j++) {
                    for (int k = 1; k <= j; k++) {
                        System.out.print(k +"*"+ j +"="+ j*k +"	");
                    }
                    System.out.println();
                }
            }
        }

            

* A: 實(shí)現(xiàn)數(shù)組的遍歷
    * a: 題目分析
        * 通過循環(huán)，我們可以完成數(shù)組中元素的獲取，數(shù)組名[索引]
        * 觀察發(fā)現(xiàn)，每個(gè)數(shù)組元素之間加入了一個(gè)逗號(hào)”,”進(jìn)行分隔；并且，整個(gè)數(shù)組的前后有一對(duì)中括號(hào)”[]”包裹數(shù)組所有元素。
        
    * b: 解題步驟
        * 使用輸出語句完成打印 左邊的中括號(hào)”[”
        * 使用循環(huán)，輸出數(shù)組元素值。輸出元素值分為兩種情況，如下：
            * 最后一個(gè)數(shù)組元素，加上一個(gè)右邊的中括號(hào)”]”
            * 非最后一個(gè)數(shù)組元素，加上一個(gè)逗號(hào)”,”
            
    * c: 案例代碼
        /*
            定義方法,實(shí)現(xiàn)數(shù)組的遍歷
            遍歷中,輸出結(jié)果  [11,33,565,66,78,89]
            int[] arr = {3,4,45,7};
            結(jié)果包含字符串, [  ]  ,
            實(shí)現(xiàn)步驟:
              1. 定義方法實(shí)現(xiàn)數(shù)組的遍歷
              2. 先打印[ 中括號(hào)
              3. 遍歷數(shù)組
                輸出數(shù)組的元素和逗號(hào)
                判斷是否遍歷到了數(shù)組的最后一個(gè)元素,如果是最后一個(gè)元素,輸出]中括號(hào)
        */
        public class ArrayMethodTest{
            public static void main(String[] args){
                int[] arr = {11,44,55,33,66};
                printArray(arr);
                
                int[] arr2 = {22,88,99,33,66};
                printArray(arr2);
                
            }
            /*
               定義方法,實(shí)現(xiàn)功能
               返回值: void
               方法參數(shù): 數(shù)組
            */
            public static void printArray(int[] arr){
                //輸出一半中括號(hào),不要換行打印
                System.out.print("[");
                //數(shù)組進(jìn)行遍歷
                for(int i = 0 ; i < arr.length ; i++){
                    //判斷遍歷到的元素,是不是數(shù)組的最后一個(gè)元素
                    //如何判斷 循環(huán)變量 到達(dá) length-1
                    if( i == arr.length-1 ){
                        //輸出數(shù)組的元素和]
                        System.out.print(arr[i]+"]");
                    }else{
                    //不是數(shù)組的最后一個(gè)元素,輸出數(shù)組元素和逗號(hào)
                        System.out.print(arr[i]+",");
                    }
                }
                System.out.println();
            }
        }
    

* A: 數(shù)組逆序原理
    * a: 題目分析(圖解見day07_source/數(shù)組的逆序原理.JPG)
        * 通過觀察發(fā)現(xiàn)，本題目要實(shí)現(xiàn)原數(shù)組元素倒序存放操作。即原數(shù)組存儲(chǔ)元素為{11,22,33,44}，
            逆序后為原數(shù)組存儲(chǔ)元素變?yōu)閧44,33,22,11}。
        * 通過圖解發(fā)現(xiàn)，想完成數(shù)組元素逆序，其實(shí)就是把數(shù)組中索引為start與end的元素進(jìn)行互換。
        * 每次互換后，start索引位置后移，end索引位置前移，再進(jìn)行互換
        * 直到start位置超越了end位置，互換結(jié)束，此時(shí)，數(shù)組元素逆序完成。
        
    * b: 解題步驟
        * 定義兩個(gè)索引變量start值為0，變量end值為數(shù)組長(zhǎng)度減去1（即數(shù)組最后一個(gè)元素索引）
        * 使用循環(huán)，完成數(shù)組索引start位置元素與end位置元素值互換。
        * 在循環(huán)換過程中，每次互換結(jié)束后，start位置后移1，end位置前移1
        * 在循環(huán)換過程中，最先判斷start位置是否超越了end位置，若已超越，則跳出循環(huán)
        
    

* A：案例代碼
    /*
       數(shù)組的逆序:
         數(shù)組中的元素,進(jìn)行位置上的交換
         逆序 不等于 反向遍歷
         就是數(shù)組中最遠(yuǎn)的兩個(gè)索引,進(jìn)行位置交換,實(shí)現(xiàn)數(shù)組的逆序
         使用的是數(shù)組的指針?biāo)枷?就是變量,思想,可以隨時(shí)變換索引
         反轉(zhuǎn) reverse
         實(shí)現(xiàn)步驟:
           1. 定義方法,實(shí)現(xiàn)數(shù)組的逆序
           2. 遍歷數(shù)組
             實(shí)現(xiàn)數(shù)組的最遠(yuǎn)索引換位置
             使用臨時(shí)的第三方變量
    */
    public class ArrayMethodTest_1{
        public static void main(String[] args){
            int[] arr = {3,5,7,1,0,9,-2};
            //調(diào)用數(shù)組的逆序方法
            reverse(arr);
            //看到數(shù)組的元素,遍歷
            printArray(arr);
        }
        
        /*
           定義方法,實(shí)現(xiàn)數(shù)組的逆序
           返回值: 沒有返回值
           參數(shù):   數(shù)組就是參數(shù)
        */
        public static void reverse(int[] arr){
            //利用循環(huán),實(shí)現(xiàn)數(shù)組遍歷,遍歷過程中,最遠(yuǎn)端換位
            //for的第一項(xiàng),定義2個(gè)變量, 最后,兩個(gè)變量++ --
            for( int min = 0 , max = arr.length-1 ; min < max  ; min++,max--){
                //對(duì)數(shù)組中的元素,進(jìn)行位置交換
                //min索引和max索引的元素交換
                //定義變量,保存min索引
                int temp = arr[min];
                //max索引上的元素,賦值給min索引
                arr[min] =  arr[max];
                //臨時(shí)變量,保存的數(shù)據(jù),賦值到max索引上
                arr[max] = temp;
            }
        }
    }

* A: 選擇排序原理
    * a: 題目分析(圖解見day07_source/選擇排序原理.JPG)
        * 通過觀察發(fā)現(xiàn)，本題目要實(shí)現(xiàn)把數(shù)組元素{13,46,22,65,3}進(jìn)行排序
        * 提到數(shù)組排序，就要進(jìn)行元素值大小的比較，通過上圖發(fā)現(xiàn)，我們想完成排序要經(jīng)過若干次的比較才能夠完成。
        * 上圖中用每圈要比較的第一個(gè)元素與該元素后面的數(shù)組元素依次比較到數(shù)組的最后一個(gè)元素，把小的值放在第一個(gè)數(shù)組元素中，數(shù)組循環(huán)一圈后，則把最小元素值互換到了第一個(gè)元素中。
        * 數(shù)組再循環(huán)一圈后，把第二小的元素值互換到了第二個(gè)元素中。按照這種方式，數(shù)組循環(huán)多圈以后，就完成了數(shù)組元素的排序。這種排序方式我們稱為選擇排序。

        
    * b: 解題步驟
        * 使用for循環(huán)（外層循環(huán)），指定數(shù)組要循環(huán)的圈數(shù)（通過圖解可知，數(shù)組循環(huán)的圈數(shù)為數(shù)組長(zhǎng)度 - 1）
        * 在每一圈中，通過for循環(huán)（內(nèi)層循環(huán)）完成數(shù)組要比較的第一個(gè)元素與該元素后面的數(shù)組元素依次比較到數(shù)組的最后一個(gè)元素，把小的值放在第一個(gè)數(shù)組元素中
        * 在每一圈中，要參與比較的第一個(gè)元素由第幾圈循環(huán)來決定。如上圖所示
            * 進(jìn)行第一圈元素比較時(shí)，要比較的第一個(gè)元素為數(shù)組第一個(gè)元素，即索引為0的元素
            * 進(jìn)行第二圈元素比較時(shí)，要比較的第一個(gè)元素為數(shù)組第二個(gè)元素，即索引為1的元素
            * 依次類推，得出結(jié)論：進(jìn)行第n圈元素比較時(shí)，要比較的第一個(gè)元素為數(shù)組第n個(gè)元素，即數(shù)組索引為n-1的元素
            

* A: 案例代碼
    /*
      數(shù)組的排序: 一般都是升序排列,元素,小到大的排列
      
      兩種排序的方式
         選擇排序: 數(shù)組的每個(gè)元素都進(jìn)行比較
         冒泡排序: 數(shù)組中相鄰元素進(jìn)行比較
         規(guī)則: 比較大小,位置交換
    */
    public class ArrayMethodTest_2{
        public static void main(String[] args){
            int[] arr  = {3,1,4,2,56,7,0};
            //調(diào)用選擇排序方法
            //selectSort(arr);
            printArray(arr);
        }
        /*
            定義方法,實(shí)現(xiàn)數(shù)組的選擇排序
            返回值: 沒有
            參數(shù):  數(shù)組
            實(shí)現(xiàn)步驟:
              1.嵌套循環(huán)實(shí)現(xiàn)排序
                外循環(huán),控制的是一共比較了多少次
                內(nèi)循環(huán),控制的是每次比較了多少個(gè)元素
              2. 判斷元素的大小值
                小值,存儲(chǔ)到小的索引
        */
        public static void selectSort(int[] arr){
            for(int i = 0 ; i < arr.length - 1; i++){
                //內(nèi)循環(huán),是每次都在減少,修改變量的定義
                for(int j = i+1 ; j < arr.length ; j++){
                    //數(shù)組的元素進(jìn)行判斷
                    if(arr[i] > arr[j]){
                        //數(shù)組的換位
                        int temp = arr[i];
                        arr[i] = arr[j];
                        arr[j] = temp; 
                    }
                }
            }
        }
        
        /*
           定義方法,實(shí)現(xiàn)功能
           返回值: void
           方法參數(shù): 數(shù)組
        */
        public static void printArray(int[] arr){
            //輸出一半中括號(hào),不要換行打印
            System.out.print("[");
            //數(shù)組進(jìn)行遍歷
            for(int i = 0 ; i < arr.length ; i++){
                //判斷遍歷到的元素,是不是數(shù)組的最后一個(gè)元素
                //如何判斷 循環(huán)變量 到達(dá) length-1
                if( i == arr.length-1 ){
                    //輸出數(shù)組的元素和]
                    System.out.print(arr[i]+"]");
                }else{
                //不是數(shù)組的最后一個(gè)元素,輸出數(shù)組元素和逗號(hào)
                    System.out.print(arr[i]+",");
                }
            }
            System.out.println();
        }
    }
    

* A: 冒泡排序功能實(shí)現(xiàn)
        * a: 題目分析
            * 通過觀察發(fā)現(xiàn)，本題目要實(shí)現(xiàn)把數(shù)組元素{13,46,22,65,3}進(jìn)行排序
            * 提到數(shù)組排序，就要進(jìn)行元素值大小的比較，通過上圖發(fā)現(xiàn)，我們想完成排序要經(jīng)過若干次的比較才能夠完成。
            * 上圖中相鄰的元素值依次比較，把大的值放后面的元素中，數(shù)組循環(huán)一圈后，則把最大元素值互換到了最后一個(gè)元素中。
                數(shù)組再循環(huán)一圈后，把第二大的元素值互換到了倒數(shù)第二個(gè)元素中。按照這種方式，數(shù)組循環(huán)多圈以后，
                就完成了數(shù)組元素的排序。這種排序方式我們稱為冒泡排序。
                
        * b: 解題步驟
            * 使用for循環(huán)（外層循環(huán)），指定數(shù)組要循環(huán)的圈數(shù)（通過圖解可知，數(shù)組循環(huán)的圈數(shù)為數(shù)組長(zhǎng)度 - 1）
            * 在每一圈中，通過for循環(huán)（內(nèi)層循環(huán)）完成相鄰的元素值依次比較，把大的值放后面的元素中
            * 每圈內(nèi)層循環(huán)的次數(shù)，由第幾圈循環(huán)來決定。如上圖所示
                * 進(jìn)行第一圈元素比較時(shí)，內(nèi)層循環(huán)次數(shù)為數(shù)組長(zhǎng)度 - 1
                * 進(jìn)行第二圈元素比較時(shí)，內(nèi)層循環(huán)次數(shù)為數(shù)組長(zhǎng)度 - 2
                * 依次類推，得出結(jié)論：進(jìn)行第n圈元素比較時(shí)，內(nèi)層循環(huán)次數(shù)為數(shù)組長(zhǎng)度 - n
                
        * c: 案例代碼    
            /*
              數(shù)組的排序: 一般都是升序排列,元素,小到大的排列
              
              兩種排序的方式
                 選擇排序: 數(shù)組的每個(gè)元素都進(jìn)行比較
                 冒泡排序: 數(shù)組中相鄰元素進(jìn)行比較
                 規(guī)則: 比較大小,位置交換
            */
            public class ArrayMethodTest_2{
                public static void main(String[] args){
                    int[] arr  = {3,1,4,2,56,7,0};
                    //調(diào)用選擇排序方法
                    //selectSort(arr);
                    
                    //調(diào)用冒泡排序方法
                    bubbleSort(arr);
                    printArray(arr);
                }
                /*
                   定義方法,實(shí)現(xiàn)數(shù)組的冒泡排序
                   返回值: 沒有
                    參數(shù):  數(shù)組
                */
                public static void bubbleSort(int[] arr){
                    for(int i = 0 ; i < arr.length - 1; i++){
                        //每次內(nèi)循環(huán)的比較,從0索引開始, 每次都在遞減
                        for(int j = 0 ; j < arr.length-i-1; j++){
                            //比較的索引,是j和j+1
                            if(arr[j] > arr[j+1]){
                                int temp = arr[j];
                                arr[j] = arr[j+1];
                                arr[j+1] = temp;
                            }
                        }
                    }
                }
                
                /*
                   定義方法,實(shí)現(xiàn)功能
                   返回值: void
                   方法參數(shù): 數(shù)組
                */
                public static void printArray(int[] arr){
                    //輸出一半中括號(hào),不要換行打印
                    System.out.print("[");
                    //數(shù)組進(jìn)行遍歷
                    for(int i = 0 ; i < arr.length ; i++){
                        //判斷遍歷到的元素,是不是數(shù)組的最后一個(gè)元素
                        //如何判斷 循環(huán)變量 到達(dá) length-1
                        if( i == arr.length-1 ){
                            //輸出數(shù)組的元素和]
                            System.out.print(arr[i]+"]");
                        }else{
                        //不是數(shù)組的最后一個(gè)元素,輸出數(shù)組元素和逗號(hào)
                            System.out.print(arr[i]+",");
                        }
                    }
                    System.out.println();
                }
            }

* A: 數(shù)組的折半查找原理(圖解見day07_source/折半查找原理.JPG)
        * a: 題目分析
            * 通過觀察發(fā)現(xiàn)，本題目要實(shí)現(xiàn)查找指定數(shù)值在元素有序的數(shù)組中存儲(chǔ)的位置（索引），返回該位置（索引）。
            * 我們使用數(shù)組最中間位置的元素值與要查找的指定數(shù)值進(jìn)行比較，若相等，返回中間元素值的索引
            * 最中間位置的元素值與要查找的指定數(shù)值進(jìn)行比較，若不相等，則根據(jù)比較的結(jié)果，縮小查詢范圍為上次數(shù)組查詢范圍的一半；
                再根據(jù)新的查詢范圍，更新最中間元素位置，然后使用中間元素值與要查找的指定數(shù)值進(jìn)行比較
                ?    比較結(jié)果相等，返回中間元素值的索引
                ?    比較結(jié)果不相等，繼續(xù)縮小查詢范圍為上次數(shù)組查詢范圍的一半，更新最中間元素位置，繼續(xù)比較，依次類推。
            * 當(dāng)查詢范圍縮小到小于0個(gè)元素時(shí)，則指定數(shù)值沒有查詢到，返回索引值-1。
            
        * b: 解題步驟
            * 定義3個(gè)用來記錄索引值的變量，變量min記錄當(dāng)前范圍最小索引值，初始值為0；變量max記錄當(dāng)前范圍最大索引值，初始值為數(shù)組長(zhǎng)度-1；變量mid記錄當(dāng)前當(dāng)前范圍最中間元素的索引值，初始值為(min+max) / 2
            * 使用循環(huán)，判斷當(dāng)前范圍下，最中間元素值與指定查找的數(shù)值是否相等
            ?    若相等，結(jié)束循環(huán)，返回當(dāng)前范圍最中間元素的索引值mid
            ?    若不相等，根據(jù)比較結(jié)果，縮小查詢范圍為上一次查詢范圍的一般
            ?    中間元素值 比 要查詢的數(shù)值大，說明要查詢的數(shù)值在當(dāng)前范圍的最小索引位置與中間索引位置之間，此時(shí)，更新查詢范圍為:
                    范圍最大索引值 = 上一次中間索引位置 -1；
            ?    中間元素值 比 要查詢的數(shù)值小，說明要查詢的數(shù)值在當(dāng)前范圍的最大索引位置與中間索引位置之間，此時(shí)，更新查詢范圍為:
                    范圍最小索引值 = 上一次中間索引位置 +1；
            ?    在新的查詢范圍中，更新中間元素值的位置，再次使用最中間元素值與指定查找的數(shù)值是否相等。
                    中間索引值 = (范圍最小索引值 +范圍最大索引值) / 2;
            * 每次查詢范圍縮小一半后，使用if語句判斷，查詢范圍是否小于0個(gè)元素，若小于0個(gè)元素，則說明指定數(shù)值沒有查詢到，返回索引值-1。
            

* A: 案例代碼
    /*
       數(shù)組的查找功能
         在一個(gè)數(shù)組中,找一個(gè)元素,是否存在于數(shù)組中,如果存在,就返回索引
         
         普通查詢:
           找到元素在數(shù)組中出現(xiàn)的索引,如果沒有這個(gè) 元素,結(jié)果就是負(fù)數(shù)
            
    */
    public class ArrayMethodTest_3{
         public static void main(String[] args){
             int[] arr = {1,3,5,7,9,11,15};
             int index = binarySearch(arr,10);
             System.out.println(index);
             
         }
         
         /*
             定義方法,實(shí)現(xiàn),折半查找
             返回值: 索引
             參數(shù): 數(shù)組,被找的元素 
             實(shí)現(xiàn)步驟:
               1. 需要的變量定義
                  三個(gè),三個(gè)指針
                  
               2. 進(jìn)行循環(huán)折半
                  可以折半的條件  min <= max
               
               3. 讓被找元素,和中間索引元素進(jìn)行比較
                   元素 > 中間索引  小指針= 中間+1
                   元素 < 中間索引  大指針= 中間-1
                   元素 == 中間索引  找到了,結(jié)束了,返回中間索引
                   
                4. 循環(huán)結(jié)束,無法折半
                  元素沒有找到 ,返回-1
         */
         public static int binarySearch(int[] arr, int key){
             //定義三個(gè)指針變量
             int min = 0 ;
             int max = arr.length -1 ;
             int mid = 0;
             //循環(huán)折半,條件 min<=max
             while( min <= max){
                 //公式,計(jì)算中間索引
                 mid = (min+max)/2;
                 //讓被找元素,和中間索引元素進(jìn)行比較
                 if(key > arr[mid]){
                     min = mid + 1;
                 }else if (key < arr[mid]){
                     max = mid - 1;
                 }else{
                     //找到元素,返回元素索引
                     return mid;
                 }
             }
             return -1;
         }
         
        /*
           定義方法,實(shí)現(xiàn)數(shù)組的普通查詢
           返回值: 索引
           參數(shù):   數(shù)組, 被找的元素
           
           實(shí)現(xiàn)步驟:
             1. 遍歷數(shù)組
             2. 遍歷過程中,使用元素和數(shù)組中的元素進(jìn)行比較
                如果相同,返回元素在數(shù)組中的索引
                如果不同,返回負(fù)數(shù)
        */
        public static int search(int[] arr, int key){
            //遍歷數(shù)組
            for(int i = 0 ; i < arr.length ; i++){
                //數(shù)組元素,被查找的元素比較
                if(arr[i] == key){
                    //返回索引
                    return i;
                }
            }
            return -1;
        }
    }
            

把今天的知識(shí)點(diǎn)總結(jié)一遍。