SuifengFlying

公告

欢迎来到我的博客，这里记录生活与技术。

了解更多

2345 字

12 分钟

数组（Array）

2026-07-28

JavaSE

Java

/

JavaSE

/

数组

数组（Array）#

为什么要使用数组？

之前在使用变量时，要将一个数据存储到内存中；而我们要存储很多数据时，不能定义n多个变量，可以定义一个数组存储若干数据。
数组的定义

数组是用来存储一组相同数据类型的数据的数据结构。数据结构是计算机存储数据、组织数据的方式。数组存储的数据是具有结构型的，每个元素（存储的数据）都具有索引（相当于自然分配的编号），数组的优点是按索引查找数据效率高，缺点是插入数据效率低。
java中数组的特点

存储相同数据类型；数组的长度是不能改变的，我们在创建一个java数组时一定要明确长度。在使用java数组时，经常进行扩容的操作（新建新数组，将原数组的内容拷贝到新数组）

数组的定义和创建#

数组变量的定义

语法：

数据类型[] 标识符

或者：数据类型标识符 [] (不推荐)

数组类型是引用类型

1
 int[] arr ;
2
 double[] arr2;
3
 String[] arr3;

创建数组

1.静态初始化创建

1
//创建一个数组时，必须要明确2件事
2
        //长度：4  ，类型： int数组
3
        int[] arr = {2,5,7,8};

只能在数组变量声明时，用静态初始化创建方式

2.动态创建语法： new 数据类型[长度]

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

动态创建并初始化

语法： new 数据类型[]{值，值}

1
int[] arr = new int[]{2,3,4};

动态创建的数组，如果没有指定元素值，系统会自动分配默认值

byte\short\int\long动态创建的数组，默认元素值是0

float/double动态创建的数组，默认元素值是0.0

char动态创建的数组，默认元素值是\u0000 ,空字符

boolean动态创建的数组，默认元素值是false

String动态创建的数组，默认元素值是 null值

内存模型抽象#

先抽象两段代码： int i = 3 ; String str = “abc” ;

基本类型存储的数据是直接存储在变量空间中

引用类型的变量固定是8字节，存储的是地址

如果我的代码是 String str = null;

null是一个值，通常称为空值，实际的含义是这个引用类型的变量中没有存储任何的地址。因此null值只能赋给引用类型的变量

抽象代码： int[] arr = new int[3] ;

1767839596190
抽象代码： String[] strs = new String[3] ;

1767839848583
抽象代码： String[] strs = new String[]{“ab”,“cd”,“e”} ;

数组的应用#

数组的索引（index）#

数组的索引是从0开始的（第一个位置），一个数组的最大索引是其长度-1，如果我们使用索引超出了最大长度将会出现异常（错误）

数组[索引] 操作数组中的元素

1
int[] arr = {3,5,6,4,25,7,3,8,9};
2
//获取第一个3
3
int i = arr[0];
4
System.out.println(arr[0]);
5
arr[0] = 30;
6
//输出9
7
System.out.println(arr[8]);
8
//错误
9
System.out.println(arr[9]);

我们要记住这个数组索引越界异常的单词：

遍历所有元素#

1
 int[] arr = {3,5,6,4,25,7,3,8,9};
2
 //输出所有的元素
3
 for (int i = 0; i < arr.length; i++) {
4
    System.out.println(arr[i]);
5
 }

找到元素的最大、最小值、求和#

1
int[] arr = {3,5,6,4,25,7,3,8,9};
2
int max = arr[0];
3
int sum = 0;
4
for (int i = 0; i < arr.length; i++) {
5
    if(arr[i]>max){
6
        max = arr[i];
7
    }
8
    sum += arr[i];
9
}

数组元素的查找#

1
 Scanner scanner = new Scanner(System.in);
2
 int n = scanner.nextInt();
3
 int[] arr = {3,5,6,4,25,7,3,8,9};
4
 boolean flag = false;
5
 for (int i = 0; i < arr.length; i++) {
6
    if(arr[i]==n){
7
        flag = true;
8
        break;
9
    }
10
 }
11
 if(flag){
12
    System.out.println("有");
13
 }else{
14
    System.out.println("没有");
15
 }

数组的拷贝#

1
         int[] arr = {3,5,6,4,25,7,3,8,9};
2
        int[] arr2 = new int[arr.length];
3
        //反向拷贝
4
 /*        for (int i = 0; i < arr.length; i++) {
5
            arr2[i] = arr[arr.length-1-i];
6
        }*/
7
        //或者
8
        int index = 0;
9
        for (int i = arr.length-1; i >=0 ; i--) {
10
            arr2[index++] = arr[i];
11
        }
12
        for (int i = 0; i < arr2.length; i++) {
13
            System.out.println(arr2[i]);
14
        }

排序#

选择排序

1
int[] arr = {3,5,6,4,25,7,2,8,9,11};
2
        int temp = 0;
3
        for (int i = 0; i < arr.length - 1; i++) {
4
            for (int j = i+1; j < arr.length; j++) {
5
                if(arr[j]<arr[i]){
6
                    temp = arr[i];
7
                    arr[i] = arr[j];
8
                    arr[j] = temp;
9
                }
10
            }
11
        }
12
        for (int i = 0; i < arr.length; i++) {
13
            System.out.print(arr[i]+"\t");
14
        }

冒泡排序

1
int[] arr = {3,5,6,4,25,7,2,8,9,11};
2
int temp = 0;
3
for (int i = 0; i < arr.length - 1; i++) {
4
    for (int j = 0; j < arr.length - i - 1; j++) {
5
        if(arr[j]>arr[j+1]){
6
            temp = arr[j];
7
            arr[j] =  arr[j+1];
8
            arr[j+1] = temp;
9
        }
10
    }
11
}
12
for (int i = 0; i < arr.length; i++) {
13
    System.out.print(arr[i]+"\t");
14
}

随机功能#

Random类#

1
 Random random = new Random();
2
 //随机0~9的数字
3
 int i = random.nextInt(10);
4
 System.out.println(i);
5
 //随机5~10的数字
6
 i = random.nextInt(6)+5;
7
 //
8
 int[] arr = new int[]{1,2,3,4,5,6,7,8,9};
9
 int temp = 0;
10
 for (int j = 0; j < arr.length; j++) {
11
    int index = random.nextInt(arr.length);
12
    temp = arr[j];
13
    arr[j] = arr[index];
14
    arr[index] = temp;
15
 }
16
 for (int j = 0; j < arr.length; j++) {
17
    System.out.print(arr[j]+"\t");
18
 }

Math.random()#

随机0~1之间的小数，其中包含0，不包含1

1
 System.out.println(Math.random());
2
 //获得0~9之间的一个随机整数
3
 //Math.random()  : 0 -  0.9999999999999
4
 //Math.random()*10  :  0 - 9.999999999999999
5
 //强制转型int  0~9
6
 System.out.println((int)(Math.random()*10));
7
 //获得5~10整数
8
 System.out.println((int)(Math.random()*6)+5);
9
 //获得-5~5整数  0~10  -5

二维数组#

为什么要使用多维数组

要存储的数据可能是多个维度的，例如，线性数据（一维数组）、表格数据（二维）
什么是多维数组

二维数组：存储的元素都是一维数组

三维数组：存储的元素都是二维数组

二维数组的定义#

二维数组变量的定义

语法：

数据类型[][] 标识符;

或者

数据类型标识符[][]
二维数组的创建

1.静态初始化创建

1
//二维数组的长度是多少？  3
2
        int[][] arr = {{1,2,3},{4,5,6},{7,8}};

2.动态创建

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

上面的，创建了一个长度为3的二维数组，创建了一个数组

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

创建了一个长度为3的二维数组，二维数组中的每个一维数组的长度是2 ，创建了4个数组

1
int[][] arr1 = new int[3][2];
2
//等同于：
3
int[][] arr2 = new int[3][];
4
arr2[0] = new int[2];
5
arr2[1] = new int[2];
6
arr2[2] = new int[2];
7
//等同于 ：
8
for (int i = 0; i < arr2.length; i++) {
9
    arr2[i] = new int[2];
10
}

动态初始化创建

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

二维数组的应用#

遍历数组

需要二层循环：一层循环遍历出每个一维数组；二层循环遍历出每个一维数组中的元素

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

二维数组的查找

1
 int[][] arr = new int[][]{{1,2},{3,4,5}};
2
 int n = 4;
3
 boolean flag = false;
4
 a:for (int i = 0; i < arr.length; i++) {
5
    for (int j = 0; j < arr[i].length; j++) {
6
        if(n==arr[i][j]){
7
            flag = true;
8
            break a;
9
        }
10
    }
11
}
12
if(flag){
13
    System.out.println("有");
14
}else{
15
    System.out.println("没有");
16
}

二维数组的拷贝

1
int[][] arr = new int[][]{{1,2},{3,4,5}};
2
int[][] newArr = new  int[arr.length][];
3
for (int i = 0; i < arr.length; i++) {
4
    newArr[i] = new int[arr[i].length];
5
    for (int j = 0; j < arr[i].length; j++) {
6
        newArr[i][j] = arr[i][j];
7
    }
8
}

排序

1
int[][] arr = new int[][]{{4,2},{6,3,1}};
2
       //排序需求
3
       //需求1：一维数组内部排序
4
       //需求2 ： 整体排序 ： 创建一个一维数组，将二维数组中的数据拷贝到一维数组中
5
       //对一维数组排序，在复制回二维数组
6
       //需求一：
7
       /*for (int i = 0; i < arr.length; i++) {
8
           int temp = 0;
9
           for (int j = 0; j < arr[i].length - 1; j++) {
10
               for (int k = 0; k < arr[i].length - j - 1; k++) {
11
                   if(arr[i][k]>arr[i][k+1]){
12
                       temp = arr[i][k];
13
                       arr[i][k] = arr[i][k+1];
14
                       arr[i][k+1] = temp;
15
                   }
16
               }
17
           }
18
       }*/
19
       //需求二：
20
       //二维数组中的所有数据，复制到一维数组中
21
       //创建一维数组
22
       int length = 0;
23
       for (int i = 0; i < arr.length; i++) {
24
           length+=arr[i].length;
25
       }
26
       int[] arrOne = new int[length];
27
       //循环二维数组，所有数据复制到一维数组中
28
       int index = 0;
29
       for (int i = 0; i < arr.length; i++) {
30
    for (int j = 0; j < arr[i].length; j++) {
31
        arrOne[index++] = arr[i][j];
32
    }
33
}
34
//一维数组进行冒泡排序
35
int temp = 0;
36
for (int i = 0; i < arrOne.length - 1; i++) {
37
    for (int j = 0; j < arrOne.length - i - 1; j++) {
38
        if(arrOne[j]>arrOne[j+1]){
39
            temp = arrOne[j];
40
            arrOne[j] = arrOne[j+1];
41
            arrOne[j+1] =temp;
42
        }
43
    }
44
}
45
//一维数组的数据写回到二维数组
46
index = 0;
47
for (int i = 0; i < arr.length; i++) {
48
    for (int j = 0; j < arr[i].length; j++) {
49
        arr[i][j] = arrOne[index++];
50
    }
51
}
52
for (int i = 0; i < arr.length; i++) {
53
    for (int j = 0; j < arr[i].length; j++) {
54
        System.out.print(arr[i][j]+"\t");
55
    }
56
    System.out.println();
57
}

数组算法工具类 Arrays#

数组拷贝功能

Arrays.copyof(源数组，长度) ：返回一个拷贝后的新数组，需要源数组和拷贝的长度（新数组的长度）

1
 int[] arr = {4,3,2,6,7,9,1,10,11};
2
 int[] arr2 = Arrays.copyOf(arr,arr.length);
3
 for (int i = 0; i < arr2.length; i++) {
4
    System.out.print(arr2[i]+"\t");
5
 }

Arrays.copyOfRange(原数组，开始索引，结束索引) ，开始和结束索引是前闭后开

1
 int[] arr = {4,3,2,6,7,9,1,10,11};
2
 int[] arr2 = Arrays.copyOfRange(arr,0,5);
3
 for (int i = 0; i < arr2.length; i++) {
4
    System.out.print(arr2[i]+"\t");
5
 }

排序

1
 int[] arr = {4,3,2,6,7,9,1,10,11};
2
 Arrays.sort(arr);
3
 for (int i = 0; i < arr.length; i++) {
4
    System.out.print(arr[i]+"\t");
5
 }

查找：二分查找法：使用之前要保证数组是有序的，查找的结果才是正确的。二分查找的效率高于全文检索

1
int[] arr = {4,3,2,6,7,9,1,10,11};
2
Arrays.sort(arr);
3
if(Arrays.binarySearch(arr,8)>=0){
4
    System.out.println("有");
5
}else{
6
    System.out.println("没有");
7
}

数组拷贝的补充

需求：数组{1,2,3,4,5,6,7} 中2~~3索引的数据拷贝到一个新数组的4~~5位置 {0,0,0,0,3,4,0,0,0,0}

System.arraycopy(源数组，源数组开始位置，目标数组，目标数组开始位置，拷贝数据长度)

1
 int[] arr = {1,2,3,4,5,6,7};
2
 //int[] arr2 = Arrays.copyOf(arr,2);
3
 //arr2 = Arrays.copyOfRange(arr,2,4);
4
 //Java 中还有一个数组拷贝的方法  System.arraycopy()
5
 int[] arr2 = new int[10];
6
 System.arraycopy(arr,2,arr2,4,2);
7
 for (int i = 0; i < arr2.length; i++) {
8
    System.out.print(arr2[i]+"\t");
9
 }