Java中的数组

数组

1.什么是数组

数组就是存储相同数据类型的一组数据,且长度固定

基本数据类型4类8种：byte/char/short/int/long/float/double/boolean

数组，是由同一种数据类型按照一定的顺序排序的集合，给这个数组起一个名字。是一种数据类型，叫引用类型！

定义数组，在类型的后面加一个[],只要看到中括号，一定是数组！

类型 数组

int int[]

byte byte[]

short short[]

long long[]

float float[]

double double[]

char char[]

boolean boolean[]

下面的是引用类型

String String[]

Object Object[]

整型 byte/short/int/long 默认值是0

char字符默认值是’\u0000’ ,空

浮点 float/double默认值是0.0

布尔型 boolean默认值是false

其它对象的默认值是null

2数组的定义格式

标准格式 []表示数组
	数据类型 数组名[] = new 数据类型[长度];
在Java中因为这样定义数组名,常被认为是一种错误的标识符,所以后期定义数组为
	数据类型[] 数组名 = new 数据类型[长度];

3.数组初始化

​数组初始化的方式: 1.静态初始化 2.动态初始化

数组静态初始化

静态初始化1
	数据类型[] 数组名 = new 数据类型[]{值1,值2,值3.....}
静态初始化2
	数据类型[] 数组名 = {值1,值2,值3....}
数组初始化后,数据的个数就是数组的长度

forEach循环
格式： for(数据类型 变量名 : 数组/集合){
			变量名;
		}
	将数组或集合中的每一个元素,遍历后交给变量,变量的数据类型要与数组或集合保持一致

public class StaticArrayDemo {

	public static void main(String[] args) {
		//声明数组,并静态初始化
		int[] nums = new int[] {1,2,3,4,5,6,7};
		//通过数组的下标,获取或者设置元素内容,下标从0开始
		nums[2] = 30;
		System.out.println("下标为2的元素:"+nums[2]);
		//2静态初始化
		String[] strs = {"赵云","关羽","吕布","典韦"};
		//通过循环的方式遍历数组
		//数组的长度length ,下标的最大数是length-1
		for (int i = 0; i < strs.length; i++) {
			System.out.println("第"+(i+1)+"个元素为:"+strs[i]);
		}
		//System.out.println(strs[4]);  //ArrayIndexOutOfBoundsException  数组下标越界,超出了数组最大位置
		//采用简易式for循环遍历数组内容,这种循环只做范围数据的遍历,这种循环叫做forEach循环
		for (String str : strs) {
			System.out.println(str);
		}
	}
}

​

数组动态初始化

动态初始化
	步骤:1.声明输出,并初始化一个固定长度的默认值数组
		 2.通过数组的下标赋值
 数据类型[] 数组名 = new 数据类型[长度];
 数组名[下标] = 值;

public class AliveArrayDemo {
	public static void main(String[] args) {
		//声明数组,并创建数组对象
		String[] names = new String[4];
		//1.通过下标为数组元素赋值
		names[0] = "张三";
		names[1] = "李四";
		names[2] = "王麻子";
		//采用简易式for循环遍历数组内容,这种循环只做范围数据的遍历,这种循环叫做forEach循环
		for (String str : names) {
			System.out.println(str);
		}
	}
}

4.使用数组实现用户的登录注册

public class LoginArray {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String[] names = new String[20];
		String[] pwds = new String[20];
		// 初始化3个账户
		names[0] = "admin";
		pwds[0] = "admin";
		names[1] = "system";
		pwds[1] = "123456";
		names[2] = "zhangsan";
		pwds[2] = "123456";
		do {
			System.out.println("========欢迎来到桑榆商城========");
			System.out.println("\t1.登录\n\t2.注册\n\t3.退出");
			System.out.println("============================");
			System.out.print("请选择:");
			int choose = in.nextInt();
			switch (choose) {
			case 1:
				System.out.println("欢迎来到桑榆商城>>登录");
				int ci = 3;
				do {
					System.out.println("请输入用户名:");
					String name = in.next();
					System.out.println("请输入密码:");
					String pwd = in.next();
					// 用于循环数组,比较所有已存在的账户,一轮for循环代表一次登录
					for (int i = 0; i < pwds.length; i++) {
						// 遍历数组所有元素,但并不是所有元素都有值,需要过滤
						if (pwds[i] != null) {
							if (names[i].equals(name) && pwds[i].equals(pwd)) {
								System.out.println("欢迎" + name + "来到桑榆商城");
								ci = 0; // 用于结束do...while循环
							}
						} else
							break; // 用于结束登录for循环
					}
					//前面所有都没匹配上,才算作登录失败一次
					ci--;
					if (ci > 0)
						System.out.println("对不起,您的账户或密码错误,您还有" + ci + "次登录机会,请重新登录");
					else if(ci==0)
						System.out.println("对不起,您的账户或密码错误,您的登录机会已用完,请明日再来...");
				} while (ci > 0);
				break; // 用于跳出switch结构
			case 2:
				System.out.println("欢迎来到桑榆商城>>注册");
				System.out.println("请输入用户名:");
				String name = in.next();
				System.out.println("请输入密码:");
				String pwd = in.next();
				for (int i = 0; i < pwds.length; i++) {
					if(pwds[i]==null) {
						names[i] = name;
						pwds[i] = pwd;
						break;
					}else if(i==pwds.length-1) {
						System.out.println("用户已上限,无法注册");
					}
				}
				break;
			default:
				//使用系统退出,直接退出系统
				System.out.println("欢迎下次光临!");
				System.exit(0);
			}
		}while(true);
	}
}

5.数组中常见的错误

public class ErrorArrayDemo {

	public static void main(String[] args) {
		// 常见错误
		//1.声明数组错误
		//静态初始化时,只需要元素,不需要填写长度
//		int[] nums = new int[5]{1,2,3,4,5,6};
		//静态初始化时,先声明,然后再直接复制错误
//		int[] num1;    //这种声明方式,是没有堆空间
//		num1 = {1,2,3,4,5,6,7};
		
		//空指针异常 NullPointerException
		//数组空指针异常
//		String[] strs = null;
//		System.out.println("strs数组中第一个元素为:"+strs[0]);
		//数组元素空指针异常,这里的5是数组的长度
		String[] strs1 = new String[5];
//		System.out.println(strs1[0].equals("admin"));
		
		//数组下标越界,这里的5是数组的下标
		strs1[5] = "张三";
	}
}

6.数组的复制

浅复制：被复制的数组和复制出来的数组拥有同一个地址，如果有操作行为，数组之间会互相影响

public class ShallowCopy {
	public static void main(String[] args) {
		int[] arr = {3,4,5};
		//要复制的数组
		int[] arr2 = arr;

		System.out.println("arr地址:" + arr);
		System.out.println("arr2地址:" + arr2);

		for (int i : arr) {
		System.out.println(i);
		}
		System.out.println("***************");
    	for (int i : arr2) {
			System.out.println(i);
		}
    
    	System.out.println("arr2[1]补改前:" + arr2[1] + ",arr[1]:" + arr[1]);
    	System.out.println("__________________");
    	arr2[1] = 33;
    	System.out.println("arr2[1]补改后:" + arr2[1] + ",arr[1]:" + arr[1]);
    
	}
}

深复制：被复制的数组和复制出来的数组不是同一个地址，如果有操作行为，不会互相影响

public class DeepCopy {
	public static void main(String[] args) {
		//第一个数组
		int[] arr = {3,4,5};

		//重新定义一个数组
		int[] arr2 = new int[4];//这个新数组的长度可以跟第一个数组的长度不一样，可长可短

		//利用循环复制
		for(int i = 0;i < arr.length;i++) {
		/*
		* 假设从第一个数组的获取到第一个元素的值赋值给新数组的第一个元素，以此类推
 		* arr2[0] = arr[0];//第一个值
 		* arr2[1] = arr[1];
 		* arr2[2] = arr[2];
		* 循环赋值后 arr2[3,4,5,0]
 		*/
			arr2[i] = arr[i];
		}

		System.out.println("arr地址:" + arr);
		System.out.println("arr2地址:" + arr2);

		for (int i : arr2) {
			System.out.println(i);
		}

		System.out.println("arr2[1]补改前:" + arr2[1] + ",arr[1]:" + arr[1]);
    	System.out.println("__________________");
    	arr2[1] = 33;
    	System.out.println("arr2[1]补改后:" + arr2[1] + ",arr[1]:" + arr[1]);
	}
}

练习:定义一个数组求数组中的最大值和最小值

public class MaxMinNumDemo {
	public static void main(String[] args) {
		int[] arr = {3,5,39,-2};
		//定义一个最大数
		int max = arr[0];

		//定义一个最小数
		int min = arr[0];
		//循环中比较
		for (int i = 0; i < arr.length; i++) {
			//找这个数组的最大数，一一比较 
			if(arr[i] > max) {
			/*
 			 * arr[0] > 3 ,不大于 ，arr[1] > 3,大于 ，把5赋值给max,arr[2]:第3次 比较  39>5,大			于，把39赋给max,2->39? 
 			 */
			max = arr[i];
			}

		//找这个数组的每一个元素，一一比较
		/*
 		* 第1次：3跟3比，不大于
 		* 第2次：3跟5，不大于
 		* 第3次：3跟39比，不大于
 		* 第4次：3跟-2比，大于，把-2赋值给min这个变量
 		*/
			if(min > arr[i]) {
				min = arr[i];
			}
		}
			System.out.println("数组里面的最大值是:" + max);
			System.out.println("数组里面的最小值是:" + min);
	}
}

数组工具类

Arrays概念

​ Arrays是数组工具类,该类为数组提供了各种静态的帮助方法,用于操作数组

​ 静态修饰的方法,可以被类直接调用,不需要创建对象

​ 常见方法

方法名	效果
sort(数组)	对数组进行自然排序
toString(数组)	对数组进行字符串打印
copyOf(数组,新的长度)	用于复制数组,并设定长度形成新的数组

数组扩容

练习:输入学生成绩,实现数组的自动扩容

public class ArraysDemo {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int[] scores = new int[3];
		for (int i = 0; i < scores.length; i++) {
			System.out.println("请输入第"+(i+1)+"个学生成绩:");
			scores[i] = in.nextInt();
		}
		System.out.println("============输入成绩结束=============");
		//toStrng输出数组
		System.out.println("学生成绩为:"+Arrays.toString(scores));
		//排序
		Arrays.sort(scores);
		System.out.println("排序后的学生成绩:"+Arrays.toString(scores));
		System.out.println("===========继续输入成绩==============");
		int index = scores.length;  //记录下一次数组要存储数据的下标位置
		String choose = "";
		do {
			//判断一下,数组还有没有空间
			if(index>=scores.length) {
				//如果空间不够,就对数组进行扩容,复制原来的数组,并添加新的长度,重新赋值给scores
				scores = Arrays.copyOf(scores, scores.length+2);
				System.out.println("=======扩容成功========");
			}
			System.out.println("请输入第"+(index+1)+"个学生成绩:");
			//index++  是对于下一个元素赋值的下标
			scores[index++] = in.nextInt();
			System.out.println("是否继续添加成绩(y继续):");
			choose = in.next();
		}while(choose.equals("y"));
		//再次排序输出
		Arrays.sort(scores);
		System.out.println("排序后的学生成绩:"+Arrays.toString(scores));
	}
}

二维数组

​简单理解: 二维数组就是数组中套数组,每一个一维数组的元素都是一个内层数组

语法: 数据类型[][] 数组名 = new 数据类型[一维长度][二维长度];
	静态语法
	 数据类型[][] 数组名 = {{元素1,元素2...},{元素1,元素2....}....}

练习:使用二维数组,输入两名学生的信息并进行打印

public class TwoArray {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		//使用二维数组存储学生信息, 编号,姓名,性别,年龄,学科,籍贯
		//1.创建二维数组
		String[][]  stus = new String[3][6];
		stus[0][0] = "编号";
		stus[0][1] = "姓名";
		stus[0][2] = "性别";
		stus[0][3] = "年龄";
		stus[0][4] = "学科";
		stus[0][5] = "籍贯";
		
		for (int i = 1; i < stus.length; i++) {
			for (int j = 0; j < stus[i].length; j++) {
				System.out.println("请输入学生"+stus[0][j]+":");
				stus[i][j] = in.next();
			}
		}
		//遍历数组
		for (int i = 0; i < stus.length; i++) {
			for (String str : stus[i]) {
				System.out.print(str+"\t");
			}
			System.out.println();
		}
		in.close();
	}
}