首页 > 代码库 > Java基础——数组

Java基础——数组

2024-08-24 06:58:40   219人阅读

1 一维数组

1.1 数组概念

数组：同一种数据类型的集合，数组就是一个容器，可以自动给数组从0开始编号，可以存储多个相同类型数据的容器，方便管理多个数据，数组中的数据会自动编号，编号从0开始。

注意：

声明一个变量就是在内存空间划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间。

所有数组的元素必须是相同的类型。

数组可以存储基本数据类型，也可以存储引用数据类型。

数组的长度是固定的。

1.2 数组定义和初始化

1.2.1数组的定义 

定义：int[] arr ;   int  arr[];（不常用）

1.2.2 数组的初始化

为数组元素分配内存空间，并为每个数组元素赋初始值。

静态初始化

当明确数组中的元素时，程序员指定每个元素的初始值，系统决定数组长度。

元素类型[] 数组名 = new 元素类型[]{元素，元素，……};

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

动态初始化

当不明确数组中的元素时，程序员只指定数组长度，系统分配初始值。

元素类型[] 数组名 = new 元素类型[元素个数或数组长度];

      int[]  a     = new int[4];

注意：

数组元素下标从0开始，比如：int[] a = {1,2};  ages[0] = 1; ages[1]=2;

数组的属性，length 数组中元素的个数，即数组的长度  a.length = 2;

数组元素最大下标值 = 数组长度 – 1。

不能同时使用静态和动态初始化，即不能既指定数组长度，又指定其元素初始值。

访问数组时要注意角标越界异常或空指针异常。

1.3 内存问题

栈内存：用于存储局部变量，即在函数中定义的变量，当数据使用完，所占空间会自动释放。

堆内存：存储的是数组和对象，通过new建立的实例都存放在堆内存中。当没有引用指向数据时，数组或对象就会变成垃圾，在随后一个不确定的时间被垃圾回收机制释放掉。

以 int[] a = new int[4]为例，说明数组在内存中的初始化过程：

首先在栈内存中出现一个数组引用a，系统在堆内存中开辟空间，为数组分配内存地址，在堆内存中建立数组对象，进行默认初始化或显示初始化。最后将内存地址赋给栈内存中的a变量。

注意：赋给a的不是数组本身，而是数组在内存中的地址。

1.4数组常见操作

1.4.1 数组遍历

1
2
for(int i=0;i<arr.length;i++)
    System.out.println(arr[i]);

1.4.2 获得最值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public static void main(String[] args)
{
    int[] arr = {3,2,1,4,5,6};
    int x = getMax(arr);
    int y = getMin(arr);
    System.out.println(x);
    System.out.println(y);
}
// 获取最大值
public static int getMax(int[] arr)
{
    int max = arr[0];
    //i从1开始，因为第一个数不用跟自己比
    for(int x=1; x<arr.length; x++)
    {
        if(arr[x]>max)
            max = arr[x];
    }
    return max;
}
// 获取最小值
public static int getMin(int[] arr)
{
    int min = arr[0];
    //i从1开始，因为第一个数不用跟自己比
    for(int i=1; i<arr.length; i++)
    {
        if(arr[i]<min)
            min = arr[i];
    }
    return min;
}

1.4.3 排序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 选择排序
 
int[] arr = {16,35,24,13,2,21};
 
for (int x = 0;x < arr.length - 1;x++){
 
    for (int y = x + 1;y < arr.length;y++){
 
        if (arr[x] > arr[y]){
 
            int temp = arr[x];
 
            arr[x] = arr[y];
 
            arr[y] = temp;
 
        }
 
    }
 
}
 
// 冒泡排序
 
int[] arr = {16,35,24,13,2,21};
 
for (int x = 0;x < arr.length - 1; x++)
 
{
 
    //-1防止角标越界
 
    //-x为了提高效率
 
    for (int y = 0;y < arr.length - 1 - x;y++)
 
    {
 
        if (arr[y] > arr[y+1])
 
        {
 
            int temp = arr[y];
 
            arr[y] = arr[y+1];
 
            arr[y+1] = temp;
 
        }
 
    }
 
}

1.4.4 查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 普通查找（无序数组）
int[] arr = {13,42,12,34,5,26};
public static int getIndex(int[] arr,int key)
{
    for (int x = 0;x < arr.length;x++){
        if (key == arr[x]){
            return x;
        }
    }
    return -1;
}
// 二分查找（有序数组）
public static int getIndex(int[] arr,int key) {
    int min = 0;
    int max = arr.length-1;
    int mid = (min + max)/2;
    while (key != arr[mid]){
        if (key > arr[mid]){
            min = mid + 1;
        }else if (key < arr[mid]){
            max = mid - 1;
        }
        if (min > max){
            return -1;
        }
        mid = (min + max)/2;
    }
    return mid;
}

1.4.5 数组反转

1
2
3
4
5
6
7
8
9
10
11
public static void revArray(int[] arr)
{
    int start = 0;
    int end = arr.length-1;
    for (int start=0,end = arr.length-1;start<end ;start++, end--)
    {
        int temp = arr[start];
        arr[start] = arr[end];
        arr[end] = temp;
    }
}

1.4.6 打印数组

1
2
3
4
5
6
7
8
9
10
11
public static String arrPrint(int[] arr) {
    String str = "[";
    for (int x = 0; x < arr.length; x++){
        if (x != arr.length - 1) {
            str = str + arr[x] + ", ";//[6, 5,
        }else {
            str = str + arr[x] +"]";
        }
    }
    return str ;
}

2 二维数组

2.1 二维数组定义和初始化

定义二维数组：数组中的数组 int[][] arr; char[][] ch;

初始化二维数组：

格式1：int[][] arr = new int[3][2];

定义了名称为arr的二维数组，arr中有3个一维数组，每一个一维数组中有2个元素，一维数组的名称分别为arr[0], arr[1], arr[2]。

arr[1]:二维数组中的第二个一维数组名

arr[1][1]:二维数组中的第二个数组的第二个元素

给第一个一维数组0脚标位赋值为1写法是：arr[0][0] = 1;

格式2：int[][] arr = new int[3][];

定义了名称为arr的二维数组，二维数组中有3个一维数组，每个一维数组都是默认初始化值null。

可以对这个三个一维数组分别进行初始化

arr[0] = new int[3];  arr[1] = new int[5];  arr[2] = new int[7];

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};

定义了名称为arr的二维数组，二维数组有3个一维数组。第一个一维数组有3个元素，第二个一维数组有2个元素，第三个一维数组有4个元素。

2.2 常见二维数组的操作

(1)二维数组的遍历

1
2
3
4
5
6
7
8
9
int[][] arr2 = new int[2][3];
public static void printArray2(int[][] arr2){
    for(int i=0; i<arr2.length; i++){
        for(int j=0; j<arr2[i].length; j++){
            System.out.print(arr2[i][j]+" ");
        }
        System.out.println();
    }
}

(2)二维数组的应用(求和)

1
2
3
4
5
6
7
8
9
public static void printArray2(int[][] arr2){
    int sum = 0;
    for(int i=0; i<arr2.length; i++){
        for(int j=0; j<arr2[i].length; j++){
            sum = sum + arr[i][j];
        }
        System.out.println("sum =" + sum);
    }
}



来自为知笔记(Wiz)


Java基础——数组


联系
我们