黑马程序员—数组

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、一维数组

概念

同一种类型的集合。其实就是一个容器。

数组的好处

可以自动给数组中的元素从0开始编号，方便操作这些元素。

格式1：

元素类型[] 数组名 = new 元素类型[元素个数或数组长度]

格式2：

元素类型[] 数组名 = new 元素类型[]{元素，元素，……}

二、二维数组

格式

int[][] arr = new int[3][4];

1,定义了名称为arr的二维数组

2,二维数组中有3个一维数组

3，每个一维数组中有2个元素

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

提示：定义数组时必须给出数组的长度，而且数组一旦被创建，就不允许在增加他的空间。

代码示例：

数组的应用之选择排序：

/*
选择排序：
需求：将一个数组按从小到大的顺序排列并输出
思路：
1，将第一个数与其之后的每一个数进行比较，遇到较小的数，将两者的位置调换
2，重复上述步骤，将之后的数据也进行处理
3，输出排序前的排序后的数组进行比较
*/
class Sorting1
{
	//定义选择排序方法
	public static void ChoiceSort(int[] a)	
	{
		int temp = 0;
		//输出数组排序前的状态
		System.out.print("选择排序前：");
		for(int x = 0; x<a.length ;x++)		
			System.out.print(a[x]+" ");
		System.out.println();
		//进行排序处理
		for(int x = 0; x<a.length ;x++)
			for(int y = 0; y<a.length ;y++)
			{
				if(a[x]<a[y])
				{
					temp = a[x];
					a[x] = a[y];
					a[y] = temp;
				}
			}
		//输出数组排序后的状态
		System.out.print("选择排序后：");
		for(int x = 0; x<a.length ;x++)		
			System.out.print(a[x]+" ");
		System.out.println();
	}
	public static void main(String[] args)
	{
		int[] arr={4,7,3,10,2,15,5};
		//调用选择排序方法
		ChoiceSort(arr);	
	}
}
/*
最终运行结果：
选择排序前：4 7 3 10 2 15 5
选择排序后：2 3 4 5 7 10 15
*/

冒泡排序：

/*
冒泡排序：
需求：将一个数组按从小到大的顺序排列并输出
思路：
1，将第一个数与其后的一个数进行比较，如果第一个数大于第二个数，将两者的位置调换
2，重复上述步骤，将之后的数据也进行处理
3，输出排序前的排序后的数组进行比较
*/
class Sorting2
{
	//定义冒泡排序放方法
	public static void BubbSort(int[] a)
	{
		int temp = 0;
		//输出冒泡排序前状态
		System.out.print("冒泡排序前：");
		for(int x = 0; x<a.length ;x++)
			System.out.print(a[x]+" ");
		System.out.println();
		//进行排序处理
		for(int y = 0; y<a.length-1 ;y++)
			for(int x = 0; x<a.length-1 ;x++)
				{
					if(a[x]>a[x+1])
					{
						temp = a[x];
						a[x] = a[x+1];
						a[x+1] = temp;
					}
				}
		//输出冒泡排序后的数组状态
		System.out.print("冒泡排序后：");
		for(int x = 0; x<a.length ;x++)
			System.out.print(a[x]+" ");
		System.out.println();
	}
	public static void main(String[] args)
	{
		int[] arr={4,7,3,10,2,15,5};
		//调用冒泡排序方法
		BubbSort(arr);
	}
}
/*
最终运行结果：
冒泡排序前：4 7 3 10 2 15 5
冒泡排序后：2 3 4 5 7 10 15
*/

查表法进制转换：

/*
查表法将十进制转换为二进制、八进制、十六进制
*/
class  ArrayTest
{
	public static void main(String[] args) 
	{
		
		toBin(60);

		toOct(60);

		toHex(-60);
	}

	//转换为二进制
	public static void toBin(int num)
	{
		conversion(num,1,1);
	}

	//转换为八进制
	public static void toOct(int num)
	{
		conversion(num,7,3);
	}

	//转换为十六进制
	public static void toHex(int num)
	{
		conversion(num,15,4);
	}
	//转换
	public static void conversion(int num,int diwei,int yiwei)
	{
		//如果num等于0，结果输出为0
		if(num==0)
		{
			System.out.println("num="+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)
		{
			arr[--pos]=chs[num&diwei];//--pos倒着往临时容器里存
			num >>>=yiwei; //无条件右移相应位数
		}
		
		//打印转换后的结果
		for(int x=pos;x<arr.length; x++)
			System.out.print(arr[x]);
		
		//换行
		System.out.println();
	}
}
/*
最终运行结果：
111100
74
FFFFFFC4
*/

小练习一个：

验证哥德巴赫猜想

/*
小练习
需求：验证哥德巴赫猜想；任何大于6的偶数可以表示为两个素数的和
思路：
1，首先求出该偶数可能为两个数之和的所有情况
2，判断每种情况下两数是否都为素数（素数是只有1和他自己本身的约数的数）
3，返回两数的值
思路：
1，定义一个方法guess
2，采用for循环求出所有的可能情况
3，定义一个判断素数的方法（对小于自己的任何数取模都不为0）
4，返回结果return x,y;
*/
class GDBH
{
	//定义素数判断方法
	static boolean sushu(int a)
	{
		for(int m = 2; m<a ;m++)
			if(a%m==0)
				return false;
		return true;
	}
	//定义验证哥德巴赫猜想方法
	static void guess(int a)
	{
		int x,y;
		for(x = 3; x<a ;x++)
			for(y = 3; y<a ;y++)
				if(x+y==a)
					if(sushu(x))
						if(sushu(y))
							System.out.println(a+"="+x+"+"+y);
	}
	public static void main(String[] args)
	{
		int num = 44;
		//调用方法
		guess(num);
	}
}
/*
最终运行结果：
44=3+41
44=7+37
44=13+31
44=31+13
44=37+7
44=41+3
*/