java基础05数组中的常见操作函数

class Demo1


{

     /*
      定义一个获取int数组中最大值的功能
     1：确定结果；返回值类型为int
  2；未知内容，要获取哪个数组中的最大值不确定，数组就是未知内容，需要定义成参数。
  思路：1：定义一个变量，记录住数组中比较大的元素，因为该元素是不确定的，该变量初始化成任意一个元素即可，
         2；遍历数组，让数组中每一个元素和改变量进行比较
  3;当便利到的袁术比记录的元数大时，需要将该变量记录住比较大的元素，当循环结束，该变量就是数组中的最大值


*/


     public static int getMax(int[] arr)   //获取最大值
{
       int max=arr[0];
 
 for(int i=1;i<arr.length;i++)
{
      if(arr[i]>max)
{
     max=arr[i];
}
}
return max;

}
   
     /*
选择排序：
     以一个角标的元素和其他元素进行比较
 在内循环第一次结束，最值出现在头角标的位置上
*/


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;
     }
}
}


/*
     冒泡排序：
   比较方式；相邻两个元素进行比较，如果满足条件就进行位置置换
原理：内循环结束一次，最值出现在尾角标位置。
   
*/


    public static void bubbleSort(int[] arr)
{
 for(int x=0;x<arr.length-1;x++)
{
 for (int y=0;y<arr.length-x-1;y++)  //-x：让没次参与比较的元素递减，-1：避免角标越界，
 {
 if(arr[y]>arr[y+1])
 {
                  int temp=arr[x];
      arr[x]=arr[y];
  arr[y]=temp;
 }
 }
}
}


/*
      将一个int数组变成字符串
 其实很简单，就是使用字符串相连接的原理，
*/


     public static String arrayToString(int[] arr)
{ 
      String str="";
 for(int x=0;x<arr.lengthl;x++)
{
    if(x!=arr.length-1;x++)
{
     str=str+arr[x]+",";
    }
else
  str=str+arr[x];


     }


}


    /*
为了提高效率，可使用折半查找的方式，注意：这种查找只对有序的数组有效，
这种方法也称为二分查找法。
*/
  public static int halfSearch(int[] arr,int key)
{
      int min,max,mid;
 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=(max+min)/2;   
}
return mid;
}


/*
对数组中的元素进行查找，获取该元素第一次出现的位置
*/


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 void reverseArray(int[] arr)
{
for(int start=0,end=arr.length-1;start<end;start++,end--)
{ 
       int temp=arr[start];
      arr[start]=arr[end];
  arr[end]=temp; 
   }
}


  /*
  定义一个功能，完成十进制转成二进制的运算
  */
  public static void toBin(int num)
{
      while(num>0)
{
     System.out.println(num%2);
 num=num/2; 
 }
}


  /*
     获取十进制到十六进制的转换，
  */
  public static void toHex(int num)
{
 for(int x=0;x<8;x++)//int类型是32位，没次移4位，总共移8次，
{
    int temp=num&15;  //获取num最低的四个二进制位
    


 if(temp>9)
{
     System.out.println((char)(temp-10+'a'));
 
}
else
System.out.println((char)(temp+'0'));
 num=num>>>4;
}
}




/*查表法：当我们发现：
       1.&15后的结果肯定在1-15之间，
  2.该数字结果都有对应的十六进制中的元素，
   这时就有了一个想法，如果把十六进制的元素存储到一个数组中，
然后将&15后的结果作为该数组的角标去获取对应的字符，即可完成十六进制获取，
不用在进行-10+'a'的动作，这样比较简单，


因为每次&运算后的结果和十六进制的元素都有一一对应的关系，

    什么时候使用查表法？
   当运算的结果和已有的数据有对应关系时，就可以使用查表法
这个表是一个容器，可以是数组，也可以是集合，


*/
   public static void toHex(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];  //32位2进制，是8位十六进制。


 //3定义指针用于操作arr数组，并给数组中的元素进行赋值
 int pos=arr.length;
 
       //4定义循环，重复进行&运算和查表运算和右移运算，
  while(num!=0)
{
     //进行&15运算获取四个二进制位
 int temp=num&15;
 //将temp作为角标去查chs表，并将查到的结果存储到arr数组中，
    
  arr[--pos]=chs[temp];
  //获取下一组四个二进制位
  num==num>>>4;
}
for(int x=pos;x<arr.length;x++)
{
 System.out.println(arr[x]);
}


    }




 //根据查表法的原理，完成十进制--二进制的操作，
 //java提供的方法Integer.toBinaryString(num);
 public static void toBin(int num)
{
    char[] chs={'0','1'};


char[] arr=new char[32];


int pos=arr.length;


while(num!=0)
{
   int temp=num&1;
arr[--pos]=chs[temp];


num=num>>>1;


   }


for(int x=pos;x<arr.length;x++)
{
System.out.println(arr[x]);
}
     }




 //二维数组，int[][] arr=new int[x][]; //必须有x
















public static void main(String[] args) 
{
int[] arr={3,4,8,5,2,1,0,9};
   int a=getMax(arr);
System.out.println("max"+a);
 
}
 


}