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

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

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

    * 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í)功能實現(xiàn)
    * a: 題目分析
        * 明確什么樣的數(shù)就是水仙花數(shù)。水仙花數(shù)是指一個3位數(shù)（100-999之間），其每位數(shù)字立方之和等于該3位數(shù)本身。
            如153 = 1*1*1 + 3*3*3 + 5*5*5，即 3位數(shù)本身 = 百位數(shù)立方 + 十位數(shù)立方 + 個位數(shù)立方;
        * 獲取水仙花范圍內(nèi)的所有3位數(shù)（100-999之間的每個3位數(shù)）
        * 判斷該3位數(shù)是否滿足水仙花數(shù)，滿足，打印該3位數(shù)
        
    * b: 解題步驟
        * 使用for循環(huán)，得到100-999之間的每個3位數(shù)
        * 獲取3位數(shù)中百位數(shù)字、十位數(shù)字、個位數(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，美國標(biāo)準(zhǔn)信息交換代碼
    * b: ASCII編碼表由來
        * 計算機中，所有的數(shù)據(jù)在存儲和運算時都要使用二進制數(shù)表示
        * a、b、c、d這樣的52個字母（包括大寫）、以及0、1等數(shù)字還有一些常用的符號, 在計算機中存儲時也要使用二進制數(shù)來表示
        * 具體用哪些二進制數(shù)字表示哪個符號，當(dāng)然每個人都可以約定自己的一套（這就叫編碼）
        * 大家如果要想互相通信而不造成混亂，那么大家就必須使用相同的編碼規(guī)則，于是美國有關(guān)的標(biāo)準(zhǔn)化組織就出臺了ASCII編碼，
            統(tǒng)一規(guī)定了上述常用符號用哪些二進制數(shù)來表示。
    * c: 中文編碼表
        * GB2312
        * UNICODE
    * d: 字符中重要的ASCII碼對應(yīng)關(guān)系
        * a : 97
        * A : 65
        * 0 : 48
        

* A: char類型的存儲
    * a: 取值范圍
        * short:占兩個字節(jié),是有符號數(shù)據(jù),取值范圍-32768-32767
        * char: 占兩個字節(jié),是無符號數(shù)據(jù),取值范圍0-65536
        
    * b: 類型轉(zhuǎn)換
        * char類型的數(shù)據(jù)參加運算時要線程程int數(shù)據(jù)類型
        
    * c: 案例代碼
        /*
            ASCII編碼表演示
            字符Java 數(shù)據(jù)類型,char
            整數(shù)Java 數(shù)據(jù)類型,int
            
            int 類型和 char 數(shù)據(jù)類型轉(zhuǎn)換
            char  兩個字節(jié), int 四個字節(jié)
            
            char轉(zhuǎn)成int類型的時候,類型自動提示,char數(shù)據(jù)類型,會查詢編碼表,得到整數(shù)
            int轉(zhuǎn)成char類型的時候,強制轉(zhuǎn)換,會查詢編碼表
            
            char存儲漢字,查詢Unicode編碼表
            
            char可以和int計算,提示為int類型, 內(nèi)存中兩個字節(jié)
            char取值范圍是0-65535, 無符號的數(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個大小寫字母，那么，可以考慮循環(huán)26次。在每次循環(huán)中，完成指定字母的大小寫打印
        * 找出ABCDEFG…XYZ這些字母之間的變化規(guī)律
            通過ASCII表發(fā)現(xiàn)，后面的字母比它前面的字母，ASCII值大1
            下一個字母 = 上一個字母 + 1
            如： A    B    C    D
                65    66    67    68
        * 在每次循環(huán)中打印上一個字母大小寫，并指定下一個字母

    * b: 解題步驟
        * 定義初始化大寫變量，值為’A’； 初始化小寫變量，值為’a’
        * 使用for循環(huá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行星，每行打印星的個數(shù)與當(dāng)前行數(shù)相等。
        再觀察“1*3=3 2*3=6 3*3=9”得出它們?nèi)缦碌淖兓?guī)律：
                每行第n次 +"*"+ 行號 +"="+ 每行第n次 * 行號
            如:    1    +"*"+  2    +"="+   1*2; // 相當(dāng)于1*2=2
                2    +"*"+  2    +"="+   2*2; // 相當(dāng)于2*2=4    

    * c: 解題步驟
        * 定義一個外層for循環(huán)，初始值從1開始，循環(huán)9次。用來控制打印的行數(shù)
        * 在外層for循環(huán)內(nèi)部，定義一個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代表：行號
        * 在外循環(huán)中，當(dāng)每行指定次數(shù)的乘法公式打印完畢后，通過System.out.println()切換到下一行。
            這樣，再次打印乘法公式時，就在下一行輸出打印了

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

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

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

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

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

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

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

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

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

把今天的知識點總結(jié)一遍。