Question

我正在尝试实现一个解决方案（在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>其中String是属性的名称，您可以使用名称获取值，而无需解析。

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

List和HashMap之间是否存在任何性能差异？

提前感谢您的帮助。

Answer 1

我认为更好的是拥有这样的自定义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());
    }
}

您需要根据getter中的enum Type将对象转换为特定类型。

Answer 2

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

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;
    }
}

Answer 3

我认为选项2对你来说是最好的。考虑到你正在存储属性，我希望你会经常查询这个列表，它再次指向HashMap的方向，因为这会使你的查找非常有效。

Answer 4

我建议改用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's site了解有关枚举的更多信息。

Answer 5

我不确定是否有最好的＆＃39;办法。这实际上取决于在数据结构中存储后如何使用数据。

如果我只需要累积属性并对每个属性执行某些操作，我有时会使用列表，甚至是数组。

如果您可能需要获取特定属性（例如名称），那么HashMap可以提供帮助。

再次，如果你想使用本机对象类型或属性的实例取决于你有什么样的数据。

哪种表现更好取决于您拥有的对象数量，您如何访问它们，您插入的频率以及其他一些因素。

List <customobject>和HashMap <string，object =“”> </string，> </customobject>之间有什么优势吗？

5 个答案: