黑马程序员Java初级<四>---> 数组

一、概述：

1、定义：数组是一种数据结构，用来存储同一类型值的集合。简单来说，就是一个存放同种类型的容器。

2、使用数组的好处：数组可将其中的每一个值自动添加对应的编号，每一个值称为一个元素，元素从0开始编号，方便对每个元素的管理。

二、格式：

1、格式一：

数据元素类型[]  变量名  =  new 元素类型[参数];      说明：参数表示数组中元素的个数。

如：int[] a = new int[10];

内存分配情况如图：

2、格式二：

元素类型[] 变量名 = new 元素类型[]{元素1,元素2,......}; 

如：int[] a = new int[10]{0,1,2,3,4,5,6,7,8,9};

三、数组赋值：

1、数组的初始化：

1）对于上面两种格式的赋值：

      第一种是隐式初始化，每个元素的值都为相对应的各类型的初始化值，具体看数据类型的总结。

      第二种是显式初始化，每个元素都已经被赋予初值。

2）还可以定义匿名数组：

      new int[]{3,2,6,7,9,1,4}

2、数组的间的赋值：

java中，可以将一个数组的变量的引用值赋给另一个数组的变量。如：String[] b = a;

具体见图示：

四、多维数组：也称数组中的数组

这里主要总结一下二维数组：

1、格式：

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

定义了一个名为arr的数组，数组中有2个一维数组，每个一维数组中含有3个元素。

可以对其赋值：arr[0][0] = 3;即对第一个一位数组的第一个元素赋值。

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

此二维数组中含有3个一维数组，每个一维数组的默认初始化值都为null，每个一维数组中的元素值都为0；可对每个元素赋值，如：

       arr[0] = new int[3];

       arr[1] = new int[2];

       arr[2] = new int[1];

3）格式三：

显式初始化二维数组：int[][] arr = {{1,5,7},{4,8},{3,9,20,12}}

2、数组长度：

以格式二为例：

a.二维数组的长度：arr.length//为3

b.二维数组中的第一维数组的长度：arr[0].length//为3

五、数组的排序与查找：

1、获取最大值：

/**需求：获取数组中的最大值
思路：将数组中的元素进行从小到大（或从大到小）的排列，然后取第一个元素为最小值，取最后一个值为最大值
步骤：
	1创建类ArrayTextMax
	2创建一个数组并赋值
	3用for循环对其进行排序，
	4打印排序后的数组的第一个元素和最后一个元素
*/

class ArrayTextMax
{
	//定义功能：在数组中取最大值
	public static int getMax(int[] arry)
	{
		int max = arry[0];
		for (int i=0;i<arry.length;i++)
		{
			//用第一个元素的值和后面的比较，大则换值
			if (max<arry[i])
			{
				max = arry[i];
			}
		}
		return max;
	}

	public static void main(String [] args)
	{
		int[] arr = {5,2,4,8,6,1,9};
		int max = getMax(arr);//只是获取最大值的方法
		System.out.println("getMax方法：arr数组中最大值为；" + max);
	}
}

2、数组的排序：（选择排序、冒泡排序以及java中的排序方法）

/*
定义功能：
获取最大值，先用第一个值和每一个比较，
再用第二个值和后面的值比较，将小的放前面
*/
import java.util.*;
class ArrayText
{
	//第一种排序方法：选择排序
	public static void getPaixu0(int[] arry)
	{
		for (int j=0;j<arry.length;j++)
		{
			//i=j，每比较一轮就减少一个数，比较后，再用第二个数获得后面的最小值
			for (int i=j+1;i<arry.length;i++)
			{
				//换值
				if (arry[j]>arry[i])
				{
					int temp = 0;
					temp = arry[j];
					arry[j] = arry[i];
					arry[i] = temp;
				}
			}
		}
	}

	//第二种排序方法：冒泡排序--相邻的两个元素比较
	public static void getPaixu(int[] arr)
	{
		for (int j=0;j<arr.length*arr.length;j++)
		{
			for (int i=1;i<arr.length;i++)//设置为1是为了防止越界
			{
				if (arr[i-1]>arr[i])//若改成<是从大到小排序
				{
					int temp = 0;
					temp = arr[i-1];
					arr[i-1] = arr[i];
					arr[i] = temp;
				}
			}
		}
	}

	public static void main(String [] args)
	{
		int[] arr0 = {5,2,4,8,6,1,9};
		System.out.println("arr数组排序前:\n"+ Arrays.toString(arr0));
		System.out.println();
		int[] arr1 = {5,2,4,8,6,1,9};
		getPaixu0(arr1);//第一种排序方法
		System.out.println("选择排序方法：arr数组排序后:\n"+ Arrays.toString(arr1));//打印排序后的数组
		System.out.println();
		int[] arr2 = {5,2,4,8,6,1,9};
		Arrays.sort(arr2);//java中自带的排序函数
		System.out.println("java中自带的排序函数sort：arr数组排序后:\n"+Arrays.toString(arr2));
		System.out.println();
		int[] arr3 = {5,2,4,8,6,1,9};
		getPaixu(arr3);//第二种排序方法
		System.out.println("冒泡排序方法：arr数组排序后:\n"+ Arrays.toString(arr3));
		System.out.println();
		System.out.println("arr数组中最小值为；" + arr3[0]);
		System.out.println("arr数组中最大值为：" + arr3[arr3.length-1]);
	}
}

3、数组中元素的查找：

/**需求|：查找数组中的元素
思路|：遍历数组中的元素，并与要查找的内容比较，相同，则返回脚标
步骤
	1创建类FindArry
	2用for遍历数组，如果查找到相同内容，记录脚标并返回
	3如果未找到，就返回-1

	如果要在一个有序数组中插入一个数，之后仍有序
	就是先查找数组，用折中法：如果查找到有此数，则返回的中间值就是插入的地方，否则将返回的-1改成返回min，即为插入的地方
	如：{1, 2, 3, 5, 6, 8, 11, 13}插入8，返回mid = 5；插入后为{1, 2, 3, 5, 6, 8, 8, 11, 13}
	插入10，返回min = 6，插入后为{1, 2, 3, 5, 6, 8, 10, 11, 13}
*/

import java.util.*;
class FindArry
{
	//方法一：遍历每一个元素查找
	public static int findarr(int[] arr,int key)
	{
		for(int i=0;i<arr.length;i++)
		{
			if(arr[i] == key)
			{
				return i;
			}
		}
		return -1;
	}

	//方法二：折半，前提是数组是按大小顺序排列好的，
	//用查找的值和中间值比较，大则和下一半中间值比依次，小则和上一半中间值比，找到则返回。
	//        小值的编号在左移或大值的编号在右移。要判断是否大小值的编号相遇，仍若未找到，则不再循环，返回-1
	public static int FindArry1(int[] arr,int key)
	{
		int min,max,mid;
		min = 0;
		max = arr.length-1;
		mid = (min + max)/2;
		
		//循环，查找中间值与要查找的值比较
		while(key != arr[mid])
		{
			if (key > arr[mid])
				min = mid +1;
			else 
				max = mid - 1;
			if (min > max)
				return -1;
			mid = (min + max)/2;
		}
		return mid;
	}

	//方法三：折半第二种
	//while的条件改变
	public static int FindArry2(int[] arr,int key)
	{
		int min,max,mid;
		min = 0;
		max = arr.length-1;
		
		
		//循环，查找中间值与要查找的值比较
		while(min <= max)
		{
			mid = (min + max)>>1;
			if (key > arr[mid])
				min = mid +1;
			else if(key<arr[mid])
				max = mid - 1;
			else
				return mid;
		}
		return -1;
	}

	public static void main(String [] args)
	{
		int[] arr = {1,6,11,2,8,5,3,13};
		int m = findarr(arr,3);
		System.out.println("m=" + m);
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
		int x = FindArry1(arr,13);
		int y = FindArry2(arr,25);
		System.out.println("查找13的结果x=" + x + "\n查找25的结果y=" + y);
	}
}