数组学习知识点整理

xn_xy19

已于 2022-10-09 22:32:36 修改

阅读量384

点赞数

文章标签：学习数据结构算法

于 2022-10-09 22:31:03 首次发布

本文链接：https://blog.csdn.net/xn_xy19/article/details/127235139

版权

#博学谷IT技术支持#

1. 一维数组

1.1 定义格式

格式1：数据类型[] 变量名;
范例： int[] arr;
定义了一个int类型的数组，数组名是arr
格式2：数据类型变量名[];
范例： int arr[];
定义了一个int类型的变量，变量名是arr数组

推荐使用格式1。

1.2 静态初始化

格式：数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,…};
范例：int[] arr = new int[]{1,2,3};

简化格式：数据类型[] 变量名 = {数据1,数据2,数据3,…};
范例：int[] arr = {1,2,3};

1.2.1 遍历

/*
    遍历
 */
public class ArrayTest01 {
    public static void main(String[] args) {
        //定义数组并初始化
        int[] arr = {77, 88, 99, 66, 55, 44};
        
        //遍历
        for (int i=0; i<arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.2.2 获取最大值

/*
    获取最大值
 */
public class ArrayTest02 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};

        //定义变量max存储最大值，取第一个数据为变量的初始值
        int max = arr[0];

        //与数组中剩余数据逐个比对，每次比对将最大值保存到变量max中
        for (int i=1; i<arr.length; i++) {
            if(arr[i] > max) {
                max = arr[i];
            }
        }

        //循环结束后输出变量max的值
        System.out.println("max:" + max);
    }
}

1.2.3 数组元素打乱

import java.util.Random;

/*
    元素打乱
 */
public class ArrayTest03 {
    public static void main(String[] args) {
        //定义数组
        int[] arr = {12, 45, 98, 73, 60};

        //获取随机数
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) {
            int index = r.nextInt(arr.length);

            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }

        //遍历数组
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

1.3 动态初始化

格式：数据类型[] 变量名 = new 数据类型[数组长度];
范例：int[] arr = new int[3];

1.3.1 键盘录入数组元素

import java.util.Scanner;

/*
    需求：定义一个可以存储5个元素的int数组，数据来自于键盘录入，最后遍历数组，把元素输出在控制台
 */
public class ArrayTest {
    public static void main(String[] args) {
        //定义一个数组，并进行动态初始化
        int[] arr = new int[5];

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in);


        for (int i = 0; i < arr.length; i++) {
            System.out.println("请输入第" + (i + 1) + "个元素：");
            arr[i] = sc.nextInt();
        }

        printArray(arr);

    }

    public static void printArray(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i==arr.length-1) {
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i] + ", ");
            }
        }
        System.out.println("]");
    }

}

2.二维数组

2.1 定义格式

格式1：数据类型[] [] 变量名;
范例：int[] [] arr;
格式2：数据类型变量名[] []；
范例：int arr[] [];
格式3：数据类型[] 变量名[]；
范例： int[] arr[];

推荐使用格式一

2.2 静态初始化

格式：数据类型[] [] 变量名 = new 数据类型[] []{{元素…},{元素…},{元素…},…};
范例：int[] [] arr = new int[] []{{1,2,3},{4,5,6},{7,8,9}};

解读：

定义了一个二维数组
二维数组中有三个元素(一维数组)
每一个一维数组有三个元素(int类型数据)
注意：一维数组中元素的个位可以是不同的
比如： int[] [] arr = new int[] []{{1,2,3},{4,5},{6,7,8,9}};

同样，针对静态初始化，二维数组也给出了简化格式：

简化格式：数据类型变量名 = {{元素…},{元素…},{元素…},…};
范例：int[] [] arr = {{1,2,3},{4,5,6},{7,8,9}};

2.2.1 遍历

/*
    需求：已知一个二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}}; 请把元素在控制台输出
 */
public class ArrayTest01 {
    public static void main(String[] args) {
        //定义二维数组，并进行静态初始化
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        //遍历
        for (int i = 0; i < arr.length; i++) {
            //arr[i]
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j]+" ");
            }
        //打印
            System.out.println();
        }
    }
}

2.2.2 二位数组元素打乱

import java.util.Random;

/*
    需求：已知二维数组 arr = {{1,2,3},{4,5,6},{7,8,9}};用程序实现把数组中的元素打乱,并在控制台输出打乱后的数组元素
 */
public class ArrayTest02 {
    public static void main(String[] args) {
        //定义二维数组，并进行静态初始化
        int[][] arr = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

        //创建随机数对象
        Random r = new Random();

        //遍历二维数组，进行元素打乱
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                //arr[i][j]
                int x = r.nextInt(arr.length);
                int y = r.nextInt(arr[x].length);

                //元素交换
                int temp = arr[i][j];
                arr[i][j] = arr[x][y];
                arr[x][y] = temp;
            }
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}