Java数组

---

Java中定义数组的语法如下：
数据类型[] 数组名 = new 数据类型[数组长度];

数据类型指的是数组中元素的数据类型
数组名是自定义的数组标识符
数组长度指的是数组中元素的个数

例如，定义一个int类型的数组，长度为5：

int[] numbers = new int[5];
1

如果要给数组赋初值，可以在定义数组时使用花括号括起来的初值列表，例如：

int[] numbers = {1, 2, 3, 4, 5};
1

这样就定义了一个包含5个元素的整数数组，初始值分别为1、2、3、4、5。

前言

提示：这里可以添加本文要记录的大概内容：

在Java语言中，数组是引用类型中的一个，它在概念上属于类的范畴，但处理的方式又与类和对象不完全相同。
比如程序里面要想处理十位员工的数据，那么程序里要存十个变量，如果是一万名员工呢？我们只需要把一些相似的数据（员工姓名、工资）放到一个组里就好。用这个组代表多个相同的数据，对外只需要一个名字即可，方便管理多个数据。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一维数组

数组是相同类型的数据按照顺序组合后的一种引用类型。
数组可以看成是多个相同类型数据的组合，实现对这些数据的统一管理。
数组的长度一旦确定后就不能更改，因此它是一个固定长度的结构。数组结构中每个存储的数据叫数组元素，数组元素由索引来定位。
索引（或叫数组下标）是指当前元素相对于第一个元素的位移，因此第一个元素的下标就是0，第二个元素的下标就是1，以此类推。

数组定义

数组声明的语法：
数据类型 [] 数组名;
[]放中间或后面都行
例如：
int [] a;
double [] b;
String str [];

定义时[]中不能指定长度

在Java中，声明一个数组并不会立即为其分配内存空间，需要在创建数组时确定其长度以便为其分配具体的内存空间。如果在访问数组之前未创建数组，可能会导致NullPointerException异常的发生。

创建数组

数组的长度在创建时指定，并且一旦指定就不能更改。创建数组有两种方式：

1、静态初始化
这种方式在声明的同时就直接初始化数组，同时也创建了数组空间。如：

int[] n = {1,2,3,4,5};
1

上面的语句运行后，就会创建一个数组n，这个数组的长度是5，他有5个元素，分别是1,2,3,4,5

2、动态初始化
这种创建方式的语法是：
数组名 = new 数组类型[数组长度];

int [] a = new int [3];
1

虚拟机运行java主方法时，会为主方法分配一块内存空间——栈区
栈区存放的是主方法运行时的定义的变量
java程序运行时，运行到new关键字时，虚拟机会在堆区中开辟新空间
引用数据类型的本质 存储的是堆区中某一块空间的地址

数字类型，默认值为0
字符型，默认值为‘\u0000’
布尔类型，默认值为false
对象类型，默认值为null

数组的内存模型

数组是存储多个相同类型数据的对象。数组的所有元素保存在堆内存中。
创建一个数组就是在堆中创建一个数组对象。数组创建后立即拥有默认值。索引从0开始。

int i = 10;
int [] a = new int [3];
System.out.println(a[2]);
1
2
3

数组空间在堆区中是连续分配的
数组空间中是有默认值

数组数据初始化

//数据的初始化
int a [] = {1,2,3}
int a [] = new int [] {1,2,3}
1
2
3

【例】创建数组并初始化

public class 数组数据初始化 {
	public static void main(String[] args) {
		int [] x = {30,22,28};
		System.out.println(x[1]);
		
		char [] n = new char [] {'a','b','c'};
		System.out.println(n[2]);
	}
}
1
2
3
4
5
6
7
8
9

数组元素访问

数组元素的访问需要根据数组名和下标共同实现

【例】

public class 数组数据访问 {
	public static void main(String[] args) {
		double [] x = {1.73,1.83,1.70,1.69};
		System.out.println(x[2]);
		x[3]=1.8;  //数组名[元素下标] = 元素值；
		System.out.println(x[3]);
	}
}
1
2
3
4
5
6
7
8

数组数据访问 数组名[下标]
下标是从0开始第一位，连续分配
下标范围 0到长度-1

遍历数组length

数组是引用类型，具有属性，常用的数组属性就是数组的长度length，它必须>=0，利用它遍历数组

public class 使用长度属性遍历数据 {
	public static void main(String[] args) {
		String [] names = {"张三","李四","王五","赵六"} ;
		System.out.println(names.length);
		for (int i = 0; i < names.length; i++) {
			System.out.println(names[i]);			
		}
	}
}
1
2
3
4
5
6
7
8
9

数组遍历：从第一个数据开始，依次使用访问到最后一个
数组使用时必须遍历才有最终意义
使用for循环结合长度属性遍历数组

常见数组异常

常见的数组异常包括：

1、数组下标越界异常（ArrayIndexOutOfBoundsException）：当访问数组时使用了超出数组长度的下标，会引发数组下标越界异常。

2、空指针异常（NullPointerException）：当尝试引用一个空对象的数组时，会抛出空指针异常
如：数组未初始化、没有创建而直接使用数组、数组为空等。

3、数组类型不匹配异常：当尝试将一个数据类型不匹配的值添加到数组中时，会引发数组类型不匹配异常。

4、非法参数异常：当传递给方法的参数不符合预期时，会引发非法参数异常，如传递负数长度。

5、数组存储异常：当试图将一个无效值存储到数组中时，会引发数组存储异常。

public class 数组使用异常 {
	public static void main(String[] args) {
		int [] a = {1,2,3};
		System.out.println(a[0]);
		//System.out.println(a[3]);
		//使用数组时，下标超出范围会引发数组越界异常
		
		double [] num = null;//空地址
		System.out.println(num[0]);
		//数组未被创建时去使用会引发空指针异常	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

二分查找

二分查找算法是一种常用的查找算法，它的核心思想是将一个有序的数组从中间分开，然后判断要查找的元素在哪一半，根据判断结果继续从一半中查找，以此类推，直到找到要查找的元素或者确定要查找的元素不在数组中。

以下是Java实现二分查找算法的代码：

public static int binarySearch(int[] arr, int target) {
    int start = 0, end = arr.length - 1;
    while (start <= end) {
        int mid = (start + end) / 2;
        if (arr[mid] == target) {
            return mid;
        } else if (arr[mid] > target) {
            end = mid - 1;
        } else {
            start = mid + 1;
        }
    }
    return -1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个代码中，我们将要查找的区间的起始点和末尾点定义为start和end，然后计算中间值mid。
如果中间值等于目标值，则返回mid。如果中间值大于目标值，则在start到mid-1的区间内继续查找。
如果中间值小于目标值，则在mid+1到end的区间内继续查找。如果找不到目标值，则返回-1。

示例：

int[] arr = {1, 3, 5, 7, 9, 11}; // 定义一个有序数组
int target = 5; // 要查找的目标值
int position = binarySearch(arr, target); // 查找目标值的位置
if (position != -1) {
    System.out.println("目标值" + target + "在数组中的位置为" + position);
} else {
    System.out.println("目标值" + target + "不在数组中");
}
1
2
3
4
5
6
7
8

输出结果为：
目标值5在数组中的位置为2

数组的操作

数组的复制

Java中的数组的复制使用System.arraycopy方法就可以实现

复制source数组中从下标srcPos开始的length个元素到目标数组dest，并从目标数组的下标为destPos的位置开始储存

其中各个参数的含义如下：
source： 源数组中的起始位置
srcPos：起始的下标
dest： 目标数组
destPos：目标数组中复制的起始位置
length： 要复制的数组元素的个数

【例】

public class 数组的复制 {
	public static void main(String[] args) {
		int [] abc = {1,2,3,4,5};
		int [] mn = new int [10];
		
		//System.arraycopy(source,srcPos,dest,destPos,length)
		System.arraycopy(abc, 0, mn, 3, 4);
		//abc, 0, mn, 3, 4分别代表的意思
		//我从谁复制？从源头的哪个下表开始？复制给谁？赋值给mn的第几个数据开始？复制几个数据？
		for (int i = 0; i < mn.length; i++) {
			System.out.print(mn[i]+"\t");
		}	
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

【例】

int[] sourceArray = {1, 2, 3, 4};
int[] targetArray = new int[4];
System.arraycopy(sourceArray, 0, targetArray, 0, 4);
1
2
3

以上示例会将sourceArray数组中的元素复制到targetArray数组中。
因为源数组和目标数组的长度都是4，所以length参数传递的是4。
其中，srcPos和destPos都传递的是0，表示从数组的起始位置开始复制。

数组的排序

Java中可以使用Arrays类提供的sort()方法对数组进行排序。
下面是一个示例代码：

public class ArraySortExample {
    public static void main(String[] args) {
        int[] arr = {3, 7, 1, 9, 2, 5, 4, 6, 8};
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}
1
2
3
4
5
6
7

输出结果为：[1, 2, 3, 4, 5, 6, 7, 8, 9]
在这个示例代码中，首先定义了一个int类型的数组arr，然后使用sort()方法对数组进行升序排序。
最后使用Arrays.toString()方法将排序后的数组转化为字符串输出。

如果需要对数组进行降序排序，则可以使用Collections类提供的reverseOrder()方法来获取一个降序排序的Comparator对象，然后将其作为参数传递给sort()方法。
示例代码如下：

public class ArraySortExample {
    public static void main(String[] args) {
        Integer[] arr = {3, 7, 1, 9, 2, 5, 4, 6, 8};
        Arrays.sort(arr, Collections.reverseOrder());
        System.out.println(Arrays.toString(arr));
    }
}
1
2
3
4
5
6
7

输出结果为：[9, 8, 7, 6, 5, 4, 3, 2, 1]

在这个示例代码中，首先定义了一个Integer类型的数组arr，然后使用Collections.reverseOrder()方法获取一个降序排序的Comparator对象，最后将其作为参数传递给sort()方法。
需要注意的是，由于Java中的基本数据类型不能直接使用泛型，因此在进行降序排序时需要将int类型的数组转化为Integer类型的数组。

二维数组

Java中的二维数组是指每个元素都是一个一维数组的数组，也就是说它是由多个一维数组组成。
二维数组可以看做一个表格，其中每行都是一个一维数组，每行中的每列都是一个元素。
在Java中，可以通过以下方式声明和初始化一个二维数组：

int[][] arr = new int[3][4];
1

这个语句声明了一个3行4列的二维数组，并将其所有元素初始化为0。
也可以通过以下方式初始化一个二维数组：

int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
1

这个语句声明了一个3行3列的二维数组，并将其初始化为指定的值。

访问二维数组中的元素需要使用两个索引，一个用于指定行，另一个用于指定列。例如，要访问二维数组中的第2行第3列的元素，可以使用以下语句：

int x = arr[1][2];
1

这个语句将数组中第2行第3列的元素赋值给变量x。

使用循环可以遍历二维数组中的所有元素。
例如，以下代码使用两个嵌套的for循环遍历一个3行4列的二维数组：

for(int i=0;i<3;i++){
    for(int j=0;j<4;j++){
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}
1
2
3
4
5
6

这个代码将输出该二维数组中的所有元素。

❗扩展

找出数组中最大的数及下标

public class 找出数组中最大的数及下标 {
	public static void main(String[] args) {
		int[] arr = {10, 25, 33, 15, 27};
		//假定第一个数据为最大，0为最大下标
		int maxNum = arr[0];
		int maxIndex = 0;

		for(int i=1; i<arr.length; i++){
		    if(arr[i] > maxNum){
		        maxNum = arr[i];
		        maxIndex = i;
		    }
		}
		System.out.println("数组中最大的数为：" + maxNum + "，下标为：" + maxIndex);

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

代码中，我们先设定数组的第一个元素为最大值，并将其下标设为0，然后通过for循环依次比较数组中的每个元素，如果当前元素比最大值大，则将最大值和最大值的下标更新为当前元素和当前元素的下标。最后输出最大值和其下标。