数组定义的方式：
1、静态初始化：在声明数组的同时，直接给出数组元素的初始值。适用于数组元素已知的情况。
int[] array = {32,5,7,87};
int[] array = new int[]{32,5,7,87};
2、动态初始化：在声明数组时，仅指定数组的长度，然后通过赋值语句逐个给数组元素赋值。适用于数组元素在声明时未知的情况。
int[] array = new int[4];
array[0] = 34;
累加和
@Test
public void test189() {
int[] array = new int[4];
array[0] = 33;
array[1] = 2;
array[2] = 45;
array[3] = 19;
//array.fori fori
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum = sum + array[i];
}
System.out.println("sum: " + sum);
}最大值 最小值
//数组最重要操作就是遍历。
//只要能遍历所有元素：求最大值、最小值、排序。
@Test
public void test23(){
int[] array = {23, 45, 67, 2, 12};
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
System.out.println("max: " + max);
}
@Test
public void test333() {
int[] array = {23, 45, 67, 2, 12};
int max = getMax(array);
System.out.println(max);
}
//参数，形参
/**
* 返回数组的最大值
* @param array 传递过来的数组
* @return 数组最大值
*/
public int getMax(int[] array) {
int max = array[0];
for (int i = 0; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
}
return max;
}
@Test
public void test24(){
int[] array = {23, 45, 67, 2, 12};
int min = array[0];
for (int i = 0; i < array.length; i++) {
//正在遍历的比假设的最小的还要小
if (array[i] < min) {
min = array[i];
}
}
System.out.println("min: " + min);
}数组的排序：冒泡排序
int[] array = {40, 17, 21, 1}; // 1, 17,21,40
第一轮：40冒到最右边
17,40,21,1
17,21,40,1
17,21,1,40 ——- 40 冒出来
第二轮：21冒出来
17,21,1,40
17,1,21,40 ——- 21冒出来
第三轮：17冒出来
1,17,21,40 ——- 17冒出来
public void sort(int[] array) {
}
4个数只要比较3轮就可以，剩下那个数不要要排序就是最小的
第1轮：比较3次
第2轮：比较2次
第3轮：比较1次
i+j =4=array.length
j=array.length-i
@Test
public void test22() {
//i=1 j=
int[] array = {40, 17, 21, 1}; // 1, 17,21,40
sort(array);
for (int i = 0; i < array.length; i++) {
System.out.println(array[i]);
}
}
private void sort(int[] array) {
for (int i = 1; i <= array.length - 1; i++) {
for (int j = 0; j < array.length - i; j++) {
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
}数组扩容
System.arraycopy（重点）
这是标准且高效的方法，适用于复制数组的部分或全部。
System.arraycopy(原数组, 原数组起始索引, 目标数组, 目标数组起始索引, 复制长度);
public class SystemArrayCopy {
public static void main(String[] args) {
String[] original = {"Java", "Python", "C++", "Go"};
String[] copy = new String[original.length];
// 复制整个数组
System.arraycopy(original, 0, copy, 0, original.length);
// 复制部分数组（仅复制索引1-2的元素）
String[] partialCopy = new String[2];
System.arraycopy(original, 1, partialCopy, 0, 2);
// 验证
System.out.println("完整复制：" + Arrays.toString(copy)); // [Java, Python, C++, Go]
System.out.println("部分复制：" + Arrays.toString(partialCopy)); // [Python, C++]
}
}Arrays.copyOf
- Arrays.copyOf：复制指定长度（长度不足截断，过长补默认值）
数组类型[] 新数组 =Arrays.copyOf(原数组, 新数组长度);
- Arrays.copyOfRange：复制指定范围（从原数组起始索引到结束索引，不包含结束索引）
数组类型[] 新数组 =Arrays.copyOfRange(原数组, 起始索引, 结束索引);
import java.util.Arrays;
public class ArraysCopyOf {
public static void main(String[] args) {
int[] original = {10, 20, 30, 40, 50};
// 1. 复制整个数组（新数组长度=原数组）
int[] copy1 = Arrays.copyOf(original, original.length);
// 2. 复制并扩容（长度6，多余位置补0）
int[] copy2 = Arrays.copyOf(original, 6);
// 3. 复制指定范围（索引1到4，即元素20、30、40）
int[] copy3 = Arrays.copyOfRange(original, 1, 4);
System.out.println("完整复制：" + Arrays.toString(copy1)); // [10, 20, 30, 40, 50]
System.out.println("扩容复制：" + Arrays.toString(copy2)); // [10, 20, 30, 40, 50, 0]
System.out.println("范围复制：" + Arrays.toString(copy3)); // [20, 30, 40]
}
}Arrays 工具类
java.util.Arrays 类提供了很多操作数组的实用方法：
| 方法 | 作用 |
|---|---|
Arrays.toString(arr) |
把数组转成字符串，方便打印 |
Arrays.sort(arr) |
对数组排序 |
Arrays.binarySearch(arr, key) |
二分查找，返回索引，找不到返回负数 |
Arrays.copyOf(original, newLength) |
复制数组，改变长度 |
Arrays.fill(arr, val) |
把所有元素填充为指定值 |
Arrays.equals(arr1, arr2) |
比较两个数组内容是否相同 |
string.toCharArray() 将字符串转为数组
二维数组
从最高维开始，分别为每一维分配空间：
int[][] array = new int[3][];
array[0] = new int[2];
array[1] = new int[2];
array[2] = new int[3];
array[0][0] = 1;
array[1][1] = 3;
