入坑Java（九）数组

数组

1）一维数组，其实就是int [ ] array 啦，前面是这个数组的类型，后面是这个数组的名称。也可以写成String [ ] stringArray 这样啦。
2）实例化数组：

int [] oneIntArray ; 
oneIntArray = new int[3];//实例化数组,[]里面的3表示这个数组有3个变量
int [] instructNewArray = new int [3];//声明的时候直接实例化也可以

3）往数组里面添加变量：

a.实例化后，挨个添加

//实例化之后，数组oneIntArray里的第一个变量是5，第二个变量是2，第三个变量是8
	oneIntArray[0]=5;
	oneIntArray[1]=2;
	oneIntArray[2]=8;

中括号[ ]里面的参数又叫做key，指的是数组中的第几个变量，从0开始的，0表示的是第一个变量。

b.实例化时，直接添加

int [] instructNewArrayAddNumber = new int[] {5,9,11,4};

这表示的是instructNewArrayAddNumber数组一共有4个变量，分别是：5，9，11，4.

4）访问数组里的变量：
a.直接通过key来进行单个访问

System.out.println("oneIntArray的第一个变量："+oneIntArray[0]);

b.通过for循环，进行全部变量的访问

String str = "instructNewArrayAddNumber的所有变量分别是：";
	for (int i = 0; i < instructNewArrayAddNumber.length; i++) {
		str += instructNewArrayAddNumber[i]+"、";
	}
	System.out.println(str);

这样写for循环太长了，可以用加强for循环：

String str2 = "加强for循环获取到的数组：";
	for (int i : instructNewArrayAddNumber) {
		str2 += i + "、";
	}
	System.out.println(str2);

其中的instructNewArrayAddNumber表示的是要循环的数组，而 i 表示的是，数组里循环的变量，表示的是变量哦，不是key，别搞错了！
整体例子如下：

public class TryArray {
	// 一维数组
	static int[] oneIntArray;
	static int[] instructNewArrayAddNumber;

	void newArray() {
		// 实例化数组,[]里面的3表示这个数组有3个变量
		oneIntArray = new int[3];

		// 声明的时候直接实例化也可以
		int[] instructNewArray = new int[3];
		// 往数组里面添加变量,以下表示的是，数组oneIntArray里的第一个变量是5，第二个变量是2，第三个变量是8
		oneIntArray[0] = 5;
		oneIntArray[1] = 2;
		oneIntArray[2] = 8;
		// 因为在最开始就定义了oneIntArray数组有三个变量oneIntArray = new int[3];
		// 所以oneIntArray只能添加3个变量，添加超过3个的话，写的时候代码不会报错，但编译的时候会报错
		// oneIntArray[4]=7;//你要是不注释这一行的话，就会报错

		// 声明的时候可以直接添加变量，如下，表示有4个变量，每个变量分别是1，2，3，4
		instructNewArrayAddNumber = new int[] { 5, 9, 11, 4 };
		// 等于:aa = new int[4];aa[0]=5;aa[1]=9;aa[2]=11;aa[3]=4;
	}

	// 访问数组中的变量
	public static void main(String[] args) {
		TryArray tryArray = new TryArray();
		tryArray.newArray();
		// 直接通过key，也就是数组中的第几个变量，如果是第一个，那就是[0]来获取,如下：
		System.out.println("oneIntArray的第一个变量：" + oneIntArray[0]);
		String str = "instructNewArrayAddNumber的所有变量分别是：";
		// 通过循环挨个获取
		for (int i = 0; i < instructNewArrayAddNumber.length; i++) {
			str += instructNewArrayAddNumber[i] + "、";
		}
		System.out.println(str);
		String str2 = "加强for循环获取到的数组：";
		// 简化版for循环，又叫加强for循环
		for (int i : instructNewArrayAddNumber) {
			str2 += i + "、";
		}
		System.out.println(str2);
	}
}

5）二维数组
其实就是多一个中括号 []：“int [ ][ ] array”，它是用来干嘛的呢，其实跟一维数组一样，也是用来存变量的啦，只是key不同而已，如下面这个表的变量：

我可以通过一维数组添加9个变量来进行保存，然后通过[0][1][2]…来获取变量。
也可以通过二维数组来存，如下：

public class TryArray {
static int [][]twoDArray;
	void newTwoDArray() {
		twoDArray = new int[3][3];
		twoDArray[0][0]=5;
		twoDArray[0][1]=7;
		twoDArray[0][2]=2;
		twoDArray[1][0]=8;
		twoDArray[1][1]=11;
		twoDArray[1][2]=4;
		twoDArray[2][0]=14;
		twoDArray[2][1]=6;
		twoDArray[2][2]=12;
		//或者这样:twoDArray = new int[][] {{5,7,2},{8,11,4},{14,6,12}};
	}
	public static void main(String[] args) {
		TryArray tryArray = new TryArray();
		tryArray.newTwoDArray();
		for (int i = 0; i < twoDArray.length; i++) {
			for (int j = 0; j < twoDArray[0].length; j++) {
				System.out.print(twoDArray[i][j]+"|");
				if(j+1==twoDArray[0].length) {System.out.println();}
			}
		}
	}
}

输出结果是：

5|7|2|
8|11|4|
14|6|12|

二维数组只是存变量和取变量的时候跟一维数组不同而已，除此之外跟一维没什么区别了。需要注意的是，二维数组不能用加强for循环来取值啦，如果想单独取某个值的话，只要twoDArray[0][1]就可以取到了。
有2维当然就有三维、四维、五维啦，都一样，就不一一说了。

6）不对称数组
如下表：

要用二维数组来存的话，也可以，但这样的话，就会有很多空位是多余的啊，那怎么办，这个时候就需要用到不规则数组了，直接举例：

public class TryArray {
	static int asymmetricArray[][];
	void newAsymmetricArray() {
		asymmetricArray = new int[3][];
		asymmetricArray[0] = new int[3];
		asymmetricArray[1] = new int[1];
		asymmetricArray[2] = new int[2];
		asymmetricArray[0][0]=5;
		asymmetricArray[0][1]=7;
		asymmetricArray[0][2]=2;
		asymmetricArray[1][0]=8;
		asymmetricArray[2][0]=14;
		asymmetricArray[2][1]=6;
	}
	public static void main(String[] args) {
		TryArray tryArray = new TryArray();
		tryArray.newAsymmetricArray();
		for (int i = 0; i < asymmetricArray.length; i++) {
			for (int j = 0; j < asymmetricArray[i].length; j++) {
				System.out.print(asymmetricArray[i][j]+"|");
				if(j+1==asymmetricArray[i].length) {System.out.println();}
			}
		}
	}
}

这样就不会浪费空间啦，每一行的长度都不同。

7）常用数组排序法之冒泡法
比如一个数组，里面的变量是不规则排序的，我想让它从小到大进行排序，怎么玩呢，如下：

public class TryArray {
	public static void main(String[] args) {
		int array[] = new int[] {8,3,2,1,6,5,0,4,9,7};
		for (int i = 0; i < (array.length-1); i++) {
			for (int j = i+1; j < array.length; j++) {
				if(array[i]>array[j]) {
					int k = array[i];
					array[i] = array[j];
					array[j] = k;
					//不用new第三个变量进行调换的话，如下：
					//array[i] = array[j]+array[i];
					//array[j] = array[i]-array[j];
					//array[i] = array[i]-array[j];
				}
			}
		}
		for (int i = 0; i < array.length; i++) {
			System.out.println(array[i]);
		}
	}
}

--------END