数组

在java中，数组属于引用数据类型，所以在数组操作过程中，一定会牵扯到内存的分配问题。

1 声明并开辟数组
数据类型 数组名称 [] = new 数据类型 [长度] ;
数据类型 [] 数组名称 = new 数据类型 [长度] ;
2 分步完成
声明数组 : 数据类型 数组类型 [] = null ;
开辟数组 : 数组名称 = new 数据类型 [长度] ;

java为了方便数组的使用 ，提供了"数组名称 . length"的属性 ,可以取得数组的长度 。

public class TestDemo1
{
	public static void main(String args[]){
		int data [] =new int [3] ;  // 动态定义数组
		data[0]=0;
		data[1]=1;
		data[2]=2;
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+"\t");
		}
		System.out.print("\n");
			int data1[] =null ; //分步动态初始化数组
			data1=new int [3];
			data1[0]=1;
			for(int j=0;j<data1.length;j++){
				System.out.print(data1[j]+"\t");
			}
			System.out.print("\n");
			int data2[]=new int []{9,8,7};
			for(int k=0;k<data2.length;k++){
				System.out.print(data2[k]+"\t");
			}
	}
}

程序执行结果 ：0       1       2
			  1       0       0
			  9       8       7

上述代码分别用不同的方式定义了三个数组 。真麻烦。。。

数组的引用

public class TestDemo1
{
	public static void main(String args[]){
		int data [] =new int [3] ;  // 动态定义数组
		data[0]=0;
		data[1]=1;
		data[2]=2;
		int data1[]=data ;
		data1[0]=2;
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+"\t");
		}
	}
}

程序执行结果 ：2       1       2

还是可以把数组名理解为栈内存 ，他指向一块堆内存 。一块堆内存可以同时被多个栈内存指向 。

二维数组

动态初始化:数组类型 数组名称 [][] =new 数据类型 [行的个数][列的个数];
静态初始化:数组类型 数组名称 [][]= new 数组类型 [][]{{值，值},{值，值}}。

public class TestDemo1
{
	public static void main(String args[]){
		int data[][]=new int[][]{{1,2,3},{9,8,7}};
		for(int i=0;i<data.length;i++){
			for(int j=0;j<data[i].length;j++){
				System.out.print(data[i][j]+" ");
			}
			System.out.println();
		}
	}
}
程序执行结果 ：1 2 3
			  9 8 7

数组做方法参数传递

public class TestDemo1
{
	public static void main(String args[]){
		int data[]= new int []{1,2,3};
		ok(data);
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");
		}
	}
	public static void ok(int temp[]){
		for(int i=0;i<temp.length;i++){
			temp[i]*=2;
		}
	}
}
程序执行结果 ：2 4 6

方法返回数组

public class TestDemo1
{
	public static void main(String args[]){
		int data[]=ok();
		for(int i=0;i<data.length;i++){
			System.out.print(data[i]+" ");
		}
		System.out.print("数组长度："+ok().length);
	}
	public static int [] ok(){
		return new int []{8,5,7};
		}
}
程序执行结果 ：8 5 7 数组长度：3

上述代码 ，使用ok（）方法返回一个数组 ，只需要将方法的返回值改为数组即可 ，返回的可以理解为一个堆内存，让栈内存指向他 。我们也可以直接调用length属性取得长度。

数组操作方法

1：数组复制

System.arraycopy(原数组名称 ，原数组开始下标 ，目标数组名称，目标数组开始下标，长度);

public class TestDemo1
{
	public static void main(String args[]){
		int data[]=new int []{1,2,3,4,5,6};
		int data1[]=new int []{9,8,7,6,5,4,3,2,1};
		System.arraycopy(data,1,data1,0,5);
		for(int i=0;i<data1.length;i++){
			System.out.print(data1[i]+" ");
		}
	}
}
程序执行结果 ：2 3 4 5 6 4 3 2 1

2：数组排序

java.util.Arrays.sort(数组名称);

需要注意的是，上面的代码只能从小到大排序 。
java .util是java的系统包，Arrays是系统提供的一个类 。

public class TestDemo1
{
	public static void main(String args[]){
		int data1[]=new int []{9,8,7,6,5,4,3,2,1};
		java.util.Arrays.sort(data1);
		for(int i=0;i<data1.length;i++){
			System.out.print(data1[i]+" ");
		}
	}
}
程序执行结果 ：1 2 3 4 5 6 7 8 9

对象数组