黑马程序员_数组的操作

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

怎么操作数组？

数组的操作：获取数组中的元素。通常会用到遍历；通常会用到for循环。

数组中有一个属性可以直接获取到数组元素个数，length.

使用方式：数组名称.length =；

 

定义功能，用于打印数组中的元素，元素间用逗号隔开。

 

获取数组中的最大值。

思路：

1. 获取最值需要进行比较，每一次比较都会有一个较大的值，因为该值不确定。通过一个变量进行临储。
2. 让数组中的每一个元素都和这个变量中的值进行比较。如果大于了变量中的值，就用该变量记录较大值。
3. 当所有的元素都比较完成，那么该变量中存储的就是数组中的最大值了。

步骤：

1. 定义变量，初始化为数组中任意一个元素即可。
2. 通过循环语句对数组进行遍历。
3. 在变量过程中定义判断条件，如果遍历到的元素比变量中的元素大，就赋值给该变量；

需要定义一个功能来完成，以便提高复用性。

1. 明确结果，数组中的最大元素int。

2. 未知内容：一个数组。Int[]。

 

选择排序（selectSort）：

从零角标开始分别与后面的元素进行比较，如果符合条件换位；各个元素依次比较。

/*
选择排序，内循环结束一次，最值出现在头角标位置上
*/
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;
			}
		}
	}
}

比较过程：

1. 0角标位上的数组元素3首先和1角标位上的数组元素1进行比较，将较大的数值放到后面，所以此时3和1换位置，原数组现在就变成了{1,3,4,2，7,5}；
2. 还是用0角标位与其他的进行比较。接下来即用0角标位的1与2角标位的4进行比较；小的数值在前面，大的在后面，所以不用换位置；然后再用零角标位的1与3角标位的2进行比较；依次按此方式进行比较。
3. 按次方式比较完一圈后发现，最小值已经确定在了0角标位上。所以这个值就不需要参与后面的运算了。

4. 按此思路可以将1角标位上的值分别与后面的元素进行比较，这样可以确定出第二小的值。

5. 以此类推，各元素就按照从小到大的方式全部排序完了。

 

 

冒泡排序（bubbleSort）：

相邻的两个元素进行比较，如果符合条件换位。

特点：第一圈：最值出现在最后一位。

-x:为了让每一次比较的元素减少；-1：是为了避免角标越界。

/*
冒泡排序
*/
public static void bubbleSort(int[] arr)
{
	for (int x=0; x<arr.length-1; x++)
	{
		if (arr[y]<arr[y+1])
		{
			int temp = arr[y];
			arr[y] = arr[y+1];
			arr[y+1] = temp;
		}
	}
}

优化方式：把堆内存中频繁要换的位置暂时先放到栈内存中。

真实开发中，排序直接用：Arrays.sort(arr);

发现无论什么排序，都需要对满足条件的元素进行位置置换；所以可以将这部分相同的代码提取出来，单独封装成一个函数。

 

数组的查找操作

class ArrayTest 
{
	public static void main(String[] args) 
	{
		int[] arr = {3,2,1,5,4,2,9};
		int index = getIndex(arr,2);
		System.out.println("index="+index);
	}
	/*
	定义功能，获取key第一次出现在数组中的位置，
	如果返回-1，则代表该key在数组中不存在。
	*/
	public static int getIndex(int[] arr,int key)
	{
		for (int x=0; x<arr.length; x++)
		{
			if (arr[x] == key)
			{
				return x;
			}
			return -1;
		}
	}
}

 

折半查找(halfSearch)：可以提高效率，但该数组必须是有序的。

练习：采用折半查找值为13的元素的角标；代码如下：

数组中有该元素输出该元素的角标，没有该元素则返回-1。

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr = {3,2,1,5,4,2,9};
		int index = getIndex(arr,2);
		System.out.println("index="+index);
	}
	/*
	折半查找。提高效率，但是必须要保证该数组是有序的数组。
	*/
	public static int halfSearch(int[] arr,int key)
	{
		int min,max,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(min>max)
				return -1;
			mid = (max+min)/2;
		}
		return mid;
	}

}

十进制转二进制：

/*
StringBuffer容器中给我们提供了一个方法，
也就是一个功能，append
这个容器还有一个反转的功能，reverse
*/
class ArrayTest1 
{
	public static void main(String[] args) 
	{
		toBin(6);
	}
	//十进制 --> 二进制
	public static void toBin(int num)
	{
		//定义一个存储数据的容器
		StringBuffer sb = new StringBUffer();
		while(num>0)
		{
			//将每次num与2的结果存储起来
			ab.append(num%2);
			num = num/2;
		}
		System.out.println(ab.reverse());
	}
}

十进制转十六进制：

/*
1，因为两个数相与，都为1，与出来的结果才为1；
而四位十六进制数最大为B（1111）=D（15），所以将所求的数与上15
2，从后数第一个四位与上15后，算出来的是十六进制的最后一位；
然后将要转换进制的数右移四位，再与上15，算出来的又是十六进制中的一位；
依次计算；
3，32位即八个二进制位，所以最多只需与上八次，所以循环体判断八次，即x<8;
4，（temp-10+'A'）的解释：减去数字基数加上字母基数，获取的是一个字母超过A的值；
*/

class ArrayTest5
{
	public static void main(String[] args)
	{
		toHex(60);
	}
	/*
	十进制-->十六进制
	*/
	
	public static void toHex(int num)
	{
		StringBuffer sb = new StringBuffer();
		for (int x = 0; x<8; x++)
		{
			int temp = num & 15;
			if(temp>9)
				//System.out.println(temp-10+'A');
				sb.append((char)(temp-10+'A'));
			else
				//System.out.println(temp);
				sb.append(temp);
			num = num >>> 4;
		}
		System.out.println(sb.reverse());

		}
		
}

 

查表法：

（十进制转换为十六进制）
将所有的元素临时存储起来，建立对应关系；每一次&15后的值作为索引去查建立好的表，就可以找对应的元素；这样比-10+'a'简单得多。
 · 这个表怎么建立呢？
可以通过数据的形式来定义。
发现终于出结果了，但却是反着的，想要正过来呢？可以通过StringBuffer reverse功能来完成，但这个工具还没有学习。
所以可以使用已经学习过的容器：数组来完成存储。
十进制转换为十六进制：

class ArrayTest6 
{
	public static void main(String[] args) 
	{
		toHex(-60);
	}

	public static void toHex(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 = arr.length;       //指针取值为8

		while (num != 0)
		{
			int temp = num & 15;
			arr[--pos] = chs[temp];   //
			num = num >>> 4;
		}

		//存储数据的arr数组遍历
		for (int x = pos; x < arr.length; x++)
		{
			System.out.print(arr[x]+",");
		}
	}
}

 

进制转换优化：

class ArrayTest7 
{
	public static void main(String[] args) 
	{
		//toBin(-6);
		//toHex(-60);
		//toOct(60);
	}
	/*
	十进制-->二进制
	*/
	public static void toBin(int num)
	{
		trans(num,1,1);
	}
	
	/*
	十进制-->八进制
	*/
	public static void toOct(int num)
	{
		trans(num,7,3);
	}

	/*
	十进制-->十六进制
	*/
	public static void toHex(int num)
	{
		trans(num,15,4);
	}
	
	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]);
		}
	}
}

 

数组中的数组：

• 二维数组[][]

• 格式1：int[][] arr = new     int[3][2];

• 定义了名称为arr的二维数组；

• 二维数组中有3个一维数组；
• 每一个一维数组中有2个元素；

• 一维数组的名称分别为arr[0]，arr[1]，arr[2]；

• 给定一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

• 格式2：int[][] arr = new     int[3][];

• 二维数组中有3个一维数组；

• 每个一维数组都是默认初始化值null；

• 可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];

arr[1] = new int[1];

arr[2] = new int[2];

class Array2Demo 
{
	public static void main(String[] args) 
	{
//		int[] arr = new int[3];//一维数组。

		//int[][] arr = new int[3][4];//定义了名称为arr的二维数组。二维数组中有3个一维数组。
									//每一个一维数组中有四个元素。

		//System.out.println(arr[0][1]);
		
		/*
		int[][] arr  = new int[3][];

		arr[0] = new int[3];
		arr[1] = new int[1];
		arr[2] = new int[2];


		System.out.println(arr.length);//打印是二维数组的长度 3；
		System.out.println(arr[0].length);//打印二维数组中第一个一维数组长度
		*/

		int[][] arr = {{3,5,1,7},{2,3,5,8},{6,1,8,2}};

		int sum = 0;
		for(int x=0; x<arr.length;x++)
		{
			for(int y=0; y<arr[x].length; y++)
			{
				sum = sum + arr[x][y];
			}
		}

		System.out.println("sum="+sum);
	}
}
/*
int[] x; int x[];
int[][] y; int y[][]; int[] y[];


int[] x,y[];//x一维，y二维。
int[] x;
int[] y[];

a.
x[0] = y;//error

b.
y[0] = x;//yes

c.
y[0][0] = x;//error

d.
x[0][0] = y;//error

e.
y[0][0] = x[0];//yes

f.
x=y;//error
*/

 

 

----------------------------------------------------------------------------- android培训、java培训、期待与您交流！--------------------------------------------------------------------------------
详细请查看：http://edu.csdn.net/heima/