目录
1. 什么是数组
数组是一种数据结构，它可以存储多个相同类型的数据。可以将数组想象为一个有序的集合，每个元素都有一个对应的索引（位置），通过索引可以访问和操作数组中的元素。
举个例子，假设我们有一个数组用来存储学生的分数，其中每个元素表示一个学生的分数。我们可以使用索引来访问特定学生的分数，比如数组中的第一个元素表示第一个学生的分数，第二个元素表示第二个学生的分数，以此类推。
数组的优点是可以方便地存储和访问大量的数据，同时提供了一些内置的方法和函数来操作数组，比如添加元素、删除元素、排序等。在编程中，数组是一种重要的数据结构，被广泛应用于各种算法和数据处理任务中。
2. 数组的使用
当我们需要存储一组相同类型的数据时，可以使用数组来方便地管理和操作这些数据。在Java中，数组是一种非常常见且重要的数据结构。下面详细介绍数组的使用：
-
声明数组：在使用数组之前，需要先声明数组的类型和名称。语法如下：
数据类型[] 数组名; 或者 数据类型 数组名[];例如：
int[] numbers; //声明一个整数类型的数组 String[] names; //声明一个字符串类型的数组 -
创建数组：在声明数组之后，需要使用
new关键字来创建数组对象，并指定数组的长度。语法如下：数组名 = new 数据类型[长度];例如：
numbers = new int[5]; //创建一个包含5个整数的数组 names = new String[3]; //创建一个包含3个字符串的数组 -
初始化数组：可以使用静态初始化或动态初始化来为数组分配初始值。
- 静态初始化：为数组的每个元素指定初始值。语法如下：
例如：数据类型[] 数组名 = {值1, 值2, 值3, ...};int[] numbers = {1, 2, 3, 4, 5}; //静态初始化整型数组 String[] names = {"John", "Mary", "Bob"}; //静态初始化字符串数组 - 动态初始化：为数组的每个元素分配默认值。语法如下：
例如：数据类型[] 数组名 = new 数据类型[长度];int[] numbers = new int[5]; //动态初始化整型数组，默认值为0 String[] names = new String[3]; //动态初始化字符串数组，默认值为null
- 静态初始化：为数组的每个元素指定初始值。语法如下：
-
访问数组元素：可以使用索引来访问数组中的元素。索引从0开始，到数组长度减1。语法如下：
数组名[索引];例如：
int firstNumber = numbers[0]; //访问数组中第一个元素 String secondName = names[1]; //访问数组中第二个元素 -
数组长度：可以使用
数组名.length来获取数组的长度。语法如下：数组名.length;例如：
int length = numbers.length; //获取整型数组的长度 -
遍历数组：可以使用循环结构来遍历数组中的元素。常用的循环结构有
for循环和foreach循环。例如：- 使用
for循环遍历：for (int i = 0; i < 数组名.length; i++) { // 访问数组中的元素，进行相应的操作 } - 使用
for-each循环遍历：for (数据类型 变量名 : 数组名) { // 访问数组中的元素，进行相应的操作 }
- 使用
-
数组的方法和属性：Java提供了一些内置的方法和属性来操作数组。
Arrays.toString(数组名): 将数组转换为字符串表示形式。Arrays.sort(数组名): 对数组进行排序。数组名.length: 获取数组的长度。
使用数组可以方便地存储和操作多个相同类型的数据。它在Java中被广泛使用，对于数据处理和算法实现非常重要。掌握数组的使用能够提高编程效率和代码的可读性。
3. 使用注意细节
在Java中使用数组时，需要注意以下几个细节：
-
数组的默认值
- 整型数组（int[]）的默认值为0；
- 双精度浮点型数组（double[]）的默认值为0.0；
- 字符型数组（char[]）的默认值为'\u0000'，即空字符；
- 布尔型数组（boolean[]）的默认值为false；
- 引用类型数组（例如String[]）的默认值为null，表示数组元素尚未引用任何对象。
-
数组的下标范围
- 数组的下标从0开始，所以第一个元素的下标是0，第二个元素的下标是1，以此类推；
- 在访问数组元素时，需要确保下标在数组范围内，否则会抛出ArrayIndexOutOfBoundsException异常。
-
数组的传递
- 当数组作为参数传递给方法时，实际上传递的是数组的引用，而不是数组本身；
- 这意味着在方法中修改数组的元素会影响到原始数组；
- 如果不希望修改原始数组，可以在方法内部创建一个新的数组并进行操作。
4. 数组赋值机制
在Java中，数组赋值机制涉及到数组引用、数组对象和数组元素三个概念。下面详细介绍Java中数组赋值机制的相关概念：
-
数组引用：数组引用是指向数组对象的引用，类似于指针。在Java中，数组引用存储数组对象在内存中的地址。通过数组引用，可以访问和操作数组对象中的元素。
-
数组对象：数组对象是在内存中分配的一段连续的存储空间，用于存储数组元素。数组对象包含了元素的值，并且可以通过数组引用来访问和操作这些元素。
-
数组元素：数组元素是存储在数组对象中的数据项，可以通过索引来访问。数组元素的类型必须一致，即数组中的所有元素都必须属于同一数据类型。
在Java中，数组赋值机制遵循以下原则：
- 数组变量存储的是数组对象的引用，而不是数组对象本身。因此，数组变量之间的赋值实际上是将数组对象的引用复制给另一个数组变量，使它们指向同一个数组对象。
- 当对一个数组对象进行操作时，所有指向该数组对象的数组变量都会受到影响，因为它们指向同一个数组对象。
- 数组赋值不会复制数组对象本身，而是复制数组对象的引用。因此，对一个数组对象的修改会影响到所有指向该数组对象的数组变量。
- 如果需要复制数组对象本身，可以使用
clone()方法进行浅拷贝，或者使用循环逐个复制数组元素进行深拷贝。
总之，了解数组引用、数组对象和数组元素的概念，可以帮助我们理解在Java中数组赋值的机制，并正确地操作和赋值数组。
5. JVM 内存分配
JVM（Java虚拟机）内存分配主要包括堆内存、栈内存和方法区。以下是对这三个内存区域的作用、特点和分配过程的详细介绍：
-
堆内存（Heap Memory）：
- 作用：堆内存用于存储对象实例和数组，是Java程序中最常用的内存区域。
- 特点：堆内存是线程共享的，所有线程都可以访问堆内存中的对象。堆内存的大小可以动态调整，通过-Xms和-Xmx参数可以设置堆内存的初始大小和最大大小。
- 分配过程：当一个对象被创建时，JVM会在堆内存中分配一块空间来存储该对象。如果对象所需空间超过了堆内存的剩余空间，会触发垃圾回收机制来释放不再使用的对象，从而为新对象腾出空间。
-
栈内存（Stack Memory）：
- 作用：栈内存用于存储方法调用的信息、局部变量和方法参数。
- 特点：栈内存是线程私有的，每个线程都有自己的栈内存。栈内存的大小是固定的，当栈内存空间不足时会抛出栈溢出异常。
- 分配过程：当一个方法被调用时，JVM会在栈内存中为该方法分配一块空间，用来存储方法的参数、局部变量和方法调用的信息。方法执行完毕后，栈内存中的空间会被释放。
-
方法区（Method Area）：
- 作用：方法区用于存储类的信息、静态变量、常量池等。
- 特点：方法区是线程共享的，所有线程都可以访问方法区中的内容。方法区的大小是固定的，当方法区空间不足时会抛出OutOfMemoryError异常。
- 分配过程：当类被加载到内存中时，类的信息会被存储在方法区中。方法区中还包括运行时常量池，用于存储常量和符号引用。
总的来说，JVM内存分配是一个动态的过程，根据程序的需求动态分配内存空间。合理调整堆内存大小、栈内存大小和方法区大小可以提高程序的性能和稳定性。同时，及时进行垃圾回收可以释放不再使用的内存，避免内存泄漏和内存溢出问题。
6. 数组底层原理
在Java虚拟机（JVM）中，数组的内存分配涉及到堆内存和栈内存。
-
堆内存分配：
- 当创建一个数组对象时，JVM会在堆内存中为该数组分配一块连续的内存空间。
- 这块内存空间的大小取决于数组类型和长度。
- JVM会检查堆内存中是否有足够的空闲空间来存储该数组。
- 如果有足够的空闲空间，则分配这块内存空间给数组，否则会触发垃圾回收机制来释放不再使用的对象，为数组腾出空间。
-
栈内存分配：
- 数组引用变量存储在栈内存中。
- 数组引用变量是指向数组对象的指针，它保存着数组对象在堆内存中的起始地址。
- 当声明一个数组引用变量时，该变量会被分配到栈内存中。
- 如果数组是一个局部变量，则当该变量超出作用域时，栈内存中的存储空间将被自动释放。
-
数组元素的内存分配：
- 对于基本数据类型的数组，在堆内存中直接存储数组元素的值。
- 对于对象类型的数组，在堆内存中存储的是对象的引用，而对象本身的数据则存储在堆内存中的其他位置。
-
数组的内存释放：
- 当数组对象不再被引用时，JVM的垃圾回收机制会自动回收该数组对象占用的堆内存空间。
- 如果数组元素是对象类型，并且数组元素引用的对象也不再被引用，那么这些对象也会被垃圾回收机制回收。
总的来说，数组的内存分配涉及到堆内存和栈内存。数组对象本身在堆内存中分配，数组引用变量存储在栈内存中。数组元素的内存分配取决于数组类型。合理地管理数组的内存分配对于程序的性能和内存利用效率是非常重要的。
7. 数组拷贝
在Java中，数组分为基本数据类型数组和引用数据类型数组。
浅拷贝是指创建一个新数组，新数组中的元素与原数组中的元素相同。对于基本数据类型数组，浅拷贝是深拷贝，因为基本数据类型存储的是值，通过拷贝数组可以得到一个新的数组，新数组中的元素与原数组中的元素值相同，但存储在不同的内存空间中，互不影响。
对于引用数据类型数组，浅拷贝只复制了对象的引用，而不是真正创建了新的对象。这意味着新数组和原数组中的元素引用的是同一个对象。当修改新数组中的对象时，原数组中的对象也会受到影响。这是因为数组存储的是对象的引用，而不是对象本身。
深拷贝是指创建一个新数组，新数组中的元素与原数组中的元素相同，但它们是独立的对象。对于引用数据类型数组，深拷贝会创建新的对象，并将原数组中的对象的值复制到新对象中。这样，新数组和原数组中的对象互不影响。
实现数组的深拷贝可以使用以下方法：
- 利用循环遍历原数组，并为每个元素创建新的对象，并将原始对象的值复制到新对象中，然后将新对象添加到新数组中。
- 使用数组的克隆方法（clone()）来创建新数组。对于引用数据类型数组，还需要对每个对象使用克隆方法来创建新的对象副本。
需要注意的是，对于引用数据类型数组，深拷贝涉及到对象的复制和对象内部可能存在的引用类型属性的复制。只有当对象及其所有引用类型属性都可以进行深度复制时，才能实现真正的深拷贝。否则，只能实现浅拷贝或部分深拷贝。
在Java中，String类是一个特殊的引用数据类型，但它具有不可变性。这意味着一旦创建了一个String对象，它的值就不能被修改，任何修改String对象的操作都会创建一个新的String对象。
当你对一个String对象进行修改时，实际上是创建了一个新的String对象，而原始的String对象保持不变。这与普通的引用数据类型不同，普通的引用数据类型对象是可变的，修改对象的内容会影响所有引用该对象的地方。
8. 数组反转
在Java中，可以使用以下方法来实现数组的反转：
-
使用临时数组：创建一个与原数组大小相同的临时数组，然后使用一个循环将原数组的元素从末尾开始赋值到临时数组，最后将临时数组赋值回原数组。
- 示范代码：
// 定义原数组 int[] array = {1, 2, 3, 4, 5}; // 创建临时数组 int[] temp = new int[array.length]; // 将原数组的元素从末尾开始赋值到临时数组 for (int i = array.length-1, j = 0; i >= 0; i--, j++) { temp[j] = array[i]; } // 将临时数组赋值回原数组 for (int i = 0; i < array.length; i++) { array[i] = temp[i]; } // 打印反转后的数组 System.out.println(Arrays.toString(array));
- 示范代码：
-
使用递归方法：创建一个递归方法，该方法将数组索引从头到尾进行反转。递归方法的基本情况是当索引小于等于数组长度的一半时停止递归。
- 示范代码：
// 定义递归方法 public static void reverseArray(int[] array, int start, int end) { // 递归的基本情况 if (start >= end) { return; } // 交换数组元素 int temp = array[start]; array[start] = array[end]; array[end] = temp; // 递归反转剩余的部分 reverseArray(array, start+1, end-1); } // 定义原数组 int[] array = {1, 2, 3, 4, 5}; // 调用递归方法 reverseArray(array, 0, array.length-1); // 打印反转后的数组 System.out.println(Arrays.toString(array));
- 示范代码：
以上是两种常见的在Java中实现数组反转的方法。无论使用哪种方法，都可以得到原数组的反转结果。
9. 数组扩容
数组扩容是指在原有数组的基础上增加其容量。在Java中，数组的长度是固定的，一旦创建后就无法改变其长度。因此，当数组已满，并且需要继续向数组中添加元素时，就需要进行数组扩容操作。
数组扩容的主要步骤如下：
-
创建一个新数组：根据需要扩容的大小，创建一个新的数组，通常会将原数组的长度扩大一倍或按照一定的增长因子进行扩容。
-
复制原数组元素：将原数组中的元素逐个复制到新数组中，保持相对顺序不变。可以使用循环遍历原数组，并使用赋值语句将元素逐个复制到新数组。
-
添加新元素：将需要添加的新元素放置在新数组的最后一个位置。
-
更新引用：将原数组的引用指向新数组，使得新数组可以被访问。
以下是一个示例代码，演示了数组扩容的过程：
// 原数组
int[] originalArray = new int[5];
originalArray[0] = 1;
originalArray[1] = 2;
originalArray[2] = 3;
originalArray[3] = 4;
originalArray[4] = 5;
// 扩容数组
int newCapacity = originalArray.length * 2; // 扩容一倍
int[] newArray = new int[newCapacity];
// 复制原数组元素
for (int i = 0; i < originalArray.length; i++) {
newArray[i] = originalArray[i];
}
// 添加新元素
newArray[originalArray.length] = 6;
// 更新引用
originalArray = newArray;
在实际使用中，通常会使用更高级的数据结构，如ArrayList，来自动处理数组的扩容。ArrayList内部实际上就是使用了数组，并在需要扩容时自动进行了上述步骤。
10. 二维数组
在Java中，二维数组是一个数组的数组，也就是每个元素都是一个一维数组。二维数组在Java中主要用于存储表格数据、矩阵等二维结构化数据。以下是关于Java中二维数组的详细介绍：
-
声明二维数组
- 在Java中声明一个二维数组的语法如下：
type[][] arrayName; - 其中，type表示数组中元素的数据类型，arrayName是数组的名字。
- 例如，可以声明一个int类型的二维数组：
int[][] matrix;
- 在Java中声明一个二维数组的语法如下：
-
创建和初始化二维数组
- 可以使用new关键字来创建和初始化二维数组。
- 例如，创建一个2行3列的二维数组并初始化为全0：
int[][] matrix = new int[2][3]; - 也可以在声明时直接初始化二维数组：
int[][] matrix = {{1, 2, 3}, {4, 5, 6}};
-
获取二维数组的长度
- 二维数组的长度可以通过arrayName.length获取，表示二维数组中一维数组的个数。
- 每个一维数组的长度可以通过arrayName[i].length获取，表示第i个一维数组的长度。
- 例如，假设有一个名为arr的二维数组，我们可以通过以下方式获取它的行数和列数：
int rows = arr.length; // 获取行数 int cols = arr[0].length; // 获取列数，假设每一行的长度相同
-
访问二维数组元素
- 可以使用两个索引来访问二维数组中的元素。第一个索引表示行号，第二个索引表示列号。
- 例如，访问二维数组中第1行第2列的元素：
int element = matrix[0][1]; // 第1行第2列对应索引[0][1]
-
不规则二维数组
- Java中的二维数组也可以是不规则的，即每个一维数组的长度可以不同。
- 例如，可以声明一个不规则的二维数组：
int[][] irregularArray = new int[3][]; irregularArray[0] = new int[2]; irregularArray[1] = new int[3]; irregularArray[2] = new int[4];
-
遍历二维数组
- 可以使用嵌套的循环来遍历二维数组中的所有元素。
- 例如，逐行打印二维数组中的元素：
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(); }
以上是关于Java中二维数组的简要介绍。使用二维数组可以方便地存储和访问二维数据，可以进行各种操作，如查询、修改、计算等。在处理二维数据时，二维数组提供了一种简洁有效的数据结构。
11. 二维数组底层原理
Java中的二维数组是基于一维数组的实现，其底层原理与一维数组类似，主要是在内存中连续存储多个一维数组。
在内存中，二维数组被存储为一块连续的内存空间。二维数组的每个元素，实际上是指向了一片连续的内存空间，这片内存空间存储了一个一维数组。
需要注意的是，Java的二维数组的每个一维数组长度可以不同，也就是不规则的二维数组。这是因为每个一维数组对象都是独立分配的，可以有不同的长度。
12. 冒泡排序
冒泡排序(Bubble Sort)是一种简单的排序算法，它通过不断交换相邻元素的位置来将数组元素按照升序或降序排列。该算法重复地遍历数组，比较相邻的两个元素，如果它们的顺序错误，则交换它们的位置，直到整个数组排序完成。
下面是冒泡排序的详细步骤：
-
从数组的第一个元素开始，比较相邻的两个元素。如果第一个元素大于第二个元素，则交换它们的位置，使得较大的元素往后移动。
-
继续比较相邻的元素，依次进行上述的交换操作，直到遍历到倒数第二个元素。
-
重复以上步骤，每次遍历都比较并交换相邻元素的位置，直到整个数组排序完成。
-
每一次遍历后，最大的元素都会被移动到数组的末尾，因此，下一次遍历时可以减少一次对已排序的元素进行比较。
实现冒泡排序的Java代码如下所示：
public class BubbleSort {
public static void bubbleSort(int[] arr) {
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
// 交换相邻元素的位置
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
System.out.println("排序后的数组：");
for (int num : arr) {
System.out.print(num + " ");
}
}
}
输出结果为：
13. 顺序查找
顺序查找（Sequential Search），也称为线性查找，是一种简单直观的查找算法。它会按顺序从头到尾依次遍历给定的数据集合，直到找到目标元素或者遍历完整个集合为止。
下面是顺序查找的详细步骤：
-
从数据集合的第一个元素开始，将当前元素与目标元素进行比较。
-
如果当前元素等于目标元素，则查找成功，返回当前元素所在位置的索引。
-
如果当前元素不等于目标元素，则继续下一个元素。
-
重复以上步骤，直到遍历完整个数据集合或者找到目标元素为止。
顺序查找的实现非常简单，可以使用循环来遍历数据集合，并进行元素的比较。如果找到目标元素，则返回其索引；如果遍历完整个数据集合仍未找到目标元素，则返回-1表示查找失败。
以下是用Java语言实现顺序查找的示例代码：
public class SequentialSearch {
public static int sequentialSearch(int[] arr, int target) {
int n = arr.length;
for (int i = 0; i < n; i++) {
if (arr[i] == target) {
return i; // 找到目标元素，返回索引
}
}
return -1; // 遍历完整个数据集合仍未找到目标元素，返回-1
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
int target = 22;
int index = sequentialSearch(arr, target);
if (index != -1) {
System.out.println("目标元素 " + target + " 位于索引 " + index);
} else {
System.out.println("目标元素 " + target + " 不存在");
}
}
}
输出结果为：
840
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
