Java 中如何优化递进式判断？

java中递进式判断如何优化？

在代码中，使用了嵌套的 if-else 语句来判断四个字符串变量是否为空。当变量数量较多时，这种递进式判断方式会变得冗长且难以维护。

优化方案

方案一：使用 switch-case 语句

这种方法将不同的判别条件映射到特定的整型值，然后使用 switch-case 语句进行判断。

public class judgeoptimize {

    private static final int code_condition_one = 0000;
    private static final int code_condition_two = 0001;
    private static final int code_condition_three = 0011;
    private static final int code_condition_four = 0111;
    private static final int code_condition_five = 1111;

    private static void test(string a, string b, string c, string d) {
        switch (init(a, b, c, d)) {
            case code_condition_one:
                // do something ...
                break;
            case code_condition_two:
                // do something ...
                break;
            case code_condition_three:
                // do something ...
                break;
            case code_condition_four:
                // do something ...
                break;
            case code_condition_five:
                // do something ...
                break;
        }
    }

    private static int init(string... allparam) {
        if (allparam == null) {
            return 1;
        }
        string resultnumberstr = "";
        for (string s : allparam) {
            resultnumberstr += stringutils.isnotempty(s) ? 0 : 1;
        }
        return integer.valueof(resultnumberstr);
    }
}

方案二：使用自动化的反射

这种方法通过反射来动态调用预定义的处理方法。当判别条件数量较多时，这种方法更灵活和可维护。

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Arrays;

public class SolutionTwo {

    private static Object result;

    private static class Action {
        private Class<?> targetInvokeClass;
        private String targetMethodName;
        private Class<?>[] parameterTypes;
        private Object[] params;
        private boolean isCurrentClass;
        private boolean isNoParams;

        public Action() {
        }

        public Action(Class<?> targetInvokeClass, String targetMethodName, Class<?>[] parameterTypes, Object[] params, boolean isCurrentClass, boolean isNoParams) {
            this.targetInvokeClass = targetInvokeClass;
            this.targetMethodName = targetMethodName;
            this.parameterTypes = parameterTypes;
            this.params = params;
            this.isCurrentClass = isCurrentClass;
            this.isNoParams = isNoParams;
        }
    }

    private static final HashMap<Object, Action> ACTION_MAP = new HashMap<>();

    static class ResultAction {
        public void helloWorld(String name) {
            System.out.println(name + ",你好世界");
        }
    }

    static {
        // 都不为空
        ACTION_MAP.put(0, new Action(ResultAction.class, "helloWorld", new Class[]{String.class}, new String[]{"我是张三"}, false, false));
        // abc不为空，d为空
        ACTION_MAP.put(1, new Action(ResultAction.class, "helloWorld", new Class[]{String.class}, new String[]{"我是李四"}, false, false));
        // ab不为空，cd为空
        ACTION_MAP.put(11, new Action(ResultAction.class, "helloWorld", new Class[]{String.class}, new String[]{"我是王五"}, false, false));
        // a不为空，bcd为空
        ACTION_MAP.put(111, new Action(ResultAction.class, "helloWorld", new Class[]{String.class}, new String[]{"我是赵六"}, false, false));
        // abcd都为空
        ACTION_MAP.put(1111, new Action(ResultAction.class, "helloWorld", new Class[]{String.class}, new String[]{"我是张三他爹"}, false, false));
    }

    private static void test(String a, String b, String c, String d) {
        int result = init(a, b, c, d);
        Action action = ACTION_MAP.get(result);
        if (action != null) {
            handler(action);
        } else {
            System.out.println("未找到对应映射键");
        }
    }

    private static void handler(Action action) {
        try {
            Method method = null;
            Class<?> cls = null;
            if (action.isCurrentClass()) {
                method = getMethod(SolutionTwo.class, action.getTargetMethodName(), action.getParameterTypes());
                cls = SolutionTwo.class;
            } else {
                Class<?> targetClass = action.getTargetInvokeClass();
                method = getMethod(targetClass, action.getTargetMethodName(), action.getParameterTypes());
                cls = action.getTargetInvokeClass();
            }
            result = method.invoke(cls.newInstance(), action.getParams());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            e.printStackTrace();
        }
    }

    private static Method getMethod(Class<?> cls, String methodName, Class<?>[] parameterTypes) throws NoSuchMethodException {
        return cls.getMethod(methodName, parameterTypes);
    }

    private static int init(String... allParam) {
        if (allParam == null) {
            return 1;
        }
        String resultNumberStr = "";
        for (String s : allParam) {
            resultNumberStr += StringUtils.isNotEmpty(s) ? 0 : 1;
        }
        return Integer.valueOf(resultNumberStr);
    }
}

以上就是Java 中如何优化递进式判断？的详细内容，更多请关注其它相关文章！