前言
本章大家介绍一个存储相同数据类型的容器----数组,以及便于我们对数组操作的工具类Arrays类的使用。
导航助手
🏆为什么要使用数组?
假设我们要存储5个学生其期末考试的成绩,凭借目前的知识我们只能用五个整型的变量的去储存。
代码示例
public class Demo7 { public static void main(String[] args) { int score1 = 70; int score2 = 80; int score3 = 85; int score4 = 60; int score5 = 90; System.out.print(score1 + " "); System.out.print(score2 + " "); System.out.print(score3 + " "); System.out.print(score4 + " "); System.out.print(score5); } }
上述打码确实可以存储5个学生的期末考试成绩,但是实际上一个学校里通常都是几百上千的学生,如果我们再用上述的方式去存储学生的成绩是非常麻烦且无聊的,我们可以发现上述代码中的5个变量都是整型变量,那么是否有存储相同类型数据的类型吗?答案是有的,就是本篇要讲解的数组。
🚀什么是数组?
通过上面的分析,我们可以知道数组是用来储存相同类型数据的内存区域或者是容器。通俗点来说就是一个比较大的可回收垃圾的垃圾桶,专门用来存放可回垃圾。
Java中的数组如同现实中的车库,从上图我们可以看
- 1.数组存放的元素类型是相同
- 2.数组在内存中的空间是连续的
- 3.数组的每个区域都有自己的编号,起始位置为0,即数组的下标。
知道什么是数组后,我们要会创建数组,接下来就来一一走入数组的创建
🔥数组的创建和初始化
🚩数组的创建
T[] 数组名 = new T[N];
T:表示数组中存放元素的类型 T[]:表示数组的类型 N:表示数组的长度
####🚩 创建数组的实例
int[] array1 = new int[10]; // 创建一个可以容纳10个int类型元素的数组 double[] array2 = new double[5]; // 创建一个可以容纳5个double类型元素的数组 String[] array3 = new double[3]; // 创建一个可以容纳3个字符串元素的数组
🚩数组的初始化
数组的初始化主要分为两种动态初始化和静态初始化
1.动态初始化:在创建数组时,直接指定数组中元素的个数
数据类型[] 数组名 = new 数据类型[10]; double[] scores = new double[10];
动态初始化示例代码
int[] array1 = new int[10]; double[] array2 = new double[3]; String[] array3 = new String[10];
动态初始化数组堆内存情况
2.静态初始化:在创建数组时不直接指定数据元素个数,而直接将具体的数据内容进行指
数据类型[] 数组名 = new 数据类型[]{元素1,元素2 ,元素3… }; double[] scores = new double[]{89.9, 99.5, 59.5, 88.0};
静态初始化示例代码
int[] array1 = new int[]{0,1,2,3,4,5,6,7,8,9}; double[] array2 = new double[]{1.0, 2.0, 3.0, 4.0, 5.0}; String[] array3 = new String[]{"hell", "Java", "!!!"};
静态初始化数组堆内存情况
注意事项
- 1.静态初始化虽然没有指定数组的长度,编译器在编译时会根据{}中元素个数来确定数组的长度。
- 2.静态初始化可以简写,省去后面的new T[]。
- 3.动态初始化:只指定数组长度,后期赋值,适合开始知道数据的数量,但是不确定具体元素值的业务
数组也可以按照如下C语言个数创建,不推荐
int arr[] = {1, 2, 3}
因为我们平时定义一个变量时是int a=0;int 是类型,a是变量名,同理我们看到int []arr 时,可以更加直观理解int []是类型 ,arr是这种类型的一个变量,采用C语言明显是不符合习惯的,也有点让人不好理解.
静态和动态初始化也可以分为两步,但是省略格式不可以拆分开
int[] array1; array1 = new int[10]; int[] array2; array2 = new int[]{10, 20, 30};
注意:静态初始化和动态初始化不能混用比如int [] arr=new int[3]{12,24,36};这是错误的
🚩默认值规则
如果没有对数组进行初始化,数组中元素有其默认值
🚩 数组的使用
🚩 数组中元素的访问
数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过 下标访问其任意位置的元素。
比如
public class Demo10 { public static void main(String[] args) { int[]array = new int[]{10, 20, 30, 40, 50}; System.out.println(array[0]); System.out.println(array[1]); System.out.println(array[2]); System.out.println(array[3]); System.out.println(array[4]); } }
也可以通过[]对数组中的元素进行修改
public class Demo10 { public static void main(String[] args) { int[]array = new int[]{10, 20, 30, 40, 50}; array[0] = 100; System.out.println(array[0]); } }
🚩数组常见的Bug
1.索引越界
代码示例
public class Demo11 { public static void main(String[] args) { int arr[]=new int[]{12,14,15,16}; System.out.println(arr[7]); } }
控制台输出结果
遇到索引越界,检查数组的下标是否超过合法范围。
2.空指针异常
代码示例
public class Demo11 { public static void main(String[] args) { int arr[] = new int[]{12, 14, 15, 16}; System.out.println(arr[7]); arr = null; System.out.println(arr[0]); } }
控制台抛出结果
一旦遇到空指针异常,需检查引用类型是否为null,null在java中表示空引用,就是一个不指向对象的引用,而在java中对象就要有对应的引用指向它,不然我们是无法对它进行操作,因为没有引用指向它,它就会JVM中垃圾回收站直接当做垃圾给回收。
注意
1.null的作用类似于C语言中的NULL,都是表示一个无用的内存区域,因此不能对此区域进行任何读写操作,一旦尝试读写,就会抛出空指针
2.Java 中并没有约定 null 和 0 号地址的内存有任何
遍历
所谓 “遍历” 是指将数组中的所有元素都访问一遍, 访问是指对数组中的元素进行某种操作,比如:
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{90, 790, 20}; System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } }
上述代码可以起到对数组中元素遍历的目的,但问题是:现在是三个元素我们可以这样使用,如果有成千上百个元素,那不得写输出语句写的累死,此时就需要通过观察代码可以发现,上述代码存在大量的重复,因为唯一的不同就是数组的下标在不断的变化,所以我们可采用for循环来遍历数组
for循环
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{90, 790, 20}; for (int i = 0; i < 3; i++) { System.out.print(arr[i]+" "); } } }
改成循环之后,大量的重复解决了,但是我们该如何获取数组的长度呢?是否是如同C语言中使用sizeof()计算,自然是不好在java中直接数组对象.length 来获取数组的长度,没有必要像C语言中使用sizeof(),java中把这些事已经办好了
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{90, 790, 20}; for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } }
增强for循环(for-each
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{90, 790, 20}; for (int i : arr) { System.out.println(i); } } }
i为数组array中的元素,当不需要使用下标时采用增强for,需要使用下标则for
数组是引用类型
java中的数组是对象,它是通过new出来的,数组对象生存在堆区,有一个在栈区的引用变量指向该对象,为了更好的理解,我们来看看JVM的内存分布
🚩初始JVM的内存
内存是一段连续的存储空间,主要用来存储程序运行时数据的。
比如
- 1.程序运行时代码需要加载到内存
- 2.程序运行产生的中间数据要存放在内存
- 3.程序中的常量也要保存到内存
- 4.有些数据可能需要长时间存储,而有些数据当方法运行结束后就要被销毁
如果对内存中存储的数据不加区分的随意存储,那对内存管理起来将会非常麻烦。比如一个干净的房间和一个杂乱的房间
因此JVM也对所使用的内存按照功能的不同进行了划分
1.程序计数器 (PC Register): 只是一个很小的空间, 保存下一条执行的指令的地址
2.虚拟机栈(JVM Stack): 与方法调用相关的一些信息,每个方法在执行时,都会先创建一个栈帧,栈帧中包含 有:局部变量表、操作数栈、动态链接、返回地址以及其他的一些信息,保存的都是与方法执行时相关的一 些信息。比如:局部变量。当方法运行结束后,栈帧就被销毁了,即栈帧中保存的数据也被销毁了。
3.本地方法栈(Native Method Stack): 本地方法栈与虚拟机栈的作用类似. 只不过保存的内容是Native方法的局 部变量. 在有些版本的 JVM 实现中(例如HotSpot), 本地方法栈和虚拟机栈是和虚拟机栈是一起的
4.堆(Heap): JVM所管理的最大内存区域. 使用 new 创建的对象都是在堆上保存 (例如前面的 new int[]{1, 2, 3} ),堆是随着程序开始运行时而创建,随着程序的退出而销毁,堆中的数据只要还有在使用,就不会被销毁。
5.方法区(Method Area): 用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数 据. 方法编译出的的字节码就是保存在这区域。
我们只需关心虚拟机栈和堆区已经方法区即可。
基本类型变量与引用类型变变量
基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值; 而引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地
代码示例
public class Demo12 { public static void main(String[] args) { func(); } private static void func() { int a = 10; int b = 20; int[] arr = new int[]{1, 2, 3}; } }
在上述代码中,a、b、arr,都是函数内部的变量,因此其空间都在main方法对应的栈帧中分配。 a、b是内置类型的变量,因此其空间中保存的就是给该变量初始化的值。 array是数组类型的引用变量,其内部保存的内容可以简单理解成是数组在堆空间中的首地址。
从上图可以看到,引用变量并不直接存储对象本身,而是存储对象的在堆空间的起始地址。通过该地址,引用变量便可以去操作对象。有点类似C语言中的指针,但是Java中引用要比指针的操作更简单,没有指针的加减。
两个数组引用变量指向同一个数组对象
代码示例
public class Demo9 { public static void main(String[] args) { int[] arr1 = new int[]{11, 22, 33}; int[] arr2 = arr1; System.out.println(arr1); System.out.println(arr2); arr2[1] = 90; System.out.println(arr1[1]); System.out.println(arr2[1]); } }
图解上述内存
🚩数组的应用场景
🚩作为函数的参数
参数传基本数据类型
代码示例
public class Demo13 { public static void main(String[] args) { int num = 0; func(num); System.out.println("num = " + num); } private static void func(int x) { x = 10; System.out.println("x = " + x); } }
因为func()方法在栈区开辟栈帧创建局部变量x并赋值为10,一旦出了该方法,func()方法栈帧就会被销毁。所以并没有影响到num值的改变,依然是0。
参数传数组类型(引用数据类型)
代码示例
public class Demo14 { public static void main(String[] args) { int[] arr = {1, 2, 3}; func(arr); System.out.println("arr[0] = " + arr[0]); } private static void func(int[] arr) { arr[0] = 10; System.out.println("a[0] = " + arr[0]); } }
发现在func方法内部修改数组的内容, 方法外部的数组内容也发生改变. 因为数组是引用类型,按照引用类型来进行传递,是可以修改其中存放的数组内容。
总结: 引用就是存放数组对象的地址,java将数组设置为引用类型,是为了方便传参,因为形参是实参的一份拷贝,如果不传地址的话,就要将数组的内容都进行一份拷贝对于内存的开销十分大,为了节约内存,故将数组设置为引用类型。
比如:获取斐波那契数列
class TestArray { public static int[] fib(int n) { if (n <= 0) { return null; } int[] arr = new int[n]; arr[0] = arr[1] = 1; for (int i = 2; i < n; ++i) { arr[i] = arr[i - 1] + arr[i - 2]; } return arr; } public static void main(String[] args) { int[] arr = fib(10); for (int i = 0; i < arr.length; i++) { System.out.print(arr[i]+" "); } } }
🚀数组工具类Arrays
Arrays类是工具类,被static修饰我们使用其成员方法直接类型.方法名();来调用。
🚀Arrays类常用API
接下来我们就来使用Arrays类,体验它的强大。
🚀数组转字符串
代码示例
public class Demo2 { public static void main(String[] args) { int [] arr=new int[]{12,145,6,7,8,9,876543}; System.out.println(Arrays.toString(arr)); } }
最左边的括号和最右边的括号都是toString();给拼接上的,以后打印数组的内容可以采用这种快捷的方式。
🚀数组的拷贝
🚀Arrays.copyOf();
代码示例
public class Demo3 { public static void main(String[] args) { int [] arr={1,2,3,4,5,6,7}; int [] newArr=arr; System.out.println(arr); newArr[0]=10; System.out.println("arr:"+Arrays.toString(arr)); System.out.println("newArr:"+Arrays.toString(newArr)); arr[0]=1; newArr=Arrays.copyOf(arr,arr.length); System.out.println(newArr); System.out.println("newArr:"+Arrays.toString(newArr)); System.out.println("arr:"+Arrays.toString(arr)); arr[0]=99; System.out.println("newArr:"+Arrays.toString(newArr)); System.out.println("arr:"+Arrays.toString(arr)); //拷贝某个范围 int [] newArr2= Arrays.copyOfRange(arr,2,4); System.out.println("newArr2"+Arrays.toString(newArr2)); } }
运行结果
对于上述代码首先我们将arr赋值给newArr后此时这两个引用都指向同一块堆内存,所以打印出来也是一样的,然后将newArr[0]改为10,因为newArr指向数组对象arr,所以可以修改第一个元素,当我们使用copyOf();后,使用arr[0]=99后再将这两个数组的内容打印出来,会发现arr[0]的修改并不会影响到newArr[0].这就说明copyOf之后newArr不在指向arr所指向的对象,newArr指向了一个新的数组对象。
图解上述代码
图一
图二
for循环拷贝
代码示例
public class Demo10 { public static void main(String[] args) { int [] arr=new int[]{1,2,3,4,5,6}; int [] ret= copyArray(arr); System.out.println(Arrays.toString(ret)); } public static int [] copyArray(int [] arr){ int [] tmp=new int[arr.length]; for(int i=0;i<arr.length;i++){ tmp[i]=arr[i]; } return tmp; } }
for拷贝本质是利用一个中间数组接收原数组数据
🚀clone()方法
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3, 4, 5, 6}; int[] ret = new int[arr.length]; ret = arr.clone(); System.out.println(Arrays.toString(ret)); } }
clone()方法属于Object类,而Object是java中的祖宗类是所有类默认都继承的,所以可以使用数组对象调用。
🚀System.arraycopy()方法
native修饰的方法底层基于C/C++实现.好处就是速度快。
代码示例
public class Demo11 { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3, 4, 5, 6}; int[] ret = new int[arr.length]; System.arraycopy(arr, 0, ret, 0, ret.length); System.out.println(Arrays.toString(ret)); } }
🚀查找数组中指定元素
给定一个数组, 再给定一个元素, 找出该元素在数组中的位置。
代码示例
public class Demo4 { public static void main(String[] args) { int[] arr = {1, 2, 3, 10, 5, 6}; System.out.println(find(arr, 10)); } private static int find(int[] arr, int data) { for (int i = 0; i < arr.length; i++) { if (arr[i] == data) { return i; } } return -1; // 表示没有找到 } }
🚀二分查找(折半查找)
针对有序数组, 可以使用更高效的二分查找.什么是有序数组? 有序分为 “升序” 和 “降序” 如 1 2 3 4 , 依次递增即为升序. 如 4 3 2 1 , 依次递减即为降序.以升序数组为例, 二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进比较。
- 如果相等,即找到了返回该元素在数组下标
- 如果小于,以类似方式到数组左半侧查找
- 如果大于,以类似方式到数组右半侧查找
代码示例
public class Demo5 { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5, 6}; //System.out.println(Arrays.binarySearch(arr,6)); System.out.println(MyBinarySearch(arr, 6)); } private static int MyBinarySearch(int[] arr, int toFind) { int left = 0; int right = arr.length - 1; while (left <= right) { int mid = (left + right) / 2; if (toFind < arr[mid]) { // 去左侧区间找 right = mid - 1; } else if (toFind > arr[mid]) { // 去右侧区间找 left = mid + 1; } else { // 相等, 说明找到了 return mid; } } // 循环结束, 说明没找到 return -1; } }
可以看到,二分查找每次查找都能缩小一半的范围,针对一个长度为 10000 个元素的数组查找, 二分查找只需要循环 14 次就能完成查找. 随着数组元素个数 越多, 二分的优势就越大.在Aarrays中有个二分查找的方法,以后我们就不用再手写二分了,直接用Arrays中的即可
🚀Arrays中的二分查找
代码示例
public class Demo5 { public static void main(String[] args) { int[] arr = {1, 2, 3, 4, 5, 6}; System.out.println(Arrays.binarySearch(arr,6)); }
🚀数组排序(冒泡排序)
给定一个数组, 让数组升序 (降序)排序
假设
将数组中相邻元素从前往后依次进行比较,如果前一个元素比后一个元素大,则交换,一趟下来后最大元素 就在数组的末尾,依次从上上述过程,直到数组中所有的元素到排列好。
代码示例
public class Demo6 { public static void main(String[] args) { int[] arr = {13,45,67,79,2,56}; //bubbleSort(arr); Arrays.sort(arr); System.out.println(Arrays.toString(arr)); } private static void bubbleSort(int[] arr) { for (int i = 0; i < arr.length; i++) { for (int j = 1; j < arr.length - i; j++) { if (arr[j - 1] > arr[j]) { int tmp = arr[j - 1]; arr[j - 1] = arr[j]; arr[j] = tmp; } } } } }
Arrays中也有一个更高效的排序算法sort()
代码示例
public class Demo6 { public static void main(String[] args) { int[] arr = {13,45,67,79,2,56}; // bubbleSort(arr); Arrays.sort(arr); System.out.println(Arrays.toString(arr)); } }
判断数组的内容是否相等
代码示例
public class Demo8 { public static void main(String[] args) { int [] arr=new int[]{1,2,3,4,5,6,7,8,9,10}; int [] arr2=new int[]{1,2,3,4,5,6,7,8,9,10}; int [] arr3=new int[]{1,2,3,4,5,6,7,8,9,1}; System.out.println(Arrays.equals(arr, arr2)); System.out.println(Arrays.equals(arr, arr3)); } }
运行结果
🚀将指定的元素填充到数组中
填充数组,该方法会将已有的元素
代码示例
public class Demo5 { public static void main(String[] args) { int [] arr=new int[]{1,2,3,4,5,6,7,8}; Arrays.fill(arr,23); System.out.println(Arrays.toString(arr)); } }
用比较器对象自定义比较
首先创建一个Student类
package task3; public class Student { private String name; private int age; private double height; public Student() { } public Student(String name, int age, double height) { this.name = name; this.age = age; this.height = height; } 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 double getHeight() { return height; } public void setHeight(double height) { this.height = height; } @Override public String toString() { return "Student{" + "name='" + name + '\'' + ", age=" + age + ", height=" + height + '}'; } }
创建测试类
package task3; import java.util.Arrays; import java.util.Comparator; public class ArraysDemo2 { public static void main(String[] args) { int[] ages = {34, 12, 42, 23}; Arrays.sort(ages); System.out.println(Arrays.toString(ages)); Integer[] ages1 = {34, 12, 42, 23}; Arrays.sort(ages1, new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { // 指定比较规则。 //if(o1 > o2){ // return 1; //}else if(o1 < o2){ //return -1; //} //return 0; // return o1 - o2; // 默认升序 return o2 - o1; // 降序 } }); System.out.println(Arrays.toString(ages1)); System.out.println("-------------------------"); Student[] students = new Student[3]; students[0] = new Student("吴磊", 23, 175.5); students[1] = new Student("谢鑫", 18, 185.5); students[2] = new Student("王亮", 20, 195.5); System.out.println(Arrays.toString(students)); // Arrays.sort(students); // 直接运行奔溃 Arrays.sort(students, new Comparator<Student>() { @Override public int compare(Student o1, Student o2) { // 自己指定比较规则 // return o1.getAge() - o2.getAge(); // 按照年龄升序排序! // return o2.getAge() - o1.getAge(); // 按照年龄降序排序!! // return Double.compare(o1.getHeight(), o2.getHeight()); // 比较浮点型可以这样写 升序 return Double.compare(o2.getHeight(), o1.getHeight()); // 比较浮点型可以这样写 降序 } }); System.out.println(Arrays.toString(students)); } }
Arrays.sort();无法比较定义类型,如果要比较自定义类型的数据需要使用比较器对象,自己指定比较规则来对自定义类型中的数据进行排序。
🚀数组逆序
设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素. 然后让前一个下标自增, 后一个下标自减, 循环继续即可。
思路
- 1.设定两个下标, 分别指向第一个元素和最后一个元素. 交换两个位置的元素.
- 2.然后让前一个下标自增, 后一个下标自减, 循环继续即可.
代码示例
public class Demo7 { public static void main(String[] args) { int[] arr = {12,34,56,67,89,6}; reverse(arr); System.out.println(Arrays.toString(arr)); } private static void reverse(int[] arr) { int left = 0; int right = arr.length - 1; while (left < right) { int tmp = arr[left]; arr[left] = arr[right]; arr[right] = tmp; left++; right--; } } }
⭐二维数组
二维数组其实就是一一维数组为元素的数组,在底层就是一个一维数组。
⭐ 二维数组的动态初始化
格式1:类型 [] []arr=new 类型 [X] [T]; //X,T是大于等于0的整数。
int [] [] arr=new int [3][2];
定义了一个名称为arr的二维数组,该数组中包含3个一维数组,每个一维数组的元素是2个。三个一维数组的名称分别为arr[0],arr[1],arr[2],如果想给一维数组中的第一个元素赋值可以这样写,arr[0] [1]=19;
格式二:int [] [] arr=new int [3] [];
定义了一个有三个一维数组的二维数组,每个一维数组都是默认初始化值为null,可以分别对这三个一维数组进行初始化arr[0]=new int [3]; arr[1]=new arr[1];,arr[2]=new int[2].
⭐二维数组的静态初始化
格式:类型 [] [] arr=new [] []{{元素1,元素2,元素3},{元素1,元素2},{元素1,元素2,元素3}};
定义一个名为arr的二维数组,该数组中有三个一维数组。对二维数组中地方一维数组进行初始化arr[0]={1,2,3};arr[1]={1,2,3};arr[2]={1,2,3};。
注意特殊写法:int [] x,y[];x是一维数组,y时二维数组。
二维数组的内存解析
public class Demo8 { public static void main(String[] args) { int[][] arr = new int[4][]; arr[1] = new int[]{1,2,3}; arr[2] = new int[4]; arr[2][1] = 30; } }
图解
首先main加载到栈区,创建一个有4个未初始化的一维数组的二维数组,在堆区就会开辟4个一维数组,因为一维数组属于引用类型所以默认值为null,然后将第2个一维数组进行初始化为1,2,3,再将第3个数组初始化其默认值为0,最后将其第二个元素赋值为30。
⭐使用二维数组打印杨辉三角
如图所示
代码
public class Demo9 { public static void main(String[] args) { int [] [] arr=new int[10][]; for(int i=0;i<arr.length;i++){ arr[i]=new int[i+1]; arr[i][0]=arr[i][i]=1; for(int j=1;j<arr[i].length-1;j++){ arr[i][j]=arr[i-1][j-1]+arr[i-1][j]; } } for(int i=0;i<arr.length;i++){ for(int j=0;j<arr[i].length;j++){ System.out.print(arr[i][j]+" "); } System.out.println(); } } }
最后的话
各位看官如果觉得文章写得不错,点赞评论关注走一波!谢谢啦!。如果你想变强那么点我点我 牛客网。