Ming-Log's Blog

记录生活中的点点滴滴

0%

Java(3)数组

发表于 更新于 分类于
本文字数： 5.6k 阅读时长 ≈ 5 分钟

JAVA数组

数组：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组的特点：

  1. 数组是一种引用数据类型

  2. 数组当中的多个数据，类型必须统一

  3. 数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值。

两种常见的初始化方式：

  1. 动态初始化（指定长度）

  2. 静态初始化（指定内容）

动态初始化

动态初始化数组的格式：

1
数据类型[] 数组名称 = new 数据类型[数组长度]

解析含义：

  • 左侧数据类型：也就是数组当中保存的数据，全都是统一的数据类型
  • 左侧的中括号：代表我是一个数组
  • 左侧数组名称：给数组取一个名字
  • 右侧的new：代表创建数组的动作
  • 右侧数据类型：必须和左边的数据类型保持一致
  • 右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class demo01 {
    public static void main(String[] args) {
        // =================动态初始化====================
        // 创建一个数组，里面可以存放300个int数据
        // 格式：数据类型[] 数组名称 = new 数据类型[数组长度];
        int[] array1 = new int[300];

        // 创建一个数组，能存放10个double类型的数据
        double[] double1 = new double[10];

        // 创建一个数组，能存放5个字符串
        String[] string1 = new String[5];
    }
}

静态初始化

1
格式：数据类型[] 数组名称 = new 数据类型[] {元素1, 元素2, 元素3, ...};

注意事项：虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

1
2
3
4
5
6
7
8
9
10
11
12
13
public class demo01 {
    public static void main(String[] args) {
// =================静态初始化======================
        // 创建一个int数组，具体为: 5, 15, 25
        int[] array2 = new int[]{5, 15, 25};
        // 创建一个String数组，具体为: "Hello", "World", "Java"
        String[] string2 = new String[]{"Hello", "world", "Java"};

        // 使用静态初始化数组时，格式还可以省略一下。
        // 数据类型[] 数组名称 = {元素1, 元素2, 元素3, ...}
        int[] array3 = {5, 15, 20};
    }
}

注意事项

  1. 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。

  2. 静态初始化标准格式可以拆分成为两个步骤。

    1
    2
    int[] array;
    array = new int[]{5, 15, 20};

  3. 动态初始化也可以拆分为两个步骤。

    1
    2
    int[] array;
    array = new int[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
package com.tipdm.demo1;

/**
 * 使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。
 * 规则如下：
 * 如果是整数类型，那么默认为0；
 * 如果是浮点类型，那么默认为0.0；
 * 如果是字符类型，那么默认为‘\u0000’；
 * 如果是布尔类型，那么默认为false；
 * 如果是引用类型，那么默认为null。
 *
 * 注意事项：
 * 静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成了大括号当中的具体数值。
 */
public class demo03 {
    public static void main(String[] args) {
        // 动态初始化一个数组
        int[] array = new int[3];
        System.out.println(array);  // 内存地址值

        System.out.println(array[0]);  // 0
        System.out.println(array[1]);  // 0
        System.out.println(array[2]);  // 0
        System.out.println("===============");

        // 修改数据
        // 将数据123赋值给array当中的1号元素
        array[1] = 123;
        System.out.println(array[0]);  // 0
        System.out.println(array[1]);  // 123
        System.out.println(array[2]);  // 0
    }
}
1
2
3
4
5
6
7
8
9
10
[I@1b6d3586
0
0
0
===============
0
123
0

进程已结束,退出代码0

Java的内存划分

Java的内存需要划分为5个部分。

栈（Stack）

  • 存放的都是方法中的局部变量。方法的运行一定要在栈当中。

局部变量：方法的参数，或者是方法{}内部的变量。

作用域：一旦超出作用域，立刻从栈内存当中消失。

堆（Heap）

  • 凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据，都有默认值。规则：

  • 如果是整数类型，那么默认为0；
  • 如果是浮点类型，那么默认为0.0；
  • 如果是字符类型，那么默认为‘\u0000’；
  • 如果是布尔类型，那么默认为false；
  • 如果是引用类型，那么默认为null。

方法区（Method Area）

  • 存储.class相关信息，包含方法的信息。

本地方法栈（Native Method Stack）

  • 与操作系统相关

寄存器(pc Register)

  • 与CPU相关

数组在内存中工作原理

单个数组

image-20211207104307875

多个数组（不产生交叉）

image-20211207105816183

多个数组（产生交叉）

image-20211207105845505

案例练习

计算数组中的最大值和最小值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.tipdm.demo1;

/**
 * 计算数组中的最大值和最小值
 */

public class demo11 {
    public static void main(String[] args) {
        int[] array = {15, 20, 35, 45, 55, 11, 31, 88, 1000, 31, 0, -55};
        int max = array[0];
        int min = array[0];
        for (int i = 1; i < array.length; i++) {
            if (max < array[i]){
                max = array[i];
            }
            if (min > array[i]){
                min = array[i];
            }
        }
        System.out.println("Max:" + max);
        System.out.println("Min:" + min);
    }
}

1
2
3
4
Max:1000
Min:-55

进程已结束,退出代码0

数组元素的反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package com.tipdm.demo1;

/**
 * 数组元素的反转：
 * 本来的样子{1, 2, 3, 5, 6}
 * 输出的结果{6, 5, 3, 2, 1}
 *
 * 数组的元素反转，其实就是对称位置的元素交换
 */
public class demo12 {
    public static void main(String[] args) {
        int[] array = {15, 20, 3, 2, 5, -1, 0};

        for(int min = 0, max = array.length - 1; min <= max; min++, max--){
            int temp = array[min];
            array[min] = array[max];
            array[max] = temp;
        }

        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}
1
2
3
4
5
6
7
8
9
0
-1
5
2
3
20
15

进程已结束,退出代码0

数组作为参数传入方法

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
54
55
56
57
58
59
60
61
62
63
64
65
package com.tipdm.demo1;

public class demo13 {
    public static void main(String[] args) {
        int [] array = {10, 20, 30, 40, 50};
        String[] array1 = {"Hello", "World"};
        printArray(array);
        printArray(array1);
    }

    public static void printArray(int[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(String[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(short[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(byte[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(long[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(char[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(float[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(double[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }

    public static void printArray(boolean[] array){
        for (int i = 0; i < array.length; i++) {
            System.out.println(array[i]);
        }
    }
}

1
2
3
4
5
6
7
8
9
10
20
30
40
50
Hello
World

进程已结束,退出代码0

数组作为方法返回值返回

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
package com.tipdm.demo1;

/**
 * 数组作为返回值
 * 一个方法可以有0，1，多个参数；但是只能有0/1个返回值，不能有多个返回值。
 *
 * 案例计算一个int数组的均值和总和。
 */
public class demo14 {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int[] result = cal(array);
        for (int i = 0; i < result.length; i++) {
            System.out.println(result[i]);
        }
    }

    public static int[] cal(int[] x){
        int sum = 0;
        for (int i = 0; i < x.length; i++) {
            sum += x[i];
        }
        int avg = (int) sum/x.length;
        int[] res = {sum, avg};
        return res;
    }
}
1
2
3
4
45
5

进程已结束,退出代码0
-------------本文结束感谢您的阅读-------------