黑马程序员_Java基础Day04_数组(Done)

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

数组

概念：数组就是同一种类型的数据的集合，数组就是一个容器。

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

定义数组的格式： 

格式a:

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

int[] array = new int[3];//定义数据类型为int型，长度为(元素个数为)3的数组，数组名为array。

或者

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

int array[] = new int[3]

格式b:

元素类型[] 数组名 = new 元素类型[]{具体元素};

int[] array = new int[]{1,2,3,4,5,6,7};//这种写法时，[]中最好不要声明数组长度

或者

元素类型[] 数组名 = {具体元素};

int[] array = {1,2,3,4,5,6,7};

Java内存结构

Java程序运行时，需要在内存中分配空间。为了提高程序的运行效率，又对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

Java程序在运行时，将内存主要划分为5个区域：

1.栈内存：用于存储局部变量，当数据使用完毕，数据所占的内存空间会自动释放(局部变量就是定义在方法中或者语句中的变量)

2.堆内存：存储数组和对象。通过new操作符创建的实例对象都存放在堆内存中。每一个实例对象在堆内存中都有各自的内存地址。实例对象中的变量都有默认初始化值：引用型变量初始化值为null、int型初始化值为0、double型为0.0、float型为0.0f、boolean型初始化值为false。当堆内存中的实例对象不再被使用(没有引用指向)，则会在不确定的时间里被垃圾回收器回收。

3.4.5分别是：方法区，本地方法区，寄存器

操作数组时，常见的问题：

a.ArrayIndexOutOfBoundsException：数组角标越界异常。即，操作数组时，尝试访问数组中不存在的角标。

int[] arr = new int[3];
System.out.println(arr[3]);//数组长度为3，最大角标为2，没有角标为3的元素

b.NullPointerException：空指针异常。当引用没有任何指向，值为null时，该引用还在用于操作实体，会发生此异常。

int[] arr = new int[3];
arr = null;//arr引用指向null
System.out.println(arr[1]);//arr引用为null，不存在arr[1]

数组中的常见操作。

一、获取数组中的元素。(通常会用到遍历，即：循环)

补充：数组中有一个length属性，可以通过arr.length获取对应数组的长度。

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr = new int[]{2,4,1,23,8,33};
		for (int x=0;x<arr.length ;x++ )
		{
			System.out.println("arr["+x+"]="+arr[x]);
		}
	}
}

二、获取数组中的最值(以最大值为例)

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr = {67,35,75,12,6,123};
		int max = getMax(arr);
		System.out.println("arr数组中的最大值为："+max);
	}
	public static int getMax(int[] arr)
	{
		int max = 0;
		for (int x=1;x<arr.length ;x++ )
		{
			if (arr[x]>arr[max])
				max = x;
		}
		return arr[max];
	}
}

三、对数组进行排序。

1.选择排序：从数组第一个元素开始，每个元素都与其后面的元素进行对比。

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr = {5,4,8,43,21,1};//定义一个数组
		printArr(arr);//排序前打印arr
		System.out.println();
		selectSort(arr);//调用选择排序方法
		printArr(arr);//排序后打印arr
	}
	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);
				}
			}
		}
	}
	public static void printArr(int[] arr)//定义打印数组方法
	{
		System.out.print("[");
		for (int x=0;x<arr.length ;x++ )
		{
			if (x!=arr.length-1)
			{
				System.out.print(arr[x]+",");
			}
			else
				System.out.print(arr[x]+"]");
		}
	}
	public static void swap(int[] arr,int x,int y)//定义互换方法
	{
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

运行结果：

2.冒泡排序：相邻两个元素进行比较

class  ArrayTest
{
	public static void main(String[] args) 
	{
		int[] arr = {5,4,8,43,21,1};//定义一个数组
		printArr(arr);//排序前打印arr
		System.out.println();
		bubbleSort(arr);//调用冒泡排序方法
		printArr(arr);//排序后打印arr
	}
	public static void bubbleSort(int[] arr)//定义冒泡排序法
	{
		for (int x=0;x<arr.length-1 ;x++ )
		{
			for (int y=x;y<arr.length-x-1 ;y++ )//-x：让每一次比较的元素减少，-1：必秒数组角标越界
			{
				if (arr[y]>arr[y+1])
					swap(arr,y,y+1);
			}
		}
	}
	public static void printArr(int[] arr)//定义打印数组方法
	{
		System.out.print("[");
		for (int x=0;x<arr.length ;x++ )
		{
			if (x!=arr.length-1)
			{
				System.out.print(arr[x]+",");
			}
			else
				System.out.print(arr[x]+"]");
		}
	}
	public static void swap(int[] arr,int x,int y)//定义互换方法
	{
		int temp = arr[x];
		arr[x] = arr[y];
		arr[y] = temp;
	}
}

运行结果同上。

四、数组的查找。
1.查找某元素在数组中第一次出现的位置，如果不存在则返回-1。部分关键代码如下：

public static int getIndex(int[]arr ,int key)
	{
		for (int x=0;x<arr.length ;x++ )
		{
			if (arr[x]==key)
				return x;
		}
		return -1;
	}

2.折半查找，能够提高对数组中元素的查找效率。但是必须保证数组是有序的。如果是无序数组，应先对数组进行排序后，再使用折半查找方法。

class ArrayTest4 
{
	public static void main(String[] args) 
	{
		int[] arr = {2,4,5,7,19,32,45};
		int index = halfSearch(arr,302);
		System.out.println("index="+index);
	
	}
	public static int halfSearch(int[] arr,int key)
	{
		int min = 0;
		int max = arr.length-1;
		int 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 = (min+max)/2;
		}
		return mid;
	}
}

五、进制转换。

这里使用的是建表法。优点是：对需要转换的数字没有要求，负数也可以转换，应用范围很广。同时，建立一张char[] 的表后，可同时应用于二进制，八进制和十六进制，功能扩充性很强。

class ArrayTest6
{
	public static void main(String[] args) 
	{
		toBin(60);
		toOctal(60);
		toHex(60);
	}
	public static void toBin(int num)
	{
		trans(num,1,1);
	}
	public static void toOctal(int num)
	{
		trans(num,7,3);
	}
	public static void toHex(int num)
	{
		trans(num,15,4);
	}
	public static void trans(int num,int key,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 & key;
			arr[--pos] = chs[temp];
			num = num >>> offset;
		}
		for (int x=pos;x<arr.length ;x++ )
		{
			System.out.print(arr[x]);
		}
		System.out.println();
	}
}

二维数组(数组中的数组)

二维数组的定义方法：

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

含义：定义一个名称为arr的二维数组。二维数组中有3个一维数组，每一个一维数组中有4个元素。即：3代表的是二维数组的长度，4代表的是二维数组中，每一个一维数组的长度。
定义二维数组时，第一个[]中必须填写数字，因为第一个[]定义的是二维数组的长度；第二个[]中可以不写数字，这时，相当于只定义了二维数组的长度，而没有给二维数组中的一维数组进行初始化，如果打印 arr[0] 显示是"null" ，即二维数组中的一维数组没有具体指向，没有 被定义。

练习：对int型二维数组中的所有一维数组的所有元素进行求和。

class ArraysSum 
{
	public static void main(String[] args) 
	{
		int[][] arr = {{3,4,7,8},{9,2,7},{7,6},{9,6,12,4}};//任意定义一个二维数组
		int sum = arraysSum(arr);
		System.out.println(sum);
	}
	public static int arraysSum(int[][] arr)
	{
		int sum = 0;//定义累加器
		for (int x=0;x<arr.length ;x++ )//遍历每一个二维数组
		{
			for (int y=0;y<arr[x].length ;y++ )//遍历某个一维数组中的每个元素，并累加
			{
				sum += arr[x][y];
			}
		}
		return sum;
	}
}

运行结果：

还可以使用int[][] arr = {{arr[0]中具体元素},{arr[1]中具体元素},{arr[2]中具体元素},{arr[3]中具体元素},{arr[4]中具体元素}......{arr[N]中具体元素}}的方法定义二维数组。同一维数组的类似定义方法类似，在定义二维数组的同时，也对二维数组中的元素进行了初始化。