【知晓的丧day拯救计划】java基础学习笔记6 数组

笔记来自2019求知讲堂零基础Java入门编程视频教程 https://www.bilibili.com/video/av76235341

数组是存放相同类型数据的有序集合，可以把多个数据放到一个变量里。

• 数组的特点：
  ○ 数组长度是确定的，一旦被创建，其大小就不可以改变
  ○ 数组元素必须是相同的数据类型，不允许出现混合类型
  ○ 数组类型可以是任何数据类型，包括基本数据类型和引用数据类型
  ○ 数组变量属于引用类型，数组也是对象，数组中的元素相当于属性

一维数组

• 声明方式：type var[]或type[] var。
  数组声明时并没有被真正创建

int a[];
int[] a1;

• 初始化：
  动态初始化：数组声明且为数组元素分配空间与赋值的操作分开。即声明数组时仅定义数组容量，赋值过程另外操作。
  静态初始化：在定义数组的同时就为元素分配空间并赋值。
  默认初始化：数组在被分配空间时已经按照声明的类型初始化了。比如int类型数组每个元素默认初始化为0。（数组是引用类型，元素相当于类的成员变量，所以分配空间后，每个元素也按照成员变量同样的方式被隐式初始化）

//动态：创建一个可以存放3个int类型数据的数组 aa
int aa[] = new int[3];
aa[0] = 3;
aa[1] = 4;
aa[2] = 5;

//静态:创建一个存放了3,4,5的数组
int bb[] = new int[] {3,4,5};
int cc[] = {3,4,5};

• 数组元素引用：
  ①定义数组，并使用new为之分配空间后，才可以引用数组中的元素；
  ②通过数组内元素的下标（数组内元素从左到右元素下标从0开始）引用；
  ③引用方式：数组名[元素下标]；元素下标可以是整型常量或整型表达式——a[i+1]；
  ④元素下标从零开始，长度为n的数组的合法下标取值范围是0~n-1；
  ⑤数组有一个length属性可以查看数组长度（元素个数）——a.length， 数组一旦初始化，其长度不可变。

• 数组元素赋值：
  数组名[元素下标] = n；

多维数组

二维数组：一维数组中的每个元素都是一个数组（或者理解成二维数组是一个一维数组的集合）。

• 声明方式
  int[][] var 或 int var[][] 或int[] var[]；
  特殊写法： int[] x，y[]；x是一维数组，y是二维数组。

• 初始化
  动态初始化可以将两个维度的长度都定义，也可以只定义第一维的长度。
  注： 多维数组不必都是规则矩阵形式。

//动态初始化：定义一个二维数组aa
//2表示第一维长度是2，即该二维数组有两个数组元素
//3表示第二维长度为3，也就是第一维每个数组元素中有3个int数据
int[][] aa = new int[2][3];

//动态初始化：只定义第一维长度为2，第二维默认为空数组
int[][] bb = new int[2][];

//静态初始化,定义了一个二维数组cc,其有3个一维数组元素
//第一个一维数组元素是一个长度为2的数组
//第二个一维数组元素是一个长度为3的数组
//第三个一维数组元素是一个长度为1的数组
//由此可见，Java中多维数组不必是规则矩阵形式
int[][] cc = new int[][] {
	{1,2},{2,3,3},{8}
};

• 二维数组元素的引用与赋值
  数组名[]——获得一个一维数组
  数组名[][]——获得数组中具体数据

//求数组cc中所有元素的和
int[][] cc = new int[][] {
	{1,2},{2,3,3},{8}
};
int sum = 0;
for (int i = 0;i < cc.length;i++) {
	for (int j = 0;j <cc[i].length;j++) {
		sum += cc[i][j];
	}				
}
System.out.println(sum);	

数组中的常见算法

• 数组元素最大值、最小值、总和、平均数

int[] arr = new int[]{4,2,7,1,3,5};
int max = arr[0];
int min = arr[0];
int sum = 0;
int avg = 0;
for(int i = 0; i < arr.length; i++) {
	if (max < arr[i]) {
		max = arr[i];
	}
	if (min > arr[i]) {
		min = arr[i];
	}
	sum += arr[i];			
}
avg = sum/arr.length;
System.out.println("max:" + max);	
System.out.println("min:" + min);
System.out.println("sum:" + sum);
System.out.println("avg:" + avg);

• 数组的遍历
  ○ for循环
  ○增强for循环——foreach（适用于遍历，不涉及索引的操作）

int[] a = {1,2,3,4,5};
		
//for循环
for(int i = 0; i < a.length; i++) {
	System.out.println(a[i]);			
}
		
//foreach循环，用于数组和集合的遍历
//将数组a中的每个元素依次拿出赋给i
for(int i : a) {
	System.out.println(i);
}

• 数组的复制
  复制不是赋值，赋值后的两个数组实际上是同一个；而复制的数组和原数组是不同的，具体通过代码直观的展现。

首先看赋值

//将数组arr通过赋值符"="赋给数组arr1
int[] arr = new int[]{4,2,7,1,3,5};
int[] arr1 = arr;
//使用"=="和"equals"分别判断arr和arr1是否相等
System.out.println(arr == arr1);        //运行结果：true
System.out.println(arr.equals(arr1));   //运行结果：true
//改变其中一个数组中的值，看另一个是否改变
arr[2] = 6;
System.out.println(arr1[2]);            //运行结果：6

可以看出比较结果都是true，一个改变另一个也发生改变
由此可见，赋值后的两个数组实际上是同一个

然后看复制

//通过for循环复制一个arrcopy数组
int[] copyarr = new int[arr.length];       //声明copyarr，其长度与arr一致
for (int i = 0; i < arr.length; i++) {     //循环将arr中每个元素赋值给arrcopy
	copyarr[i] = arr[i];			
}
//使用"=="和"equals"分别判断arr和arr1是否相等
System.out.println(arr == copyarr);        //运行结果：false
System.out.println(arr.equals(copyarr));   //运行结果：false
//改变其中一个数组中的值，看另一个是否改变
arr[2] = 7;
System.out.println(copyarr[2]);            //运行结果6

由此可见，arr和arrcopy是两个不同的数组，这是数组复制想要的结果

还可以使用System类中提供的arrayCopy方法进行数组的复制。
static void arrayCopy(object src, int srcpos, object dest, int destpos, int length)
○ src：原数组
○ dest：接收复制的数组
○ srcpos：从src数组第几个元素开始复制
○ destpos：从dest第几个元素开始接收复制的内容
○ length：复制的长度

int[] b = {1,2,3,4,5,6,7,8,9,10};
int[] bCopy = new int[b.length];

//复制数组b到bCopy
System.arraycopy(b, 0, bCopy, 0, b.length);
for(int i : b) {
	System.out.print(i + " ");
}
System.out.println();
for(int i : bCopy) {
	System.out.print(i + " ");
}
System.out.println();
/*运行结果
* 1 2 3 4 5 6 7 8 9 10 
* 1 2 3 4 5 6 7 8 9 10 
*/

//理解arraycopy方法
int[] bCopy1 = new int[b.length];
System.arraycopy(b, 2, bCopy1, 5, 3);
for(int i : b) {
	System.out.print(i + " ");
}
System.out.println();
for(int i : bCopy1) {
	System.out.print(i + " ");
}
/*运行结果
* 1 2 3 4 5 6 7 8 9 10 
* 0 0 0 0 0 3 4 5 0 0 
*/

• 数组的反转

//我自己写的
int[] arr = new int[]{4,2,7,1,3,5};
int[] temp = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
	temp[i] = arr[arr.length-(i+1)];			
}
arr = temp;

//视频老师写的
int[] arr = new int[]{4,2,7,1,3,5};
int[] temp = new int[arr.length];
int k = 0;
for (int i = arr.length-1; i >= 0; i--) {
	temp[k] = arr[i];
	k++;
}
arr = temp;

• 数组元素的排序
  之后单独写吧，留一个链接的位置：)

Arrays工具类

java.util.Arrays 工具类，提供了操作数组的一系列方法

• 打印：void java.util.Arrays.sort(array a)
• 排序：void java.util.Arrays.sort(array a)
• 填充：void java.util.Arrays.fill(array a, int fromIndex, int toIndex, object val)
  将数组a中索引[fromIndex, toIndex)的元素填充为val
• 二分查找：int java.util.Arrays.binarySearch(array a, object key)
  在数组a中查找元素key，找到则返回元素索引，找不到则返回负数

int[] array = {5,13,8,69,7,22};
//打印数组
System.out.println(Arrays.toString(array));  //[5, 13, 8, 69, 7, 22]
//数组排序
Arrays.sort(array);
System.out.println(Arrays.toString(array));  //[5, 7, 8, 13, 22, 69]
//在数组a中查找13,返回索引，没找到返回负数
System.out.println(Arrays.binarySearch(array, 13));  // 3
//将array数组索引1~3的元素填充为100
Arrays.fill(array, 1, 3, 100);
System.out.println(Arrays.toString(array));  //[5, 100, 100, 13, 22, 69]

** 二维数组存储表格数据**

id	姓名	年龄	出生日期
2001	张三	26	1994-8-1
2002	李四	30	1990-5-20
2003	王麻子	36	1984-1-13

每一行数据都可以用一个数组表示，因为类型不同，所以数组类型使用Object
多行数据组合就是二维数组

Object[] person1 = {2001,"张三",26,"1994-8-1"};
Object[] person2 = {2002,"李四",30,"1990-5-20"};
Object[] person3 = {2003,"王麻子",36,"1984-1-13"};
		
Object[][] persons = new Object[3][];
persons[0] = person1;
persons[1] = person2;
persons[2] = person3;
		
//打印二维数组（表格数据）
for(int i = 0;i < persons.length; i++) {
	System.out.println(Arrays.toString(persons[i]));
}

** JavaBean和一维数组存储表格数据**

public class Test3{
	public static void main(String[] args) {
		Person person1 = new Person(2001,"张三",26,"1994-8-1");
		Person person2 = new Person(2002,"李四",30,"1990-5-20");
		Person person3 = new Person(2003,"王麻子",36,"1984-1-13");
		
		Person[] persons = {person1,person2,person3};
		
		for(Person person:persons) {
			System.out.println(person.toString());
		}		
	}	
}

class Person {
	private int id;
	private String name;
	private int age;
	private String birth;
	
	public Person() {}
	
	public Person(int id, String name, int age, String birth) {
		super();
		this.id = id;
		this.name = name;
		this.age = age;
		this.birth = birth;
	}

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getBirth() {
		return birth;
	}
	public void setBirth(String birth) {
		this.birth = birth;
	}
	
	@Override
	public String toString() {
		return getId() + "\t" + getName() + "\t" + getAge() + "\t" + getBirth();
	}	
}

数组常见异常

这两种异常编译时不会报错，只有运行时才会报错

• ArrayIndexOutOfBoundsException（下标越界异常）
  访问到了数组中不存在的下标时发生的异常

int[] arr = new int[2];
System.out.println(arr[3]);

• NullPointerException（空指针异常）
  数组引用没有指向实体，却在操作实体中的元素时发生的异常

int[] arr = null;
System.out.println(arr[0]);