Java个人学习之旅(第四天)

1. 数组：

1.1 定义

1. 数组是编程语言中最常见的一种数据类型,可用于存储多个数据,每个数组元素存放一个数据,通常可以通过数组元素的索引(下标)来访问数组元素,包括为元素赋值和去除数组元素的值.

2. 初始化后的数组对象存储在JVM的堆内存中,而其内存地址则保存在栈中.

3. 语法格式

int[] arr = new int[长度] //动态初始化
int[] arr = new int[]{元素1,元素2,...}  //静态初始化

其实还有一种定义的方式

int arr[] = new int[长度]

但是这种方式的可读性没有前面的好,所以不建议使用

3. 注意:
   定义好的数组只能存放指定类型的元素,但是有一种特殊情况

int[] arr = new int[]{1,2,'a'};

这样写是可行的,因为’a’属于char类型,char类型其实是特殊的整形,可参考ASCII表

1.2 遍历方式

1. for循环

int[] arr = new int[]{1,2,3};
for(int i = 0;i < arr.length;i++){
	System.out.println(arr[i]); //通过i作为数组的下标,输出数组中每个元素
}

2. 增强for循环(foreach)

int[] arr = new int[]{1,2,3};
for(int i : arr){
	System.out.println(i); //这里的i指的是数组内的每一个元素,而不是数组的下标,要与普通for循环区别开来
}

其中,arr.length是取数组的长度,数组作为一个类,有一个名为length的属性,用于存放数组的长度

1.3 常见异常：

1. java.lang.NullPointerException
   定义:空指针异常
   指针,就是java中对象的引用
   当指针指向的是空对象,这个指针就被称为空指针,通过操作空指针去使用对象时,会引发空指针异常
2. java.lang.ArrayIndexOutOfBoundsException
   定义:数组下标越界异常
   数组的长度定义好后无法改变,当访问到了数组中不存在的下标时,会引发数组下标越界异常

1.4 数组拷贝：

1. 浅拷贝
   两个数组所指向的地址相同,更改其中一个数组中的元素,另一个数组中的元素也会改变
   示例代码:

		int[] arr = new int[] {1,2,3};
		
		int[] arr2 = arr; //将arr赋值给arr2
		
		System.out.println("-----打印两个数组的内存地址------");
		System.out.println(arr);
		System.out.println(arr2);
		
		System.out.println("-----打印两个数组的元素------");
		for (int i : arr) {
			System.out.print(i+ " ");
		}
		System.out.println();
		
		for (int i : arr2) {
			System.out.print(i+ " ");
		}
		
		System.out.println();
		
		
		//更改其中一个数组中的元素
		arr2[1] = 20;
		
		System.out.println("-----重新打印两个数组的元素------");
		for (int i : arr) {
			System.out.print(i + " ");
		}
		
		System.out.println();
		
		for (int i : arr2) {
			System.out.print(i + " ");
		}

运行结果如下:

可以看到,如果直接将一个数组赋值给另一个数组,则两个数组的内存地址是相同的

2. 深拷贝

初始化一个长度更长的数组,将原先的数组通过循环赋值给新的数组,两个数组指向的地址不同,各自元素的更改不会有影响

示例代码:

		int[] arr = new int[] {1,2,3};
		int[] arr2 = new int[4];
		
		System.out.println("-----------打印两个数组的内存地址--------");
		System.out.println(arr);
		System.out.println(arr2);
		
		System.out.println("-----------打印两个数组的内部元素--------");
		
		for (int i : arr) {
			System.out.print(i+ " ");
		}
		System.out.println();
		
		for (int i : arr2) {
			System.out.print(i+ " ");
		}
		System.out.println();
		
		System.out.println("----将arr的元素通过循环赋值给arr2");
		for(int i=0;i < arr.length;i++){
			arr2[i] = arr[i];
		}
		
		System.out.println("-----------重新打印两个数组的内部元素--------");
		
		for (int i : arr) {
			System.out.print(i + " ");
		}
		System.out.println();
		
		for (int i : arr2) {
			System.out.print(i+ " ");
		}
		System.out.println();
		

结果如下图:

可以看到,两个数组的内存地址不同,内部的元素互不影响

Random工具类的使用

话不多说直接上代码

/*
 * java.util.Random 类是用于产生随机数  可用于验证码 
 * 使用步骤：
 *     1 用导包命令 import java.util.Random
 *     2 产生随机类对象 Random r = new Random();
 *     3 要整型的数字 int num = r.nextInt(); 
 *       要指定范围内整型的数字 int num2 = r.nextInt(10); //产生的是0-9的数字
 *       要随机的long的一个数字 long l = r.nextLong();
 *       要什么类型的数，就 调用 r.nextXxx()的方法
 *     在循环内
 *        数组[索引] = 随机数; 
 */ 
import java.util.Random;
public class RandomDemo {
	public static void main(String[] args) {
		//定义一个int类型的数组，有10个元素
		int[] arr = new int[10];
		
		//产生随机数对象
		Random r = new Random();
		
		System.out.println("long:" + r.nextLong());
		System.out.println("boolean:" + r.nextBoolean());
		System.out.println("double:" + r.nextDouble());
		
		//3循环
		for(int i = 0;i<arr.length;i++) {
			//4产生随机值，指定范围内的数
			int num = r.nextInt(10)+1;//产生的是0-9 ，要1-10的数字 ，在后面加1
			//5赋值  arr[0] = 3; arr[1]=5; arr[2]=9; arr[3] = 4;...
			arr[i] = num;
		}
		
		//6循环打印这个数组
		for (int i : arr) {
			System.out.print(i + "\t");
		}
		
	}
}

运行结果图:

数组是我的一生之敌,我将用我的大半生去克服他