黑马程序员————用java数组

---------------------- android培训、java培训、期待与您交流！ ----------------------

 

首先理解一下java数组，

  数组可以看成是多个相同数据类型的组合（数组的数据可以使任何类型，基础类型或引用类型），对这些数据对象的统一管理；

 数组属引用类型，也可看成是对象，每个数据可以看做是对象的成员变量；

 

一维数组的声明：

  type name[ ]  或 type[ ] name;

  例如：  int [ ] a ;  int a[ ];  String[ ] str;

 

利用关键字 new 创建数组  如： int a[ ] = new int [ 5];

 

可以进行动态初始化 如：

                                  int a[ ] = new int [ 5];

                                 for(int i=0; i<a.length; i++){
                                      System.out.print(a[i]+" ");
                                    }

或静态初始化 如：

                                  String str[ ] = { "this","is","array","!"};

 

下面利用一维数组写两实现一些小功能：

 

/*
 *功能：1.求最值，（最大getMax，最小getMin）
 *  2.排序，（选择排序selectSort）
 *  3.打印结果
*/
public class TestArray {
 
 public static void main(String[] args) {
  
  int[] arr = {5,3,9,6,1,8,7,2,4};
  int min = getMin(arr);
  System.out.println(min);
  
  int max = getMax(arr);
  System.out.println(max);
  
  printArr(arr);
  //selectSort(arr);
  bubbleSort(arr);
  printArr(arr);
  
  int key = halfSearch_2(arr,9);
  System.out.println(key);
  
  toHex(60);
  
  toBin(-6);
  }
  
 //求最小值
 public static int getMin(int[] arr) {
  
  int min = 0;
  for(int i=0;i<arr.length; i++){
   
   if(arr[i]<arr[min]){
    
    min = i;
    }
  }
  return arr[min];
 }
  
 //求最大值
 public static int getMax(int[] arr) {
  
  
  int max = 0;
  for(int i=0;i<arr.length; i++){
   
   if(arr[i]>arr[max]){
    
    max = i;
    }
  }
  return arr[max];
 }
  
 //选择排序，原理，将数组中的第一个元素假定为最小值，一次和后面的元素比较，如果比后面的元素值大，则交换位置
 public static void selectSort(int[] arr) {
  
  int temp = 0;//用于交换数据时存储的变量
  
  //循环嵌套，一次次比较。
  for(int i=0;i<arr.length; i++){
   
   for(int j=i+1;j<arr.length; j++){
    
    //判断数据，进行交换
    if(arr[i]>arr[j]){//正序排序;倒序排序if(arr[i]<arr[j])
     temp = arr[i];
     arr[i] = arr[j];
     arr[j] = temp;
     }
   }
  }
 }
  

 //冒泡排序，原理。每两个相邻的元素进行比较，将较大的数向后移。那么最后一个元素则是最大的。
 public static void bubbleSort(int[] arr) {
  
  int temp = 0;
  for (int i=0;i<arr.length-1; i++)//arr.length-1意思是，每两相邻的比较，数组的最后元素必为最大
  
   for(int j=0;j<arr.length-i-1;j++){//arr.length-i,以后每次循环的长度。-1，防止数组下标越界。
    
    if(arr[j]>arr[j+1]){
     temp = arr[j];
     arr[j] = arr[j+1];
     arr[j+1] = temp;
     
     }
    }
  
  }
 
 
 //打印数组元素的方法printArr（）
  
 public static void printArr(int[] arr) {
  
  System.out.print("{");
  for(int i=0;i<arr.length; i++){
   
   if(i != arr.length-1){
    System.out.print(arr[i]+", ");
   }else{
    
    System.out.print(arr[i]);
    }
  }
  System.out.println("}");
  }
  
 //查找指定元素的下标值
 public static int search(int[] arr,int key) {
  
  for(int i=0; i<arr.length; i++){
   if(arr[i]==key)
   return i;
  }
  
  return -1;
 }
 
 
 //用折半查找，查找指定值的下标。注意：前提是数组必须是有序的。
 
 public static int halfSearch(int[] arr,int key) {
  
  int min,mid,max;
  min = 0;
  
  max = arr.length-1;
  mid = (min+max)/2;
  
  while(arr[mid] != key){
   
   if(key>arr[mid]){
    
    min = mid+1;
    }
   else if(key<arr[mid]){
    max = mid -1;
   }
   
   if(min>max) return -1;
   
   mid = (min+max)/2;
  }
  
  return mid;
 }
 
 //折半的第二种方式
 public static int halfSearch_2(int[] arr,int key) {
  
 int min =0,mid,max = arr.length-1;
 
  while(min<=max){//意思是，如果最小值与最大值之间有空间，则循环
   
   mid = (min+max)/2;
   if(arr[mid]<key){
    min = mid +1;
    
    }else if(arr[mid]>key){
     max = mid -1;
    
    }else{
     return mid;
     }
   
   } 
  return -1;
 }
 
 /*
 
 //十进制转十六进制
 public static void getHex(int key){
  
    //用数组优化
  char[] ch ={'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-1;//相当于定义一个表示游标的计数器，初始值为存储转换十六进制后装于数组容器的长度。
  
  while(key !=0){//只要不断移位后的值不等于0循环。
   
   int temp = key&15;
   
   arr[pos--] = ch[temp];//用一个数组将求的的十六进制数用char数组封装、
   
   key = key >>>4;
  }
  
  for(int i=0;i<arr.length;i++){
   System.out.print(arr[i]);
  }

  StringBuffer s = new StringBuffer();
  
  for(int i=0;i<8; i++){//i<8意思是每一个int类型32位，4个为一组，8组
   int num = key&15;//求出第一个4位十六进制的数；
   if(num>9){
   // System.out.print((char)(num-10+'A'));//如果大于9，转换为十六进制表现形式
   s.append((char)(num-10+'A'));
    }else{
    // System.out.print(num);
    s.append(num);
    }
    key = key >>>4;//将参数的二进制形式右移4为，>>>表示无符号右移，主要区分于负数。
  }
  System.out.println(s.reverse());
  

  
  }*/
  
  //进制转换的通用方法
  public static void trans(int num,int base,int offset){//num需转换的数，base与的基数，offset，移的位数
   
    char[] ch ={'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] = ch[temp];
     
     num = num>>>offset;
     }
     
    for(int i=pos;i<arr.length;i++){
     System.out.print(arr[i]);
    }
    System.out.println();
  }
  
  //通用二进制转换

  public static void toBin(int num){
   trans(num,1,1);
   }
   
   
  
  //通用二进制转换
  
   public static void toBa(int num){
   trans(num,7,3);
   }
   
  
  //通用二进制转换
  
   public static void toHex(int num){
   trans(num,15,4);
   }
   
}

 

 

---------------------- android培训、java培训、期待与您交流！ ----------------------