Java4——数组

一、 一维数组

（一）、一维数组的声明

类型 名称[] 或 类型[] 名称

   		   int a[];
	   	   int[] a1;
		   double  b[];
		   Mydate[] c;  //对象数组

（二）、一维数组初始化

动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行。声明时就定义数组容量。

int [] ii=new int[4];//声明一个能放4个int类型数据的数组。 

静态初始化：在定义数组的同时就为数组元素分配空间并赋值。

int [] ii=new int[]{1,2,3,4};//声明了存放{1，2，3，4}的数组

（三）、数组元素的引用

1. 定义并用运算符new为之分配空间后，才可以引用数组中的每个元素
2. 数组元素的引用方式：数组名[数组元素下标]
3. 数组元素下标可以是：整型常量、整型表达式。如a[3] , b[i] , c[6*i];
4. 数组元素下标从0开始，长度为n的数组合法下标取值范围: 0 —>n-1；如int a[]=new int[3];
5. 可引用的数组元素为a[0]、a[1]、a[2] 每个数组都有一个属性length指明它的长度，例如：a.length
6. 指明数组a的长度(元素个数) 数组一旦初始化，其长度是不可变的

（四）、数组元素的默认初始化

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化。
使用动态初始化时，数组有默认值
数字的默认值是0、对象的默认值是null

二、多维数组

即每个一维数组中的元素都是数组。

1. 格式1（动态初始化）：int[][] arr = new int[3][2];
2. 格式2（动态初始化）：int[][] arr = new
   int[3][]; ps:int[][]arr = new int[][3]; //非法
3. 格式3（静态初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

注意特殊写法情况：int[] x,y[]; x是一维数组，y是二维数组。
Java中多维数组不必都是规则矩阵形式
数不能给数组赋值，数组不能给数赋值

静态：
int [] ii=new int [][]{{1,2},{3,4}};

声明：int[] x,y[];  以下选项允许通过编译的是：
a )   x[0] = y;  //no, x[0]是一个数，y是一个二维数组
b)    y[0] = x; //yes， y[0]就是一维数组，x是一维数组
c)    y[0][0] = x;//no， y[0][0] 是一个数字，x是一维数组
d)    x[0][0] = y;//no， x[0][0] 不存在，x是一维数组，没有第二维
e)    y[0][0] = x[0];//yes， y[0][0] 是一个数字， x[0]是一个数
f)    x = y; //no， x是一维数组，y是一个二维数组
一维数组：int[] x  或者int x[]   
二维数组：int[][] y 或者  int[] y[]  或者 int  y[][]

三、数组中涉及的常见算法

1.求数组元素的最大值、最小值、总和、平均数

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
		int i=0;
		int max=a[0];
		int min=a[0];				//min=数组的第一个元素即可，不能等于0.当然，定义这个数的时候必须要在定义数组之后
		double sum=0;				//因为后面会用sum来存放一个除法结果，所以为了保留小数部分定义为double型的
		for(i=0;i<a.length;i++)
		{
			if(a[i]>max)
			{
				max=a[i];			//每次比较结果较大的放在max中，最后循环完max中就存放了最大的一组数据
			}
			if(a[i]<min)
			{
				min=a[i];
			}
			sum+=a[i];
		}
		System.out.println("max="+max);
		System.out.println("min="+min);
		System.out.println("arry="+sum/a.length);
	}
}

2.数组的复制、反转

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
//		int [] m=a;这个不是数组的复制，而是数组的赋值。
		int [] copy=new int [4];		//新数组的长度必须与被复制数组的长度相同。
		int [] turn=new int [4];
		int i=0;
		int k=0;
		for(i=0;i<a.length ;i++)//复制
		{
			copy[i]=a[i];
		}
		for(i=3;i>=0;i--)//反转，a数组的最后一个赋值给turn的第0个
		{
			turn[k]=a[i];
			k++;
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(a[i]);
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(copy[i]);
		}
		for(i=0;i<a.length ;i++)
		{
			System.out.println(turn[i]);
		}
	}
}
结果：
4 7 8 2
4 7 8 2
2 8 7 4

3.数组元素的排序

1. 插入排序
   直接插入排序、折半插入排序、Shell排序

2. 交换排序
   冒泡排序、快速排序（或分区交换排序）
   冒泡排序思想：
   相邻两元素进行比较，如有需要则进行交换，每完成一次循环就将最大元素排在最后（如从小到大排序），下一次循环是将其它的数进行类似操作。
   轮次是数组次数减1

public class test1 
{
	public static void main(String[] args)
	{
		int [] a=new int []{4,7,8,2};
		int i=0;
		int k=0;
		int temp=0;
		for(i=0;i<a.length-1 ;i++)//循环轮次,数值为数组长度-1
			for(k=0;k<a.length-1-i;k++)//每一轮的数字对比，
				if(a[k]>a[k+1])//相邻元素，前面的大于后面的则令前后交换。正序和倒序不同的地方。
				{
					temp=a[k];
					a[k]=a[k+1];
					a[k+1]=temp;
				}
		for(i=0;i<a.length ;i++)
		{System.out.println(a[i]);}
	}
}

3. 选择排序
   简单选择排序、堆排序

4. 归并排序

5. 基数排序