Java Array数组

最新推荐文章于 2025-10-25 06:15:37 发布
原创 最新推荐文章于 2025-10-25 06:15:37 发布 · 1.1k 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

Java 是世界上最流行的编程语言之一，是任何 Web 和应用开发专业人士工具箱中的重要组成部分。

Java 有许多组件和概念需要理解，本文将重点讨论 Java 中的数组。

数组是 Java 编程中一个简单但至关重要的概念。

无论你是经验丰富的程序员还是初学者，在 Java 编程的各个方面都不可避免地会使用到数组。

什么是 Java 数组？

数组是一种数据结构，用于存储同质元素。这意味着数组中的所有元素都是同一数据类型。例如：
在这里插入图片描述

int[] numbers = {40, 55, 23, 87, 21, 11, 94};

这是一个包含七个元素的数组。所有元素都是整数，因此是同质的。数组下方的绿色框称为索引，索引总是从零开始，到 n-1 结束。在这个例子中，有七个元素，所以索引是从零到六。数组有三个主要特征：

  1. 动态分配：数组的内存是动态创建的，这减少了代码所需的存储空间。
  2. 单一名称存储元素：所有元素都存储在一个名称下。这个名称在使用数组时始终使用。
  3. 连续位置存储：数组中的元素存储在相邻的位置，这使得用户可以轻松找到元素的位置。

Java 数组的优点

  • 随机访问：借助索引，可以随机访问任何元素。
  • 管理大数据集：易于存储和操作大型数据集。

Java 数组的缺点

  • 固定大小：一旦声明，数组的大小不能增加或减少。
  • 同质数据：Java 数组只能存储同一类型的原始数据。

定义和声明 Java 数组

定义数组

数组的定义语法如下：

type varName[];

其中 type 可以是 int、String、double、long 等，varName 是数组的变量名。

声明数组

声明数组有两种方式：

  1. 声明并初始化：

    int[] arr = {1, 2, 3, 4, 5};

  2. 先声明后初始化：

    int[] arr;
arr = new int[5];
arr[0] = 1;
arr[1] = 2;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;

访问数组元素

使用 for 循环打印数组元素：

public class Main {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3, 4, 5};
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

输出：

1
2
3
4
5

Java 数组类型

在 Java 中，数组是一种基本的数据结构，用于存储相同类型的元素集合。根据维度的不同，Java 数组可以分为以下几种类型：

1. 一维数组

一维数组是最简单的数组类型，也称为线性数组。它将元素存储在一列中，每个元素都有一个唯一的索引，索引从 0 开始。

定义和声明
int[] numbers; // 声明一个整数数组
numbers = new int[5]; // 分配内存，数组大小为 5
初始化
int[] numbers = {1, 2, 3, 4, 5}; // 声明并初始化
访问元素
int firstElement = numbers[0]; // 访问第一个元素
int lastElement = numbers[numbers.length - 1]; // 访问最后一个元素
示例代码
public class OneDimensionalArrayExample {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4, 5};
        for (int i = 0; i < numbers.length; i++) {
            System.out.println(numbers[i]);
        }
    }
}

输出：

1
2
3
4
5
2. 二维数组

二维数组是包含多个一维数组的数组，通常用于表示表格数据。每个元素都有两个索引，分别表示行和列。

定义和声明
int[][] matrix; // 声明一个二维整数数组
matrix = new int[3][3]; // 分配内存，3 行 3 列
初始化
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};
访问元素
int firstElement = matrix[0][0]; // 访问第一行第一列的元素
int lastElement = matrix[2][2]; // 访问最后一行最后一列的元素
示例代码
public class TwoDimensionalArrayExample {
    public static void main(String[] args) {
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[i].length; j++) {
                System.out.print(matrix[i][j] + " ");
            }
            System.out.println();
        }
    }
}

输出：

1 2 3 
4 5 6 
7 8 9
3. 多维数组

多维数组是包含多个二维数组的数组，可以扩展到任意维度。常见的多维数组有三维数组，用于表示立方体数据。

定义和声明
int[][][] cube; // 声明一个三维整数数组
cube = new int[2][3][4]; // 分配内存，2 层 3 行 4 列
初始化
int[][][] cube = {
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    },
    {
        {13, 14, 15, 16},
        {17, 18, 19, 20},
        {21, 22, 23, 24}
    }
};
访问元素
int firstElement = cube[0][0][0]; // 访问第一层第一行第一列的元素
int lastElement = cube[1][2][3]; // 访问第二层第三行第四列的元素
示例代码
public class MultiDimensionalArrayExample {
    public static void main(String[] args) {
        int[][][] cube = {
            {
                {1, 2, 3, 4},
                {5, 6, 7, 8},
                {9, 10, 11, 12}
            },
            {
                {13, 14, 15, 16},
                {17, 18, 19, 20},
                {21, 22, 23, 24}
            }
        };
        for (int i = 0; i < cube.length; i++) {
            for (int j = 0; j < cube[i].length; j++) {
                for (int k = 0; k < cube[i][j].length; k++) {
                    System.out.print(cube[i][j][k] + " ");
                }
                System.out.println();
            }
            System.out.println();
        }
    }
}

输出：

1 2 3 4 
5 6 7 8 
9 10 11 12 

13 14 15 16 
17 18 19 20 
21 22 23 24

总结

  • 一维数组：最简单的数组类型，元素存储在一列中。
  • 二维数组：包含多个一维数组，用于表示表格数据。
  • 多维数组：包含多个二维数组，可以扩展到任意维度，用于表示复杂的数据结构。

通过理解这些不同类型的数组，你可以更灵活地在 Java 中管理和操作数据。希望这些示例代码能帮助你更好地掌握 Java 数组的使用。

数组操作示例

1. 数组求和

public class SumArray {
    public static void main(String[] args) {
        int[] myArray = {1, 2, 3, 4, 5};
        int sum = 0;
        for (int i = 0; i < myArray.length; i++) {
            sum += myArray[i];
        }
        System.out.println("Sum: " + sum);
    }
}

输出：

Sum: 15

2. 数组乘积

public class MultiplyArray {
    public static void main(String[] args) {
        int[] myArray = {1, 2, 3, 4, 5};
        int product = 1;
        for (int i = 0; i < myArray.length; i++) {
            product *= myArray[i];
        }
        System.out.println("Product: " + product);
    }
}

输出：

Product: 120

3. 数组复制

import java.util.Arrays;

public class CopyArray {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = Arrays.copyOf(a, a.length);
        System.out.println(Arrays.toString(b));
    }
}

输出：

[1, 2, 3, 4, 5]

4. 数组克隆

public class CloneArray {
    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = a.clone();
        System.out.println(Arrays.toString(b));
    }
}

输出：

[1, 2, 3, 4, 5]

5. 二分查找

二分查找算法用于在数组中查找元素。数组必须按升序排列。算法将数组分成两半，比较目标值和中间值。如果目标值小于中间值，则在较低的一半中继续查找；否则，在较高的一半中继续查找。

import java.util.Scanner;

public class BinarySearch {
    public static int binarySearch(int[] arr, int key) {
        int low = 0;
        int high = arr.length - 1;
        while (low <= high) {
            int mid = (low + high) / 2;
            if (arr[mid] == key) {
                return mid;
            } else if (arr[mid] < key) {
                low = mid + 1;
            } else {
                high = mid - 1;
            }
        }
        return -1;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("Enter the number of elements: ");
        int n = scanner.nextInt();
        int[] arr = new int[n];
        System.out.println("Enter " + n + " elements in ascending order:");
        for (int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }
        System.out.print("Enter the element to search: ");
        int key = scanner.nextInt();
        int result = binarySearch(arr, key);
        if (result == -1) {
            System.out.println("Element not found.");
        } else {
            System.out.println("Element found at index: " + result);
        }
    }
}

输出示例：

Enter the number of elements: 7
Enter 7 elements in ascending order:
1 3 5 7 9 11 13
Enter the element to search: 11
Element found at index: 5

总结

1. 基本概念
  • 数组定义：数组是一种基本的数据结构，用于存储相同类型的元素集合。数组中的元素是同质的，即所有元素都是同一数据类型。
  • 索引：数组的索引从 0 开始，到 n-1 结束，其中 n 是数组的长度。
  • 不可变性：数组的大小在创建时确定，之后不能改变。但是，数组中的元素值可以改变。
2. 数组的特点
  • 动态分配：数组的内存是在运行时动态分配的。
  • 单一名称存储元素：所有元素都存储在一个名称下，通过索引访问。
  • 连续位置存储：数组中的元素存储在连续的内存位置，这使得访问元素非常高效。
3. 数组的类型
  • 一维数组：最简单的数组类型，元素存储在一列中。
  • 二维数组：包含多个一维数组，通常用于表示表格数据。
  • 多维数组：包含多个二维数组，可以扩展到任意维度，用于表示复杂的数据结构。
4. 数组操作

  • 求和：

    int sum = 0;
for (int i = 0; i < numbers.length; i++) {
    sum += numbers[i];
}
System.out.println("Sum: " + sum);

  • 乘积：

    int product = 1;
for (int i = 0; i < numbers.length; i++) {
    product *= numbers[i];
}
System.out.println("Product: " + product);

  • 复制数组：

    int[] b = Arrays.copyOf(numbers, numbers.length);
System.out.println(Arrays.toString(b));

  • 克隆数组：

    int[] b = numbers.clone();
System.out.println(Arrays.toString(b));

  • 二分查找：

5. 优点和缺点

  • 优点：

    • 随机访问：通过索引可以快速访问任何元素。
    • 高效管理数据：适合存储和管理大量同类型数据。

  • 缺点：

    • 固定大小：一旦声明，数组的大小不能改变。
    • 同质数据：只能存储同一类型的元素。

通过本文，你应该对 Java 数组有了全面的理解，包括如何声明、初始化、访问和修改数组元素，以及如何遍历和操作数组。数组是 Java 编程中非常基础且重要的概念，掌握好数组的使用对于编写高效的 Java 程序至关重要。希望这些内容能帮助你在实际开发中更好地利用 Java 数组。

Java Array数组 遍历 四种方式（包含 Lambda 表达式遍历）
litlit023的专栏
09-22 982
转载地址：https://www.cnblogs.com/miracle-luna/p/10995469.html
java实现数组逆置 (附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-15 439
java实现数组逆置 (附完整源码)
Java 数组
热门推荐
Naion的博客
03-22 2万+
本文章介绍了Java中数组的一些概念和一些方法的使用。
Java Array 数组
m0_72168501的博客
05-08 580
java 数组
Java基础：数组（Array）
最新发布
lzq617789的博客
10-25 861
关键点说明基础但高效数组是 Java 最底层的容器，性能最优固定长度无法动态扩容，需提前规划大小工具类强大Arrays提供排序、查找、复制等实用方法与集合互补数组适合底层/性能场景，集合适合业务逻辑🔍 技术之路没有捷径，但每一次阅读、思考和实践，都在悄悄拉近你与目标的距离。💬 欢迎在评论区留下你的想法、疑问或建议，我会一一回复，我们一起交流、共同成长 🌿🔔 关注我，不错过下一篇干货！我们下期再见！✨。
Java基础语法（四）| 数组
很开心你能来~
03-27 1241
java基础语法|数组
学习java Day10
Angeefly的博客
07-05 237
①数组 定义 数组是相同类型数据的集合。 数组描述相同类型的若干个数据，按一定的先后次序排列组合而成。 每个数据称作一个数组元素，每个数据元素可以通过一个下标来访问。 声明 首先必须声明数组变量，才能在程序中使用数组。 声明数组变量语法如下： dataType[] arrayRefVar; //首选方法 或 dataType arrayRefVar[]; //效果相同，但不是首选方法 Java语言使用new操作符来创建数组，语法如下： dataType[] arrayRefVar
java 数组
Claroja
03-14 2213
定义数组 float[] arr = new float[10]; // arr可以装10个float数据 int[] arr2 = new int[8]; // arr2可以装8个int数据 String[] arr3 = new String[7]; //arr3 可以装7个String数据 添加数据 arr[0] = 1.8; arr2[2]=5; arr3[1] = ...
Java array 数组用法源码集.rar
07-10
Java array 数组用法源码集，比如测试数组、划分成绩等级、从方法中返回数组、二分查找法、求二维数组的长度、锯齿数组、处理二维数组等，相信通过这些基础的数组操作实例，会对你了解Java中的数组有很好的帮助作用...
java关于数组（学习笔记）
12-21
Java中的数组是一种重要的数据结构，它允许我们存储多个同类型的元素。数组被定义为一个容器，可以一次性容纳多个数据项，这些数据项在内存中是连续存放的，这使得访问和检索元素非常高效。在Java中，数组属于引用...
java 数组
无成的博客
08-12 443
数组 数组与继承 父类类型数组引用 子类类型数组 √ 将父类类型存入 实际上是子类类型的数组 ——&gt; 运行时产生 java.lang.ArrayStoreException 异常 数组元素的类型称为该数字的基类型 数组的长度为固定属性 length java支持引用类型和基类型的数组 通过索引操作符[ ]来访问元素 一维数组 ...
java数组
cpf1985的专栏
08-20 187
[code="java"] --java里面的数组不能这样写int a[5]; *为什么呢？如果这样写的话一般情况下会将五个内存空间分配到栈上，但是java的数据是放在堆上的，栈上只能分配一个指针地址而已 *数组的神明有两种方式int[] a;或者int a[]; --数据的问题 方法中int[] a=new int[5];由于使用了new关键字，那么数组中的值（堆中已经分配内...
第十五遍：数组篇
Zerozroone的博客
05-07 245
数组 数组概述 数组声明创建 数组使用 多维数组 Arrays类 稀疏数组 数组的定义 数组是相同类型的有序结合 数组描述的是相同类型的若干个数据，按照一定的先后次序排列组合而成。 其中，每一个数据称做一个数组元素，每个数组元素可以通过一个下标来访问它们。 数组的四个基本特点 其长度是正确的。数组一旦被创建，它的大小就是不可以改变的。 其元素必须是相同类型，不允许出现混合类型。 数组中的元素可以是任何数据类型，包括基本类型和引用类型。 数组变量属引用类型，数组也可以看成对象，数组中的
JavaSE_day14【基础API与常见算法】
yangqian1794的博客
03-15 308
JavaSE_day14【基础API与常见算法】 主要内容 常用类 基础算法 学习目标 了解数学相关API 了解日期时间API 了解系统类API 掌握数组基础算法 掌握数组工具类的使用 第十章 基础API与常见算法 10.1 和数学相关的类 10.1.1 java.lang.Math java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。 public static
猿创征文 | Java知识【数组上篇】
日常学习总结
09-11 501
数组：数组定义，数组的静态初始化，地址值，数组元素访问
java array数组
11-12
在Java中，Array是一种特殊的引用类型，它用于存储固定大小的一组同类型数据。Array有基本类型的Array（如int[]）和对象类型的Array（如Object[]）。创建Array需要指定其元素类型和初始容量。以下是关于Java Array的一些关键点： 1. **声明和初始化**：例如，`int[] numbers = new int[5];` 创建了一个包含5个整数元素的数组。 2. **索引和长度**：数组通过索引来访问元素，索引从0开始（0, 1, ..., n-1），其中n是数组的长度。例如，`numbers[0]`表示第一个元素。 3. **遍历**：可以使用for循环或增强for循环（也叫foreach循环）来遍历数组的所有元素。 4. **动态扩容**：虽然Array在创建时指定大小，但在实际使用中如果需要添加更多元素，通常会创建一个新的大一些的Array并将原数组内容复制过去，因为Java Array是不可变的。 5. **修改元素**：可以直接通过索引修改数组中的元素，如 `numbers[0] = 10;`。 6. **常用方法**：`length`属性获取数组长度，`clone()`方法用于复制一个数组，`Arrays`类提供了一些操作数组的静态方法，比如排序等。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值