Java基础复习第四天

关键词：数组的综合应用

1.将数组转成字符串

         定义功能，将{23,27,998}数组中的元素转成字符串”[23,27,998]”

         public
static void toString(int[] arr){
      String temp = "[";
      for(int i=0;i<arr.length;i++){
        if(i<arr.length-1){
           temp = temp + arr[i] + ",";
        }
        if(i==arr.length-1){
           temp = temp + arr[i] + "]";
        }
      }
      System.out.println(temp);
   }

2.总结：数组使用的核心思想

-容器特点：a.固定长度   b.元素都有索引

         -什么时候使用容器呢？数据多了，必须先进行存储。然后进行操作。

         -对于数组容器什么时候用呢？数据多，个数确定，而且有对应关系。

         -在分析需求时，

                   1，需求中的数据是否有对应的有序编号？

                   2，需求中的数据是否需要有序的编号？

            如果有，就用数组存储。

-查表法：数据之间存在对应关系。通过关系中一方查询另一方。当对应关系存在，但没有一方是有序编号时，使用另一个容器 map。

3. 进制之间的转换

a.需求：十进制-->十六进制。

public
static void main(String[] args) {
      int[] arr = {12,23,14,15,16,17};
      toString(arr);
     System.out.println("--------------分割线---------------");
     
      int num = 60;
      String str = toHex(num);
      System.out.println(str);
     System.out.println("--------------分割线---------------");
     
      int num2 = 60;
      String str2 = toHex_2(num2);
      System.out.println(str2);
   }
  
   //1.定义功能，将{23,27,998}数组中的元素转成字符串”[23,27,998]”
   public
static void toString(int[] arr){
      String temp = "[";
      for(int i=0;i<arr.length;i++){
        if(i<arr.length-1){
           temp = temp + arr[i] + ",";
        }
        if(i==arr.length-1){
           temp = temp + arr[i] + "]";
        }
      }
      System.out.println(temp);
   }
  
   //2.需求：十进制-->十六进制。&15  >>>4 
循环 

   //eg,   60 --> 3C
   public
static String toHex(int num){
      //2.1.定义容器，存储的是字符，长度为8，一个整数最多为8个16进制位。
      char[] chs =
new char[8];
      //2.2.定义一个用于操作数组的索引。
      int index = chs.length;
      //2.3.循环存数组。
      while(num!=0){
        int temp = num & 15;
        if(temp > 9){
           chs[--index] = (char)(temp-10+'A');
        }else{
           chs[--index] = (char)(temp +
'0');
        }
        num = num >>> 4;
      }
      return
"0X"+toString(chs);
   }
   //2.4.定义一个功能，将字符数组转成字符串
   private
static String toString(char[] arr) {
      String temp = "";
      for(int i=0;i<arr.length;i++){
        temp = temp + arr[i];
      }
      return temp;
   }
  
   //第二题的改进版：
   /*
    思路：
      十进制转成十六进制的每一位都是十六进制元素中的某一个，
      十六进制的元素是固定个数的，而且还有对应的编号。
      所以，可以使用传说中的  
查表法。
    */
   public
static String toHex_2(int num){
      //1.建立表
      char[] chs = {'0','1','2','3'
                ,'4','5','6','7'
                ,'8','9','A','B'
                ,'C','D','E','F'};
     
      //2.创建临时容器
      char[] arr =
new char[8];
     
      //3.创建操作临时容器的角标
      int index = arr.length;
     
      //4.通过循环对num进行&和>>>操作
      while(num!=0){
        //5.对num进行&运算
        int temp = num & 15;
        //6.根据&运算后的结果作为角标查表，获取对应的字符。并将字符存储到临时容器中。
        arr[--index] = chs[temp];
        //7.对num进行右移
        num = num >>> 4;
       
      }
      return
"0X"+toString(arr,index);
   }
   private
static String toString(char[]
arr, int index) {
      String temp = "";
      for (int i = index; i <
arr.length; i++) {
        temp = temp + arr[i];
      }
      return temp;
   }
  

b.总结版：进制之间的转换

需求：十进制-->十六进制，终结版。

            思路：

               十进制转成十六进制的每一位都是十六进制元素中的某一个。

               十六进制的元素有很多固定个数。而且还有对应的编号。

               所以可以使用传说中的查表法！

4. 进制总结大集合。十进制向2进制、8进制、16进制等的转换。

public
static void main(String[] args) {
     
      //10--->2
      int num = 76;
      String str1 = trans(num, 1, 1);
      System.out.println("10--->2进制:  "+str1);
      System.out.println("-------------分割线----------------");
     
      //10--->8
      String str2 = trans(num, 7, 3);
      System.out.println("10--->8进制：  "+str2);
      System.out.println("-------------分割线----------------");
     
      //10--->16
      String str3 = trans(num, 15, 4);
      System.out.println("10--->16进制：  "+str3);
      System.out.println("-------------分割线----------------");
 
   }
  
   //十进制与二进制、八进制、十六进制之间的转换。--终极版
   public
static String trans(int num,int base,int offset){
      //1.建表，通用表，任何进制都是通用的。
      char[] chs = {'0','1','2','3'
              ,'4','5','6','7'
              ,'8','9','A','B'
              ,'C','D','E','F'};
      //2.建立临时容器，用来存放获取对应的进制数。
      char[] arr =
new char[32];//这边是因为，如果是二进制的话，就有可能是32位了，
                        //这个大一点没事，反正是从后面开始存的，转成字符串的话也是从非0的位置来进行的。
      //3.反过来存放进制数的角标
      int index = arr.length;
      //4.获取进制数，进行转换
      while(num!=0){
        int temp = num & base;
        arr[--index] = chs[temp];
        num = num >>> offset;
      }
      //5.转为字符串
      return
toString(arr,index);
   }
 
   private
static String toString(char[] arr,
int index) {
      String temp = "";
      for (int i = index; i < arr.length; i++) {
        temp = temp + arr[i];
      }
      return temp;
   }
  

5. 数组的反转。有序数组的插入点

a.在数组中查找一个数时，如果没有找到这个数，通常会返回-1，这里的-1,代表的是角标不存在的情况。

b. 需求：如果往有序的数组中插入一个元素并继续保证有序，问如何获取该位置？

分析：既然是有序的数组，而且是找位置，必须要想到 二分查找法。

解答：

public
static void main(String[] args) {
      int[] arr = {9,13,22,51,54,78,110};
      int index =
searchIndex(arr, 34);
      System.out.println("Theindex=  "+index);
      //这里因为数组的长度是不能变化的，所以只能获取到插入点，而不能将这个数插入到这个数组中。
    }
  
   //如果往有序的数组中插入一个元素并继续保证有序，问如何获取该位置？
   public
static int searchIndex(int[] arr,int key){
        int max,min,mid;
        min = 0;
        max = arr.length-1;
         while(min<=max)
        {
           mid = (min+max)>>1;
            if(key>arr[mid])
              min = mid + 1;
           else
if(key<arr[mid])
              max = mid - 1;
           else
              return mid;
        }
        return min;
      }
}