java基础-数组

数组的动态初始化

• 格式：数据类型[] 数组名 = new 数据类型[长度];
• 给定数组的长度，有系统分配空间和初始值，数组长度一旦给定无法改变；
• 数组本身是引用数据类型，数组内的元素可以是基本数据类型，也可以是引用数据类型（）；
• 赋值：数组名[索引值：元素在数组中的序号，从0开始] = 要赋的值；
• 取值：数组名[索引值]；

	public static void main(String[] args) {
		int[] arr = new int[5];
		arr[0] = 1;
		arr[1] = 2;
		arr[2] = 3;
		arr[3] = 4;
		arr[4] = 5;
		System.out.println(arr[2]); //结果为3
	}

数组的静态初始化

• 格式：数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
• 简写：数据类型[] 数组名 = {元素1, 元素2, 元素3…};

	public static void main(String[] args) {
		int[] a = new int[]{1,2,3,4,5};
		int[] b = {1,2,3,4,5};
		//遍历数组b
		for(int i = 0; i < b.length; i++) { //数组长度：数组名.length
			System.out.print(a[i] + " " );
		}
	}  //结果为：1 2 3 4 5

数组的内存分析

• 栈：存储局部变量，方法的执行，没有初始值
• 堆：new出来的东西，有初始值，堆的空间很大
  基本数据类型初始值：默认值
  引用数据类型初始值：null

	//形参出现在函数定义中，在整个函数体内都可以使用，离开该函数则不能使用。方法执行完毕会释放掉分配的空间，调用结束后便不能再使用形参
	//实参出现在主调函数中，进入被调函数后，实参变量也不能使用。
	static int a = 5;
	public static void main(String[] args) {
		change(a);  //调用方法在栈中执行,执行完毕方法会释放掉分配的空间，同样形参被释放掉，因此实参内容不会改变
		System.out.println(a); //此处为定义的实参,结果为：5
		int[] arr = new int[5];
		String[] arr1 = new String[5];
		System.out.println(arr[0]); //结果为：0
		System.out.println(arr1[0]); //结果为：null
	}
	public static int change(int m) {
		return m += 2;
	}

案例

1、随机点名
		//点名系统
		//构建String类型的数组
		String[] string = new String[] {"1号", "2号", "3号", "4号", "5号", "6号", "7号", "8号", "9号"};
		//创建随机数
		Random random = new Random();
		//创建一个index索引值，使用随机数
		int index = random.nextInt(string.length-1);
		//点名
		System.out.println(string[index]);
2、遍历数组
		//遍历数组，按照如下格式输出：[1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
		int[] a = {1,2,3,4,5,6,7,8,9,0};
		System.out.print("[");
		for(int i = 0; i < a.length; i++) {
			if(i == a.length-1) {
				System.out.print(a[i] + "]" );
			}else {
				System.out.print(a[i] + ", ");
			}
		}
3、数组的工具类封装
	//下方这个例子是格式输出int类型数组，可以再写输出其他数据类型的工具类封装
	public static void printArr(int[] arr) {
		for(int i = 0; i < arr.length; i++) {
			if(arr.length == 1) {
				System.out.print("[" + arr[0] + "]");
			}else if(i == 0) {
				System.out.print("[" + arr[i] + ", ");
			}else if (i == arr.length-1) {
				System.out.print(arr[i] + "]" );
			}else {
				System.out.print(arr[i] + ", " );
			}
		}
	}
	//打印数组中的最大值和最小值
	public static void printMaxAndMin(int[] arr) {
		int max = arr[0];
		int min = arr[0];
		for(int i = 0; i < arr.length; i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
			if(arr[i] < min) {
				min = arr[i];
			}
		}
		System.out.println("最大值：" + max);
		System.out.println("最小值：" + min);
	}
1、数组逆序
    //将遍历封装
	public static void bianLi(int[] arr) {
		System.out.print("[");
		for(int i = 0; i < arr.length; i++) {
			if(i == arr.length-1) {
				System.out.print(arr[i] + "]" );
			}else {
				System.out.print(arr[i] + ", ");
			}
	}
	}
	//数组逆序1
	public static void reverse(int[] arr) {
		for(int start = 0, end = arr.length-1; start < end; start++, end--) {
			int temp = arr[start];
			arr[start] = arr[end];
			arr[end] = temp;
		}
		bianLi(arr);
	}
	//数组逆序2
	public static void getReverse(int[] arr) {
		for(int i = 0; i < arr.length; i++) {
			int temp = arr[i];
			arr[i] = arr[arr.length-i-1];
			arr[arr.length-i-1] = temp;
		}
		bianLi(arr);
	}

二维数组

格式：

• 数据类型[][] 数组名 = new 数据类型[m][n]; m：一维数组的个数，n：一维数组的内容
• 数据类型[][] 数组名 = new 数据类型[m][];
• 数据类型[][] 数组名 = new 数据类型[][]{{一维数组}, {一维数组}…}
• 简写：数据类型[][] 数组名 = {{一维数组}, {一维数组}…}

		int[][] i1 = new int[3][5];
		int[][] i2 = new int[5][];
		int[][] i3 = new int[][] {{1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7}};
		int[][] i4 = {{1,2,3,4,5}, {2,3,4,5,6}, {3,4,5,6,7}};
		//二维数组的遍历
		for(int i = 0; i < i1.length; i ++) {
			for(int j = 0; j < i1[i].length; j++) {
				System.out.println(i1[i][j]);
			}
		}