java笔记--数组的使用

public static void main(String[] args) {
        // TODO Auto-generated method stub
        //格式
        //1. int[] arr = new int[3];
        
        //2. 元素类型[] 数组名 = new 元素类型[]{元素，元素，...};
        
        /*对数组操作最基本的动作就是存和取
        核心思想：就是对角标的操作*/
        //遍历
        /*int[] arr={89,5,6,7};
        for(int n=0;n<arr.length;n++){
            System.out.println(arr[n]);
        }*/
        
        //获取数组中最大值
        //int[] arr={1,6,3,2,-8,0};
        int[] arr={13,15,19,28,33,45,78,106};
        /*int max=getMax(arr);
        System.out.println(max);
        //bubbleSort(arr);
        selectSort_2(arr);
        //selectSort(arr);
        for(int x=0;x<arr.length;x++){
            System.out.print(arr[x]+",");
        }*/
        //查找值所对应的角标
        /*int index=getIndex(arr,-8);
        System.out.print(index);*/
        //二分查找
        int index=halfSearch_3(arr,500);
        System.out.print(index);
        //java自带
        int index1=Arrays.binarySearch(arr, 45);//这个方法，若数值存在返回的是具体的角标位置，不存在返回的是   -插入点-1
        System.out.println(index1);
        toHex_3(61);
        toBinary(16);
        toOctal(10);
        System.out.print(Integer.toBinaryString(16));
        String week = getWeek(4);
        System.out.print(week);
    }   
    public static int getMax(int[] arr){
        
        int max = arr[0];
        for(int x=0;x<arr.length;x++)
        {
            if(arr[x]>max)
                max = arr[x];
        }
        return max;
    }
    //利用角标求最大值
public static int getMax_2(int[] arr){
        
        int maxIndex = 0;
        for(int x=1;x<arr.length;x++)
        {
            if(arr[x]>arr[maxIndex])
                maxIndex = x;
        }
        return arr[maxIndex];
    }
//选择排序
public static void selectSort(int[] arr){
    /*for(int x=0;x<arr.length-1;x++){
        for(int y=x+1;y<arr.length;y++){
            if(arr[x]>arr[y]){
                int temp=arr[x];
                arr[x]=arr[y];
                arr[y]=temp;
            }
        }
    }*/
    for(int x=arr.length-1;x>0;x--){
        for(int y=0;y<x;y++){
            if(arr[x]>arr[y]){
                int temp=arr[x];
                arr[x]=arr[y];
                arr[y]=temp;
            }
        }
    }
}
public static void swap(int[] arr, int a,int b){
    int temp=arr[a];
    arr[a]=arr[b];
    arr[b]=temp;
}
//冒泡排序
/*内循环：
-1：为了避免角标越界
-x：为了让外循环增加一次，内循环参数与比较的元素个数递减*/
public static void bubbleSort(int[] arr){
    for(int x=0;x<arr.length-1;x++){
        for(int y=0;y<arr.length-1-x;y++){
            if(arr[y]>arr[y+1]){
                /*int temp=arr[y];
                arr[y]=arr[y+1];
                arr[y+1]=temp;*/
                swap(arr,y,y+1);
            }
        }
    }
}
public static void selectSort_2(int[] arr){
    
    for ( int x=0 ;x<arr.length-1;x++){
        
        int num = arr[x];//记录数组中的数值
        int index = x;//记录角标
        for(int y=x+1;y<arr.length;y++){
            if(num>arr[y])
            {
                num=arr[y];
                index=y;
            }           
        }
        if(index!=x)
            swap(arr,x,index);
    }
}
//数组常见供能：查找
public static int getIndex(int[] arr,int key){
    for(int x=0;x<arr.length;x++){
        if(arr[x]==key)
            return x;
    }
    return -1;
}
//二分查找法
public static int halfSearch(int[] arr,int key){
    int max,min,mid;
    min=0;
    max=arr.length-1;
    mid=(max+min)/2;
    
    while(arr[mid]!=key){
        if(key>arr[mid])
            min=mid+1;
        else if(key<arr[mid])
            max=mid-1;
        if(max<min)
            return -1;
        mid=(max+min)/2;
    }
    return mid;
}
public static int halfSearch_2(int[] arr,int key){
    int max,min,mid;
    min=0;
    max=arr.length-1;
    
    while(min<=max){
        mid=(max+min)>>1;
    if(key>arr[mid])
        min=mid+1;
    else if(key<arr[mid])
            max=mid-1;
        else 
            return mid;
    }
    return -1;
}
/*
 面试题：
 给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是
 有序的，那么这个元素的角标如何获取。
 {13,15,19,28,33,45,38,106}
 */
public static int halfSearch_3(int[] arr,int key){
    int max,min,mid;
    min=0;
    max=arr.length-1;
    
    while(min<=max){
        mid=(max+min)>>1;
    if(key>arr[mid])
        min=mid+1;
    else if(key<arr[mid])
            max=mid-1;
        else 
            return mid;
    }
    return min;
}
//十进制转换为十六进制
//0，1，2，3，4，5，6，7，8，9，A, B, C, D, E, F
//0，1，2，3，4，5，6，7，8，9，10,11,12,13,14,15
/*
 什么时候使用数组
 如果数据出现了对应关系，而且对应关系的一方是有序的数字编号。并作为角标使用。
 这时就必须要想到数组的使用
 
  就可以将这些数据存储到数组中。
  根据运算的结果作为角标直接去查数组中对应的元素即可。
  
  这种方式：称为查表法
 */
public static void toHex_2(int num){
    //定义一个对应关系表
        char[] chs = {'0','1','2','3',
                    '4','5','6','7',
                    '8','9','A','B',
                    'C','D','E','F'};
        /*一会查表会查到比较多的数据。
        数据一多，就先存储起来，再进行操作。
        所以定一个数组。临时容器。*/
        char[] arr = new char[8];
        int pos = 0;
        
        while(num!=0){
            int temp = num & 15;
            arr[pos++] = chs[temp];
            num = num >>> 4;
        }
        System.out.println("pos="+pos);
        for(int x=0;x<pos;x++){
            System.out.print(arr[x]);
        }
}
//在toHez_2的基础上，将数组倒过来
public static void toHex_3(int num){
    if(num==0){
        System.out.print("0");
        return ;//不写return还是会执行以下的操作，写上return，函数立马就返回了
    }
    //定义一个对应关系表
        char[] chs = {'0','1','2','3',
                    '4','5','6','7',
                    '8','9','A','B',
                    'C','D','E','F'};
        /*一会查表会查到比较多的数据。
        数据一多，就先存储起来，再进行操作。
        所以定一个数组。临时容器。*/
        char[] arr = new char[8];
        int pos = arr.length;
        
        while(num!=0){
            int temp = num & 15;
            arr[--pos] = chs[temp];
            num = num >>> 4;
        }
        System.out.println("pos="+pos);
        for(int x=pos;x<arr.length;x++){
            System.out.print(arr[x]);
        }
        return ;
}
public static void toHex_1(int num){
    //定义一个对应关系表
    char[] chs = {'0','1','2','3',
                '4','5','6','7',
                '8','9','A','B',
                'C','D','E','F'};
    
    for(int x=0;x<8;x++){
        int temp = num & 15;
        System.out.println(chs[temp]);
        num=num >>> 4;
    }
}
  public static void toHex(int num){
      for(int x=0;x<8;x++){
          int temp = num & 15;
          if(temp>9)
          System.out.println((char)(temp-10+'A'));
          else
              System.out.println(temp);
          num = num>>>4;
      }
      /*int n1=num & 15;
      System.out.println("n1="+n1);
      
      num=num>>>4;
    int n2 = num & 15;
    System.out.println("n2="+n2);*/
  }
  //十进制-->十六进制
  public static void toHex_4(int num){
      trans(num,15,4);
  }
  //-->二进制
  public static void toBinary(int num){
      trans(num,1,1);
  }
  //-->八进制
  public static void toOctal(int num){
      trans(num,7,3);
  }
  public static void trans(int num,int base,int offset){
        if(num==0){
            System.out.print("0");
            return ;//不写return还是会执行以下的操作，写上return，函数立马就返回了
        }
        //定义一个对应关系表
            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;
            }
            System.out.println("pos="+pos);
            for(int x=pos;x<arr.length;x++){
                System.out.print(arr[x]);
            }
            return ;
    }
  /*
   使用查表法。
   星期。
 String s=“abc”
 int x =4  
   */
   public static String getWeek(int num){
       if(num>7||num<1){
           return "错误的星期";
       }
       String[] weeks={"","星期1","星期2","星期3","星期4","星期5","星期6","星期7"};
       return weeks[num];
   }

运行：