【Java笔记】第6章：数组

05-28 1089阅读

  • 前言
  • 1. 数组概括
  • 2. 数组的内存
  • 3. 数组扩容
  • 4. 二维数组
  • 5. 数组的排序
  • 结语

    【Java笔记】第6章：数组

    【Java笔记】第6章：数组

    #include

    int main {

    上期回顾:【Java笔记】第5章：函数

    个人主页：C_GUIQU

    归属专栏：【Java学习】

    return 一键三连;

    }

    【Java笔记】第6章：数组

    前言

    各位小伙伴大家好！上期小编给大家讲解了Java中的函数，接下来讲讲数组！

    1. 数组概括

    在Java中，数组是一种用于存储多个相同类型数据的集合。数组在内存中占据连续的空间，每个元素都可以通过索引来访问。

    【数组的概念】

    1. 索引（或下标）：Java中的数组索引从0开始，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。
    2. 长度：数组的长度是数组中元素的数量，这个信息可以通过数组的length属性获得。
    3. 元素：数组中的单个数据项称为元素，每个元素都可以通过其索引来访问。
    4. 多维数组：Java支持多维数组，即数组的数组。例如，一个二维数组可以看作是一行行的数组。

    【数组的性质】

    1. 类型安全：Java数组是类型安全的，这意味着一个数组只能包含特定类型的元素。例如，一个int类型的数组只能包含int类型的元素。
    2. 固定长度：在Java中，一旦数组被创建，其长度就固定不变。如果需要改变数组的长度，必须创建一个新的数组并将原数组的内容复制过去。
    3. 连续内存分配：Java数组中的所有元素都存储在连续的内存块中，这有助于提高访问效率。
    4. 默认初始化：Java中的数组在创建时会自动初始化。例如，整型数组默认初始化为0，对象数组默认初始化为null。
    5. 遍历和访问：可以使用for循环、while循环或do-while循环遍历数组元素。也可以通过索引直接访问数组中的特定元素。

    【创建数组】

    在Java中，可以使用以下方式创建数组：

    // 创建一个包含10个整数的数组
int[] numbers = new int[10];
// 创建一个并初始化一个字符串数组
String[] names = {"Alice", "Bob", "Charlie"};
// 创建一个二维数组
int[][] matrix = new int[3][4];

    【访问和修改数组元素】

    // 访问第一个元素
int firstElement = numbers[0];
// 修改第三个元素
numbers[2] = 50;
// 输出数组长度
System.out.println("数组长度：" + numbers.length);

    【 数组操作】

    Java提供了Arrays类，该类包含了许多用于操作数组的静态方法，如排序、搜索、填充和复制等。

    import java.util.Arrays;
// 对数组进行排序
Arrays.sort(numbers);
// 在数组中搜索元素
int index = Arrays.binarySearch(numbers, 50);
// 填充数组
Arrays.fill(numbers, 10);

    【注意事项】

    • Java数组在创建时必须指定类型，不能像某些动态语言那样存储不同类型的元素。
    • 数组是引用类型，当将一个数组赋值给另一个数组时，实际上是将引用赋值，两个数组变量将指向同一块内存空间。
    • 数组可以存储基本数据类型值，也可以存储对象引用，但不能直接存储对象本身。

      Java数组是编程中非常基础且重要的数据结构，理解和掌握数组的这些概念和性质对于Java编程至关重要。

      2. 数组的内存

      在Java中，数组是一种引用数据类型，用于存储多个相同数据类型的元素。

      Java中的数组内存分配可以分为两个部分：数组引用的存储和数组元素的存储。

      1. 数组引用的存储：数组引用是一个变量，存储在栈内存（Stack）中。当声明一个数组时，比如 int[] arr;，这时只是在栈上分配了一个引用变量 arr，这个变量此时并没有指向任何实际的数组对象。
      2. 数组元素的存储：实际的数组元素存储在堆内存（Heap）中。当使用 new 关键字创建数组时，如 arr = new int[10];，会在堆上分配足够的空间来存储数组元素，并且栈上的数组引用 arr 指向这个堆内存中的数组。

        在Java中，数组的创建是动态的，即数组的大小在运行时确定。一旦数组被创建，其大小就固定了，不能动态改变。

      数组初始化：

      • 静态初始化：在声明数组的同时初始化数组元素，例如 int[] arr = {1, 2, 3};。
      • 动态初始化：在声明数组后，通过分配空间的方式进行初始化，例如 int[] arr = new int[3];，此时数组元素会自动初始化为该数据类型的默认值（如整型为0，布尔型为false等）。

        数组的访问：

        Java中的数组是通过索引来访问的，索引从0开始。例如，arr[0] 表示访问数组 arr 的第一个元素。

        数组的遍历：

        可以使用for循环或者增强for循环（foreach循环）来遍历数组。

        数组的默认值：

        • 整型数组元素的默认值为0。
        • 浮点型数组元素的默认值为0.0。
        • 字符型数组元素的默认值为’\u0000’。
        • 布尔型数组元素的默认值为false。
        • 引用类型数组元素的默认值为null。

          注意事项：

          • 数组是对象，所以在使用前必须初始化。
          • 数组一旦创建，其长度就固定不变。
          • 数组可以存储基本数据类型值，也可以存储对象引用。
          • 数组也是一种数据结构，可以用来实现复杂的数据处理逻辑，如数组列表（ArrayList）、数组队列（ArrayDeque）等。

            3. 数组扩容

            在Java中，数组一旦创建，其大小就固定不变。这意味着如果你创建了一个长度为10的数组，你就不能直接将其大小增加到20。如果你需要更大的数组，你必须创建一个新数组，然后将原数组的内容复制到新数组中。这个过程通常称为“数组扩容”。

            以下是一个简单的数组扩容示例：

            public class ArrayExpansion {
    public static void main(String[] args) {
        int[] originalArray = {1, 2, 3, 4, 5}; // 创建一个初始数组
        int newLength = originalArray.length * 2; // 新数组的长度是原数组长度的两倍
        // 创建一个新数组，长度是原数组长度两倍
        int[] newArray = new int[newLength];
        // 将原数组的内容复制到新数组中
        for (int i = 0; i  

            在这个例子中，我们首先创建了一个长度为5的数组 originalArray。然后，我们创建了一个新数组 newArray，其长度是原数组长度的两倍。接着，我们使用一个for循环将 originalArray 中的所有元素复制到 newArray 中。现在，newArray 就是一个长度为10的数组，前5个元素与 originalArray 相同，后5个元素为默认值（对于整型数组，默认值为0）。
            这种方法虽然可以实现数组扩容，但效率并不高，因为涉及到数组的复制。在实际应用中，如果需要频繁地对数组进行扩容，通常会使用一些动态数据结构，如 ArrayList，它内部会自动处理数组的扩容问题，并提供更高效的添加和删除元素的操作。
             

            4. 二维数组
             

            在Java中，二维数组是数组的数组，即一个一维数组的每个元素都是一个一维数组。二维数组可以看作是一个表格，有行和列。在内存中，二维数组可以看作是数组的数组，或者是一维数组的嵌套。
             

            二维数组的声明和初始化：
             

            1.  
              静态初始化：
               
              int[][] myArray = {
    {1, 2, 3},    // 第一行
    {4, 5, 6},    // 第二行
    {7, 8, 9}     // 第三行
};

               
            2.  
              动态初始化：
               
              int rows = 3;
int cols = 4;
int[][] myArray = new int[rows][cols]; // 创建一个3行4列的二维数组

               
              在动态初始化的情况下，每个一维数组默认初始化为其元素类型的默认值（例如，整型为0，布尔型为false等）。
               
            访问二维数组的元素：
            二维数组的元素通过行索引和列索引来访问。例如，要访问上面静态初始化的二维数组中的元素5，可以使用 myArray[1][1]，其中 1 是行索引，1 是列索引。
             

            遍历二维数组：
            可以使用嵌套的for循环来遍历二维数组的所有元素：
             

            for (int i = 0; i  

            注意事项：
            • Java中的二维数组不必是规则的，即每一行的列数可以不同。
            • 二维数组的每一行实际上是一个一维数组，因此每一行的大小可以单独分配。
            • 二维数组的内存分配是在堆上进行的，而数组的引用存储在栈上。
            • 二维数组的创建和初始化也可以分开进行，先创建数组的引用，然后再为每一行分配空间。

              5. 数组的排序

              在Java中，数组排序是一个常见的操作，可以通过多种方式实现。以下是一些常用的数组排序方法：

              1. 使用Java标准库的排序方法：

                Java的Arrays类提供了一个sort方法，可以用来对数组进行排序。这是最简单和最直接的方法。

                int[] numbers = {3, 1, 4, 1, 5, 9};
Arrays.sort(numbers);
                对于对象数组，sort方法会使用元素的compareTo方法（如果对象实现了Comparable接口）来进行排序。
              2. 使用冒泡排序算法：

                冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

                public static void bubbleSort(int[] arr) {
    int n = arr.length;
    for (int i = 0; i  arr[j + 1]) {
                // 交换 arr[j+1] 和 arr[j]
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}
              3. 使用快速排序算法：

                快速排序是一种更高效的排序算法，它使用分治法策略来把一个序列分为较小的序列，在递归中分别对它们进行排序。

                public static void quickSort(int[] arr, int low, int high) {
    if (low
VPS购买请点击我

文章版权声明：除非注明，否则均为主机测评原创文章，转载或复制请以超链接形式并注明出处。

相关阅读

目录[+]