数组与Arrays工具类

数组

---

内容：

• 一些数组的常规应用

• 多维数组

• Arrays工具类

一、一些数组的常规应用

1.元素访问

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

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

/*

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

*/

// 这是要检查元素的数组

int[] arr= { 101, 103, 102, 102, 111, 333, 222 };

// 要有一个比较的值

intcho=102;

// 最终要获取的游标

intindex=-1;

// 开始比较

for (inti=0; i<arr.length; i++) {

intitem=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};

inttemp=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(inti=arr.length-1 ; i>0 ; i--){

inttemp=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};

intmax=arr[0];//最大值

intmin=arr[0];//最小值

doubleavg=0;//平均值

intsum=0;//总和

intcount=arr.length;//总数量

for(intitem : 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};

//需要扩容的长度

intappendSize=5;

//新数组长度的公式是：原数组长度+要扩容的长度

intnewLength=arr.length+appendSize;

//创建新的数组

int[] newArray=newint[newLength];

//循环赋值，把原数组里的元素赋值给新数组相同的位置

for(inti=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};

//确定要删除的元素游标

intdeleteIndex=5;

//从其自身所在位置开始循环

for(inti=deleteIndex ; i<arr.length-1 ; i++){

intnextIndex=i+1;

arr[i] =arr[nextIndex];//把下一位移动到我当前位置

}

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

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

//新数组的长度为：原数组长度-1

intnewLength=arr.length-1;

int[] newArray=newint[newLength];

//以新数组为标准进行循环

for(inti=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));