Java基于数组的专项实验

最新推荐文章于 2025-07-30 14:04:28 发布

原创最新推荐文章于 2025-07-30 14:04:28 发布 · 329 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #深度学习

实验一：数组基础操作

目标：掌握数组的声明、初始化、遍历及基本操作。

public class ArrayBasicExperiment {

public static void main(String[] args) {

// 1. 数组声明与初始化

int[] nums1 = new int[5]; // 动态初始化（指定长度）

String[] names = {"Alice", "Bob", "Charlie"}; // 静态初始化

// 2. 赋值与访问

nums1[0] = 10;

nums1[1] = 20;

System.out.println("nums1[0] = " + nums1[0]); // 输出：10

// 3. 遍历数组

// 传统for循环

System.out.println("传统遍历：");

for (int i = 0; i < names.length; i++) {

System.out.println(names[i]);

}

// 增强for循环（foreach）

System.out.println("foreach遍历：");

for (String name : names) {

System.out.println(name);

}

// 4. 数组复制

int[] nums2 = new int[3];

System.arraycopy(nums1, 0, nums2, 0, 3); // 从nums1复制前3个元素到nums2

System.out.println("复制后nums2[0] = " + nums2[0]); // 输出：10

}

关键点：

- 数组长度固定，声明时需指定类型（如 int[] ）和长度（动态初始化）或直接赋值（静态初始化）。

- 通过数组名.length 获取长度，下标从0开始。

实验二：多维数组与矩阵操作

目标：实现二维数组（矩阵）的创建、遍历及运算。

public class MultiDimensionArrayExperiment {

public static void main(String[] args) {

// 1. 创建二维数组（3x3矩阵）

int[][] matrix = {

{1, 2, 3},

{4, 5, 6},

{7, 8, 9}

};

// 2. 遍历二维数组（行列遍历）

System.out.println("矩阵原始数据：");

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();

}

// 3. 矩阵转置（行列互换）

int[][] transpose = new int[3][3];

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 3; j++) {

transpose[i][j] = matrix[j][i];

}

System.out.println("矩阵转置后：");

for (int[] row : transpose) {

for (int num : row) {

System.out.print(num + " ");

}

System.out.println();

}

// 4. 不规则二维数组（每行长度不同）

int[][] irregularArray = new int[3][];

irregularArray[0] = new int[2];

irregularArray[1] = new int[3];

irregularArray[2] = new int[1];

// 赋值与遍历略

}

关键点：

- 二维数组本质是“数组的数组”，每行长度可不同（不规则数组）。

- 矩阵运算需注意维度匹配（如转置、加法、乘法）。

实验三：数组排序与搜索算法

目标：实现常见排序和搜索算法，理解数组在算法中的应用。

import java.util.Arrays;

public class ArrayAlgorithmExperiment {

public static void main(String[] args) {

int[] nums = {5, 3, 8, 4, 2, 1, 7, 6};

// 1. 冒泡排序（升序）

bubbleSort(nums.clone()); // 克隆数组避免修改原数据

// 2. 快速排序（Java内置）

int[] nums2 = nums.clone();

Arrays.sort(nums2);

System.out.println("Arrays.sort排序结果：" + Arrays.toString(nums2));

// 3. 二分查找（需先排序）

int target = 4;

int index = Arrays.binarySearch(nums2, target);

System.out.println("二分查找 " + target + " 的索引：" + index);

}

// 冒泡排序实现

private static void bubbleSort(int[] arr) {

long startTime = System.currentTimeMillis();

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;

}

long endTime = System.currentTimeMillis();

System.out.println("冒泡排序结果：" + Arrays.toString(arr));

System.out.println("冒泡排序耗时：" + (endTime - startTime) + "ms");

}

关键点：

- 排序算法：冒泡排序（O(n²)）、快速排序（O(n log n)，Java内置 Arrays.sort ）。

- 搜索算法：二分查找（O(log n)，需数组有序）。

实验四：数组与集合的转换

目标：掌握数组与Java集合（如ArrayList）的相互转换。

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class ArrayCollectionConversionExperiment {

public static void main(String[] args) {

// 1. 数组转集合

String[] fruits = {"苹果", "香蕉", "橙子"};

List<String> fruitList = Arrays.asList(fruits); // 转换为固定长度列表

System.out.println("数组转集合：" + fruitList);

// 注意：Arrays.asList返回的列表不支持add/remove操作

// fruitList.add("葡萄"); // 会抛出UnsupportedOperationException

// 2. 集合转数组

List<Integer> numList = new ArrayList<>();

numList.add(1);

numList.add(2);

numList.add(3);

// 转换为Integer数组

Integer[] numArray1 = numList.toArray(new Integer[0]);

// 转换为int数组（需手动遍历）

int[] numArray2 = new int[numList.size()];

for (int i = 0; i < numList.size(); i++) {

numArray2[i] = numList.get(i);

}

System.out.println("集合转Integer数组：" + Arrays.toString(numArray1));

System.out.println("集合转int数组：" + Arrays.toString(numArray2));

// 3. 基本类型数组与包装类型集合的转换（使用Stream）

int[] primitiveArray = {10, 20, 30};

List<Integer> wrapperList = Arrays.stream(primitiveArray)

.boxed() // 基本类型装箱为Integer

.collect(Collectors.toList());

System.out.println("基本类型数组转包装集合：" + wrapperList);

}

关键点：

- Arrays.asList() 将数组转为固定长度列表，不支持增删操作。

- 集合转基本类型数组需手动遍历或使用Stream API（Java 8+）。

实验五：数组应用场景实战

目标：用数组实现简单数据结构（如栈、队列），理解数组的底层应用。

public class ArrayDataStructureExperiment {

// 1. 数组实现栈（后进先出）

static class ArrayStack {

private int[] data;

private int top; // 栈顶指针

public ArrayStack(int capacity) {

data = new int[capacity];

top = -1;

}

// 入栈

public void push(int element) {

if (top >= data.length - 1) {

System.out.println("栈已满，无法入栈");

return;

}

data[++top] = element;

}

// 出栈

public int pop() {

if (top < 0) {

System.out.println("栈为空，无法出栈");

return -1;

}

return data[top--];

}

// 查看栈顶元素

public int peek() {

if (top < 0) {

System.out.println("栈为空");

return -1;

}

return data[top];

}

// 判断栈是否为空

public boolean isEmpty() {

return top == -1;

}

public static void main(String[] args) {

// 测试栈

ArrayStack stack = new ArrayStack(5);

stack.push(10);

stack.push(20);

stack.push(30);

System.out.println("栈顶元素：" + stack.peek()); // 输出：30

System.out.println("出栈元素：" + stack.pop()); // 输出：30

System.out.println("栈是否为空：" + stack.isEmpty()); // 输出：false

// 2. 数组实现队列（先进先出，简化版）

// 提示：可通过头指针和尾指针实现，或使用循环数组优化空间利用率

}

关键点：

- 数组实现栈：通过指针 top 跟踪栈顶，入栈和出栈时间复杂度均为O(1)。

- 数组实现队列：需处理“假溢出”问题（如使用循环数组或移动元素）。

实验总结：数组的优缺点与适用场景

1. 优点：

- 访问速度快（随机访问时间复杂度O(1)）；

- 内存连续分配，适合存储同类型数据。

2. 缺点：

- 长度固定，无法动态扩容；

- 插入/删除元素需移动大量数据（时间复杂度O(n)）。

3. 适用场景：

- 需频繁随机访问数据（如数组排序、矩阵运算）；

- 实现基础数据结构（栈、队列、哈希表底层数组）；

- 与原生数据交互（如Java Native Interface, JNI）。