List <CustomObject>和HashMap <String，Object>之间是否有任何优点

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将Object从Object转换为特定类型。

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网站上阅读有关枚举的更多信息。

Answer 5

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

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

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

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

哪个表现更好取决于你拥有的对象数量，你如何访问它们，你插入的频率和其他几个因素。