[JavaSE] 第三章 数组

3.1 数组

3.1.1 数组的概述

  • 数组（Array）：是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理

  • 常见概念

    • 数组名
    • 下标/索引/角标
    • 元素
    • 数组的长度（元素的个数）

  • 特点

    • 数组是有序排列的
    • 数组属于引用数据类型的变量。数组的元素既可以是基本数据类型，也可以是引用数据类型
    • 创建数据对象会在内存中开辟一整块连续的空间
    • 数组的长度一旦确定，就不能修改

  • 数组元素的默认初始化值

    • 数组元素是整型：0
    • 数组元素是浮点型：0.0
    • 数组元素是 char 型：0 或 '\u0000'，而非 '0'
    • 数组元素是 boolean 型：false
    • 数组元素是引用数据类型：null

3.1.2 一维数组的使用

  • 声明

    int[] ids; //声明
//1.1 静态初始化：数组的初始化和数组元素的赋值操作同时进行
ids = new int[]{100, 101, 102};
//2.2 动态初始化：数组的初始化和数组元素的赋值操作分开进行
String[] names = new String[5];

  • 调用

    //2.如何调用数组的指定位置的元素：通过索引的方式调用
//数组的索引从 0 开始，到数组的 长度-1 结束
names[0] = "李四1";
names[1] = "李四2";
names[2] = "李四3";
names[3] = "李四4";
names[4] = "李四5";

  • 遍历

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

3.1.3 多维数组的使用

对于二维数组的理解，我们可以看成是一维数组 array1 又作为另一个一维数组 array2 的元素而存在，实际上从数组底层的运行机制来看，其实没有多维数组

  • 声明

    //动态初始化
//方式一：
//外层元素的初始化值为：地址值
//内层元素的初始化值为：与数组初始化情况相同
int[][] arr = new int[3][2];
System.out.println(arr[0]);//[I@4554617c
System.out.println(arr[0][0]);//0
System.out.println(arr);//[[I@74a14482

//方式二：
//外层元素的初始化值为：null
//内层元素的初始化值为：不能调用，否则报错
int[][] arr2 = new int[3][];


//静态初始化
int[][] arr3 = new int[][]{{1,2,3},{4,3,2},{2,1}}

//特殊写法：
int[] x, y[];//x是一维数组，y是二维数组

  • 调用数组的指定位置的元素

    System.out.println(arr3[0][2]);//3

  • 遍历二维数组

    for (int[] ints : arr3) {
    for (int anInt : ints) {
    	System.out.println(anInt);
    }
}

3.1.4 数组中常见算法

  • 杨辉三角

    package com.ws.exer;
/*
使用二维数组打印一个10行杨辉三角。
【提示】
1．第一行有 1个元素，第 n 行有 n 个元素
2．每一行的第一个元素和最后一个元素都是 1
3．从第三行开始,对于非第一个元素和最后一个元素的元素。即:
yanghui[i][j] = yanghui[i-1][j-1] + xanghui[i-1][j];

 */
public class YangHuiTest {
    public static void main(String[] args) {
        //1.声明并初始化二维数组
        int[][] yangHui = new int[10][];

        //2.给数组的元素赋值
        for (int i = 0; i < yangHui.length; i++) {
            yangHui[i] = new int[i+1];//给每列赋值为 0

            //2.1 给首末元素赋值
            yangHui[i][0] = 1;//每行第一个元素值为 1
            yangHui[i][i] = 1;//每行最后一个元素值为 1

            //2.2 给每行的非首末元素赋值
            for (int j = 1; j < yangHui[i].length -1; j++) {
                yangHui[i][j] = yangHui[i-1][j-1] + yangHui[i-1][j];
            }
        }

        //3.遍历二维数组
        for (int i = 0; i < yangHui.length; i++) {
            for (int j = 0; j < yangHui[i].length; j++) {
                System.out.print(yangHui[i][j] + "\t");
            }
            System.out.println();
        }
    }
}

  • 数组的复制、反转、查找（线性查找、二分法查找）

    package com.ws.exer;

import java.util.Arrays;

/*
算法的考查:数组的复制、反转、查找(线性查找、二分法查找)

 */
public class ArrayExercise6 {
    public static void main(String[] args) {

        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};

        //数组的复制
        String[] arr1 = new String[arr.length];
        for (int i = 0; i < arr1.length; i++) {
            arr1[i] = arr[i];
        }
        System.out.println(Arrays.toString(arr));
        System.out.println(Arrays.toString(arr1));


        //数组的反转 [JJ, DD, MM, BB, GG, AA]
        //方法一
        for (int i = 0; i < arr1.length / 2; i++) {
            String temp = arr1[i];
            arr1[i] = arr1[arr1.length - i - 1];
            arr1[arr1.length - i - 1] = temp;
        }
        System.out.println(Arrays.toString(arr1));

        //方法二
        for (int i = 0, j = arr1.length - 1; i < j; i++, j--) {
            String emp = arr1[i];
            arr1[i] = arr1[j];
            arr1[j] = emp;
        }
        System.out.println(Arrays.toString(arr1));


        //查找（或搜索）
        //线性查找
        boolean isFlag = true;
        String dest = "CC";
        for (int i = 0; i  < arr.length; i++) {
            if (arr[i].equals(dest)) {
                System.out.println("找到了相同的值，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("没找到");
        }

        //二分法查找：比较快
        //前提：索要查找的数组必须有序
        int[] arr2 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int dest1 = -34;
        int head = 0; //初始的首索引
        int end = arr2.length - 1; //初始的末索引 9
        boolean isFlag2 = true;
        int i = 0;//查询次数
        while (head <= end) {
            i++;
            int middle = (head + end) / 2;
            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag2 = false;
                break;
            } else if (arr2[middle] > dest1) {//查找到的值大于要查找的
                end = middle - 1; //往前找
            } else {
                head = middle + 1; //往后找
            }

        }
        System.out.println("查找了：" + i);
        if (isFlag2) {
            System.out.println("没有找到该元素");
        }
    }
}

  • 排序算法（冒泡排序）

    package com.ws.exer;

import java.util.Arrays;

/*
数组的冒泡排序的实现
 */
public class BubbleSortTest {
    public static void main(String[] args) {
        int[] arr = new int[]{1, 3, 7, 2, 7, 8, 9, -23, 34, 68, 12, 2, 3, 7};

        //冒泡排序（两两对比，比出最大的那个元素，然后把最大的元素放到最后，再进行第二轮比较，第二轮比较比第一轮比较少比一次）
        for (int i = 0; i < arr.length - 1; i++) {//比几轮

            for (int j = 0; j < arr.length - 1 - i; j++) {//第j个和每一个去比

                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        /*
        int i = 0; i < 13;
            int j = 0; j < 14 - 1 - 0; arr[0] > arr[1]
            j++; j =2 < 14 - 1; arr[1] > arr[2]
            j++; j = 3 < 14 - 1; arr[2] > [3]; temp = arr[2]=7; arr[2] = arr[3]=2; arr[3] = 7;
         */

        System.out.println(Arrays.toString(arr));
    }
}

3.1.5 Arrays 工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

import java.util.Arrays;

/*
java.util.Arrays：操作数组的工具类
 */
public class ArraysTest {
    public static void main(String[] args) {
        //1.boolean equals(int[] a,int[] b)：判断两个数组是否相等。
        int[] arr1 = new int[]{1, 2, 3, 4};
        int[] arr2 = new int[]{1, 3, 2, 4};
        boolean ifEquals = Arrays.equals(arr1, arr2);
        System.out.println(ifEquals);

        //2.String toString(int[] a)：输出数组信息
        System.out.println(Arrays.toString(arr1));

        //3.void fill(int[ ] a, int val)：将指定值填充到数组之中
        Arrays.fill(arr1, 10);
        System.out.println(Arrays.toString(arr1));

        //4.void sort(int[] a)：对数组进行排序
        Arrays.sort(arr2);
        System.out.println(Arrays.toString(arr2));

        //5.int binarySearch(int[] a ,int key)
        int[] arr3 = new int[]{-98,-34,2,34,54,66,79,105,210,333};
        int index = Arrays.binarySearch(arr3, 34);
        if (index > 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }

    }
}

3.1.6 数组常见异常

  • NullPointerException：空指针异常（没有引用地址值）

  • ArrayIndexOutOfBoundsException：数组的索引越界异常

posted @   Aunean  阅读(43)  评论(0)  编辑  收藏  举报
编辑推荐：
· SQL Server 2025 AI相关能力初探
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决：字节Trae VS Cursor，谁才是开发者新宠？
· 展开说说关于C#中ORM框架的用法！
点击右上角即可分享
微信分享提示