Java面试八股文宝典:初识数据结构-数组

已于 2023-09-14 17:50:46 修改
阅读量233 收藏 1
点赞数 1
分类专栏： JAVA面试 文章标签： java 开发语言 后端 面试 数据结构 spring
于 2023-09-11 15:59:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34445142/article/details/132765884
版权

数组（Array）

数组是计算机编程中最基本的数据结构之一。它是一个有序的元素集合，每个元素都可以通过索引进行访问。本文将详细介绍数组的特性、用法和注意事项。

数组的基本特性

数组具有以下基本特性：

  • 有序性： 数组中的元素是有序排列的，可以通过索引访问。
  • 固定长度： 数组的长度在创建时固定，无法动态改变。
  • 相同数据类型： 数组中的元素通常是相同数据类型的。

示例代码 - 创建和访问数组

让我们首先了解如何创建和访问数组：

// 创建一个整数数组
int[] numbers = new int[5];

// 插入元素
numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;

// 访问元素
int thirdNumber = numbers[2]; // 访问第三个元素，值为3

数组的源码分析

数组是一种非常基础的数据结构，通常由编程语言的底层机制直接支持。在 Java 中，数组是通过内存分配和索引访问实现的。你可以在 Java 的 java.util 包中找到一些与数组相关的工具类和方法，如 Arrays 类。

注意事项

在使用数组时，需要注意以下事项：

  • 固定长度： 数组的长度一旦确定，就无法更改。如果需要动态添加或删除元素，可能需要使用其他数据结构。
  • 索引越界： 访问数组元素时必须确保索引在有效范围内，否则会导致索引越界异常。
  • 内存占用： 数组的内存占用是固定的，如果分配了过多的空间，可能会浪费内存。

数组的使用场景

数组在许多场景下都非常有用，包括：

  • 列表存储： 数组可以用来存储列表数据，如学生成绩、购物清单等。
  • 数据检索： 由于数组的有序性，可以快速检索元素，例如查找最大值或最小值。
  • 算法实现： 数组是许多算法的基础，如排序算法和搜索算法。

主要知识点讲解

动态数组和静态数组的区别

动态数组和静态数组是两种常见的数组类型，它们在内存管理和使用灵活性方面存在显著的区别。以下是它们的主要区别：

  1. 大小变化：

    • 静态数组： 静态数组在创建时需要指定固定的大小，一旦分配了空间，大小不能更改。如果需要更多的存储空间，必须创建一个新的数组，将数据复制到新数组中，然后释放旧数组。这导致了内存的浪费和复杂的操作。
    • 动态数组： 动态数组在创建时可以指定初始大小，但如果数组元素数量超过当前容量，动态数组会自动扩展，分配更多的内存空间。这使得动态数组能够有效地处理大小变化的数据。

  2. 内存管理：

    • 静态数组： 静态数组在创建时分配了固定大小的内存，因此可能浪费内存（如果未充分利用）或不足以存储所有数据（如果超过容量）。
    • 动态数组： 动态数组能够根据需要分配和释放内存，以适应数据的大小。这减少了内存浪费，并确保有效使用可用内存。

  3. 使用灵活性：

    • 静态数组： 静态数组的大小是固定的，因此对于不同大小的数据集可能不够灵活。如果需要存储的数据数量不确定，静态数组可能无法满足需求。
    • 动态数组： 动态数组的大小可以动态增加，因此适用于处理不同大小的数据集。这使得它们更灵活且适用于各种情况。

  4. 实现复杂度：

    • 静态数组： 静态数组的实现通常比较简单，因为它们不需要处理大小变化的逻辑。
    • 动态数组： 动态数组的实现相对复杂，因为它们需要管理内存分配和复制数据的逻辑。通常，动态数组使用静态数组作为底层存储，以便动态扩展和收缩。

综上所述，动态数组在处理不确定数据大小的情况下更为灵活和高效，因为它们可以自动调整大小，而静态数组则需要在创建时指定大小，并且无法轻松适应不同的数据集。因此，大多数编程语言和应用程序更倾向于使用动态数组或提供动态数组的数据结构，如 Java 中的 ArrayList 或 Python 中的列表。

以下是Java中的一个简单示例，展示了静态数组和动态数组（ArrayList）的用法，以及它们之间的一些主要区别：

import java.util.ArrayList;

public class ArrayExample {
    public static void main(String[] args) {
        // 静态数组（固定大小）
        int[] staticArray = new int[5]; // 创建一个包含5个整数的静态数组

        staticArray[0] = 10;
        staticArray[1] = 20;
        staticArray[2] = 30;
        staticArray[3] = 40;
        staticArray[4] = 50;

        // 注意：静态数组大小不可更改
        // staticArray[5] = 60; // 这将导致数组越界错误

        System.out.println("静态数组元素：");
        for (int i = 0; i < staticArray.length; i++) {
            System.out.print(staticArray[i] + " ");
        }
        System.out.println();

        // 动态数组（ArrayList）
        ArrayList<Integer> dynamicArray = new ArrayList<Integer>(); // 创建一个空的动态数组

        dynamicArray.add(10);
        dynamicArray.add(20);
        dynamicArray.add(30);

        System.out.println("动态数组元素：");
        for (int i = 0; i < dynamicArray.size(); i++) {
            System.out.print(dynamicArray.get(i) + " ");
        }
        System.out.println();

        // 动态数组可以根据需要自动扩展
        dynamicArray.add(40);
        dynamicArray.add(50);

        System.out.println("动态数组元素（添加后）：");
        for (int i = 0; i < dynamicArray.size(); i++) {
            System.out.print(dynamicArray.get(i) + " ");
        }
        System.out.println();
    }
}

在这个示例中，我们首先创建了一个静态数组 staticArray 和一个动态数组 dynamicArray（使用 ArrayList 实现）。静态数组的大小在创建时固定，无法更改，而动态数组可以根据需要自动扩展。我们演示了如何向这两种数组中添加和访问元素。

请注意，在使用动态数组时，我们使用 ArrayList 的 add 方法来添加元素，而使用 size 和 get 方法来访问元素。此外，动态数组的大小可以根据添加的元素自动增长，而静态数组的大小是固定的。

当进一步扩展示例以更好地理解静态数组和动态数组之间的差异时，我们可以考虑以下方面：

  1. 动态数组的自动扩展： 通过向动态数组添加元素来展示其自动扩展的特性。

  2. 静态数组的大小限制： 展示静态数组的大小限制以及如何处理超出容量的情况。

  3. 性能比较： 比较静态数组和动态数组在插入、删除和访问元素方面的性能差异。

下面是一个扩展示例，演示了这些方面的比较：

import java.util.ArrayList;

public class ArrayExample {
    public static void main(String[] args) {
        // 静态数组（固定大小）
        int[] staticArray = new int[5];

        // 添加元素到静态数组
        for (int i = 0; i < staticArray.length; i++) {
            staticArray[i] = i * 10;
        }

        // 试图添加超出容量的元素
        // staticArray[5] = 50; // 这将导致数组越界错误

        // 动态数组（ArrayList）
        ArrayList<Integer> dynamicArray = new ArrayList<Integer>();

        // 添加元素到动态数组
        for (int i = 0; i < 5; i++) {
            dynamicArray.add(i * 10);
        }

        // 展示动态数组的大小自动扩展
        for (int i = 5; i < 10; i++) {
            dynamicArray.add(i * 10);
        }

        // 访问静态数组的元素
        System.out.println("静态数组元素：");
        for (int i = 0; i < staticArray.length; i++) {
            System.out.print(staticArray[i] + " ");
        }
        System.out.println();

        // 访问动态数组的元素
        System.out.println("动态数组元素：");
        for (int i = 0; i < dynamicArray.size(); i++) {
            System.out.print(dynamicArray.get(i) + " ");
        }
        System.out.println();

        // 比较静态数组和动态数组的性能
        long startTime = System.nanoTime();
        // 在静态数组中执行一系列操作
        long endTime = System.nanoTime();
        System.out.println("静态数组操作耗时：" + (endTime - startTime) + "纳秒");

        startTime = System.nanoTime();
        // 在动态数组中执行相同系列操作
        endTime = System.nanoTime();
        System.out.println("动态数组操作耗时：" + (endTime - startTime) + "纳秒");
    }
}

在这个扩展示例中，我们添加了更多元素到动态数组，展示了其自动扩展的特性。我们还演示了如何访问静态数组和动态数组的元素，并进行性能比较。

请注意，在性能比较方面，动态数组通常具有更好的性能，因为它可以自动扩展，而不需要手动管理容量。但这也取决于具体的操作和场景。

多维数组的概念和使用

多维数组是一种特殊类型的数组，它可以包含其他数组作为其元素，从而形成多维数据结构。多维数组在处理复杂的数据和表格时非常有用，通常用于表示矩阵、图像、表格等具有多个维度的数据集。

以下是多维数组的概念和使用示例：

多维数组的概念

多维数组是一个包含多个维度的数组，每个维度都可以看作是一个单独的数组。通常，我们使用二维数组和三维数组最为常见，但我们可以创建具有任意数量维度的多维数组。

  • 二维数组： 二维数组是一个表格状的数组，具有行和列。它可以看作是一个数组的数组，其中每个元素是一个数组，代表一行或一列的数据。

  • 三维数组： 三维数组可以被视为一堆二维数组。每个元素是一个二维数组，代表了一个平面或一层的数据。

  • 多维数组： 多维数组可以扩展到更多的维度，例如四维数组、五维数组等。每个维度都会增加一个方向，用于组织数据。

多维数组的声明和初始化

在Java中，声明和初始化多维数组的语法如下：

// 声明和初始化二维数组
dataType[][] arrayName = new dataType[rows][columns];

// 例如，创建一个3x4的整数二维数组
int[][] twoDArray = new int[3][4];

// 声明和初始化三维数组
dataType[][][] arrayName = new dataType[depth][rows][columns];

// 例如，创建一个2x3x4的整数三维数组
int[][][] threeDArray = new int[2][3][4];

多维数组的访问和操作

多维数组的访问和操作涉及到多个索引，每个索引对应一个维度。例如，对于二维数组：

int value = twoDArray[rowIndex][columnIndex];

对于三维数组：

int value = threeDArray[layerIndex][rowIndex][columnIndex];

我们可以使用嵌套的循环来遍历和操作多维数组的元素，例如：

// 遍历二维数组
for (int i = 0; i < rows; i++) {
    for (int j = 0; j < columns; j++) {
        int value = twoDArray[i][j];
        // 进行操作
    }
}

// 遍历三维数组
for (int i = 0; i < depth; i++) {
    for (int j = 0; j < rows; j++) {
        for (int k = 0; k < columns; k++) {
            int value = threeDArray[i][j][k];
            // 进行操作
        }
    }
}

示例：二维数组的应用

以下是一个示例，演示了如何使用二维数组表示一个矩阵，并进行一些基本的操作：

public class TwoDArrayExample {
    public static void main(String[] args) {
        // 创建一个3x4的整数二维数组
        int[][] matrix = {
            {1, 2, 3, 4},
            {5, 6, 7, 8},
            {9, 10, 11, 12}
        };

        // 访问元素
        int value = matrix[1][2]; // 访问第2行第3列的元素（值为7）

        // 遍历并打印矩阵
        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();
        }
    }
}

这个示例创建了一个3x4的整数二维数组，访问了其中的元素，并遍历了整个矩阵。

多维数组在编程中具有广泛的应用，尤其是在处理矩阵、图像、游戏地图等需要多维数据结构的场景中。通过多维数组，我们可以更方便地组织和访问复杂的数据。

多维数组是一种包含多个维度的数组，每个维度可以看作是一个单独的数组。它们用于表示多维数据结构，例如矩阵、立方体、三维坐标等。在多维数组中，每个元素都由多个索引确定，每个索引对应一个维度。

以下是多维数组的更详细描述和代码示例：

二维数组

二维数组是最常见的多维数组类型，它包含两个维度：行和列。在Java中，可以通过嵌套数组来创建二维数组。下面是一个示例：

// 创建一个3x3的整数二维数组
int[][] matrix = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// 访问元素
int value = matrix[1][2]; // 访问第2行第3列的元素（值为6）

三维数组

三维数组包含三个维度，通常用于表示立体数据。在Java中，可以使用嵌套的数组来创建三维数组。以下是一个示例：

// 创建一个2x3x4的整数三维数组
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 value = cube[1][2][3]; // 访问第2层、第3行、第4列的元素（值为24）

多维数组的遍历

遍历多维数组需要嵌套循环，每个维度一个循环。以下是遍历二维数组和三维数组的示例：

// 遍历二维数组
for (int i = 0; i < matrix.length; i++) {
    for (int j = 0; j < matrix[i].length; j++) {
        int value = matrix[i][j];
        // 进行操作
    }
}

// 遍历三维数组
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++) {
            int value = cube[i][j][k];
            // 进行操作
        }
    }
}

多维数组的应用

多维数组在编程中有许多应用，例如：

  • 图像处理： 图像通常表示为二维数组，其中每个元素代表像素的颜色或亮度值。

  • 游戏开发： 游戏地图、三维模型等数据可以使用多维数组表示。

  • 科学计算： 在科学和工程领域中，多维数组用于表示复杂的数据集，如物理模拟、地理信息系统（GIS）等。

  • 数据分析： 在数据分析和机器学习中，多维数组用于存储和处理大规模数据集。

多维数组在处理需要多个维度的数据时非常有用，它们提供了一种有效的方式来组织和访问这些数据。根据需求，我们可以创建具有更多维度的多维数组，以满足特定的应用需求。

数组的时间复杂度分析，包括插入、删除和查找操作的性能分析

数组是一种基本的数据结构，其性能分析涉及到插入、删除和查找操作的时间复杂度。下面是关于数组各种操作的时间复杂度分析：

  1. 插入操作：

    • 在末尾插入元素（尾部插入）：插入操作的时间复杂度为 O(1)。因为在数组末尾添加元素不需要移动其他元素，只需将新元素放在最后即可。

    • 在中间或开头插入元素：如果要在数组中间或开头插入元素，需要将插入位置之后的所有元素都向后移动一个位置。这样的操作的时间复杂度是 O(n)，其中 n 是数组中的元素数量，因为它需要线性时间来移动元素。

  2. 删除操作：

    • 删除末尾元素（尾部删除）：与插入类似，删除操作的时间复杂度为 O(1)。只需将末尾元素标记为删除即可，不需要移动其他元素。

    • 删除中间或开头元素：与插入相同，删除中间或开头的元素需要将删除位置之后的所有元素向前移动一个位置，时间复杂度为 O(n)。

  3. 查找操作：

    • 按索引查找元素：查找特定索引位置的元素的时间复杂度是 O(1)。因为可以通过数组的索引直接访问元素。

    • 线性查找：如果需要在数组中查找特定值，且数组未排序，那么最坏情况下需要遍历整个数组，时间复杂度为 O(n)。

    • 二分查找：如果数组已排序，可以使用二分查找来提高查找效率，时间复杂度为 O(log n)。但前提是数组必须是有序的。

总结：

  • 插入和删除操作的性能受到插入或删除的位置以及元素数量的影响。在尾部插入或删除元素时性能最好，时间复杂度为 O(1)，而在中间或开头插入或删除元素时性能较差，时间复杂度为 O(n)。

  • 查找操作的性能取决于具体情况。按索引查找元素的时间复杂度为 O(1)。在无序数组中线性查找的时间复杂度为 O(n)，而在有序数组中二分查找的时间复杂度为 O(log n)。

因此，对于需要频繁进行插入、删除和查找操作的情况，可能需要考虑使用其他数据结构，如链表或哈希表，以获得更好的性能。数组在具体应用中的选择应根据操作的频率和性能要求来决定。
以下是关于数组插入、删除和查找操作的Java代码示例：

import java.util.Arrays;

public class ArrayOperationsExample {
    public static void main(String[] args) {
        // 创建一个整数数组
        int[] arr = {10, 20, 30, 40, 50};

        // 打印原始数组
        System.out.println("原始数组：" + Arrays.toString(arr));

        // 插入操作
        int insertValue = 60;
        int insertIndex = 2; // 在索引2处插入元素
        insertElement(arr, insertValue, insertIndex);
        System.out.println("插入元素 " + insertValue + " 后的数组：" + Arrays.toString(arr));

        // 删除操作
        int deleteIndex = 3; // 删除索引3处的元素
        deleteElement(arr, deleteIndex);
        System.out.println("删除索引 " + deleteIndex + " 处的元素后的数组：" + Arrays.toString(arr));

        // 查找操作
        int searchValue = 30;
        int searchIndex = searchElement(arr, searchValue);
        if (searchIndex != -1) {
            System.out.println("元素 " + searchValue + " 在数组中的索引位置为 " + searchIndex);
        } else {
            System.out.println("元素 " + searchValue + " 不在数组中。");
        }
    }

    // 插入元素
    public static void insertElement(int[] arr, int value, int index) {
        if (index < 0 || index > arr.length) {
            System.out.println("插入位置无效。");
            return;
        }

        // 创建一个新数组，比原数组多一个元素
        int[] newArr = new int[arr.length + 1];

        // 将原数组前半部分复制到新数组中
        for (int i = 0; i < index; i++) {
            newArr[i] = arr[i];
        }

        // 插入新元素
        newArr[index] = value;

        // 将原数组后半部分复制到新数组中
        for (int i = index; i < arr.length; i++) {
            newArr[i + 1] = arr[i];
        }

        // 更新原数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = newArr[i];
        }
    }

    // 删除元素
    public static void deleteElement(int[] arr, int index) {
        if (index < 0 || index >= arr.length) {
            System.out.println("删除位置无效。");
            return;
        }

        // 创建一个新数组，比原数组少一个元素
        int[] newArr = new int[arr.length - 1];

        // 将原数组前半部分复制到新数组中
        for (int i = 0; i < index; i++) {
            newArr[i] = arr[i];
        }

        // 将原数组后半部分复制到新数组中
        for (int i = index + 1; i < arr.length; i++) {
            newArr[i - 1] = arr[i];
        }

        // 更新原数组
        for (int i = 0; i < arr.length - 1; i++) {
            arr[i] = newArr[i];
        }
    }

    // 查找元素
    public static int searchElement(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i; // 找到元素并返回索引
            }
        }
        return -1; // 元素不在数组中
    }
}

当进行插入、删除和查找操作时，我们需要综合考虑时间复杂度和空间复杂度。在数组中执行这些操作时，它们的性能表现如下：

1. 插入操作：

  • 时间复杂度： 对于数组的插入操作，最好的情况是在末尾插入，时间复杂度为O(1)。这是因为只需要在数组的末尾追加元素，不需要移动其他元素。但如果要在中间或开头插入元素，则需要将插入位置之后的元素向后移动，平均时间复杂度为O(n)，其中n是数组的大小。

  • 空间复杂度： 插入操作的空间复杂度通常很低，仅包括新插入的元素所占用的空间。

示例代码 - 插入操作（数组）：

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int insertValue = 60;
        int insertIndex = 2; // 在索引2处插入元素
        insertElement(arr, insertValue, insertIndex);
    }

    // 插入元素
    public static void insertElement(int[] arr, int value, int index) {
        if (index < 0 || index > arr.length) {
            System.out.println("插入位置无效。");
            return;
        }

        // 创建一个新数组，比原数组多一个元素
        int[] newArr = new int[arr.length + 1];

        // 将原数组前半部分复制到新数组中
        for (int i = 0; i < index; i++) {
            newArr[i] = arr[i];
        }

        // 插入新元素
        newArr[index] = value;

        // 将原数组后半部分复制到新数组中
        for (int i = index; i < arr.length; i++) {
            newArr[i + 1] = arr[i];
        }

        // 更新原数组
        for (int i = 0; i < arr.length; i++) {
            arr[i] = newArr[i];
        }
    }
}

2. 删除操作：

  • 时间复杂度： 删除操作的时间复杂度与插入类似，最好的情况是删除末尾元素，时间复杂度为O(1)。但如果要删除中间或开头的元素，则需要将删除位置之后的元素向前移动，平均时间复杂度为O(n)，其中n是数组的大小。

  • 空间复杂度： 删除操作的空间复杂度通常很低，仅包括被删除元素的空间。

示例代码 - 删除操作（数组）：

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int deleteIndex = 2; // 删除索引2处的元素
        deleteElement(arr, deleteIndex);
    }

    // 删除元素
    public static void deleteElement(int[] arr, int index) {
        if (index < 0 || index >= arr.length) {
            System.out.println("删除位置无效。");
            return;
        }

        // 创建一个新数组，比原数组少一个元素
        int[] newArr = new int[arr.length - 1];

        // 将原数组前半部分复制到新数组中
        for (int i = 0; i < index; i++) {
            newArr[i] = arr[i];
        }

        // 将原数组后半部分复制到新数组中
        for (int i = index + 1; i < arr.length; i++) {
            newArr[i - 1] = arr[i];
        }

        // 更新原数组
        for (int i = 0; i < arr.length - 1; i++) {
            arr[i] = newArr[i];
        }
    }
}

3. 查找操作：

  • 时间复杂度： 在数组中查找操作通常需要线性搜索，时间复杂度为O(n)，其中n是数组的大小。如果数组是有序的，可以使用二分查找，时间复杂度为O(log n)。

  • 空间复杂度： 查找操作的空间复杂度通常很低，仅包括存储查找结果所需的空间。

示例代码 - 查找操作（数组）：

public class ArrayExample {
    public static void main(String[] args) {
        int[] arr = {10, 20, 30, 40, 50};
        int searchValue = 30;
        int searchIndex = searchElement(arr, searchValue);
        if (searchIndex != -1) {
            System.out.println("元素 " + searchValue + " 在数组中的索引位置为 " + searchIndex);
        } else {
            System.out.println("元素 " + searchValue + " 不在数组中。");
        }
    }

    // 线性查找元素
    public static int searchElement(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) {
                return i; // 找到并返回元素的索引
            }
        }
        return -1; // 元素不在数组中
    }
}

总结：

  • 数组在插入和删除操作中的性能通常受到插入或删除位置和数组大小的影响。查找操作的性能取决于数组是否有序。
  • 在选择数据结构和算法时，需要根据特定的需求和性能要求来做出决策。不同的数据结构和算法适用于不同的情况。
结语

下一章我们将继续探讨数组的应用扩展，包括 HashMap、HashMap、ConcurrentHashTable、HashSet、LinkedHashMap 。这些数据结构在特定的应用场景中发挥了重要作用，它们具有不同的特性和性能特点，我将详细介绍它们的使用方法、优势以及适用的情况。如果您在这些内容中发现任何不准确或需要进一步说明的地方，欢迎提出，我将尽力提供准确和有用的信息。让我们共同学习，共同进步。

爱打架的小白兔
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面试宝典：掌握基本数据结构 - 理论与实践案例深度解析
用文字记录下每一个瞬间的感动和每一次思考的火花
03-27 7万+
问题描述：在一个线上教育平台的项目中，需要实现一个实时在线问答功能，允许学生提交问题，讲师按照问题提交的顺序回答。使用技术点：使用队列来管理问题的提交和回答过程。设计思路：处理过程：总结经验：
Java面试八股文001-Java-Java基础
07-05
Java面试八股文001-Java-Java基础 1. Java 中的几种基本数据类型是什么？对应的包装类型是什么？各自占用多少字节呢？ 2. String、StringBuffer 和 StringBuilder的区别是什么？String为什么是不可变的？ 3. String ...
java面试八股文
weixin_45927841的博客
03-21 5万+
目录一、java（1）集合1.list：LinkedList、ArrayList和Vector2.set：HashSet和TreeSet3.map：HashMap、TreeMap和HashTable4.list和set的区别（2）其他1.面向对象三大特性2.Object类的常用方法3.Java中线程安全的基本数据结构4.string、stringBuffer和stringBuilder5.抽象类与接口的区别6.java的基本数据类型7.java代码块执行顺序8.static关键字9.覆盖（重写）和重载的区别
JAVA面试八股文宝典（黑马学习随笔）--虚拟机篇
qq_46447737的博客
09-26 1193
跟随着黑马满老师的《Java八股文面试题视频教程，Java面试八股文宝典》学习，视频教程地址：【Java八股文面试题视频教程，Java面试八股文宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等最新java面试真题）】 https://www.bilibili.com/video/BV15b4y117RJ?本篇更新虚拟机篇的内容。
2024年 Java 面试八股文（20w字）
热门推荐
leader_song的博客
08-04 20万+
目录第一章-Java基础篇1、你是怎样理解OOP面向对象 难度系数：⭐2、重载与重写区别 难度系数：⭐3、接口与抽象类的区别 难度系数：⭐4、深拷贝与浅拷贝的理解 难度系数：⭐5、sleep和wait区别 难度系数：⭐6、什么是自动拆装箱 int和Integer有什么区别 难度系数：⭐7、==和equals区别 难度系数：⭐8、String能被继承吗 为什么用final修饰 难度系数：⭐9、String buffer和String builder区别
JAVA面试八股文宝典（黑马学习随笔）-- 基础篇
qq_46447737的博客
07-24 2411
​ 跟随着黑马满老师的《Java八股文面试题视频教程，Java面试八股文宝典》学习，视频教程地址：Java八股文面试题视频教程，Java面试八股文宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等最新java面试真题）_哔哩哔哩_bilibili 共分为四个部分，分别是基础篇、并发篇、虚拟机、框架篇 ​.......................................
Java面试八股文(2023最新)--Java基础面试题
不知名菜鸡
05-25 1059
持续更新ing
JAVA面试八股文宝典（黑马学习随笔）-- 并发篇
qq_46447737的博客
07-30 726
​ 跟随着黑马满老师的《Java八股文面试题视频教程，Java面试八股文宝典》学习，视频教程地址：Java八股文面试题视频教程，Java面试八股文宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发，jvm等最新java面试真题）_哔哩哔哩_bilibili 共分为四个部分，分别是 基础篇、并发篇、虚拟机、框架篇 本篇更新并发篇的内容 ​.........
Java面试八股文合集（持续更新）
qq_51580161的博客
09-27 1万+
我们使用java编译命令就能将java源文件编译对应成字节码文件（.class），字节码文件是一种八位数据的二进制流文件，可以被JVM快速加载到内存中运行。
Java面试八股文(2023最新)--SpringBoot面试题
不知名菜鸡
06-04 1765
持续更新ing...
Java面试宝典合集-八股文-自我介绍-案例
09-11
Java面试宝典2018版.docx java面试自我介绍 涵盖通用案例.docx java面试逻辑思维题txt Java面试问题集,pdf 关于Java面试知识点pdf 通用面试技巧和注意事项,pdf 阿里巴巴 iava 研发成功笔面试总结.doc 面试技巧之自我...
黑马Java八股文面试题视频教程，Java面试八股文宝典（含阿里、腾迅大厂java面试真题，java数据结构，java并发
05-23
2. **数据结构**：数据结构是算法的基础，Java面试中常涉及数组、链表、栈、队列、树（二叉树、平衡树如AVL和红黑树）、图等。理解它们的特性、操作时间复杂度以及如何在实际问题中应用是考察技术深度的重要部分。 ...
Java面试八股文2024最新版
12-19
工作了二年多想跳槽了，自己整理的Java面试八股文 java面试题 2023最新整理 java八股文 高频面试题 里边包含了很多领域的java se基础、springboot springcloud MyBatis、ZooKeeper、Dubbo、Elasticsearch、Memcached...
java面试八股文各类面试题
03-07
1. **Java基础**：Java是面试的基础，深入理解其语法特性、异常处理、内存管理（如垃圾回收机制）以及面向对象的设计原则是必要的。 2. **MyBatis**：MyBatis是一个流行的持久层框架，了解它的动态SQL、映射文件、...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 548
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
小明的Java问道之路
07-08 768
已解决 javax.xml.transform.TransformerFactoryConfigurationError 异常的正确解决方法，亲测有效！！！
springboot中抽离日志
最新发布
qq_24223159的博客
07-08 204
【代码】springboot中抽离日志。
ShardingSphere
Casual_Lei的博客
07-04 668
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值