java：数组

一、数组是什么：

有序的数据序列，同一数组的数据类型是相同的。

数组为引用类型，数组型数据是对象。

二、一维数组

1、数组的定义

（1）、静态初始化：数据类型 []  数组名 = {变量0，变量1，变量2}；

注：[]也可以写在数组名后，这种方法定义的数组长度根据后方变量的数量而定

（2）、动态初始化1：数据类型 [] 数组名 = new int[n]

表示创建一个长度为n的数组

（3）、动态初始化2：也可以先声明，在需要的时候再定义

声明时不分配内存，定义后再分配。

int[] array1 = {1, 2, 3, 4, 5};


int array1[] = {1, 2, 3, 4, 5};


int a = new int();

int a;   //此时还是空的
a= new int();

2、、数组的引用

数组的引用：array1[i] ,其中i是索引值，表示的是引用第i+1个变量

其中第一个变量索引值为0。

注：索引值又被称为下标。

3、length，长度属性

array1.length = 数组中的变量的数量。

public static void main(String[] args) {
		int[] array1 = new int[6];
		Scanner myScanner = new Scanner(System.in);//设立监听器

		for(int i = 0;i <= (array1.length - 1);i++) {//变量输入
			System.out.println("请输入数组的第"+i+"个变量:");
			array1[i] = myScanner.nextInt();
		}
		System.out.println("数组的各个变量为:");
		for(int i = 0;i <= 5;i++) {    //输出
			System.out.print(array1[i]+"\t");
		}
	}

三、数组的数值传递。

1、数组时引用类型数据，数组的数值传递传递的是数组的地址。即赋值时将数组的地址赋给另一个数组，赋值完后，两者共用一块地址。

 

2、用一个数组A给另一个数组B赋值：无论被赋值前的数组B是怎么样的，被赋值后都会被数组A同化

        int[] arr1 = {1, 2, 3, 4};
		int[] arr2 = new int[3];
		int[] arr3 = new int[3];
		int[] arr4 = new int[5];
		int[] arr5 = {1,2,3};
		arr3 = arr1;//若待赋值数组比原数组短
		arr4 = arr1;//若待赋值数组比原数组短，且已经被赋值
		arr5 = arr1;//若待赋值数组比原数组长
		System.out.println(arr2.length);//3
		System.out.println(arr3.length);//4
		System.out.println(arr4.length);//4
		System.out.println(arr5.length);//4
		/* 数组3,4,5分别是比数组1，短、短且已经被赋值，长，但输出的长度都一样。
		 * 以上说明，无论被赋值前的原数组是怎么样的，被赋值后都会被同化。
		 */

3、数组的赋值是将地址赋给其他数组，即上图中，赋值完后，arr1，arr3，arr4，arr5是同一个数组。

arr3[2] = 1;
		//此时的arr1，arr3，arr4，arr5是同一个数组。
		for(int i = 0; i <= 3; i++) {
			System.out.print(arr1[i]);
		}

4、数据拷贝，数据拷贝会产生一个新的数组，并给新的数组赋值一个新的地址。

        int[] arr1 = {1, 2, 3, 4};
		int[] arr2 = new int[4];
		for(int i = 0; i <= 3; i++) {
			arr2[i] = arr1[i];
		}

5、数组的扩容

		int[] arr1 = {1, 2, 3};
		int[] newarr = new int[4];
		
		for(int i = 0; i <= newarr.length - 2; i++) {
			newarr[i] = arr1[i];
		}
		newarr[3] = 4;
		arr1 = newarr;

四、二维数组

1、定义：数据类型[][] 数据名 = { {第一行的变量} ， {第二行的变量} ，。。。 }

二维数组相当于一维数组的每一个数组都变成一个数组。

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}
//静态初始化

int[][] arr = new int[3][3]
//动态初始化

2、二维数组的引用

当引用二维数组的变量 arr[2][2]时，表示引用第3行，第3列的（从0开始）数值

        int[][] dimenArray = {{1, 2, 3}, 
				              {4, 5, 6}, 
				              {7, 8, 9}};
		
		System.out.println(dimenArray[2][2]);//9

3、二维数组的长度：

二维数组的长度“arr.length”表示的是二维数组的行数，即这个二维数组有多少个一维数组。

注：可以理解为二维数组的元素是一维数组，二维数组的元素个数是其中一维数组的个数。

                          “arr[i].length”表示二维数组的列数。

4、二维数组在计算机中的存储：

已知，一维数组存储的是一段引向堆栈的地址，那么二维数组是如何在计算机中存储的呢？

运行如下代码，我们发现，二维数组中的每一个一维的元素都是以一维数组的形式存在。所以我们可以认为，二维数组实际是对一维数组的嵌套。二维数组实质上是数据类型为“地址”（C语言中称之为指针）的一维数组。

    public static void main(String[] arg) {
		int[][] dimenArray = {{1, 2, 3}, //初始化二维数组
				              {4, 5, 6}, 
				              {7, 8, 9}};
		
		System.out.println(dimenArray[2][2]);//9
		
		int[] arr2 = dimenArray[1];  
        //将二维数组的一个一维数组赋值给一个一维数组
	    arr2[1]++;   //对一维数组中的一个元素进行操作
	    
	    System.out.println(dimenArray[1][1]);//6
        //结果影响到了二维数组。
	}

在Java中二维数组中的每一个一维数组相对独立性较强

 5、列数不等的数组

在“二维数组在计算机中的存储”中，我们已知二维数组的每一个一维数组都有很强的独立性，这个独立性也体现在二维数组的列数可以不相等上。

int[][] arr3 = new int[3][];// 
		for(int i=0;i<arr3.length;i++){//遍历arr每个一维数组
			arr3[i] = new int[i + 1];//遍历一维数组，并给一维数组的每个元素赋值 
			for(int j = 0; j <arr3[i].length; j++) {
				arr3[i][j] = i + j;
			}
		}
		for(int i=0;i<arr3.length;i++) {
			for(int j=0;j<arr3[i].length;j++) {
				System.out.print(arr3[i][j]+"\t");
				
			}
			System.out.print("\n");
		}

五、new

在JAVA里就是创建一个新的实例,或者说一个新的对象,一个普通类在没有实例化之前,就是new之前,它的属性,方法等等在内存中都是不存在的。只有使用new了以后,这个类的一些东西在内存中才会真的存在,也就是说只有new了之后,这个类才能用

int c = new int[2];意思就是说，把这个对象在内存中的地址 赋值 给数组c，这就是Java中引用概念，c就叫做引用，或者叫引用变量，或者直接叫变量，没问题，都是它;c的值就是一个内存地址，或者叫引用地址。

总结：java中的数组和C语言中的数组有很大差别，java中的变量更像C语言中的指针。存储时存储的是一个地址，指向存储数据的地址，如果是基本变量类型的变量则可以进行简单的运算。如果是引用变量类型则只能进行地址上的运算。