2.1数组概要
数组是一种引用数据类型,在内存中存储示意图如下:
![](https://i-blog.csdnimg.cn/blog_migrate/28d03b8b947110b53879d755d477a401.png)
数组是一组数
据的集合
数组作为一种引用类型
数组元素的类型可以是基本类型,也可以是引用类型,但同一个数组只能是同一种类型
数组作为对象,数组中的元素作为对象的属性,除此之外数组还包括一个成员属性
length
,
length
表示数组的长度
数组的长度在数组对象创建后就确定了,就无法再修改了
数组在内存方面存储的时候,内存地址是连续的
数组中首元素的内存地址作为整个数组对象的内存地址
数组元素是有下标的,下标从 0
开始,也就是第一个元素的下标为
0
,依次类推最后一
个元素的下标为
n-1
,我们可以通过数组的下标来访问数组的元素
![](https://i-blog.csdnimg.cn/blog_migrate/110459dac634ed08afdc536da5443e14.png)
2.2一维数组的声明和使用
2.2.1数组的声明
一维数组的声明有以下两种形式:
数组元素的类
型[] 变量名称
数组元素的类型 变量名称[]
数组元素的类型,可以是 java 中的任意类型,变量名称可以是任意合法的标识符,上面两
种格式较常用的是第一种,例如:
int [] a;
Student[] stu
在一行中也可以声明多个数组,例如:
int[] a, b, c
2.2.2数组的创建
两种方式:
第一种,使用 new
操作符来创建数组。
格式为:
new 数组元素的数据类型
[
数组元素的个数]
int[] nums = new int[5];
1.基本类型的数组
数组为引用类型,它在堆中分配
2.引用类型的数组
public class Test20 { public static void main(String[] args) { //声明引用类型的数组 Student[] student = new Student[2]; //出现空指针 //因为引用类型的数组,它采用 null 作为默认的初始化值 student[0].id = 1001; student[0].name = "张三"; student[1].id = 1002; student[1].name = "李四"; } }
修正空指针
public class Test20 { public static void main(String[] args) { //声明引用类型的数组 Student[] student = new Student[2]; //出现空指针 //因为引用类型的数组,它采用 null 作为默认的初始化值 /*student[0].id = 1001; student[0].name = "张三"; student[1].id = 1002; student[1].name = "李四"; */ //可以采用如下方式赋值 Student zhangsan = new Student(); zhangsan.id = 1001; zhangsan.name = "张三"; student[0] = zhangsan; Student lisi = new Student(); lisi.id = 1002; lisi.name = "李四"; student[1] = lisi; } } class Student { int id; String name; }
第二种,使用数组的初始化语句,格式为:数组元素的类型
[]
变量名称
= {
数组元素
1
,
数组元素
2,......
数组元素
n}
或数组元素的类型 变量名称
[] = {
数组元素
1
,数组元素
2,......
数组元素
n}
//静态初始化
int[] nums = {1, 2, 3, 4, 5};
//静态初始化
Student[] students = {zhangsan, lisi};
2.3二维数组的声明和使用
二维数组属于多维数组,那么什么是多维数组呢,当数组元素的类型是数组时就成了多维数
组,二维数组的声明格式如下:
数组元素的数据类型[][]
变量名;
数组元素的数据类型 变量名[][]
;
其中方括号的个数就是数组的维数。
声明二维数组如下:
int [][] data;
三种二维数组的创建方式 :
1.采用new 关键字直接创建
//
声明二维数组
int[][] data = new int[2][3];
![](https://i-blog.csdnimg.cn/blog_migrate/6816292d6e5659345689afad1c49aa0b.png)
2.从高维开始逐维创建
int[][] data = new int[2][];
data[0] = new int[2];
data[1] = new int[4];
3.
采用初始化语句块创建数组对象
//静态初始化
// 多个数组之间用逗号隔开
int[][] data = {{1,2},{1,2,3,4}};
2.4Arrays工具类
2.4.1
Arrays.sort
的使用
1.Arrays.sort(int[] a)
这种形式是对一个数组的所有元素进行排序,并且是按从小到大的顺序。
public class Main { public static void main(String[] args) { int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a); for(int i = 0; i < a.length; i ++) { System.out.print(a[i] + " "); } } }
运行结果如下:
0 1 2 3 4 5 6 7 8 9
2、Arrays.sort(int[] a, int fromIndex, int toIndex)
这种形式是对数组部分排序,也就是对数组a的下标从fromIndex到toIndex-1的元素排序,注意:下标为toIndex的元素不参与排序!
public class Main { public static void main(String[] args) { int[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; Arrays.sort(a, 0, 3); for(int i = 0; i < a.length; i ++) { System.out.print(a[i] + " "); } } }
运行结果如下:
7 8 9 2 3 4 1 0 6 5
3、public static void sort(T[] a,int fromIndex,int toIndex, Comparator c)
上面有一个拘束,就是排列顺序只能是从小到大,如果我们要从大到小,就要使用这种方式,其实就是多了一个Comparator类型的参数而已。
public class Main { public static void main(String[] args) { //注意,要想改变默认的排列顺序,不能使用基本类型(int,double, char) //而要使用它们对应的类 Integer[] a = {9, 8, 7, 2, 3, 4, 1, 0, 6, 5}; //定义一个自定义类MyComparator的对象 Comparator cmp = new MyComparator(); Arrays.sort(a, cmp); for(int i = 0; i < a.length; i ++) { System.out.print(a[i] + " "); } } } //Comparator是一个接口,所以这里我们自己定义的类MyComparator要implents该接口 //而不是extends Comparator class MyComparator implements Comparator<Integer>{ @Override public int compare(Integer o1, Integer o2) { //如果n1小于n2,我们就返回正值,如果n1大于n2我们就返回负值, //这样颠倒一下,就可以实现反向排序了 if(o1 < o2) { return 1; }else if(o1 > o2) { return -1; }else { return 0; } }
运行结果如下:
9 8 7 6 5 4 3 2 1 0
2.4.2
Arrays.binarySearch
的使用
通过二分法在已经排好序的数组中查找指定的元素,并返回该元素的下标
1.如果数组中存在该元素,则会返回该元素在数组中的下标
public class binarySearch { public static void main(String[] args) { int[] scores = {1, 20, 30, 40, 50}; //在数组scores中查找元素20 int res = Arrays.binarySearch(scores, 20); //打印返回结果 System.out.println("res = " + res); } }
运行结果: res = 1
2.如果数组中不存在该元素,则会返回 -(插入点 + 1)
这里的插入点具体指的是:如果该数组中存在该元素,那个元素在该数组中的下标
public class binarySearch { public static void main(String[] args) { int[] scores = {1, 20, 30, 40, 50}; //1.在数组scores中查找元素25 //从数组中可以看出 25位于20与30之间, //由于20的下标为1,所以25的下标为2, //最后的返回值就为:-(2 + 1) = -3 int res1 = Arrays.binarySearch(scores, 25); //2.同理在该数组中查找-2 //可以看出-2比数组中的任何一个元素都要小 //所以它应该在数组的第一个,所以-2的下标就应该为0 //最后的返回值就为:-(0 + 1) = -1 int res2 = Arrays.binarySearch(scores, -2); //3.又例如在该数组中查找55 //由于55比数组中的任何一个元素都要大 //所以他应该位于数组的最后一个,它的下标就为5 //最后的返回值就为:-(5 + 1) = -6 int res3 = Arrays.binarySearch(scores, 55); //打印返回结果 System.out.println("res1 = " + res1); System.out.println("res1 = " + res2); System.out.println("res1 = " + res3); } }
运行结果: res1 = -3 res1 = -1 res1 = -6
数组这种数据结构的优点和缺点是什么?
优点:查询/查找/检索某个下标上的元素时效率极高。可以说是查询效率最高的一个数据结构。
为什么检索效率高?
第一:每一个元素的内存地址在空间存储上是连续的。
第二;每一个元秦类型相同,所以占用空间大小一样。
第三;知道第一个元素内存地址,知道每一个元素占用空间的大小,又知道下标,所以通过一个数学表达式就可以计算出某个下标上元素的内存地址。直接通过内存地址定位元素,所以数组的检索效率是最高的。
数组中存储100个元素,或者存储100万个元素,在元素查询/检索方面,效率是相同的,因为数组中元素查找的时候不会一个一个找,是通过数学表达式计算出来的。(算出一个内存地址,查接定位的。)
缺点:
第一:由于为了保证数组中每个元素的内存地址连续,所以在数组上随机删除或者增加元素的时候,效率较低,因为随机增删元素会涉及到后面元素统一向前或者向后位移的操作。
第二:数组不能存储大数据量,为什么?
因为很难在内存空间上找到一块特别大的连续的内存空间。
注意:对于数组中最后一个元素的增删,是没有效率影响的。