Java数组

1.数组概述

    *数组是储存多个元素的容器

    *元素的数据类型要一致

2.数组的格式定义

    *数组是存储同一种数据类型多个元素的容器

    *可以存储基本数据类型和引用数据类型

    *数组格式

        *格式一:数据类型[] 数组名;

        *格式二:数据类型 数组名[];

3.数组的初始化

    *Java中数组必须要先初始化才能使用

    *初始化方式

        *动态初始化:初始化时只指定数组的长度,由系统为数组分配初始值

            *数据类型[] 数组名 = new 数据类型[数组长度];

            *int[] arr = new int[3];

                *定义了一个int类型的数组,可以存放三个int类型的值

            

package com.text;
/*
 * 数组：存储同一种数据类型的多个元素的容器。
 * 
 * 定义格式：
 * 		A:数据类型[] 数组名;
 * 		B:数据类型 数组名[];
 * 举例：
 * 		A:int[] a; 定义一个int类型的数组，数组名是a
 * 		B:int a[]; 定义一个int类型的变量，变量名是a数组
 * 
 * 数组初始化：
 * 		A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
 * 		B:我们有两种方式对数组进行初始化
 * 			a:动态初始化	只指定长度，由系统给出初始化值
 * 			b:静态初始化	给出初始化值，由系统决定长度
 * 
 * 动态初始化：
 * 		数据类型[] 数组名 = new 数据类型[数组长度];
 */
public class ArrayDemo {
	public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[数组长度];
		int[] arr = new int[3];
		/*
		 * 左边：
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		arr:是数组的名称
		 * 右边：
		 * 		new:为数组分配内存空间
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		3:数组的长度，其实就是数组中的元素个数
		 */
	
	}
}

        *静态初始化:初始化时指定每个数组元素的初始值,由系统决定长度

package com.text;
/*
 * 静态初始化的格式：
 * 		数据类型[] 数组名 = new 数据类型[]{元素1,元素2,...};
 * 
 * 		简化格式：
 * 			数据类型[] 数组名 = {元素1,元素2,...};
 * 
 * 		举例：
 * 			int[] arr = new int[]{1,2,3};
 * 
 * 		简化后：
 * 			int[] arr = {1,2,3};
 */
public class ArrayDemo2 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {1,2,3};
		
		//输出数组名和元素
		System.out.println(arr);
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

4.数组的内存分配

    *JVM内存划分

        *栈        存储局部变量,使用完毕立即回收

        *堆        存储new出来的东西

            *都有地址值

            *里面的元素都有默认值

                *byte,short,int,long    0

                *double,float    0.0

                *char    '\u0000'

                *boolean    false

                *引用数据类型    null

            *使用完毕后,在垃圾回收机制空闲的时候会被回收

        *方法区        字节码文件,方法列表,本地方法区(系统),寄存器(cpu)

    *两个数组指向同一个地址值

5.数组的使用

    *访问数组内的元素

package com.text;
/*
 * 数组：存储同一种数据类型的多个元素的容器。
 * 
 * 定义格式：
 * 		A:数据类型[] 数组名;
 * 		B:数据类型 数组名[];
 * 举例：
 * 		A:int[] a; 定义一个int类型的数组，数组名是a
 * 		B:int a[]; 定义一个int类型的变量，变量名是a数组
 * 
 * 数组初始化：
 * 		A:所谓初始化，就是为数组开辟内存空间，并为数组中的每个元素赋予初始值
 * 		B:我们有两种方式对数组进行初始化
 * 			a:动态初始化	只指定长度，由系统给出初始化值
 * 			b:静态初始化	给出初始化值，由系统决定长度
 * 
 * 动态初始化：
 * 		数据类型[] 数组名 = new 数据类型[数组长度];
 */
public class ArrayDemo {
	public static void main(String[] args) {
		//数据类型[] 数组名 = new 数据类型[数组长度];
		int[] arr = new int[3];
		/*
		 * 左边：
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		arr:是数组的名称
		 * 右边：
		 * 		new:为数组分配内存空间
		 * 		int:说明数组中的元素的数据类型是int类型
		 * 		[]:说明这是一个数组
		 * 		3:数组的长度，其实就是数组中的元素个数
		 */`
		
		System.out.println(arr); //[[e-mail],地址值
		//我们获取到地址值没有意义，我要的是数组中的数据值，该怎么办呢?
		//不用担心，java已经帮你想好了
		//其实数组中的每个元素都是有编号的，编号是从0开始的，最大的编号就是数组的长度-1
		//用数组名和编号的配合我们就可以获取数组中的指定编号的元素
		//这个编号的专业叫法：索引
		//格式：数组名[编号] -- 数组名[索引]
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
	}
}

    *数组的遍历

package com.text;

/*
 * 需求：数组遍历(依次输出数组中的每一个元素)
 * 获取数组中元素的个数：数组名.length
 */
public class ArrayTest {
	public static void main(String[] args) {
		// 定义数组
		int[] arr = { 11, 22, 33, 44, 55 };
		// 原始做法
		System.out.println(arr[0]);
		System.out.println(arr[1]);
		System.out.println(arr[2]);
		System.out.println(arr[3]);
		System.out.println(arr[4]);
		System.out.println("--------------------");

		// 用for循环改进
		for (int x = 0; x < 5; x++) {
			System.out.println(arr[x]);
		}
		System.out.println("--------------------");
		
		//为了解决我们去数数组中元素个数的问题，数组就提供了一个属性：length
		//用于获取数组的长度
		//格式：数组名.length
		System.out.println("数组共有："+arr.length+"个");
		System.out.println("--------------------");
		
		for(int x=0; x<arr.length; x++) {
			System.out.println(arr[x]);
		}
	}
}

    *取数组中的最大值

package com.text;
/*
 * 需求：数组获取最值(获取数组中的最大值最小值)
 */
public class ArrayTest2 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = {12,98,45,73,60};
		
		//定义参照物
		int max = arr[0];
		
		//遍历数组，获取除了0以外的所有元素，进行比较
		for(int x=1; x<arr.length; x++) {
			if(arr[x] > max) {
				max = arr[x];
			}
		}
		System.out.println("数组中的最大值是："+max);
	}
}

    *不死神兔问题

package com.text;

/*
 * 需求：
 * 		有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，
 * 		假如兔子都不死，问第二十个月的兔子对数为多少？ 
 * 
 * 规律：
 * 		第一个月：1
 * 		第二个月：1
 * 		第三个月：2
 * 		第四个月：3
 * 		第五个月：5
 * 		...
 * 
 * 		规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和。
 * 			第一个月和第二个月的兔子对数是1
 * 分析：
 * 		int[] arr = new int[20];
 * 
 * 		arr[0] = 1;
 * 		arr[1] = 1;
 * 
 * 		arr[2] = arr[0] + arr[1];
 * 		arr[3] = arr[1] + arr[2];
 * 		arr[4] = arr[2] + arr[3];
 * 		...
 */
public class Test4 {
	public static void main(String[] args) {
		//定义数组
		int[] arr = new int[20];
		
		//初始化第一个月和第二个月的兔子对数c
		arr[0] = 1;
		arr[1] = 1;
		
		for(int x=2; x<arr.length; x++) {
			arr[x] = arr[x-2] + arr[x-1];
		}
		
		System.out.println("第二十个月的时候的兔子对数是："+arr[19]);
	}
}

    *数组的反转

package com.text;
import java.util.Scanner;

/*
 * 需求：
 * (1)键盘录入5个int类型的数据存储数组arr中
 * (2)定义方法将arr数组中的内容反转
 * (3)定义方法对反转后的数组进行遍历
 * 
 * 分析：
 * 		A:定义一个长度为5的数组
 * 		B:通过键盘录入数据给数组中的元素赋值
 * 		C:定义方法将arr数组中的内容反转
 * 			什么是反转?如何反转?
 * 		D:定义方法遍历数组
 */
public class Test7 {
	public static void main(String[] args) {
		// 定义一个长度为5的数组
		int[] arr = new int[5];

		// 通过键盘录入数据给数组中的元素赋值
		Scanner sc = new Scanner(System.in);
		for (int x = 0; x < arr.length; x++) {
			System.out.println("请给出第" + (x + 1) + "个元素");
			arr[x] = sc.nextInt();
		}
		
		System.out.println("反转前的数组元素：");
		printArray(arr);

		// 定义方法将arr数组中的内容反转
		reverse(arr);
		
		System.out.println("反转后的数组元素：");
		//定义方法遍历数组
		printArray(arr);
	}
	
	//遍历数组
	public static void printArray(int[] arr) {
		System.out.print("[");
		for(int x=0;x<arr.length; x++){
			if(x == arr.length-1) {
				System.out.println(arr[x]+"]");
			}else {
				System.out.print(arr[x]+", ");
			}
		}
	}
	

	/*
	 * 两个明确： 返回值类型：void 参数列表：int[] arr
	 */
	public static void reverse(int[] arr) {
		for(int startIndex=0,endIndex=arr.length-1;startIndex<=endIndex;startIndex++,endIndex--) {
			int temp = arr[startIndex];
			arr[startIndex] = arr[endIndex];
			arr[endIndex] = temp;
		}
	}
}

    *数据加密

package com.text;

import java.util.Scanner;

/*
 * 需求：键盘录入数据,要求数据是四位的整数,现需要对数据进行加密,加密规则如下:
 * 每位数字都加上5,然后除以10的余数代替该数字,
 * 再将第一位和第四位交换,第二位和第三位交换,
 * 请把加密后的数据输出到控制台
 * 
 * 分析：
 * 		A:键盘录入一个四位数
 * 		B:对数据进行加密
 * 			举例：
 * 				4567
 * 				把这个四位数分成个，十，百，千存储到数组中
 * 				int[] arr = {4,5,6,7};
 * 				每位数字都加上5：
 * 					arr[x] += 5;	{9,10,11,12}
 * 				然后除以10的余数代替该数字：
 * 					arr[x] %= 10;	{9,0,1,2}
 * 				 再将第一位和第四位交换,第二位和第三位交换：
 * 					{9,0,1,2}		{2,1,0,9}
 * 		C:输出加密后的数据
 */
public class Test9 {
	public static void main(String[] args) {
		//键盘录入一个四位数
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		System.out.println("请输入一个四位数：");
		int number = sc.nextInt();
		
		//分别得到该数据的每一个位上的数据
		int ge = number%10;
		int shi = number/10%10;
		int bai = number/10/10%10;
		int qian = number/10/10/10%10;
		
		//定义一个数组
		int[] arr = new int[4];
		arr[0] = qian;
		arr[1] = bai;
		arr[2] = shi;
		arr[3] = ge;
		
		//加密规则
		//每位数字都加上5,然后除以10的余数代替该数字
		for(int x=0; x<arr.length; x++) {
			arr[x] += 5;
			arr[x] %= 10;
		}
		
		//再将第一位和第四位交换,第二位和第三位交换
		int temp = arr[0];
		arr[0] = arr[3];
		arr[3] = temp;
		
		int temp2 = arr[1];
		arr[1] = arr[2];
		arr[2] = temp2;
		
		//输出加密后的数据
		for(int x=0; x<arr.length; x++) {
			System.out.print(arr[x]);
		}
		System.out.println();
	}
}

    *数组常见问题

        *索引越界异常:ArrayIndexOutOfBoundsException,访问了不存在的索引

        *空指针异常:没有指向堆内存而是指向了null,所以就访问不到堆内存中的数据

6.二维数组

    *一个数组中设置了多个数组

    *二维数组格式

        *数据类型[][] 数组名;

    *初始化

        *数据类型[][] 数组名 = new 数据类型[m][n];

        *数据类型[][] 数组名 = new 数据类型[][]{{元素一},{元素二},{元素三},.....};

        *数据类型[][] 数组名 = {{元素一},{元素二},{元素三},.....};

package com.text;

/*
 * 二维数组：就是元素为一维数组的数组。
 * 
 * 定义格式：
 * 		A:数据类型[][] 数组名;
 * 		B:数据类型 数组名[][];	不推荐
 * 		C:数据类型[] 数组名[];	不推荐
 * 
 * 如何初始化呢?
 * 		A:动态初始化
 * 			数据类型[][] 数组名 = new 数据类型[m][n];
 * 			m表示这个二维数组有多少个一维数组
 * 			n表示每一个一维数组的元素有多少个
 * 		B:静态初始化
 * 	      数据类型[][] 数组名 = new 数据类型[][]{{元素...},{元素...},{元素...},...};
 * 			简化格式：
 * 			数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
 */
public class ArrayArrayDemo {
	public static void main(String[] args) {
		// 数据类型[][] 数组名 = {{元素...},{元素...},{元素...},...};
		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

		System.out.println(arr); // [[[e-mail]
		System.out.println(arr.length); // 二维数组中的一维数组的个数
		System.out.println(arr[0]);// [[e-mail]
		System.out.println(arr[0].length);
		System.out.println(arr[1]);// [[e-mail]
		System.out.println(arr[2]);// [[e-mail]
		
		//我如何获取到一个二维数组的元素呢?
		System.out.println(arr[0][0]);
		System.out.println(arr[1][1]);
		System.out.println(arr[2][0]);
	}
}

    *二维数组的遍历

package com.text;

/*
 * 二维数组遍历
 * 
 * System.out.println():输出内容并换行
 * System.out.print():输出内容
 * System.out.println():换行
 */
public class ArrayArrayTest {
	public static void main(String[] args) {
		// 定义二维数组
		int[][] arr = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } };

		// 二维数组中的一维数组名称：二维数组名[索引]
		// arr[0] 其实就是二维数组中的第一个一维数组的名称
		// arr[1] 其实就是二维数组中的第二个一维数组的名称
		// arr[2] 其实就是二维数组中的第三个一维数组的名称

		// for (int x = 0; x < arr[0].length; x++) {
		// System.out.println(arr[0][x]);
		// }

		// System.out.println("hello");
		// System.out.println("world");
		// System.out.print("hello");
		// System.out.print("world");

		/*
		// 第一个一维数组的元素
		for (int x = 0; x < arr[0].length; x++) {
			System.out.print(arr[0][x] + "  ");
		}
		System.out.println();

		// 第二个一维数组的元素
		for (int x = 0; x < arr[1].length; x++) {
			System.out.print(arr[1][x] + "  ");
		}
		System.out.println();

		// 第三个一维数组的元素
		for (int x = 0; x < arr[2].length; x++) {
			System.out.print(arr[2][x] + "  ");
		}
		System.out.println();
		*/
		
//		for(int y=0; y<3; y++) {
//			for (int x = 0; x < arr[y].length; x++) {
//				System.out.print(arr[y][x] + "  ");
//			}
//			System.out.println();
//		}
		
		for(int y=0; y<arr.length; y++) {
			for (int x = 0; x < arr[y].length; x++) {
				System.out.print(arr[y][x] + "  ");
			}
			System.out.println();
		}

	}
}