1.数组的基本概念
1.1为什么用数组
在程序设计中,每一个数据总是对应一个变量.当数据量越大,就需要更多的变量来存储.我们将相同类型的数据存储到一个集合中,就可以更方便我们对数据进行访问,同时可以减少不断定义变量.这个集合就叫做数组
1.2数组的定义
数组是一种基本的数据结构，用于存储相同类型的多个值。数组是引用数据类型，它可以存储基本数据类型或对象的集合。
1.3数组的创建及初始化
1.3.1语法格式
T[] 数组名 = new T[N];T : 表示数组中存放元素的类型
T[ ] : 表示数组的类型
N : 表示数组的长度
int[] arr = new arr[10];这样我们就创建了一个可以容纳10个int类型元素的数组
1.3.2数组的初始化
数组的初始化主要分为动态初始化和静态初始化
1.动态初始化:在创建数组时,直接指定数组中元素的个数
int[] arr = new arr[10];2.静态初始化:在创建数组时不指定元素个数,而是直接用数据进行指定
语法格式:
T[] 数组名称 = {data1,data2,data3.....datan};int[] arr = new int[]{0,1,2,3,4,5,6};注意事项:
- 静态初始化虽然没有指定数组的长度,编译器在编译时会根据{ }中元素个数来确定数组的长度.
- 静态初始化时, { }中数据类型必须与[]前数据类型一致.
- 静态初始化可以简写,省去后面的 new T[ ],但是编译器编译代码时还是会还原.
- 如果没有对数组初始化,数组中元素有其默认值,如果是基本数据类型,默认值为对应的默认值,如图
如果数组中存储元素类型为引用类型,默认值为null.
1.4数组的使用
1.4.1数组中元素访问
数组在内存中是一段连续的空间,空间的编号都是从0开始的,依次递增,该编号称为数组的下标,数组可以通过下标访问其任意位置的元素.
int[] arr = new int[]{11,22,33,44};
System.out.println(arr[0]);//11
System.out.println(arr[1]);//22
System.out.println(arr[2]);//33
System.out.println(arr[3]);//44也可以通过下标对数组元素进行修改
arr[3] = 55;
System.out.println(arr[3]);//55注意事项:
下标从0开始,介于 [ 0 , N ) 之间,不包含N,N为元素个数,不能越界,否则会报出下标越界异常
1.4.2数组遍历
遍历指的是将数组中所有元素都访问一遍,访问是指对数组中的元素进行某种操作,比如打印
1.4.1中的代码就是对数组arr进行了遍历,但问题是这种方法不易于修改,增加一个元素就要多一条打印语句,通过观察代码可以发现,遍历的下标都是是按照顺序逐渐增大,所有我们可以用一个循环来表示下标.
int[] arr = new int[]{11,22,33,44};
for(int i = 0;i<4;i++){
System.out.println(arr[i]);
}这样就简写了对数组的遍历,但是问题还没有解决,数组变大时还需要修改循环,我们可以通过 数组对象.length 来获取数组的长度,代码修改如下
int[] arr = new int[]{11,22,33,44};
for(int i = 0;i< arr.length;i++){
System.out.println(arr[i]);
}还可以通过 for-each 来遍历数组
int[] arr = new int[]{11,22,33,44};
for(int i:arr){
System.out.println(i);
}这种写法更简洁,但是无法反向遍历
2.数组是引用类型
2.1基本类型变量与应用类型变量的区别
基本数据类型创建的变量,称为基本变量,该变量空间中直接存放的是其所对应的值;
而引用数据类型创建的变量,一般称为对象的引用,其空间中存储的是对象所在空间的地址.
public static void main(String[] args) {
int a = 10;
int b = 20;
int[] arr = new int[]{1, 2, 3};
}在上述代码中, a、b、arr 都是函数内部的变量,因此其空间都在main方法对应的栈帧中分配;
a、b是内置类型的变量,因此其空间中保存的就是给该变量初始化的值;
array是数组类型的引用变量,其内部保存的内容可以简单理解成是数组在堆空间中的首地址.
从上图可以看到,引用变量并不直接存储对象本身,可以简单理解成存储的是对象在堆中空间的起始地址.通过该地址,引用变量便可以去操作对象.
2.2引用变量的赋值
int[] arr1 = new int[]{1,2,3};
int[] arr2 = new int[]{100,200,300};
arr1 = arr2;
arr2[2] = 400;
for(int i:arr1){
System.out.println(i);
}
for(int i:arr2){
System.out.println(i);
}这段代码中,定义了两个数组 arr1 和 arr2 ,修改了 arr2 的一个元素并对两个数组进行遍历打印
但是结果却把 arr2 打印了两遍,因为 arr1 = arr2 本质是把 arr1 去引用 arr2引用的数组的空间,此时arr1 和 arr2 实际是一个数组
修改之前
修改之后
2.3认识 null
null 在 Java 中表示 "空引用" , 也就是一个不指向对象的引用.
null 的作用类似于 C 语言中的 NULL (空指针), 都是表示一个无效的内存位置. 因此不能对这个内存进行任何读写操 作. 一旦尝试读写, 就会抛出 NullPointerException.同时 Java 中并没有约定 null 和 0 号地址的内存有任何关联
int[] arr = null;
System.out.println(arr[0]);
3.数组的应用场景
3.1保存数据
int[] arr = new int[]{11,22,33,44};
for(int i = 0;i<4;i++){
System.out.println(arr[i]);
}3.2作为函数的参数
1.参数传基本类型
public static void main(String[] args) {
int num = 0;
func(num);
System.out.println("num=" + num);
}
public static int func(int x){
x = 10;
System.out.println("x="+ x);
return x;
}
在 func 方法中修改形参 x 的值,不会影响实参的 num 的值
2.参数传数组类型(引用数据类型)
public static void main(String[] args) {
int[] arr ={1};
func(arr);
System.out.println("arr[0]="+arr[0]);
}
public static void func(int[] a){
a[0] = 10;
System.out.println("a[0]="+ a[0]);
}
这一次改变了方法外部的值,是因为数组是引用类型,按照引用类型来进行传递,是可以修改其中存放的内容的
总结: 所谓的 "引用" 本质上只是存了一个地址. Java 将数组设定成引用类型, 这样的话后续进行数组参数传参, 其实 只是将数组的地址传入到函数形参中. 这样可以避免对整个数组的拷贝(数组可能比较长, 那么拷贝开销就会很大).
3.3数组转字符串
代码示例
import java.util.Arrays;
int[] arr = {1,2,3,4,5,6};
String newArr = Arrays.toString(arr);
System.out.println(newArr);执行结果
通过将数组转为字符串,可以让打印更方便一些
3.4数组拷贝
代码示例
int[] arr = {1,2,3,4,5};
int[] newArr = arr;
newArr[0] = 10;
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));
当前 newArr 数组指向了 arr 数组,修改了 newArr 中的内容, arr 也会发生改变,虽然结果一样,但是不算真正意义上的拷贝
所以我们需要用到 Arrays 中的 copyOf 方法来完成数组的拷贝
语法格式: Arrays.copyOf(拷贝的数组,拷贝的长度)
int[] arr = {1,2,3,4,5};
int[] newArr = Arrays.copyOf(arr,arr.length);
newArr[0] = 10;
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));
这个时候,arr 和 newArr 就不是引用同一个数组了,改变其中一项就不会对另一个数组改变.
还可以使用 Arrays.copyOfRange 来指定拷贝范围
语法格式: Arrays.copyOfRange(拷贝的数组,拷贝的起点,拷贝的终点)
int[] arr = {1,2,3,4,5};
int[] newArr = Arrays.copyOfRange(arr,2,4);
System.out.println("arr:"+Arrays.toString(arr));
System.out.println("newArr:"+Arrays.toString(newArr));
可以看到拷贝的范围是左闭右开区间 [ 2 , 4)
实现自己版本的拷贝数组
public static int[] copyOf(int[] arr){
int[] ret = new int[arr.length];
for(int i = 0;i< arr.length;i++){
ret[i] = arr[i];
}
return ret;
}3.5查找指定元素(二分查找)
针对有序数组,可以使用更高效的二分查找
以升序数组为例,二分查找的思路是先取中间位置的元素, 然后使用待查找元素与数组中间元素进行比较：
- 如果相等，即找到了返回该元素在数组中的下标;
- 如果小于，以类似方式到数组左半侧查找;
- 如果大于，以类似方式到数组右半侧查找.
代码示例
public static void main(String[] args) {
int[] arr = new int[]{1,2,3,4,5,6,7,8,9,10};
System.out.println(binarySearch(arr,7));
}
public static int binarySearch(int[] arr,int toFind){
int left = 0;
int right = arr.length;
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; //没找到
}3.6数组排序(冒泡排序)
给定一个数组,让数组实现升序或降序
算法思路:
将相邻两个数进行比较,将大的数交换置于后面,遍历一躺以后,最大的数就会被交换到最后一位
每一次遍历会有一个数到自己该有的位置,所以循环次数为数组元素的个数
(生活中泡泡总是不断向上,这个排序方法也是不断的向上,所以称为冒泡排序)
代码示例
public static void main(String[] args) {
int[] arr = new int[]{9,5,8,3};
bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void bubbleSort(int[] arr){
for(int i = 0;i< arr.length;i++){
for(int j = 0;j< arr.length-i-1;j++){
if(arr[j] > arr[j+1]){
int tmp = arr[j+1];
arr[j+1] = arr[j];
arr[j] = tmp;
}
}
}
}运行结果
冒泡排序性能较低,Java中内置了更高效的排序算法
public static void main(String[] args) {
int[] arr = new int[]{9,5,8,3};
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));
}运行结果如上
3.7二维数组
二维数组本质上也是一维数组,只不过每个元素又是一个一维数组
语法格式
数据类型[][] 数组名称 = new 数据类型 [行数][列数] { 初始化数据 }同理,还有 "三维数组" , "四维数组",出现频率不高,这里不再介绍
感谢阅读,希望对你有帮助
