数组-2

数组

内容：

• 一些数组的常规应用
• 多维数组
• Arrays工具类

一、一些数组的常规应用

1.元素访问

• 判断一个元素，在任意数组当中是否存在，如果存在返回该元素所在的游标，如果不存在则为-1

• 如果存在相同元素，记录第一次出现的元素位置

	/*
		 * 判断一个元素，在任意数组当中是否存在， 如果存在返回改元素所在的游标，如果不存在则为-1
		 */
		// 这是要检查元素的数组
		int[] arr = { 101, 103, 102, 102, 111, 333, 222 };
		// 要有一个比较的值
		int cho = 102;
		// 最终要获取的游标
		int index = -1;
		// 开始比较
		for (int i = 0; i < arr.length; i++) {
			int item = arr[i];
			if (cho == item) {
				index = i;
				break;// 从这里跳出循环
			}
		}
		System.out.println("得到的游标：" + index);

2.队列位移

• 将某一个元素由队列当中的某个位置，移动到另一个位置

• 位置交换

//1.交换位置
int[] arr = {0,1,2,3,4,5,6,7,8,9,-1};
int temp = arr[arr.length-1];
arr[arr.length-1] = arr[arr.length-2];
arr[arr.length-2] = temp;
System.out.println(Arrays.toString(arr));


结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, -1, 9]

• 连续位置交换

//2.连续交换位置
int[] arr = {0,1,2,3,4,5,6,7,8,9,-1};
for(int i = arr.length - 1 ; i > 0 ; i --){
	int temp = arr[i];
	arr[i] = arr[i-1];
	arr[i-1] = temp;
}
System.out.println(Arrays.toString(arr));

• 数据聚合：最大值，最小值，平均值，总和，总数量

//数据聚合
int[] arr = {0,1,2,3,4,5,6,7,8,9,-1};
int max = arr[0];//最大值
int min = arr[0];//最小值
double avg = 0;//平均值
int sum = 0;//总和
int count = arr.length;//总数量
for(int item : arr){
	sum += item;
	if(item > max){
		max = item;
	}
	if(item < min){
		min = item;
	}
}
//算平均
avg = (double)sum / count;

• 数组长度改变

改变长度的思路，新建一个新的数组，把原本的数组元素复制过去。

正向扩容：变长

• 要复制一个新的数组，其长度为原数组长度+要扩容的长度
• 将数据依次复制到新的数组当中

//数据扩容
int[] arr = {0,1,2,3,4,5,6,7,8,9,-1};
//需要扩容的长度
int appendSize = 5;
//新数组长度的公式是：原数组长度+要扩容的长度
int newLength = arr.length + appendSize;
//创建新的数组
int[] newArray = new int[newLength];
//循环赋值，把原数组里的元素赋值给新数组相同的位置
for(int i = 0 ; i < arr.length ; i ++){
	newArray[i] = arr[i];
}
System.out.println(Arrays.toString(newArray));


结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, 0, 0, 0, 0, 0]

反向扩容：变短

• 从数组当中移除掉一个元素
• 最简单的思路就是在要删除的位置，进行连续位移

第一步：先完成位移工作

//数据反向扩容
int[] arr = {0,1,2,3,4,-1,5,6,7,8,9};
//确定要删除的元素游标
int deleteIndex = 5;
//从其自身所在位置开始循环
for(int i = deleteIndex ; i < arr.length - 1 ; i ++){
	int nextIndex = i + 1;
	arr[i] = arr[nextIndex];//把下一位移动到我当前位置
}

第二步：进行新数组的创建和元素的赋值

公式：新数组的长度为：原数组长度-1

//新数组的长度为：原数组长度-1
int newLength = arr.length - 1;
int[] newArray = new int[newLength];
//以新数组为标准进行循环
for(int i = 0 ; i < newArray.length ; i ++){
	newArray[i] = arr[i];
}
System.out.println(Arrays.toString(newArray));     

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

数组扩容所带来的问题

• 空间的浪费：内存空间
• 时间的浪费：赋值带来的时间消耗
• 算力的浪费：运算位移

二、多维数组

在一维数组的基础上，每个元素都保存一个数组，此时该数组变为二维数组
以此类推，数组的维度可以无穷无尽

语法：

//二维数组
类型[][] d2 = new 类型[高维度][低纬度];
//三维数组
类型[][][] d3 = new 类型[高纬度][中纬度][低纬度];

多维数组数据的存取方式

取值：

// 创建二维数组
int[][] d2 = new int[10][5];
System.out.println("高纬度的长度："+d2.length);
for(int i = 0 ; i < d2.length ; i ++){
	int[] d1 = d2[i];//一维数组
	for(int j = 0 ; j < d1.length ; j++){
		System.out.println("元素内容："+d1[j]);
	}
}

存值（以游标的方式）：

// 创建一个正方形二维数组
int[][] d2 = new int[5][5];
d2[0][0] = 1;
d2[1][1] = 1;
d2[2][2] = 1;
d2[3][3] = 1;
d2[4][4] = 1;

三、Arrays工具类

JDK专门为数组准备的一个工具类
可以参考API文档：https://docs.oracle.com/javase/8/docs/api/

• API说明

copyof：复制一个数组

//Arrays的API
int[] is1 = {1,2,3,4,5,6};
//一个新的数组
int[] is2 = Arrays.copyOf(is1, is1.length+1);
//复制了一个新的数组，长度+1
System.out.println(Arrays.toString(is1));
System.out.println(Arrays.toString(is2));

结果：
    
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 0]

使用copyof复制的是什么

//Arrays的API
int[] is1 = {1,2,3,4,5,6};
//一个新的数组
int[] is2 = Arrays.copyOf(is1, is1.length);
//复制了一个新的数组，长度+1
System.out.println(Arrays.toString(is1));
System.out.println(Arrays.toString(is2));
//看一看是不是同一个数组
System.out.println(is1 == is2);

结果：
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
false
    
    
结论：copyOf是新建了一个新的数组

• 复制数组

System.arraycopy
参数说明：
src：原数组
srcPos：原数组从哪个位置开始复制
dest：要复制到的数组
destPos：从哪里开始
length：复制的数组元素的长度

//Arrays的API
int[] is1 = {1,2,3,4,5,6};
//一个新的数组
int[] is2 = new int[5];
//复制数组
System.arraycopy(is1, 0, is2, 0, 3);

System.out.println(Arrays.toString(is2));

注意：
System.arraycopy的目的存粹是为了复制数组的元素
其无论是获取要复制的范围，还是复制的数组的范围，都不可以越界

• 比较数组的元素

​ 对比的主观逻辑：

//在主观上判断他是同一个东西
boolean flag = true;
if(is1.length == is2.length){
	for(int i = 0 ; i < is1.length ; i ++){
		if(is1[i] != is2[i]){
			flag = false;
			break;
		}
	}
}else{
	flag = false;
}

• equals的用法

为true的情况：两个数组的元素个数相同，对应位置的元素值也相同

//比较数组的元素
int[] is1 = {1,2,3};
int[] is2 = {1,2,3,0};
boolean result = Arrays.equals(is1, is2);
System.out.println(result);

• 填充初值

  • fill的用法

  //填充初值
  int[] is1 = new int[10];
  //把is1这个数组当中的所有元素，设为1
  Arrays.fill(is1, 1);
  System.out.println(Arrays.toString(is1));
  

• 数组排序

基于快速排序和归并排序的变种

//数组排序
int[] is1 = {5,4,3,1,2,6,7,9,8,0};
//排序
Arrays.sort(is1);
System.out.println(Arrays.toString(is1));

结果：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

• 数组打印

直接打印引用数据类型，打印的是内存地址。

要打印数组的具体内容，需要用到该方法

//数组打印
int[] is1 = {5,4,3,1,2,6,7,9,8,0};
System.out.println(Arrays.toString(is1));