数组

小白学安全 2025-03-03 22:47 阅读37分钟

概述

数组可以存放多个同一类型的数据，数组也属于数据类型，为引用类型。

数组 ------> 一组数据

使用方式

动态初始化1

数组的定义：数据类型数组名[] = new 数据类型[大小]

例如：int a[] = new int[5] -- 数组名为a，数据类型为整型，存放5个整型数据

数组的引用（使用/访问/获取数组元素）：数组名[下标/索引/index]

/**
 * 循环输入五科成绩，将数据保存到数组中，并进行输出
 */
import java.util.Scanner;
public class Array01{
    public static void main(String[] args){
        // 定义数组
        double subject[] = new double[5];
        // 输入
        Scanner myScanner = new Scanner(System.in);
        // subject.length 数组的长度
        for(int i = 0;i < subject.length;i++){
            System.out.print("请输入学科成绩：");
            subject[i] = myScanner.nextDouble();
        }

        // 输出，遍历数组
        System.out.println("===存放的值===");
        for(int i = 0;i < subject.length;i++){
            System.out.println("值为" + subject[i]);
        }
    }
}

动态初始化2

数组的定义：先声明数组，再创建数组

声明数组：数据类型数组名[ ] 或者数据类型[] 数组名

创建数组：数组名 = new 数据类型[大小]

例如：int a[]；a = new int[10];

/**
 * 循环输入五科成绩，将数据保存到数组中，并进行输出
 */
import java.util.Scanner;
public class Array02{
    public static void main(String[] args){
        double subject[];  // 申明数组
        subject = new double[5];  //创建数组，分配内存空间

        // 循环输入
        Scanner myScanner = new Scanner(System.in);
        for(int i = 0; i < subject.length; i++){
            System.out.print("请输入学科成绩：");
            subject[i] = myScanner.nextDouble();
        }

        // 输出，遍历数组
        System.out.println("===存储的数据值===");
        for(int i = 0;i < subject.length;i++){
            System.out.println("存储值为：" + subject[i]);
        }

    } 
}

静态初始化

初始化数组的定义：数据类型数组名[] = {元素值,元素值,......}

例如：int a[] = {1,2,3,4,5,6,7,8,9}; //知道元素的个数与具体值

/**
 * 存储五个值，以此进行输出
 */
public class Array03{
    public static void main(String[] args){
        int num[] ={1,2,3,4,5};
        for(int i = 0;i < num.length;i++){
            System.out.println(num[i]);
        } 
    }
}

数组使用注意事项

数组由多个相同类型数据的组合，实现对这类数据的统一管理；
数组中的元素可以是任何数据类型，包括基本类型和引用类型，但不能混用；
数组创建后，如果没有赋值，则有默认值：
使用数组步骤：1声明数组并开辟空间，2给数组各元素赋值，3使用数组；
数组的下标是从0开始的；
数组的下标必须在指定范围内使用，否则报：下标使用越界，例如：int arr[] = new int[4] //下标的范围是0-4；
数组属于引用类型，数组中的数据是对象；

数组赋值机制

基本数据类型赋值，值为具体的数据，不会互相影响，赋值方式为拷贝（拷贝的是具体的值）

数组在默认情况下是引用传递，赋值方式地址（拷贝的是数据地址）

public class ArrayAssign01{
    public static void main(String[] args){
        // 数组在默认情况下是引用传递，赋的值是地址，赋值的方式为引用赋值
        // arr2的变化会影响arr1
        int arr1[] = {1,2,3};
        int arr2[] = arr1;
        System.out.println("===arr1的元素===");
        for(int i = 0; i < arr1.length;i++){
            System.out.println(arr1[i]);
        }
        // arr2赋值
        arr2[0] = 100;
        System.out.println("===arr1的元素===");
        for(int i = 0; i < arr1.length;i++){
            System.out.println(arr1[i]);
        }
    }
}

值拷贝与地址传递的区别

数组拷贝

编写代码实现数组的拷贝（内容复制）

将int[] arr1 = {10,20,30};拷贝到arr2数组中，要求数据空间是独立的。

public class ArrayCopy01{
    public static void main(String[] args){
        int[] arr1 = {10,20,30};
        // 开辟一个新的数据空间
        int arr2[] = new int[arr1.length];
        // 将arr1中的元素拷贝到arr2对应的位置
        for(int i = 0; i < arr1.length; i++){
            arr2[i] = arr1[i];
        }

        // 打印arr2中的元素
        for(int i = 0; i < arr2.length; i++){
            System.out.println(arr2[i]);
        }
    }
}

数组反转

将数组中的元素进行反转

arr{11,22,33,44,55,66}

public class ArrayReversal{
    public static void main(String[] args){
        int[] arr = {11,22,33,44,55,66};
        int[] arr1 = new int[arr.length];
        for(int i = 0; i < arr.length; i++){
            int j = arr.length - i - 1;
            arr1[i] = arr[j];
        }
        for(int i = 0; i < arr1.length; i++){
            System.out.println(arr1[i]);
        }
    }
}

数组扩容

实现动态的给数组添加元素效果，实现对数组扩容

要求：

原始数组使用静态分配int[] arr = {1,2,3}
增加的元素，直接放在数组的最后arr = {1，2，3，4}
用户可以自己决定是否继续添加元素

代码

/**
 * 思路分析
 *     1.定义初始数组
 *     2.定义一个新的数组，新数组长度比旧数组大一（length + 1）
 *     3.遍历旧数组，将元素拷贝到新数组
 *     4.将新元素赋值给新元素的最后一个元素（length - 1）
 *     5.将旧数组指定新数组的地址  arr = arrNew
 */
import java.util.Scanner;
public class ArrayAdd01{
    public static void main(String[] args){
        // 原始数组
        int[] arr = {1,2,3};
        while(true){
            int[] arrNew = new int[arr.length + 1];
            for(int i = 0;i < arr.length;i++){
                arrNew[i] = arr[i];
            }

            Scanner myScanner = new Scanner(System.in);
            System.out.print("请输入需要添加的元素：");

            int addNum = myScanner.nextInt();
            arrNew[arrNew.length - 1] = addNum;
            // 指定新数组地址
            arr = arrNew;
            System.out.print("当前数组元素：");
            for(int i = 0;i < arr.length;i++){
                System.out.print(arr[i] + " ");
            }
            System.out.println("");
            System.out.print("是否继续添加元素(y/n)：");
            char input = myScanner.next().charAt(0);
            if(input == 'n'){
                break;
            }        
        }
        System.out.println("已退出添加");
    }
}

数组排序

概述

排序即是将多个数据，按指定的顺序进行排列的过程。

内部排序

指将需要处理的所有数据都加载到内部存储器中进行排序（包括交换式排序法、选择式排序法、插入式排序法）。

外部排序

指数据量过大，无法全部加载到内存中，需要借助外部存储器进行排序（包括合并排序法和直接合并排序法）。

冒泡排序法 - Bubble Sorting

基本思想：通过对待排序序列从后向前（从下标较大的元素开始），以此比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

示例：五个无序的值：24、69、80、57、13，使用冒泡排序法将其排成一个从小到大的有序数列。

思路：

代码：

public class BubbleSort{
    public static void main(String[] args){
        int[] arr = {24,69,80,57,13};
        int temp = 0; // 辅助交换参数

        for(int i = 0; i < arr.length - 1;i++){
            for(int j = 0; j < arr.length - 1 - i;j++){
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            System.out.print("第" + (i + 1) + "次排序：");
            for(int j = 0;j < arr.length;j++){
                System.out.print(arr[j] + "\t");
            }
            System.out.println();
        }
    } 
}

运行截图：

二维数组

使用方式1 动态初始化

语法：类型[][] [][] 数组名=new 类型[][]

例如：int a[][] = new int[2][3]

public class TwoDimensionalArray01{
    public static void main(String[] args){
        int[][] arr = new int[2][3];
        arr[1][1] = 5;
        // 遍历数组
        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();
        }
    }
}

内存变化

使用方式2：动态初始化

先声明：类型数组名[][]，例如：int arr[][]

再定义[开辟新的空间]：数组名 = new 类型[大小][大小]，例如：arr = new int[3][5]

public class TwoDimensionalArray01{
    public static void main(String[] args){
        // 先声明，再定义
        int arr[][];
        arr = new int[3][4];
        arr[2][2] = 6;
        // 遍历数组
        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();
        }
    }
}

使用方式3：动态初始化-列数不确定

代码部分

public class TwoDimensionalArray02{
    public static void main(String[] args){
        /*
            1
            2 2
            3 3 3
        */
        int[][] arr = new int[3][];
        for(int i = 0; i < arr.length;i++){
            // 为每个一维数组赋值
            arr[i] = new int[i+1];
            for(int j = 0; j < arr[i].length;j++){
                // 赋值
                arr[i][j] = i + 1;
            }
        }

        // 遍历输出
        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();
        }
    }
}

使用方式4：静态初始化

语法：类型数组名[][] = {{值1,值2,值3,...},{值1,值2,值3,...}}

例如：int[][] arr = {{1,2,3},{4,5,6},{7,8,9}}

代码部分

public class TwoDimensionalArray03{
    public static void main(String[] args){
        int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};
        int sum = 0;
        // 遍历数组
        System.out.println("数组列表为：");
        for(int i = 0;i < arr.length;i++){
            for(int j = 0;j < arr[i].length;j++){
                System.out.print(arr[i][j] + "   ");
                sum += arr[i][j];
            }
            System.out.println();
        }
        System.out.println("二位数组总和为：" + sum);
    }
}

注意事项

一维数组的声明方式：int x[] 或者 int[] x；
二维数组的声明方式：int[][] y 或者int y[][] 或者 int[] y[]；
二维数组实际上是由多个一维数组组成，它的各个维数组的长度可以相同，也可以不相同；

杨辉三角

    使用二维数组打印一个10行的杨辉三角
        1 
        1 1
        1 2 1
        1 3 3 1
        1 4 6 4 1
        1 5 10 10 5 1
        ......

代码

public class YangHui{
    public static void main(String[] args){
        int[][] arr = new int[10][];
        for(int i = 0;i < arr.length;i++){
            arr[i] = new int[i + 1];
            for(int j = 0; j < arr[i].length;j++){
                if(j == 0 || j == arr[i].length - 1){
                    arr[i][j] = 1;
                }
                else{
                    arr[i][j] = arr[i - 1][j] + arr[i - 1][j - 1];
                }
                System.out.print(arr[i][j] + "  ");
            }
            System.out.println();
        }
    }
}

数组

概述

使用方式

数组赋值机制

数组拷贝

数组反转

数组扩容

数组排序

二维数组

评论

目录

下一篇

目录

登录

数组

概述

使用方式

数组赋值机制

数组拷贝

数组反转

数组扩容

数组排序

二维数组

评论

目录

下一篇

目录