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];
}
运行：
image.png
网友评论