Java数组

最新推荐文章于 2025-05-20 18:44:14 发布
最新推荐文章于 2025-05-20 18:44:14 发布
阅读量1k 收藏 19
点赞数 27
文章标签： python 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Gao_xu_sheng/article/details/135993683
版权

1. 概述

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

  • 常见概念:数组名,下标(或索引),元素,数组的长度

  • 特点：

    • 数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。

    • 创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址。

    • 数组的长度一旦确定，就不能修改。

    • 我们可以直接通过下标(或索引)的方式调用指定位置的元素，速度很快。

    • 数组的分类:

      • 按照维度:一维数组、二维数组、三维数组、...

      • 按照元素的数据类型分:基本数据类型元素的数组、引用数据类型元素的数组(即对象数组)

  • 语法结构：

  • 元素的数据类型[] 数组名称 = new 元素的数据类型[数组容器的大小];
// 1.1 静态初始化:数组的初始化和数组元素的赋值操作同时进行
   int[] arr1 = new int[]{1, 2, 3, 4, 5};
// 1.2动态初始化:数组的初始化和数组元素的赋值操作分开进行
   double[] arr2 = new double[5];

  • 语法解释：

    • 元素：数组中的数据、数组中的变量

    • 元素的数据类型：数组中的数据的数据类型

    • []：表示是一个一维数组

    • 数组名称：数组本身也是一个变量，用于存储数组的地址的变量

    • =：赋值符号，将数组的地址，赋值给数组的名称

    • new：用于在堆内存中开辟空间

    • 元素的数据类型：和前面的元素的数据类型保持一致

    • 数组容器的大小：可以存储数据的个数

  • 打印数组的结果：[D@5cad8086

    • [：表示这是一个一维数组

    • D：表示数组中存储的是 double 类型的数据

    • @：普通的分隔符，没有具体的含义

    • 5cad8086：数组有一个内存地址

2. 数组的初始化

  • 为数组分配空间，并且赋值。

  • 分类：

    • 静态初始化：在程序书写的时候，就知道了数组中的元素是什么值

    • 动态初始化：程序运行过程中，才能知道究竟给元素赋什么值

2.1 静态初始化

  • 语法结构：

  • 元素的数据类型[] 数组名称 = new 元素的数据类型[] {元素值的罗列};

或
  
元素的数据类型[] 数组名称 = {元素值的罗列};

    语法示例：

  • double[] douArr = new double[] {9.9d,8.7,7,0};

或

double[] douArr = {9.9d,8.7,7,0};

  • 注意事项：

    • 在第二个方括号中，不要写数组元素的个数。

    • 元素值的罗列，元素和元素之间，使用逗号分隔,写了几个元素,就分配多大空间。

    • 罗列出来的元素值，数据类型必须和声明的数组元素的数据类型一致。

    • 数组名称的声明，数组名称的赋值，不能分成两行写。

2.2 动态初始化

  • 语法结构：

  • 元素的数据类型[] 数组名称 = new 元素的数据类型[数组元素的个数];

    语法示例：

  • // 声明一个数组并初始化为3个长度
double[] douArr = new double[3];

// 给元素赋值，方式：数组名称[元素的索引] = 元素值;
douArr[0] = 3.5;
douArr[1] = 4d;
douArr[2] = 7;

  • 元素索引：下角标；从0开始，数组长度 -1结束。

  • 注意事项：

    • 所有的元素，都需要逐个赋值。

    • 如果数组中的元素，没有赋值，元素也有一个默认的初始化值，为各数据类型的默认值。

    •  *    > 数组元素是整型：0
 * 		> 数组元素是浮点型：0.0
 * 		> 数组元素是char型：'\u0000'，而非""
 * 		> 数组元素是boolean型：false
 * 		> 数组元素是引用数据类型：null
        int[] arr = new int[4];
        System.out.println(arr[0]);
        boolean[] arr1 = new boolean[5];
        System.out.println(arr1[0]);
				String[] arr2 = new String[5];
        System.out.println(arr2[0]);

      错误写法:

    • int[] arr1 = new int[];
		int[5] arr2 = new int[5];
		int[] arr3 = new int[3]{1,2,3};

3. 数组的内存理解

  • JVM 是执行 Java 的容器，空间很大，按照不同的功能、不同的特点划分了三个区域：堆内存(heap)、栈内存(stack)、方法区(method)。

  • 堆内存【常用】：用于存储数组、对象等数据量较大的数据。一般都是引用数据类型。

  • 栈内存【常用】：用于执行方法，每个方法单独的分配一段空间，称为栈帧，把给方法分配内存空间，形象的称为“进栈”。特点：先进后出。

  • 方法区【常用】：用于存储类的字节码对象，存储常量、存储静态变量。

image-20230131224010010

演示下静态初始化数组的存放方式
 int[] arr = new int[]{1, 2, 3};

分析下方代码的运行结果：

public static void main(String[] args) {
     
        String[] arr1 = new String[4];
        arr1[1] = "刘德华";
        arr1[2] = "张学友";
        arr1 = new String[3];
        System.out.println(arr1[1]);
    }

image-20230131224744598

4. 数组异常

4.1 数组下角标越界异常

  • 异常代码：

  • public static void main(String[] args) {
    int[] intArr = new int[2];
    System.out.println(intArr[2]);
}

    异常显示：

  • Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 2

    异常原因：访问了数组中不存在的索引，超过元素索引范围，都会出现异常情况

4.2 空指针异常

  • 异常代码：

  • public static void main(String[] args) {
    int[] intArr = {3, 5, 9};
    intArr = null;
    System.out.println(intArr[0]);
}

    异常显示：

  • Exception in thread "main" java.lang.NullPointerException

  • 异常原因：当引用不再指向任何的堆内存中的数据时，仍然要通过这个引用访问堆内存中的数据，只能抛出异常。

  • 避免方式：

  • public static void main(String[] args) {
    int[] intArr = {3, 5, 9};
    intArr = null;
    if (intArr != null) {
        System.out.println(intArr[0]);
    }
}

5. 数组的操作

5.1 数组赋值

  • 语法结构：

  • 数组名称[元素的索引] = 元素值;

    语法示例：

  • double[] douArr = {3.5d, 4};
douArr[0] = 7;

5.2 数组遍历

  • 遍历：每个元素都要访问一遍。

  • 方式：循环数组的索引，通过索引访问数组的值。

  • public static void main(String[] args) {
    double[] douArr = {3.5d, 4, 7, 4.6f};
    for (int i = 0; i < douArr.length; i++) {
        System.out.println(douArr[i]);
    }
}

    增强for循环：

  • public static void main(String[] args) {
    double[] douArr = {3.5d, 4, 7, 4.6f};
    for (double dob : douArr) {
        System.out.println(dob);
    }
}

6. 二维数组

6.1 概述

[[],[],[]]

  • 二维数组：数组的嵌套，数组里的每一个元素都是一个数组。

  • 对于二维数组的理解，我们可以看成是一维数组 array1又作为另一个一维数组array2的元素而存在。

  • 语法结构：

  • 元素的数据类型[][] 数组名称 = new 元素的数据类型[外层数组容器的大小][每个外层数组内包含的数组容器大小];

  • 语法示例：

  • int[][] arr = new int[3][2];

    示例解释：

  • 定义了名称为arr的二维数组

  • 二维数组中有3个一维数组

  • 每一个一维数组中有2个元素

  • 一维数组的名称分别为arr[0], arr[1], arr[2]

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

  • public static void main(String[] args) {
        int[][] arr = new int[3][2];
        System.out.println(arr[0][1]);
        arr[0][1] = 78;
        System.out.println(arr[0][1]);
    }

    语法变型：

  • 变型1：

    • 语法示例

    • int[][] arr = new int[3][];

      分析下方代码：

    • public static void main(String[] args) {
        int[][] arr = new int[3][];
        System.out.println(arr[0]);
        arr[0] = new int[1];
        arr[1] = new int[2];
        arr[2] = new int[3];
        System.out.println(arr[0][0]);
   //   int[][]arr = new int[][3]; //非法
    }

    • 示例解释：

      • 二维数组中有3个一维数组。

    • 每个一维数组都是默认初始化值null (区别于实例1)

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

      • arr[0] = new int[1]; arr[1] = new int[2]; arr[2] = new int[3];

    • 变型2：

      • 语法示例：(静态初始化)

      • int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

        示例解释：

      • 定义一个名称为arr的二维数组，二维数组中有三个一维数组

      • 每一个一维数组中具体元素也都已初始化

      • 第一个一维数组 arr[0] = {3,8,2};

      • 第二个一维数组 arr[1] = {2,7};

      • 第三个一维数组 arr[2] = {9,0,1,6};

      • 第三个一维数组的长度表示方式:arr[2].length;

      •  public static void main(String[] args) {
        int[][] arr = new int[][]{{3, 8, 2}, {2, 7}, {9, 0, 1, 6}};
        System.out.println(arr[0]);
        System.out.println(arr[2].length);
    }

6.2 二维数组遍历

数组算法扩展：数组查找

  • 方式：嵌套循环，先循环外层数组，再循环每个外层数组内的一维数组。

  • 示例：

  • public static void main(String[] args) {
    // 声明一个int类型的二维数组,并赋值
    int[][] arr = {{2, 4}, {3, 6, 4}, {0, 2, 4, 10}};
    // 先循环外层的数组,变量i为数组的下角标
    for (int i = 0; i < arr.length; i++) {
        // 变量ins为外层数组的值,其本身就是一个int类型的一维数组
        int[] ins = arr[i];
        // 循环外层数组内的一维数组,变量j为一维数组的小角标
        for (int j = 0; j < ins.length; j++) {
            // 变量in为外层数组内遍历的一维数组内的值
            int in = ins[j];
            // 打印该值,但不换行
            System.out.print(in + "\t");
        }
        // 每循环一个外层数组后,进行换行的操作
        System.out.println();
    }
}

    7. 冒泡排序

  • 方式：循环遍历数组，临近的两个元素比较大小；升序（将较小的元素放置在左侧）；降序（将较大的元素放置在右侧）。

  • 升序代码示例：

  • public static void main(String[] args) {
    // 初始化一个数据顺序不规则的数组
    int[] ins = {10, 1, 37, 25, 8, 5, 46, 93, 2};
    // 依次循环数组元素,循环多少轮
    for (int i = 0; i < ins.length - 1; i++) {
        // 循环需要比较的数据,每轮比较的次数
        for (int j = 0; j < ins.length - 1 - i; j++) {
            // 交换数据
            if (ins[j] > ins[j + 1]) {
                int temp = ins[j];
                ins[j] = ins[j + 1];
                ins[j + 1] = temp;
            }
        }
    }
    for (int in : ins) {
      	System.out.println(in);
    }
}

    降序代码示例：

  • public static void main(String[] args) {
    // 初始化一个数据顺序不规则的数组
    int[] ins = {10, 1, 37, 25, 8, 5, 46, 93, 2};
    // 依次循环数组元素,循环多少轮
    for (int i = 0; i < ins.length; i++) {
        // 循环需要比较的数据,每轮比较的次数
        for (int j = 0; j < ins.length - 1 - i; j++) {
            // 交换数据
            if (ins[j] < ins[j + 1]) {
                int temp = ins[j];
                ins[j] = ins[j + 1];
                ins[j + 1] = temp;
            }
        }
    }
    for (int in : ins) {
      	System.out.println(in);
    }
}

    总结：

  • N个元素需要排序N-1轮

  • 第i轮需要比较N-i次

  • N个元素排序，需要比较(n-1)/2次

  • 效率不高，实现最简单

1.线性查找
public class ArrayDemo {
    public static void main(String[] args) {
        String[] arr = new String[]{"JJ", "DD", "MM", "BB", "GG", "AA"};
        String dest = "BB";
        dest = "CC";
        boolean isFlag = true;
        for (int i = 0; i < arr.length; i++) {
            if (dest.equals(arr[i])) {
                System.out.println("找到了指定的元素，位置为：" + i);
                isFlag = false;
                break;
            }
        }
        if (isFlag) {
            System.out.println("很遗憾，没有找到的啦！");
        }
    }
}
2.二分查找
public class ArrayDemo {
    public static void main(String[] args) {
        int[] arr2 = new int[]{-98, -34, 2, 34, 54, 66, 79, 105, 210, 333};
        int dest1 = -34;
        dest1 = 79;
        int head = 0;//初始的首索引
        int end = arr2.length - 1;//初始的末索引
        boolean isFlag1 = true;
        while (head <= end) {
            int middle = (head + end) / 2;
            if (dest1 == arr2[middle]) {
                System.out.println("找到了指定的元素，位置为：" + middle);
                isFlag1 = false;
                break;
            } else if (arr2[middle] > dest1) {
                end = middle - 1;
            } else {//arr2[middle] < dest1
                head = middle + 1;
            }
        }
        if (isFlag1) {
            System.out.println("很遗憾，没有找到的啦！");
        }
    }
}

8. Arrays类

  • Arrays工具类：针对数组进行操作的工具类，比如说排序和查找。

  • 包名：java.util.Arrays;

  • // 方法参数提示 cmd + p
import java.util.Arrays;

public class Algorithm {
    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 isEquals = Arrays.equals(arr1, arr2);
        System.out.println(isEquals);

        //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, 210);
        if (index >= 0) {
            System.out.println(index);
        } else {
            System.out.println("未找到");
        }

        //6. copyof 复制数组
        int[] arr4 = {1, 2, 3, 4, 5};
        arr4 = Arrays.copyOf(arr4, 6);
        for (int i : arr4) {
            System.out.println(i);
        }

    }
}

    9.Math.random()

  • Math.random()是令系统随机选取大于等于 0.0 且小于 1.0 的伪随机double值

  • 使用方法

  • //产生一个[0，1)之间的随机数。
Math.random();
 
//返回指定范围的随机数(m-n之间)的公式:
Math.random()*(n-m)+m；
或者
Math.random()*(n+1-m)+m
// 随机生成a~z之间的字符
(char)('a'+Math.random()*('z'-'a'+1));

  • Random类生成随机数

  • 除了Math类的Random()方法可以获取随机数之外，还可以Java.util.Random类，可以通过实例化一个Random对象创建一个随机数生成器。

  • 语法

  • Random ran=new Random();

  • Random类的实例对象以这种形式实例化对象时，Java编译器以系统当前时间作为随机数生成器的种子，因为每时每刻的时间都不可能相同，所以产生的随机数也不同。如果运行速度太快，也会产生两次运行结果相同的随机数。

  • 可以在实例化Random类对象时，自定义随机数生成器的种子。

  • Random ran=new Random(seedValue); 
Random类中还提供各种类型随机数的方法：
nextInt()：返回一个随机整数(int)
nextInt(int n)：返回大于等于0、小于n的随机整数(int)
nextLong()：返回一个随机长整型值(long)
nextBoolean()：返回一个随机布尔型值(boolean)
nextFloat()：返回一个随机浮点型值(float)
nextDouble()：返回一个随机双精度型值(double)

Java--数组
@南初的博客
02-16 2725
需要统计某公司50个员工的工资情况，例如计算平均工资、找到最高工资等。用之前知识，首先需要声明50个变量来分别记录每位员工的工资，这样会很麻烦。因此我们可以将所有的数据全部存储到一个容器中统一管理，并使用容器进行计算。水杯（装水等液体），衣柜（装衣服等物品），集装箱（装货物等）。将多个数据存储到一起，每个数据称为该容器的元素。因为第一个元素距离数组首地址间隔0个单元格。Java 语言里提供了支持多维数组的语法。如果说可以把一维数组当成几何中的线性图形，那么二维数组就相当于是一个表格。
JAVA如何存储二维数组
weixin_43328382的博客
11-16 3164
JAVA如何存储二维数组直接存储二维数组的缺点稀疏数组介绍稀疏数组的应用场景将稀疏数组转回原二维数组代码实现 直接存储二维数组的缺点 如果在二维数组中只使用了几个元素，就直接存储在内存中，这样会造成空间浪费。 由于直接使用二维数组会造成空间浪费，所以就引出了一个新的数组：稀疏数组。 稀疏数组介绍 稀疏数组的处理方法： 1）记录原二维数组的行数和列数，有多少个不同的值 2）把每个不同的值在原二维数组中的下标记录 3）稀疏数组的第一行的数据一定是原二维数组的行数和列数，和非0数字的个数 4）从第二行开始记录每个
二维数组行数列数的java代码表示
qq_37293024的博客
11-20 755
二维数组行数列数的java代码表示 给定一个二维数组int[] [] matrix,他的行数和列数分别是matrix.length和matrix[0].length
Java 中使用数组存储和操作数据
小易
09-25 1683
如果需要动态调整数组大小，需要重新创建一个新数组，并将原数组的元素拷贝到新数组中，这样会造成一定的时间和空间开销。需要注意的是，数组的性能通常比较高，因为数组中的元素在内存中是连续存储的，可以利用CPU的缓存机制提高访问速度。其中，array 表示数组的名称，index 表示元素的下标，value 表示要存储的值。其中，array 表示数组的名称，index 表示元素的下标，value 表示要访问的值。需要注意的是，数组的下标从 0 开始，因此数组的最后一个元素的下标为 length-1。
Java基础（5）-二维数组
zyljjf的博客
09-28 408
二维数组 示例： int[] a = {1,2,3,4,5,20}; int[] b = {6,7,8,9,10}; int[] c = {11,12,13,14,15,16,17,18}; //二维数组 int[][] array = {a,b,c}; //遍历array for(int
Java 数组
chen2745213271的博客
04-28 3111
今天介绍一下Java中的数组，数组在所有的编程语言中，基本是重要的数据结构之一。在Java中的数组是用来存放一组固定相同大小的数据。 1.数组的存储方式 基本数据类型：在存放基本数据类型时，数据本身是直接存放在数组中 引用数据类型：在存放引用数据类型时，存放数据的内存地址在数组中 原因是在上面说了数组存放的是一组固定相同大小的数据，而引用数据类型的长度不一，所以存放的内存地址，而数组本身也是一组引用类型 2.数组的声明 声明数组时可以声明多种数据类型，但是声明后该数组存放的数据类型只能存放声明的
java 数组 切片
qq_43615820的博客
01-20 1283
【代码】java 数组 切片。
Java数组练习题(带答案).doc
03-15
Java数组是Java编程语言中的基本数据结构之一，用于存储固定数量的同类型元素。了解和熟练掌握数组的使用是学习Java的重要环节。本篇练习题涵盖了数组的基本概念、操作和异常处理，下面是针对题目中涉及知识点的详细...
java数组
04-20
Java数组是程序设计中不可或缺的基础概念，它是一种数据结构，允许我们存储同类型的多个元素。在Java中，数组是对象，具有固定的大小，一旦创建，其长度就不能改变。本篇文章将深入探讨Java数组的各个方面，包括创建...
Java数组与内存控制
09-20
### Java数组与内存控制 #### 一、Java数组在内存分配方面的知识 ##### 1.1 数组初始化 - **声明数组的时候如何分配内存：** - 在Java中，数组的声明并不直接分配内存，而仅仅是创建了一个数组引用变量。例如： ...
Java 数组基础 详解 详细介绍了Java数组的创建、声明方式、使用、循环遍历等相关内容
03-15
关于Java数组基础知识的相关内容，详细介绍了Java数组相关知识，如创建数组的方式，使用数组的方法，循环遍历数组的内容等等 关于Java数组基础知识的相关内容，详细介绍了Java数组相关知识，如创建数组的方式，...
java数组结构图
11-15
对数组的总结和分析，通过这个结构记住它，在开发的过程中使用
如何利用 Python 获取京东商品 SKU 信息接口详细说明
J15779585792的博客
05-17 1388
通过上述步骤和代码示例，你可以轻松地使用 Python 调用京东商品 SKU 信息接口，获取商品的详细信息。希望这个指南对你有所帮助！如果你对电商数据开发有更多兴趣，可以尝试探索更复杂的功能，如多线程爬取、数据可视化等。如遇任何疑问或有进一步的需求，请随时与我私信或者评论联系。
进阶知识：无参的函数装饰器之深入理解@wraps()
最新发布
Tom的专栏
05-20 836
@wraps(func)是functools模块中的装饰器工具，主要用于保留被装饰函数的元信息，如函数名称（__name__）和文档字符串（__doc__）。通过使用@wraps(func)，装饰器返回的新函数会继承原函数的属性，保持代码的透明性。对比不使用@wraps的情况，后者会导致函数元信息丢失，调试和文档生成时难以追踪原始函数。@wraps(func)在框架开发、单元测试、API文档生成和调试定位等场景中尤为重要，建议始终使用以确保装饰器的透明性和文档一致性。
《Python星球日记》 第95天：分布式训练与推理
Code_流苏：在代码中寻诗意，在实践中觅真知
05-19 1218
《Python星球日记》 第95天：分布式训练与推理，今天，我们将探索分布式训练与推理技术，这是解决大规模AI模型训练和部署挑战的关键方法
【python】返回所有匹配项的第一个元素、第二个元素。。。
突围
05-19 516
【python】返回所有匹配项的第一个元素、第二个元素。。
weibo_comment_pc_tool | 我于2025.5月用python开发的评论采集软件，根据帖子链接爬取评论的界面工具
python布道者0516的博客
05-18 1277
开始采集前，先把自己的cookie值填入cookie.txt文件。pc端cookie获取说明：然后把复制的cookie值填写到当前文件夹的cookie.txt文件中。软件首发众公号”老男孩的平凡之路“，欢迎技术交流、深度探讨！
04 接口自动化-框架封装思想建立之httprunner框架（上）
iOS_HC的博客
05-20 850
1.httprunner是一个面向http协议的通用测试框架，目前最新的版本3.X。以前比较流行的2.X的版本。2.它的思想是只需要维护yaml/json/py文件就可以实现接口自动化测试，性能测试，线上监控，持续集成。3.架构图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Gao_xu_sheng

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值