JAVASE基础05

01- Java基础(数组-第二种定义格式)

数组的第二种定义格式：元素类型[]数组名 = new 元素类型[]{元素，元素，……}
如：int arr[] = new int[]{89,34,270,17}
这种定义格式用于定义一个容器存储已知数据。

02- Java基础(数组-常见操作-遍历)

对于数组的常见操作就是存和取
对于这个数组int arr[] = new int[]{89,34,270,17}
访问其中某个数可以用下标arr[i],一般使用循环遍历数组的下标i就可以遍历数组

03- Java基础(数组-常见操作-最值)

获取数组中的最大值、最小值也是常见操作
获取最大值：

1. 需要进行比较，并定义变量记录每次比较后较大的值
2. 遍历数组取出跟变量比较，变量记录较大的元素
3. 遍历结束，该变量就是最大记录。
   例如数组arr[10]=[x0,x1.x2,x3,x4,x5,x6,x7,x8,x9]
   int x=x0;
   for(int i=1;i<10;i++)
   { if x<x[i] x=x[i];}
   return x;
   结束后x就是该数组的最大值,求最小值也是同理。若需要记录最大值的下标，可以定义一个新的变量，当最大值发生改变时记录i。

04- Java基础(数组-常见操作-选择排序)

选择排序：将数组划分为有序区和无序区，遍历完第一遍，选择最值元素与首位元素交换，并将那里认为有序区；然后继续遍历无序区，将最值放与有序区的下一个元素交换，并将那里认为新的有序区，知道无序区没有元素。
for(int x=0;x<arr.length-1;x++)
{ for(int y=x+1;y<arr.length-1-x;x++)
{
If(arr[x]>arr[y])
{
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
}
}
}

05- Java基础(数组-常见操作-冒泡排序)

第一个开始遍历比较相邻的元素，顺序不对则交换相邻的元素。最终最值会放在一端，利用这个原理一次比一次缩小遍历范围最终排序成功。
for(int x=0;x<arr.length-1;x++)
{ for(int y=0;y<arr.length;y++)
{
If(arr[x]>arr[y+1])
{
int temp = arr[y];
arr[y] = arr[y+1];
arr[y+] = temp;
}
}
}

06- Java基础(数组-常见操作-排序位置置换代码提取)

在排序过程中，通常栩源进行数组内两个两个元素的位置交换，这是个常用操作，可以将这部分功能封装起来
public static void swap(int[] arr,int a,int b)
{
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}

07- Java基础(数组-排序的性能问题)

选择排序是一种经典的排序算法，它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。具体代码如下：
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])
{
swap(arr,x,y);
}
}
}
}
这里面导致一个问题，在每次遇到arr[x]>arr[y]时，会调用swap()方法，这会比较多次的新建临时变量和复制；如果我们只需要每次在遍历完未排序中的元素，并且使用一些变量存储最大（小）元素的数值和位置，在开始下一次遍历未完全排序部分前才调用swap()方法，这可以避免许多开销。具体代码如下：
public static void selectSort_2(int[] arr)
{
int num:
int index:
for(int x=0; x<arr.length-1; x++)
{
num = arr[x];
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);
}
}

08- Java基础(数组-常见功能-查找)

通常会遇到一些场景，需要查中某元素在数组中的位置，也可以将这部分的功能封装起来：
public static int getIndex(int[] arr,int key)
{
for(int x=0; x<arr.length; x++)
{
if(arr[x]==key)
return x;
}
return -1;
}
返回值为int类型，若没有找到，返回一个负数，负数不能作为数组下标。这种方法需要将数组遍历一遍，最坏情况下需要遍历完最后一个元素。

09- Java基础(数组-常见功能-折半查找)

假如有100张牌并且号码分别是0-99，在打乱顺序的情况下，寻找一张牌的难度大于比在排好序的情况；同样地，对于一个排序好的数组，查找数据方便些，不需要一点点进行遍历，可以跳跃地查找，经典地折半查找代码如下：
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;
}

10- Java基础(数组-常见功能-折半查找练习)

给定一个有序的数组，如果往该数组中存储一个元素，并保证这个数组还是有序的，
那么个元素的存储的角标为如何获取。
{13,15,19,28,33,45,78,106};
这个时候用折半查找就方便多了
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 min;;
}

11- Java基础(进制转换_1)

问题：获取一个整数的16进制表现形式。
public static void toHex(int num)
{

	for(int x=0; x<8; x++)//int类型有32位二进制位，去四个位合并为16进制的一位最多有8位16进制位，
	{
		int temp = num & 15;
		if(temp>9)
			System.out.print((char)(temp-10+'A'));
		else
			System.out.print(temp);
		num = num >>> 4;
	}

12- Java基础(进制转换_2-查表法)

public static void toHex_2(int num)
{

	if(num==0)
	{
		System.out.println("0");
		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]);
	}


}



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.print(chs[temp]);
		num = num >>> 4;
	}

}

13- Java基础(进制转换_整合)

//十进制-->十六进制。
public static void toHex(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.println("0");
		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;
	}

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

}