能否利用数组或集合精简嵌套大量if/else的Java冗长代码？

问题描述 #

我编写了一段嵌套多层if/else语句的Java代码，它可正常编译运行并满足需求，但当前仅为最终版本的约1/12，代码过于冗长，维护难度极大，希望能找到精简方案。

原代码 #

package randomlist;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
    
public class Randomlist {

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub

        Random generate = new Random();
           String[] name = {"A", "B", "C", "D"};
           String nesting =(name[generate.nextInt(4)]);
           
           if ("A".equals(nesting)) {
               System.out.println("A");
               Random generate1 = new Random();
               String[] name1 = {"R", "E", "M"};
               String nesting1 =(name1[generate1.nextInt(3)]);
               Thread.sleep(1000);
               if ("R".equals(nesting1)) {
                   System.out.println("R"); }
               else
                   if ("E".equals(nesting1)) {
                   System.out.println("E");}
                   else
                   if ("M".equals(nesting1)) {
                       System.out.println("M");}}
           if ("B".equals(nesting)) {
               System.out.println("B");
               Random generate1 = new Random();
               String[] name1 = {"R", "E", "M"};
               String nesting1 =(name1[generate1.nextInt(3)]);
               Thread.sleep(1000);
               if ("R".equals(nesting1)) {
                   System.out.println("R"); }
               else
                   if ("E".equals(nesting1)) {
                   System.out.println("E");}
                   else
                   if ("M".equals(nesting1)) {
                       System.out.println("M");}}
           if ("C".equals(nesting)) {
               System.out.println("C");
               Random generate1 = new Random();
               String[] name1 = {"R", "E", "M"}; // 修复原代码语法错误：多了一层大括号
               String nesting1 =(name1[generate1.nextInt(3)]);
               Thread.sleep(1000);
               if ("R".equals(nesting1)) {
                   System.out.println("R"); }
               else
                   if ("E".equals(nesting1)) {
                   System.out.println("E");}
                   else
                   if ("M".equals(nesting1)) {
                       System.out.println("M");}}
           if ("D".equals(nesting)) {
               System.out.println("D");
               Random generate1 = new Random();
               String[] name1 = {"R", "E", "M"}; // 修复原代码语法错误：多了一层大括号
               String nesting1 =(name1[generate1.nextInt(3)]);
               Thread.sleep(1000);
               if ("R".equals(nesting1)) {
                   System.out.println("R"); }
               else
                   if ("E".equals(nesting1)) {
                   System.out.println("E");}
                   else
                   if ("M".equals(nesting1)) {
                       System.out.println("M");}}
           }}

精简方案 #

核心思路是抽离重复逻辑、复用资源、去除冗余判断，优化后的代码如下：

package randomlist;
import java.util.Random;

public class Randomlist {
    // 复用同一个Random实例，避免重复创建
    private static final Random RANDOM = new Random();
    // 定义固定的子选项数组
    private static final String[] SUB_OPTIONS = {"R", "E", "M"};

    public static void main(String[] args) throws InterruptedException {
        String[] mainOptions = {"A", "B", "C", "D"};
        // 随机选中主选项
        String selectedMain = mainOptions[RANDOM.nextInt(mainOptions.length)];
        System.out.println(selectedMain);
        
        // 执行子选项逻辑，抽成独立方法
        printRandomSubOption();
    }

    private static void printRandomSubOption() throws InterruptedException {
        Thread.sleep(1000);
        // 随机选中子选项并直接打印，无需if/else判断
        String selectedSub = SUB_OPTIONS[RANDOM.nextInt(SUB_OPTIONS.length)];
        System.out.println(selectedSub);
    }
}

优化说明 #

1. 复用Random实例：无需每次生成随机数都创建新的Random对象，静态常量实例全局复用更高效。
2. 抽离重复方法：将打印子选项的逻辑独立成printRandomSubOption方法，原代码中重复4次的逻辑只需调用一次，后续扩展主选项时无需重复编写子逻辑。
3. 去除冗余判断：不管选中哪个主选项，子选项的逻辑完全一致，直接打印随机选中的字符串即可，无需用多层if/else判断每个子选项。
4. 修复语法错误：原代码中name1数组定义多了一层大括号，已修正。

如果后续主选项对应的子选项不同，可以用Map映射主选项到对应的子选项数组，进一步扩展：

package randomlist;
import java.util.Map;
import java.util.Random;

public class Randomlist {
    private static final Random RANDOM = new Random();
    // 用Map存储主选项与对应子选项的映射
    private static final Map<String, String[]> OPTION_MAP = Map.of(
        "A", {"R", "E", "M"},
        "B", {"X", "Y"},
        "C", {"P", "Q", "R"},
        "D", {"M", "N"}
    );

    public static void main(String[] args) throws InterruptedException {
        String[] mainOptions = OPTION_MAP.keySet().toArray(new String[0]);
        String selectedMain = mainOptions[RANDOM.nextInt(mainOptions.length)];
        System.out.println(selectedMain);
        
        printRandomSubOption(selectedMain);
    }

    private static void printRandomSubOption(String mainOption) throws InterruptedException {
        Thread.sleep(1000);
        String[] subOptions = OPTION_MAP.get(mainOption);
        String selectedSub = subOptions[RANDOM.nextInt(subOptions.length)];
        System.out.println(selectedSub);
    }
}

这种方式即使后续扩展到12倍规模，只需在OPTION_MAP中添加新的键值对即可，代码结构清晰，维护成本极低。

内容的提问来源于stack exchange，提问作者Jacob Christonsen