4

我正在尝试实现一个解决方案（在 Java 1.6 中），我需要存储一些值（用于一组属性）并考虑以下三个选项来考虑三个选项（当然，任何其他想法都是受欢迎的！）

选项1

创建一个Property可以存储不同类型对象（String、int、boolean...）的类（调用它），并将属性集作为 List<Property>

就像是：

private String type; //Store the type of Object
private String name; //Store the name of the property
private String valueStr; //Store the String value
private int valueInt; //Store the int value
private boolean valueBool; //Store the boolean value

我真的不喜欢拥有许多属性并只使用其中一个的想法。（每个属性只会设置一个值）

选项 2

HashMap<String, Object>在每种情况下使用和解析类型。

有个好东西，你可以得到Property名字

选项 3

使用HashMap<String, Property>Where String 是属性的名称，可以通过名称获取值，无需解析。

问题是：你认为哪一个是最好的？或者如果它们都不好，我想听听其他想法

List 和 HashMap 之间还有性能差异吗？

在此先感谢您的帮助。

4

5 回答 5

4

我认为最好有一个这样的自定义 Value 类：

public class MyValue {
    enum Type {
       INT, STRING, BOOL;
    }
    private Type type; //Store the type of Object in Type Enum
    private Object value; //Store the value in Object

    public void setValue(int val) {
       type = Type.INT;
       value = new Integer(val);
    }
    public void setValue(String val) {
       type = Type.STRING;
       value = val;
    }
    public void setValue(boolean val) {
       type = Type.BOOL;
       value = new Boolean(val);
    }

    public String stringVal() {
        // check type to be STRING first
        return (String) value;
    }
    public int intVal() {
        // check type to be INT first
        return ((Integer) value.intValue());
    }
    public boolean booleanVal() {
        // check type to be BOOL first
        return ((Boolean) value.booleanValue());
    }
}

您需要根据enum Type您的 getter 从 Object 转换为特定类型。

于 2013-04-25T16:27:33.570 回答
1

另一种选择是这样的，使用继承而不是保留大量未使用的字段。

public interface Property {
    String getType();
    String getName();
    Object getValue();
}

public abstract class AbstractProperty implements Property {
    private final String name;

    protected AbstractProperty(String name) {
        this.name = name;
    }
}

public class StringProperty extends AbstractProperty {
    private final String value;

    public StringProperty(String name, String value) {
        super(name);
        this.value = value;
    }

    @Override
    public String getType() {
        return String.class.getName();
    }

    @Override
    public String getValue() {
        return value;
    }
}

public class IntegerProperty extends AbstractProperty {
    private final Integer value;

    public IntegerProperty(String name, Integer value) {
        super(name);
        this.value = value;
    }

    @Override
    public String getType() {
        return Integer.TYPE.getName();
    }

    @Override
    public Integer getValue() {
        return value;
    }
}
于 2013-04-25T16:27:40.883 回答
1

我认为选项 2 最适合您。考虑到您正在存储属性，我希望您会经常查询此列表，该列表再次指向 HashMap 的方向，因为这将使您的查找非常有效。

于 2013-04-25T16:28:12.003 回答
1

我建议改用一个enum。枚举有利于保存值列表，并且在检索方面很有效。

public enum Property {
    TYPE,
    NAME,
    VALUEINT; //...

    private String sProp = "";
    private int iProp = 0;
    private boolean bProp = false;

    public String getStringProp() {return sProp;}
    public int getIntProp() {return iProp;}
    public boolean getBoolProp() {return bProp;}

    public void setStringProp(String str) {this.sProp = str;}
    public void setIntProp(int i) {this.iProp = i;}
    public void setBoolProp(boolean b) {this.bProp = b;}
}

然后可以使用Property.TYPE,Property.VALUEINT等访问它。您可以使用 设置属性Property.TYPE.setStringProp()，并使用 获取它们Property.TYPE.getStringProp()。

您可以从Oracle 的网站阅读更多关于枚举的信息。

于 2013-04-25T16:28:14.713 回答
1

我不确定是否有一种“最佳”方式。这实际上取决于存储在数据结构中后如何使用数据。

如果我只需要累积属性并对它们中的每一个做一些事情，我有时会使用一个列表，甚至是一个数组。

如果您可能必须通过名称获取特定属性，那么 HashMap 可能会有所帮助。

同样，如果您想使用本机对象类型或 Property 的实例，则取决于您拥有的数据类型。

哪个性能更好取决于您拥有的对象数量、访问它们以供使用的方式、插入的频率以及其他几个因素。

于 2013-04-25T16:30:14.093 回答