Java 入门：IDEA 高效调试与数组

静态初始化（指定内容）

// 完整写法
int[] arr1 = new int[]{1,2,3,4,5}; 
// 简写（推荐）
int[] arr2 = {1,2,3,4,5}; 

⚠️ 注意：

• 简写形式不能拆分两行写
• 下标范围：[0, length)，越界抛 ArrayIndexOutOfBoundsException

3. 数组遍历：3 种写法

1. 普通 for 循环（可修改元素）

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

2. for-each 循环（只读更简洁）

for (int num : arr) {
    System.out.println(num);
}

3. Arrays.toString（快速打印）

System.out.println(Arrays.toString(arr));

4. 关键：数组是引用类型

• 基本类型：变量存值
• 引用类型：变量存堆内存地址
• arr1 = arr2 是指向同一块内存，不是拷贝

int[] a = {1,2,3};
int[] b = a;
b[0] = 100; // a[0] 也会变成 100

• null：空引用，访问会抛 NullPointerException

5. 数组作为方法参数 / 返回值

• 传基本类型：值传递，不影响原变量
• 传数组：引用传递，方法内修改会影响原数组
• 数组可直接作为返回值，返回一组数据

6. 数组常用工具方法（java.util.Arrays）

• Arrays.toString(arr)：数组转字符串
• Arrays.copyOf(arr, len)：数组拷贝（新对象）
• Arrays.copyOfRange(arr, from, to)：范围拷贝
• Arrays.sort(arr)：高效排序
• Arrays.binarySearch(arr, key)：有序数组二分查找

import java.util.Arrays;

/**
 * Arrays.binarySearch()：二分查找
 * 前提：数组必须是升序排序后的！
 * 特点：
 * 1. 找到：返回元素下标
 * 2. 未找到：返回 -(插入点) - 1
 * 3. 有重复元素：返回任意一个匹配下标（不保证是第一个）
 */
public class ArraysBinarySearchDemo {
    public static void main(String[] args) {
        int[] sortedArr = {1, 2, 3, 5, 7, 9, 10}; // 必须先排序！
        System.out.println("有序数组：" + Arrays.toString(sortedArr));

        // 场景 1：查找存在的元素
        int key1 = 7;
        int index1 = Arrays.binarySearch(sortedArr, key1);
        System.out.println("查找" + key1 + "：下标=" + index1);

        // 场景 2：查找不存在的元素
        int key2 = 4;
        int index2 = Arrays.binarySearch(sortedArr, key2);
        System.out.println("查找" + key2 + "：返回值=" + index2 + "（插入点是 3，-(3)-1=-4）");

        // 场景 3：查找超出范围的元素
        int key3 = 11;
        int index3 = Arrays.binarySearch(sortedArr, key3);
        System.out.println("查找" + key3 + "：返回值=" + index3 + "（插入点是 7，-(7)-1=-8）");

        // 错误示例：未排序数组查找（结果不可靠）
        int[] unsortedArr = {5, 2, 9};
        int index4 = Arrays.binarySearch(unsortedArr, 2);
        System.out.println("\n未排序数组查找 2：" + index4 + "（结果错误，不可信）");
    }
}
/*
结果：
有序数组：[1, 2, 3, 5, 7, 9, 10]
查找 7：下标=4
查找 4：返回值=-4（插入点是 3，-(3)-1=-4）
查找 11：返回值=-8（插入点是 7，-(7)-1=-8）
未排序数组查找 2：-1（结果错误，不可信）
*/

import java.util.Arrays;

/**
 * Arrays.sort()：数组排序
 * 特点：
 * 1. 基本类型数组：快速排序/双轴快排，效率高
 * 2. 直接修改原数组（原地排序）
 * 3. 字符串数组：按 Unicode 编码升序（字母 A-Z 对应升序）
 */
public class ArraysSortDemo {
    public static void main(String[] args) {
        // 场景 1：int 数组升序排序
        int[] intArr = {5, 2, 9, 1, 5, 6};
        System.out.println("排序前 int 数组：" + Arrays.toString(intArr));
        Arrays.sort(intArr);
        System.out.println("排序后 int 数组：" + Arrays.toString(intArr));

        // 场景 2：字符串数组排序
        String[] strArr = {"Java", "Python", "C", "JavaScript"};
        System.out.println("\n排序前字符串数组：" + Arrays.toString(strArr));
        Arrays.sort(strArr);
        System.out.println("排序后字符串数组：" + Arrays.toString(strArr));

        // 场景 3：指定范围排序（sort(arr, from, to)：左闭右开）
        int[] rangeArr = {10, 5, 8, 2, 7, 1};
        System.out.println("\n排序前范围数组：" + Arrays.toString(rangeArr));
        Arrays.sort(rangeArr, 1, 5); // 只排序下标 1 到 4 的元素
        System.out.println("排序 [1,5) 后：" + Arrays.toString(rangeArr));
    }
}
/*
结果：
排序前 int 数组：[5, 2, 9, 1, 5, 6]
排序后 int 数组：[1, 2, 5, 5, 6, 9]
排序前字符串数组：[Java, Python, C, JavaScript]
排序后字符串数组：[C, Java, JavaScript, Python]
排序前范围数组：[10, 5, 8, 2, 7, 1]
排序 [1,5) 后：[10, 2, 5, 7, 8, 1]
*/

import java.util.Arrays;

/**
 * Arrays.copyOfRange()：范围拷贝
 * 特点：
 * 1. 左闭右开：[from, to)
 * 2. from = 0 且 to = 原长度 → 等价于 copyOf
 * 3. 下标越界会抛 ArrayIndexOutOfBoundsException
 */
public class ArraysCopyOfRangeDemo {
    public static void main(String[] args) {
        String[] originalArr = {"A", "B", "C", "D", "E", "F"};
        System.out.println("原数组：" + Arrays.toString(originalArr));

        // 场景 1：拷贝中间范围（下标 1 到 4，包含 1，不包含 4）
        String[] range1 = Arrays.copyOfRange(originalArr, 1, 4);
        System.out.println("拷贝 [1,4)：" + Arrays.toString(range1)); // [B, C, D]

        // 场景 2：拷贝从 0 到末尾（完整拷贝）
        String[] range2 = Arrays.copyOfRange(originalArr, 0, originalArr.length);
        System.out.println("拷贝完整数组：" + Arrays.toString(range2));

        // 场景 3：拷贝到超出原长度（补默认值 null）
        String[] range3 = Arrays.copyOfRange(originalArr, 3, 8);
        System.out.println("拷贝 [3,8)（补 null）：" + Arrays.toString(range3));
    }
}
/*
结果：
原数组：[A, B, C, D, E, F]
拷贝 [1,4)：[B, C, D]
拷贝完整数组：[A, B, C, D, E, F]
拷贝 [3,8)（补 null）：[D, E, F, null, null]
*/

import java.util.Arrays;

/**
 * Arrays.copyOf()：数组拷贝
 * 特点：
 * 1. 返回新数组，原数组不受影响（深拷贝）
 * 2. len < 原长度：截取前 len 个元素
 * 3. len > 原长度：补默认值（int 补 0，String 补 null）
 */
public class ArraysCopyOfDemo {
    public static void main(String[] args) {
        int[] originalArr = {10, 20, 30, 40, 50};
        System.out.println("原数组：" + Arrays.toString(originalArr));

        // 场景 1：拷贝长度 = 原长度（完整拷贝）
        int[] copyFull = Arrays.copyOf(originalArr, originalArr.length);
        System.out.println("完整拷贝：" + Arrays.toString(copyFull));

        // 场景 2：拷贝长度 < 原长度（截取）
        int[] copyShort = Arrays.copyOf(originalArr, 3);
        System.out.println("截取前 3 个元素：" + Arrays.toString(copyShort));

        // 场景 3：拷贝长度 > 原长度（补默认值）
        int[] copyLong = Arrays.copyOf(originalArr, 7);
        System.out.println("补 0 到 7 个元素：" + Arrays.toString(copyLong));

        // 验证：修改新数组，原数组不变
        copyFull[0] = 999;
        System.out.println("修改后新数组：" + Arrays.toString(copyFull));
        System.out.println("原数组仍不变：" + Arrays.toString(originalArr));
    }
}
/*
结果：
原数组：[10, 20, 30, 40, 50]
完整拷贝：[10, 20, 30, 40, 50]
截取前 3 个元素：[10, 20, 30]
补 0 到 7 个元素：[10, 20, 30, 40, 50, 0, 0]
修改后新数组：[999, 20, 30, 40, 50]
原数组仍不变：[10, 20, 30, 40, 50]
*/

import java.util.Arrays;

/**
 * Arrays.toString()：数组转字符串
 * 特点：
 * 1. 一维数组直接输出易读格式
 * 2. 多维数组需用 Arrays.deepToString()
 * 3. 空数组输出 []
 */
public class ArraysToStringDemo {
    public static void main(String[] args) {
        // 测试 1：普通 int 数组
        int[] intArr = {1, 2, 3, 4, 5};
        System.out.println("int 数组转字符串：" + Arrays.toString(intArr));

        // 测试 2：字符串数组
        String[] strArr = {"Java", "数组", "工具类"};
        System.out.println("字符串数组转字符串：" + Arrays.toString(strArr));

        // 测试 3：空数组
        int[] emptyArr = new int[0];
        System.out.println("空数组转字符串：" + Arrays.toString(emptyArr));

        // 测试 4：多维数组（注意：一维 toString 不适用，需用 deepToString）
        int[][] multiArr = {{1,2}, {3,4}};
        System.out.println("多维数组用 toString：" + Arrays.toString(multiArr)); // 输出地址
        System.out.println("多维数组用 deepToString：" + Arrays.deepToString(multiArr)); // 正确输出
    }
}
/*
结果：
int 数组转字符串：[1, 2, 3, 4, 5]
字符串数组转字符串：[Java, 数组，工具类]
空数组转字符串：[]
多维数组用 toString：[[I@7852e922, [I@4e25154f]
多维数组用 deepToString：[[1, 2], [3, 4]]
*/

7. 经典算法手写（面试常考）

• 顺序查找
• 二分查找（有序数组）
• 数组逆序
• 自定义数组拷贝

/**
 * 自定义数组拷贝
 * 核心：创建新数组，遍历原数组，逐个复制元素到新数组
 * 对比 JDK 自带的 Arrays.copyOf：逻辑一致，帮你理解底层原理
 */
public class CustomArrayCopy {
    public static void main(String[] args) {
        // 测试数组
        int[] originalArr = {8, 3, 9, 7, 2, 5, 1, 6, 4};
        System.out.println("原数组：" + Arrays.toString(originalArr));

        // 调用自定义拷贝方法
        int[] copyArr = customCopyOf(originalArr, originalArr.length);
        System.out.println("拷贝数组：" + Arrays.toString(copyArr));

        // 验证：修改拷贝数组，原数组不受影响（证明是深拷贝）
        copyArr[0] = 100;
        System.out.println("修改后拷贝数组：" + Arrays.toString(copyArr));
        System.out.println("修改后原数组：" + Arrays.toString(originalArr));
    }

    /**
     * 自定义数组拷贝方法
     * @param original 原数组
     * @param newLength 新数组长度（可大于/小于原数组长度）
     * @return 新的拷贝数组
     */
    public static int[] customCopyOf(int[] original, int newLength) {
        // 健壮性处理：原数组为空
        if (original == null) {
            return null;
        }
        // 1. 创建新数组（指定长度）
        int[] newArr = new int[newLength];
        // 2. 确定要拷贝的元素个数（取原数组长度和新长度的较小值）
        int copyLength = Math.min(original.length, newLength);
        // 3. 遍历原数组，逐个复制到新数组
        for (int i = 0; i < copyLength; i++) {
            newArr[i] = original[i];
        }
        // 4. 返回新数组（如果新长度 > 原长度，多余位置默认值为 0）
        return newArr;
    }
}

/**
 * 数组逆序
 * 核心：双指针法，首尾元素交换，直到指针相遇
 * 优点：时间复杂度 O(n)，空间复杂度 O(1)（原地逆序，不额外占用空间）
 */
public class ReverseArray {
    public static void main(String[] args) {
        // 测试数组
        int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println("逆序前：" + Arrays.toString(arr));

        // 调用逆序方法
        reverseArray(arr);

        // 输出结果
        System.out.println("逆序后：" + Arrays.toString(arr));
    }

    /**
     * 数组逆序核心方法（原地逆序，直接修改原数组）
     * @param arr 待逆序的数组
     */
    public static void reverseArray(int[] arr) {
        // 健壮性处理
        if (arr == null || arr.length <= 1) {
            return; // 空数组/只有 1 个元素，无需逆序
        }
        // 定义首尾指针
        int left = 0;
        int right = arr.length - 1;
        // 循环交换：左指针 < 右指针时交换
        while (left < right) {
            // 交换首尾元素
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            // 左指针右移，右指针左移
            left++;
            right--;
        }
    }
}

冒泡排序

/**
 * 冒泡排序
 * 核心：相邻元素两两比较，大的元素逐步'冒泡'到数组末尾
 * 优化：如果某一轮没有交换，说明数组已有序，直接退出（减少循环次数）
 * 时间复杂度：最坏 O(n²)，最好 O(n)（已排序数组）
 */
public class BubbleSort {
    public static void main(String[] args) {
        // 测试数组
        int[] arr = {8, 3, 9, 7, 2, 5, 1, 6, 4};
        System.out.println("排序前：" + Arrays.toString(arr));

        // 调用冒泡排序方法
        bubbleSort(arr);

        // 输出结果
        System.out.println("排序后：" + Arrays.toString(arr));
    }

    /**
     * 冒泡排序核心方法（升序）
     * @param arr 待排序的数组（直接修改原数组）
     */
    public static void bubbleSort(int[] arr) {
        // 健壮性处理
        if (arr == null || arr.length <= 1) {
            return; // 空数组/只有 1 个元素，无需排序
        }
        int length = arr.length;
        // 外层循环：控制排序轮数（最多 length-1 轮）
        for (int i = 0; i < length - 1; i++) {
            // 标记：本轮是否发生交换
            boolean swapped = false;
            // 内层循环：每轮比较到 length-1-i 位置（后 i 个元素已排好序）
            for (int j = 0; j < length - 1 - i; j++) {
                // 相邻元素比较，前 > 后则交换（升序）
                if (arr[j] > arr[j + 1]) {
                    // 交换两个元素
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                    // 标记发生了交换
                    swapped = true;
                }
            }
            // 优化：本轮无交换，说明数组已有序，直接退出循环
            if (!swapped) {
                break;
            }
        }
    }
}

/**
 * 二分查找（折半查找）
 * 核心：利用有序数组特性，每次排除一半元素，效率高（时间复杂度 O(log₂n)）
 * 前提：数组必须是有序的（升序/降序，代码需对应调整）
 */
public class BinarySearch {
    public static void main(String[] args) {
        // 测试数组（必须是有序数组，这里用升序）
        int[] sortedArr = {1, 2, 3, 4, 5, 6, 7, 8, 9};
        int target = 5;

        // 调用二分查找方法
        int index = binarySearch(sortedArr, target);

        // 输出结果
        if (index != -1) {
            System.out.println("找到目标值 " + target + "，下标为：" + index);
        } else {
            System.out.println("未找到目标值 " + target);
        }
    }

    /**
     * 二分查找核心方法（升序数组）
     * @param sortedArr 有序数组（升序）
     * @param target 要找的目标值
     * @return 找到返回下标，未找到返回 -1
     */
    public static int binarySearch(int[] sortedArr, int target) {
        // 健壮性处理
        if (sortedArr == null || sortedArr.length == 0) {
            return -1;
        }
        // 定义左右指针
        int left = 0;
        int right = sortedArr.length - 1;
        // 循环条件：左指针 <= 右指针（注意是 <=，否则会漏查最后一个元素）
        while (left <= right) {
            // 计算中间下标（避免溢出：等价于 (left + right) / 2，但更安全）
            int mid = left + (right - left) / 2;
            if (sortedArr[mid] == target) {
                return mid; // 找到目标，返回下标
            } else if (sortedArr[mid] < target) {
                // 目标在右半部分，左指针右移
                left = mid + 1;
            } else {
                // 目标在左半部分，右指针左移
                right = mid - 1;
            }
        }
        // 循环结束仍未找到，返回 -1
        return -1;
    }
}

/**
 * 顺序查找（线性查找）
 * 核心：逐个遍历、逐一比较，找到返回下标，未找到返回 -1
 * 适用：无序/有序数组都能查，优点是简单，缺点是效率低（时间复杂度 O(n)）
 */
public class SequentialSearch {
    public static void main(String[] args) {
        // 测试数组（无序也能查）
        int[] arr = {8, 3, 9, 7, 2, 5, 1, 6, 4};
        int target = 7;

        // 调用查找方法
        int index = sequentialSearch(arr, target);

        // 输出结果
        if (index != -1) {
            System.out.println("找到目标值 " + target + "，下标为：" + index);
        } else {
            System.out.println("未找到目标值 " + target);
        }
    }

    /**
     * 顺序查找核心方法
     * @param arr 待查找的数组
     * @param target 要找的目标值
     * @return 找到返回下标，未找到返回 -1
     */
    public static int sequentialSearch(int[] arr, int target) {
        // 健壮性处理：数组为空/长度为 0，直接返回 -1
        if (arr == null || arr.length == 0) {
            return -1;
        }
        // 遍历数组，逐个比较
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) {
                return i; // 找到立即返回下标，无需继续遍历
            }
        }
        // 遍历完都没找到，返回 -1
        return -1;
    }
}

8. 二维数组

本质：数组的数组

int[][] arr = {{1,2},{3,4},{5,6}};
// 遍历
for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.print(arr[i][j] + " ");
    }
    System.out.println();
}

四、调试 + 数组：实战组合技巧

1. 遍历数组时用条件断点，只看目标元素
2. 调试面板直接查看数组每一位的值
3. 下标越界时，用调试看循环边界是否正确
4. 引用传递问题：在面板看地址是否相同

五、总结

• 调试是程序员的基本功，IDEA 快捷键用熟效率翻倍
• 数组是数据结构基石，连续内存、引用类型、下标 0 起步
• 先会调试排错，再扎实掌握数组，Java 基础才算稳