Java 带开关情形的复形分解法

我的应用程序中有一个取决于参数类型的逻辑，现在它的工作原理如下：

   switch (parameter.getType()) {
                case DOUBLE:
                    countOfParameters = parameter.getDoubleValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getDoubleValue(0));
                    } else if (countOfParameters > 1) {
                        Double[] doubleValues = new Double[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            doubleValues[kj] = parameter.getDoubleValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), doubleValues);
                    }
                    break;
                case BOOLEAN:
                    countOfParameters = parameter.getBoolValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getBoolValue(0));
                    } else if (countOfParameters > 1) {
                        Boolean[] booleanValues = new Boolean[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            booleanValues[kj] = parameter.getBoolValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), booleanValues);
                    }
                    break;
                case STRING:
                    countOfParameters = parameter.getStringValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getStringValue(0));
                    } else if (countOfParameters > 1) {
                        String[] stringValues = new String[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            stringValues[kj] = parameter.getStringValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), stringValues);
                        break;
                    }
                case INTEGER:
                    countOfParameters = parameter.getIntValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), parameter.getIntValue(0));
                    } else if (countOfParameters > 1) {
                        Integer[] integerValues = new Integer[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            integerValues[kj] = parameter.getIntValue(kj);
                        }
                        propertiesBuilder.addProperty(parameter.getName(), integerValues);
                    }
                    break;
                case LOCALDATE:
                    countOfParameters = parameter.getStringValueCount();
                    if (countOfParameters == 1) {
                        propertiesBuilder.addProperty(parameter.getName(), DateHelper.parseDate(parameter.getStringValue(0)));
                    } else if (countOfParameters > 1) {
                        LocalDate[] dateValues = new LocalDate[countOfParameters];
                        for (int kj = 0; kj < countOfParameters; kj++) {
                            dateValues[kj] = DateHelper.parseDate(parameter.getStringValue(kj));
                        }
                        propertiesBuilder.addProperty(parameter.getName(), dateValues);
                    }
                    break;
            }

开关（参数.getType（））{
双格：
countOfParameters=参数。getDoubleValueCount（）；
if（countof参数==1）{
propertiesBuilder.addProperty（parameter.getName（），parameter.getDoubleValue（0））；
}否则如果（参数计数>1）{
Double[]doubleValues=新的Double[countOfParameters]；
对于（int kj=0；kj1）{
Boolean[]booleanValues=新的Boolean[countOfParameters]；
对于（int kj=0；kj1）{
String[]stringValues=新字符串[countOfParameters]；
对于（int kj=0；kj1）{
整数[]integerValues=新整数[countOfParameters]；
对于（int kj=0；kj1）{
LocalDate[]dateValues=新的LocalDate[countOfParameters]；
对于（int kj=0；kj

正如您所看到的，我有相同的逻辑，唯一改变的是解析值的方法。 有可能去掉重复的代码吗？ 我想可以绘制一些功能接口功能图，但不确定应该如何做。

---

有什么建议吗？

不确定您需要什么，但您可以使用泛型类型

public class Element<T> {
    // T stands for "Type"
    private T t;

    public void set(T t) { this.t = t; }
    public T get() { return t; }
}

---

如果我没弄错的话，像这样的事情可能是：

Map<Type, Consumer<Builder>> map = Map.of(
     BOOLEAN, x -> x.add(BOOLEAN.parseBool()),
     STRING, x -> x.add(STRING.parseString())
);


map.get(type).accept(builder);

Map Map=Map.of(
BOOLEAN，x->x.add（BOOLEAN.parseBool（）），
字符串，x->x.add（STRING.parseString（））
);
map.get（type）.accept（builder）；

首先，可以在枚举中执行从双精度到双精度的映射等操作：

enum ValueType {
    DOUBLE(Double.class), // Or Double[].class
    BOOLEAN(Boolean.class),
    ...;

    public final Class<?> type;

    ValueType(Class<?> type) {
        this.type = type;
    }
}

我添加了一些反射代码（

Array

），希望不需要这些代码

enum ValueType {
    DOUBLE(Double.class), // Or Double[].class
    BOOLEAN(Boolean.class),
    ...;

    public final Class<?> type;

    ValueType(Class<?> type) {
        this.type = type;
    }
}

ValueType vt = parameter.getType();
Class<?> t = vt.type;

Object array = Array.newInstance(t, countOfParameters);
// Actuallly Double[] or such.

int countOfParameters = parameter.getValueCount();
if (countOfParameters == 1) {
    propertiesBuilder.addProperty(parameter.getName(), parameter.getValue(0));
} else if (countOfParameters > 1) {
    Object array = Array.newInstance(t, countOfParameters);
    Class<?> componentT = array.getClass().getComponentType(); // == t

    Object[] values = new Object[countOfParameters];
    for (int kj = 0; kj < countOfParameters; kj++) {
        Array.set(array, kj, parameter.getValue(kj));
        values[kj] = parameter.getValue(kj);
    }
    propertiesBuilder.addProperty(parameter.getName(), values); // or array
}