在IDEA中使用JUnit（入门）

在IDE中使用JUnit

目录

• 在IDE中使用JUnit
  • 1.JUnit简介
  • 2.待测试代码
  • 3.在IDEA中使用JUnit测试
  • 4.在IDEA的Maven项目中使用JUnit测试
    • 第一步：在 pom.xml 中添加 JUnit 6 依赖
    • 第二步：确认测试目录
    • 第三步：创建测试类
    • 第四步：编写测试代码（加上断言）
    • 第五步：故意制造一次失败，看看断言的效果
    • 第六步：运行测试

说明：本文第1、4节以AI生成的内容为框架，并在自己的计算机上进行实际测试与验证，最终成稿。

1.JUnit简介

JUnit 是 Java 里最常用的单元测试框架。简单说，它让你不用写 main 方法、不用手动 System.out.println 看结果，就能把一段代码单独拿出来跑一遍，并且清楚地告诉你它是“通过”还是“失败”。

在 IDEA 里，只要方法上加了 JUnit 的注解，左边就会出现绿色箭头，点一下就能运行，运行结果会显示在 Run 面板里。如果方法里抛出异常或者断言不成立，这个测试就会被标成红色失败；一切正常则是绿色通过。

写测试时最常用的几个注解：

• @Test：标记一个方法是测试方法，JUnit 会自动调用它。你前面写的 sort() 和 arraysSort() 用的就是这个。
• @BeforeEach：在每个 @Test 方法之前执行一次，常用来准备测试数据。
• @AfterEach：在每个 @Test 方法之后执行一次，常用来清理资源。
• @BeforeAll / @AfterAll：在整个测试类的所有方法开始前/结束后各执行一次，方法必须是 static。你之前把大数组的生成和 clone() 放在静态初始化块里，思路类似，只是这两个注解更“正式”一些。
• @Disabled：暂时跳过某个测试方法，适合还没写完或者暂时不想跑的用例。

配合注解使用的还有断言，比如 assertEquals、assertArrayEquals、assertTrue 等（来自 org.junit.jupiter.api.Assertions）。它们用来判断“实际结果”和“期望结果”是否一致——如果一致，测试通过；不一致，测试失败并给出提示。如果测试时没有加断言，所以运行结果不对，测试也会显示通过。

截至2026年：最新的JUnit版本为JUnit 6，你在你的IDE中使用Junit 5或6均可。
注意：JUnit 6要求Java 17及以上版本。

2.待测试代码

这里要测试的是一个简单自编的冒泡排序算法，代码如下：

package testDebug;

import java.util.Arrays;

public class MySort {
    public static void sort(int[] a) {
        for (int i = a.length; --i >= 0; ) {
            for (int j = 0; j < i; j++) {
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
            }
        }
    }
    public static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    public static void main(String[] args) {
        int[] intarray = {1, 2, 3, 7, 9, 0, 5, 4};
        // 测试1：测试排序算法
        long start = System.nanoTime();
        sort(intarray);
        long end = System.nanoTime();
        double seconds = (end - start) / 1_000_000_000.0;
        System.out.println("sort 耗时: " + seconds + " 秒");
        System.out.println(Arrays.toString(intarray));

        // 测试2：测试Arrays.sort方法
        start = System.nanoTime();
        Arrays.sort(intarray);
        end = System.nanoTime();
        seconds = (end - start) / 1_000_000_000.0;
        System.out.println("Arrays.sort 耗时: " + seconds + " 秒");
    }
}

上述代码中已有测试两个排序算法（自编的冒泡排序与Arrays.sort）运行速度的代码，可以直接在控制台输出两个排序算法的运行时间。

3.在IDEA中使用JUnit测试

针对如上MySort.java可以在IDEA中进行测试。

1. 点击要测试的类名，如MySort，按Alt + Enter，点击 Create Test，在Testing library 选择 JUnit5。详见下图

   • 如果提示 Junit5 library not found in the module ，点击Fix。IDE会自动下载相应的包并进行相关设置
   • 在 Class Name 中写入所要新建的用于测试的类名，这里是MySortTest，
   • 在 Destination package 中填入 所要新建的JUnit测试要放在哪个包中
   • 在 Member 中点选你要测试的方法名，如sort。
   • 

2. 打开 MySortTest.java，并编写相应的测试代码。

   • 如果提示有些类找不到的错误，可直接点击相应位置，然后按Alt + Enter进行修复
   • 测试代码如下，就是对一个大小为50000的随机生成的数组的两个副本分别进行排序：

package testDebug;

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Random;

class MySortTest {

    private static final int[] BIG_ARRAY = new int[50_000];

    // 两份副本在类加载时就准备好，clone 不计入任何测试的耗时
    private static final int[] MY_SORT_ARRAY;
    private static final int[] ARRAYS_SORT_ARRAY;

    static {
        Random random = new Random(42);
        for (int i = 0; i < BIG_ARRAY.length; i++) {
            BIG_ARRAY[i] = random.nextInt();
        }
        MY_SORT_ARRAY = BIG_ARRAY.clone();
        ARRAYS_SORT_ARRAY = BIG_ARRAY.clone();
    }
    @Test // 方法上加了 @Test，JUnit 就会在运行测试时自动调用它，不需要你写 main 方法手动调用
    void sort() {
        MySort.sort(MY_SORT_ARRAY);
    }

    @Test
    void arraysSort() {
        Arrays.sort(ARRAYS_SORT_ARRAY);
    }
}

3. 测试 MySortTest
   • 在编辑器点击 MySortTest ，按Alt + Enter，然后点击Run MySortTest 运行该类中的所有测试。
   • 也可以用同样的方法测试 MySortTest.java 中的上面使用@Test标注的方法，进行单方法测试。

说明：本例中仅对两个排序算法的实际运行时间进行比较。如果想要更进一步的测试，比如查看算法排序结果是否正确，可使用下一节提到的断言。

4.在IDEA的Maven项目中使用JUnit测试

前面的例子是在普通 Java 项目里直接跑测试的。如果你的项目是 Maven 项目，步骤会稍有不同——JUnit 不再让 IDEA 临时帮你下载，而是通过 pom.xml 声明依赖，由 Maven 统一管理。这里用 JUnit 6，它要求 Java 17 或更高版本。

第一步：在 pom.xml 中添加 JUnit 6 依赖

新建一个Maven项目，打开项目根目录下的 pom.xml，在 <dependencies> 里加入：

<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter</artifactId>
    <version>6.0.3</version>
    <scope>test</scope>
</dependency>

6.0.3 是当前可用的 JUnit 6 稳定版本。<scope>test</scope> 表示只在测试代码里可见，不会被打进最终程序包。

。

加完后，点击 IDEA 右侧 Maven 面板顶部的 “Sync All Maven Projects” 图标（通常是一个带圆形箭头的刷新按钮），让 IDEA 重新导入依赖。如果 Sync 后问题依旧，可以再尝试旁边的 “Reload All Maven Projects”（两个箭头循环的图标）来彻底重建项目模型。

第二步：确认测试目录

Maven 项目的标准目录结构是：

src/main/java   ← 生产代码
src/test/java   ← 测试代码

在项目视图里，src/test/java 应该显示为绿色的 Test Sources Root。如果不是，右键该目录 → Mark Directory as → Test Sources Root。

第三步：创建测试类

光标放在 MySort 类名上，按 Alt + Enter → Create Test。Testing library 下拉框里如果没有 JUnit 6 选项，选 JUnit 5 即可——因为 Maven 已经在 pom.xml 里指定了 JUnit 6 的依赖，IDEA 实际运行时会使用 Maven 管理的版本。类名填 MySortTest，包名保持 testDebug。如下图所示：

第四步：编写测试代码（加上断言）

JUnit 6 的 Jupiter 模型和 JUnit 5 基本一致，核心注解和断言方法都没变，你之前写的测试代码可以直接用。下面在保留耗时对比的同时，加入断言来验证排序结果：

package testDebug;

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.Random;

import static org.junit.jupiter.api.Assertions.*;

class MySortTest {

    private static final int[] BIG_ARRAY = new int[50_000];

    // 两份待测试的副本
    private static final int[] MY_SORT_ARRAY;
    private static final int[] ARRAYS_SORT_ARRAY;

    // 提前准备好的“标准答案”数组（已排序）
    private static final int[] EXPECTED_SORTED_ARRAY;

    static {
        Random random = new Random(42);
        for (int i = 0; i < BIG_ARRAY.length; i++) {
            BIG_ARRAY[i] = random.nextInt();
        }

        // 为测试方法准备副本
        MY_SORT_ARRAY = BIG_ARRAY.clone();
        ARRAYS_SORT_ARRAY = BIG_ARRAY.clone();

        // 准备标准答案：复制一份原始乱序数组，直接排好序
        EXPECTED_SORTED_ARRAY = BIG_ARRAY.clone();
        Arrays.sort(EXPECTED_SORTED_ARRAY);
    }

    @Test
    void sort() {
        MySort.sort(MY_SORT_ARRAY);
        // 断言：自编的冒泡排序结果，必须与标准答案一致
        assertArrayEquals(EXPECTED_SORTED_ARRAY, MY_SORT_ARRAY);
    }

    @Test
    void arraysSort() {
        Arrays.sort(ARRAYS_SORT_ARRAY);
        // 断言：Arrays.sort 的结果，也必须与标准答案一致
        assertArrayEquals(EXPECTED_SORTED_ARRAY, ARRAYS_SORT_ARRAY);
        // 断言2（备用）：也可以使用 assertTrue 循环遍历，验证结果是非递减的
        // 讲解 assertTrue 时可以取消注释，体验它的效果
        /*
        for (int i = 1; i < ARRAYS_SORT_ARRAY.length; i++) {
            assertTrue(ARRAYS_SORT_ARRAY[i - 1] <= ARRAYS_SORT_ARRAY[i]);
        }
        */
    }
}

两个最常用的断言：

• assertArrayEquals(expected, actual)：比较两个数组内容是否完全一致。expected 传 ARRAYS_SORT_ARRAY.clone()，避免因测试执行顺序不同导致 ARRAYS_SORT_ARRAY 已被原地排序而比对出错。
• assertTrue(condition)：条件为真则通过。这里检查相邻元素是否满足非递减关系。

第五步：故意制造一次失败，看看断言的效果

临时把 sort() 里的断言改成错误期望：

assertArrayEquals(BIG_ARRAY, MY_SORT_ARRAY); // 故意写错：拿原始乱序数组去比

再运行一次，测试会变红，Run 面板会显示类似 array contents differ at index [0] 的提示，告诉你从哪个位置开始不一致。

看完后记得把断言改回正确版本。

第六步：运行测试

点击 MySortTest 类名，按 Alt + Enter → Run MySortTest 跑整个类；也可以点某个 @Test 方法左边的绿色箭头只跑那一个。IDEA 会在 Run 面板里列出每个测试方法的耗时和通过状态。

Maven 项目还有一个额外好处：你也可以在终端（IDEA中的终端或Windows的命令行下均可）项目的根目录下执行 mvn test，让 Maven 跑完所有测试并生成报告，不依赖 IDEA。如下图所示：