从零学Java - 数组详解
Java 数组详解
文章目录
- Java 数组详解
-
- 1.数组的概念
-
- 1.1 为什么使用数组?
- 2.数组的使用
-
- 2.1 数组的声明
- 2.2 数组的初始化
-
- 2.2.1 静态初始化
- 2.2.2 动态初始化
- 2.3 数组的使用
-
- 2.3.1 数组的基本使用
- 2.3.2 遍历数组元素
- 3.数组内存分配
-
- 补充：数组扩容
- 4.方法中的数组
-
- 4.1 数组类型的参数
- 4.2 数组类型的返回值
- 4.3 可变长参数
- 5.数组的排序
-
- 5.1 冒泡排序
- 5.2 选择排序
- 5.3 插入排序
- 6.数组查找
-
- 6.1 顺序查找
- 6.2 二分查找
- 7.Arrays工具类
1.数组的概念
1.1 为什么使用数组?
如何存储100名学生的成绩？
- 办法：使用变量存储，重复声明100个double类型变量即可。缺点：麻烦，重复操作过多。
如何让100名学生成绩全部+1？
- 办法：100个变量重复相同操作，直至全部完毕。缺点：无法进行统一的操作。
概念：一组连续的存储空间，存储多个数据类型相同或兼容的值。
特点: 1.数据类型相同或兼容 2.长度固定
2.数组的使用
使用步骤: 1.声明 2.初始化(静态/动态) 3.具体使用
2.1 数组的声明
数组的声明和声明变量类似, 有两种方式
- 方式一：数组元素类型[] 数组名 (推荐)
- 方式二：数组元素类型 数组名[]
2.2 数组的初始化
Java中的数组必须先初始化，初始化就是为数组中的数组元素分配内存空间，并为每个数组元素赋初始值。
Java 有两种方式：静态初始化 和 动态初始化
2.2.1 静态初始化
初始化时由程序员指定每个数组元素的初始值，由系统计算数组长度。
语法:
数组元素类型[] 数组名 = new 数组元素类型[]{元素0，元素1,....};
可简写为：数组元素类型[] 数组名 = {元素0，元素1,....};
eg:
int[] arr1 = new int[]{10,8,28,15,12};
int[] arr2 = {10,8,28,15,12};
String[] names1= new String[]{"张三","李四","王五"};
String[] names2={"张三","李四","王五"};
注意: 简写静态初始化只能一条语句完成，不能分割成两条语句。
2.2.2 动态初始化
初始化时只指定数组长度【大于等于0整数】，由系统为数组元素分配默认值。
语法:
数组元素类型[] 数组名 = new 数组元素类型[数组长度]；
默认值分配规则如下：整数型为0 浮点型为0.0 字符型为‘\u0000’ 布尔类型为false 引用类型为null
eg:
int[] nums = new int[5];
String[] cities= new String[3];
char[] chars= new char[10];
注意：初始化数组时，不要静态初始化和动态初始化同时使用，也就是说，不要在进行数组初始化时，既指定数组的长度，也为每个数组元素分配初始值。
2.3 数组的使用
//内存
array[]: 5 | 9 | 0 | 6 | 2 | 5 | 7 //数组元素
0 1 2 3 4 5 6 //数组下标
//访问元素时，需要使用“下标”（从0开始，依次+1，自动生成）
数组中的每个数据被称为“数组元素”, 可以使用length属性获取“数组长度”
2.3.1 数组的基本使用
语法：
数组名[下标];
eg:
//修改：a[0]=10; 获取：a[0];
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组的使用
* @date 2023/12/26 14:38
*/
public class demo01 {
public static void main(String[] args) {
//创建数组
int[] a = new int[5];
//依次赋值
a[0] = 1;
a[1] = 1;
a[2] = 1;
a[3] = 1;
a[4] = 1;
//依次输出
System.out.println(a[0]);
System.out.println(a[1]);
System.out.println(a[2]);
System.out.println(a[3]);
System.out.println(a[4]);
}
}
下标范围:
//有效下标范围：0 ~ 数组长度-1
int[] a = new int[5];
//访问无效下标，会导致数组下标越界
a[5] = 1;
报错：Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException
2.3.2 遍历数组元素
若数组的大小过大，再依次赋值就会很麻烦，因此我们使用循环遍历数组，以简化操作步骤
eg：
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 遍历数组
* @date 2023/12/26 15:30
*/
public class demo02 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int[] a = new int[10];
//遍历赋值
for (int i=0; i<a.length-1; i++) {
System.out.println("请输入第"+(i+1)+"个数组元素(int):");
a[i] = in.nextInt();
}
//遍历输出
for (int i = 0; i < a.length - 1; i++) {
System.out.println(a[i]);
}
}
}
JDK1.5之后，Java提供了增强for简化数组或集合的遍历。
语法：
for(数组元素类型 n : 数组){
//n代表数组中每个元素
}
优点：语法简洁；缺点：不能使用下标，不能改变数组元素；
eg：
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 给定一个整型数组，统计数组中所有元素的平均值。
* @date 2023/12/26 16:19
*/
public class demo03 {
public static void main(String[] args) {
int num = 0;
int[] nums = {89,23,455,6453,123,453};
for (int j : nums) {
num = num + j;
}
System.out.println("平均值为："+(double)(num/nums.length));
}
}
eg：
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 给定一个整型数组，输入一个整数n，如果n在数组中存在，输出下标，不存在则输出-1
* @date 2023/12/26 16:19
*/
public class demo04 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = in.nextInt();
boolean flag = true;
int[] nums = {342,543,1231,12,547,756,432,124};
for (int i = 0; i < nums.length; i++) {
if (num == nums[i]) {
System.out.println("下标为"+i);
flag = false;
}
}
if (flag) {
System.out.println("-1");
}
}
}
eg：
package StageOne.day06.arrayDemo;
import java.util.Scanner;
/**
* @author 胡昊龙
* @version 1.0
* @description: 控制台输入5个城市的名称，使用数组保存，并遍历输出。
* @date 2023/12/26 16:20
*/
public class demo05 {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String[] cities = new String[5];
for (int i = 0; i < cities.length; i++) {
System.out.println("请输入第"+(i+1)+"个城市名称");
cities[i] = input.next();
}
for (String city : cities) {
System.out.println(city);
}
}
}
3.数组内存分配
程序运行中有两块重要的存储空间，栈 、堆；
栈：
- 先进后出，空间比较小，存储速度较快。JDK1.5之前256k，JDK1.5之后1M。
- 存储局部变量（基本类型的数据以及引用类型的地址）。
堆：
- 空间比较大，存储速度较慢。
- 存储引用类型的实际数据。
eg：
补充：数组扩容
创建数组时，必须显示指定长度，并在创建之后不可更改长度。
扩容的思路：创建大于原数组长度的新数组。将原数组中的元素依次复制到新数组中。把新数组的地址赋值给原数组。
内存图：
eg：
package StageOne.day06.arrayDemo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组扩容
* @date 2023/12/26 17:05
*/
public class demo07 {
public static void main(String[] args) {
int[] nums_1 = {98,23,44,65,23,41};//长度 5
System.out.println("-------扩容前-------");
for (int i : nums_1) {
System.out.print(i+" ");
}
//扩充思路
//1、创建大于原数组长度的新数组
int[] nums_2 = new int[nums_1.length*2];//默认值 0
//2、将原数组中的元素依次复制到新数组中
for (int i = 0; i < nums_1.length; i++) {
nums_2[i] = nums_1[i];
}
//3、把新数组的地址赋值给原数组
nums_1 = nums_2;
System.out.println();
System.out.println("-------扩容后-------");
for (int i : nums_1) {
System.out.print(i+" ");
}
}
}
4.方法中的数组
4.1 数组类型的参数
当方法参数是数组时，调用方法会将 实参 中的地址赋值给 形参，此时二者指向同一个数组。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 数组类型的参数
* @date 2023/12/27 9:41
*/
public class demo01 {
public static void main(String[] args) {
int a=10,b=20;
swap(a,b);
System.out.println("a: "+ a +" b: "+b);
System.out.println("===========================");
int[] arr = {10,15,20,25,30};
printArray(arr);
System.out.println("===========================");
for (int i : arr) {
System.out.print(i+" ");
}
}
//基本数据类型作为方法的参数
public static void swap(int x, int y) {
System.out.println("交换前：x:"+ x + " y:" + y);
int t = x;
x = y;
y = t;
System.out.println("交换后：x:"+ x + " y:" + y);
}
//引用类型（数组）作为方法的参数
public static void printArray(int[] arr) {
for (int i = 0; i < arr.length; i++) {
arr[i] += 5;
System.out.print(arr[i]+" ");
}
System.out.println();
}
}
结果：
交换前：x:10 y:20
交换后：x:20 y:10
a: 10 b: 20
===========================
15 20 25 30 35
===========================
15 20 25 30 35
传递参数时：基本类型传递的是变量中的数据；引用类型传递的是变量中的地址。
4.2 数组类型的返回值
调用基本类型返回值的方法时，方法执行后，返回的是数据。
调用引用类型返回值的方法时，方法执行后，返回的是地址。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 引用数据类型（数组）作为方法参数
* @date 2023/12/27 10:09
*/
public class demo02 {
public static void main(String[] args) {
int x=5,y=8;
System.out.println(add(x,y));
System.out.println("======================");
int[] nums = {1,2,3,4,5};
System.out.print("原数组：");
for (int num : nums) {
System.out.print(num+" ");
}
System.out.println();
nums = expend(nums);
System.out.print("新数组：");
for (int num : nums) {
System.out.print(num+" ");
}
}
//基本数据类型作为方法参数
public static int add(int x, int y) {
return x + y;
}
//引用数据类型（数组）作为方法参数
public static int[] expend(int[] nums) {
//1. 创建一个比原数组大的新数组
int[] newArr = new int[nums.length*2];
//2. 将原数组的元素复制到新数组中
for (int i = 0; i < nums.length; i++) {
newArr[i] = nums[i];
}
//3. 返回新数组的地址
return newArr;
}
}
4.3 可变长参数
概念：可以接收多个同类型实参，个数不限，使用方式类似于数组
语法：数组元素类型… 形参名
优点：灵活，可以接收多个同类型的实参
特点：只能有一个可变长参数，必须在参数列表的最后
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 可变长参数
* @date 2023/12/27 11:13
*/
public class demo03 {
public static void main(String[] args) {
int[] nums = {1,2,4,5,6};
printArray(nums);
System.out.println("=======================");
printArray(9,nums);
System.out.println("=======================");
printArray(1.6,nums);
}
public static void printArray(int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
}
public static void printArray(int x, int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
System.out.println(x);
}
public static void printArray(double x, int... arr) {
for (int i : arr) {
System.out.print(i+" ");
}
System.out.println();
System.out.println(x);
}
}
结果：
1 2 4 5 6
=======================
1 2 4 5 6
9
=======================
1 2 4 5 6
1.6
5.数组的排序
排序：把一组无序的数据，按照有序的顺序进行排列。
5.1 冒泡排序
冒泡排序：相邻的两个数值比较大小，互换位置。
- 一次比较两个相邻元素，如果它们的顺序错误就把它们交换过来。
- 重复地进行直到没有再需要交换。
- 这个算法的名字由来是因为越小的元素会经过交换慢慢“浮”到数列的顶端。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 冒泡排序
* @date 2023/12/27 11:51
*/
public class demo04 {
public static void main(String[] args) {
int[] arrays = {10,8,6,20,2};
bubbleSort(arrays);
System.out.println("=========================");
System.out.print("最终的顺序：");
printArrays(arrays);
}
public static void bubbleSort(int[] arrays){
for (int i=0; i < arrays.length-1; i++) {
System.out.println("第"+ (i+1)+"轮");
printArrays(arrays); //输出，本轮次最初的数组顺序
for (int j=0; j < arrays.length-i-1; j++) {
System.out.print("第"+ (j+1)+"次比较:\t");
for (int array : arrays) {
System.out.print(array+" ");
}
//判段大小，交换数据
if (arrays[j] > arrays[j+1]) {
arrays[j] = arrays[j] ^ arrays[j+1];
arrays[j+1] = arrays[j] ^ arrays[j+1];
arrays[j] = arrays[j] ^ arrays[j+1];
}
System.out.print("\t结果:\t");
printArrays(arrays); //输出，每次比较交换完后的顺序
}
}
}
//方法：遍历数组并输出
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
System.out.println();
}
}
结果：
第1轮
10 8 6 20 2
第1次比较: 10 8 6 20 2 结果: 8 10 6 20 2
第2次比较: 8 10 6 20 2 结果: 8 6 10 20 2
第3次比较: 8 6 10 20 2 结果: 8 6 10 20 2
第4次比较: 8 6 10 20 2 结果: 8 6 10 2 20
第2轮
8 6 10 2 20
第1次比较: 8 6 10 2 20 结果: 6 8 10 2 20
第2次比较: 6 8 10 2 20 结果: 6 8 10 2 20
第3次比较: 6 8 10 2 20 结果: 6 8 2 10 20
第3轮
6 8 2 10 20
第1次比较: 6 8 2 10 20 结果: 6 8 2 10 20
第2次比较: 6 8 2 10 20 结果: 6 2 8 10 20
第4轮
6 2 8 10 20
第1次比较: 6 2 8 10 20 结果: 2 6 8 10 20
=========================
最终的顺序: 2 6 8 10 20
5.2 选择排序
选择排序：选择固定值与其他值依次比较大小，互换位置。
- 首先在未排序数组中找到最小（大）元素，存放到排序数组的起始位置。
- 然后再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
- 依次类推，直到交换完毕。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 选择排序
* @date 2023/12/27 14:46
*/
public class demo05 {
public static void main(String[] args) {
int[] nums = {8,6,2,10,1};
selectSort(nums);
System.out.print("最终的顺序:\t");
printArrays(nums);
}
public static void selectSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
int min = i;//最小下标
System.out.println("第"+ (i+1)+"轮");
printArrays(arr); //输出，本轮次最初的数组顺序
System.out.println();
int count = 1;
for (int j = i+1; j < arr.length; j++) {
System.out.print("第"+ (count)+"次比较:\t");
System.out.print(arr[min]+"\t"+arr[j]+"\t");
if (arr[min] > arr[j]) {
min = j;
}
System.out.println("当前最小值是:\t"+arr[min]);
count++;
}
//互换
if (min!=i) {
System.out.println("将"+arr[min]+"和"+arr[i]+"交换");
arr[i] = arr[i] ^ arr[min];
arr[min] = arr[i] ^ arr[min];
arr[i] = arr[i] ^ arr[min];
}
System.out.print("当前结果为:\t");
System.out.println("==========================================");
printArrays(arr); //输出，每轮比较交换完后的顺序
System.out.println();
}
}
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
}
}
结果：
第1轮
8 6 2 10 1
第1次比较: 8 6 当前最小值是: 6
第2次比较: 6 2 当前最小值是: 2
第3次比较: 2 10 当前最小值是: 2
第4次比较: 2 1 当前最小值是: 1
将1和8交换
当前结果为: 1 6 2 10 8
==========================================
第2轮
1 6 2 10 8
第1次比较: 6 2 当前最小值是: 2
第2次比较: 2 10 当前最小值是: 2
第3次比较: 2 8 当前最小值是: 2
将2和6交换
当前结果为: 1 2 6 10 8
==========================================
第3轮
1 2 6 10 8
第1次比较: 6 10 当前最小值是: 6
第2次比较: 6 8 当前最小值是: 6
当前结果为: 1 2 6 10 8
==========================================
第4轮
1 2 6 10 8
第1次比较: 10 8 当前最小值是: 8
将8和10交换
当前结果为: 1 2 6 8 10
==========================================
最终的顺序: 1 2 6 8 10
5.3 插入排序
插入排序：从第二元素开始，向前插入合适位置，保证元素前面有顺序。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 插入排序
* @date 2023/12/27 15:22
*/
public class demo06 {
public static void main(String[] args) {
int[] nums = {10,5,8,15,2};
insertSort(nums);
System.out.print("最终的顺序:\t");
printArrays(nums);
}
public static void insertSort(int[] arr) {
int count = 1;
for (int i=1; i < arr.length; i++) {
int pos = i-1;
int t = arr[i];
//输出解释说明
System.out.println("第"+ (count)+"轮");
printArrays(arr); //输出，本轮次最初的数组顺序
System.out.println("\t当前 t 的值："+t);
System.out.println();
System.out.print("第1次 当前 pos 的位置为 "+pos+"\t值为: "+arr[pos]);
int count2 = 1;
System.out.print("\t"+arr[pos]+" "+t+" 比较"+"\t");
System.out.print(arr[pos]>t);
if(!(arr[pos]>t)){
System.out.println();
}
while (pos>=0&&arr[pos]>t) {
System.out.println("\t将"+arr[pos]+"后移一位");
arr[pos+1] = arr[pos];
pos--;
count2++;
//输出解释说明
printArrays(arr);
System.out.println();
if(pos>=0){
System.out.println();
System.out.print("第"+count2+"次 当前 pos 的位置为 "+pos+"\t"+"值为: "+arr[pos]);
System.out.print("\t"+arr[pos]+" "+t+" 比较"+"\t");
System.out.print(arr[pos]>t);
if(!(arr[pos]>t)){
System.out.println();
}
}
}
//把 t 插入 pos+1 的位置
arr[pos+1] = t;
//输出解释说明
System.out.println();
if (!(pos>=0)) {
System.out.println("当前 pos 的位置为 "+ pos +" 将"+t+"插入到第"+(pos+2)+"位");
}
System.out.print("本轮排序结果为:\t");
printArrays(arr);
System.out.println();
System.out.println("===========================================");
count++;
}
}
public static void printArrays(int[] arrays) {
for (int array : arrays) {
System.out.print(array+" ");
}
}
}
结果：
第1轮
10 5 8 15 2 当前 t 的值：5
第1次 当前 pos 的位置为 0 值为: 10 10 5 比较 true 将10后移一位
10 10 8 15 2
当前 pos 的位置为 -1 将5插入到第1位
本轮排序结果为: 5 10 8 15 2
============================================================================
第2轮
5 10 8 15 2 当前 t 的值：8
第1次 当前 pos 的位置为 1 值为: 10 10 8 比较 true 将10后移一位
5 10 10 15 2
第2次 当前 pos 的位置为 0 值为: 5 5 8 比较 false
本轮排序结果为: 5 8 10 15 2
============================================================================
第3轮
5 8 10 15 2 当前 t 的值：15
第1次 当前 pos 的位置为 2 值为: 10 10 15 比较 false
本轮排序结果为: 5 8 10 15 2
============================================================================
第4轮
5 8 10 15 2 当前 t 的值：2
第1次 当前 pos 的位置为 3 值为: 15 15 2 比较 true 将15后移一位
5 8 10 15 15
第2次 当前 pos 的位置为 2 值为: 10 10 2 比较 true 将10后移一位
5 8 10 10 15
第3次 当前 pos 的位置为 1 值为: 8 8 2 比较 true 将8后移一位
5 8 8 10 15
第4次 当前 pos 的位置为 0 值为: 5 5 2 比较 true 将5后移一位
5 5 8 10 15
当前 pos 的位置为 -1 将2插入到第1位
本轮排序结果为: 2 5 8 10 15
============================================================================
最终的顺序: 2 5 8 10 15
6.数组查找
6.1 顺序查找
顺序查找：从第一个元素遍历到最后一个元素，查找符合要求的。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 顺序查找
* @date 2023/12/27 16:07
*/
public class demo07 {
public static void main(String[] args) {
int[] nums = {2,4,6,10,13,16,38,46,89,100};
System.out.println(sequenceSearch(nums,89));
System.out.println("=======================");
System.out.println(sequenceSearch(nums,7));
}
public static int sequenceSearch(int[] arr, int key) {
for (int i = 0; i < arr.length; i++) {
if (arr[i] == key) {
return i;
}
}
return -1;
}
}
6.2 二分查找
二分查找
- 前提，数组是有序的。
- 每次从中间开始查找，如果比中间数字小，在左边查找，如果比中间数字大，在右边查找，依次再进行二分查找，直到找到为止。
eg：
package StageOne.day07.demo;
/**
* @author 胡昊龙
* @version 1.0
* @description: 二分查找
* @date 2023/12/27 16:07
*/
public class demo08 {
public static void main(String[] args) {
int[] nums = {2,4,6,10,13,16,38,46,89,100};
System.out.println(binarySearch(nums,89));
System.out.println("=======================");
System.out.println(binarySearch(nums,7));
}
public static int binarySearch(int[] arr, int key) {
int low = 0;
int high = arr.length-1;
while (low <= high) {
int mid = (low + high) >>> 1;
if (key < arr[mid]) {
high = mid - 1;
} else if (key > arr[mid]) {
low = mid + 1;
} else {
return mid;
}
}
return -1;
}
}
结果：
当前的 low 位于 0 当前的 high 位于 9 当前的 mid 位于 4
当前数组范围是 2 4 6 10 13 16 38 46 89 100
当前的 low 位于 5 当前的 high 位于 9 当前的 mid 位于 7
当前数组范围是 16 38 46 89 100
当前的 low 位于 8 当前的 high 位于 9 当前的 mid 位于 8
当前数组范围是 89 100
8
===========================================================
当前的 low 位于 0 当前的 high 位于 9 当前的 mid 位于 4
当前数组范围是 2 4 6 10 13 16 38 46 89 100
当前的 low 位于 0 当前的 high 位于 3 当前的 mid 位于 1
当前数组范围是 2 4 6 10
当前的 low 位于 2 当前的 high 位于 3 当前的 mid 位于 2
当前数组范围是 6 10
当前的 low 位于 3 当前的 high 位于 3 当前的 mid 位于 3
当前数组范围是 10
-1
7.Arrays工具类
作用：主要用于对数组进行排序，查找，填充，复制等的操作
导包：import java.util.Arrays;
eg：
package StageOne.day07.demo;
import java.util.Arrays;
/**
* @author 胡昊龙
* @version 1.0
* @description: TODO
* @date 2023/12/27 16:45
*/
public class demo09 {
public static void main(String[] args) {
//Arrays 工具类
//1. toString(); 把数组转成字符串形式输出
int[] nums = {5,2,8,15,13,20,12};
String s = Arrays.toString(nums);
System.out.println(s);
//2. sort(); 排序,效率更高
Arrays.sort(nums);
System.out.println(Arrays.toString(nums));
//3. binarySearch(); 二分查找
System.out.println(Arrays.binarySearch(nums, 9));
System.out.println(Arrays.binarySearch(nums, 2));
//4. copyOf(); 指定长度的复制
int[] nums2 = Arrays.copyOf(nums,nums.length*2);
System.out.println(Arrays.toString(nums2));
int[] nums3 = Arrays.copyOf(nums,5);
System.out.println(Arrays.toString(nums3));
//5. copyOfRange(); 指定范围的复制, from 开始的位置, to 结束的位置 含头不含尾
int[] nums4 = Arrays.copyOfRange(nums,2,5);
System.out.println(Arrays.toString(nums4));
//6. equals(); 比较两个数组的元素是否相等
int[] arr1 = {1,3,5};
int[] arr2 = {1,3,5};
System.out.println(Arrays.equals(arr1,arr2));
//7. fill(); 用指定元素填充数组
Arrays.fill(nums,0);
System.out.println(Arrays.toString(nums));
}
}