返回带有动态对象的 HashMap<key, Object> 的 Java 方法

Java method returning HashMap<key, Object> with dynamic object

提问by Alisa

I have several TSV files and want to read them and populate in a HashMap of

我有几个 TSV 文件，想读取它们并填充到 HashMap 中

[first field --> other fields in an object].

[第一个字段 --> 对象中的其他字段]。

For simplicity, assume that there are two files:

为简单起见，假设有两个文件：

File 1 contains two fields (field1 and field2).
File 2 contains three fields (f1, f2 and f3).

文件 1 包含两个字段（field1 和 field2）。
文件 2 包含三个字段（f1、f2 和 f3）。

So I defined two classes whose objects are to be values in the hashMap:

所以我定义了两个类，它们的对象是 hashMap 中的值：

Class1{
    String field1 = "";
    String field2 = "";
}
Class2{
    String f1 = "";
    String f2 = "";
    String f3 = "";
}

Now, I have these methods:

现在，我有这些方法：

public static HashMap<String, Class1> readTSV1(String fileName, Class1 c){
...
}

public static HashMap<String, Class2> readTSV2(String fileName, Class2 c){
...
}
...

But I don't want to define various methods for reading from different files:

但我不想定义从不同文件读取的各种方法：

I want something like this:

我想要这样的东西：

public static HashMap<String, Object> readTSV(String fileName, Class<?> c){
    HashMap<String, c.getClass()> hm = new HashMap<String, c.getClass()>(); //error.
    //Look which field names are in type c, 
    //and then read two or three fields from file, 
    //and put them as key and values of hm (first field is key, other fields are put in instance of the respective class, and put as values)
    return hm;
}

static void main(String[] args){
    Class1 c1;
    HashMap<String, Class1> hm1 = new HashMap<String, Class1>();
    hm1 = readTSV("firstFile.tsv", c1.getClass())

    Class2 c2;
    HashMap<String, Class2> hm1 = new HashMap<String, Class2>();
    hm1 = readTSV("firstFile.tsv", c2.getClass())

    ...
}

Any ideas? ...

有任何想法吗？...

采纳答案by ug_

Using a Hashmap<String, List<String>>is probably the simplest way. However if you really want these in objects you could do something with an interface.

使用 aHashmap<String, List<String>>可能是最简单的方法。然而，如果你真的想要在对象中使用这些，你可以用接口做一些事情。

public interface CSVConvertable {
    /* sets values in this class according to a row in the CSV file */
    public void setCSVValues(String [] values);
}

class Class1 implements CSVConvertable {
    String field1 = "";
    String field2 = "";
    @Override
    public void setCSVValues(String[] values) {
        field1 = values[0];
        field2 = values[1];
    }
}
class Class2 implements CSVConvertable {
    String f1 = "";
    String f2 = "";
    String f3 = "";
    @Override
    public void setCSVValues(String[] values) {
        f1 = values[0];
        f2 = values[1];
        f3 = values[2];
    }
}

public static <T extends CSVConvertable> HashMap<String, T> readTSV(String fileName, Class<T> c) throws InstantiationException, IllegalAccessException{
    HashMap<String, T> hm = new HashMap<String, T>();
    while(/* read rows in csv*/) {
        CSVConvertable conv = c.newInstance();
        conv.setCSVValues(/*your row array here*/);
    }

    return hm;
}


static void main(String[] args){
    HashMap<String, Class1> hm1 = new HashMap<String, Class1>();
    hm1 = readTSV("firstFile.tsv", Class1.class);

    HashMap<String, Class2> hm2 = new HashMap<String, Class2>();
    hm2 = readTSV("firstFile.tsv", Class2.class);

    ...
}

---

---

Reflection

反射

If you really want to use reflection here is a basic implementation for it. You should note however tho that this implementaion would change if you ever added a new property to the class, changed a property name or made the class extend another class.

如果你真的想使用反射，这里有一个基本的实现。但是，您应该注意，如果您向类添加新属性、更改属性名称或使类扩展另一个类，则此实现会发生变化。

public static <T> List<T> readTSV(String fileName, Class<T> c) throws InstantiationException, IllegalAccessException, IntrospectionException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException{
    List<T> list = new ArrayList<T>(); //error.
    List<String> properties = getBeanProperties(c);
    Collections.sort(properties);

    // loop through all rows of the TSV and set each value
    while(/*read rows in tsv*/) {
        T obj = c.newInstance();
        for(int i=0;i<properties.size();i++) {
            setProperty(obj, properties.get(i), /* get row column [i] */);
        }
        list.add(obj);
    }

    return list;
}


public static void main(String[] args) throws InstantiationException, IllegalAccessException, IntrospectionException, NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalArgumentException, InvocationTargetException{
    List<Class1> hm1 = readTSV("firstFile.tsv", Class1.class);
    System.out.println(hm1);

    List<Class2> hm2 = readTSV("firstFile.tsv", Class2.class);
    System.out.println(hm2);

}

public static void setProperty(Object obj, String propName, Object value) throws NoSuchFieldException, SecurityException, NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    String setterName = "set" + propName.substring(0, 1).toUpperCase()
            + propName.substring(1);

    Field field = obj.getClass().getDeclaredField(propName);
    if(Modifier.isPrivate(field.getModifiers())) {
        Method method = obj.getClass().getMethod(setterName, field.getType());
        method.invoke(obj, value);
    } else {
        field.set(obj, value);
    }
}

public static List<String> getBeanProperties(Class<?> cl) {
    List<String> properties = new ArrayList<String>();
    // check all declared fields
    for (Field field : cl.getDeclaredFields()) {
        // if field is private then look for setters/getters
        if (Modifier.isPrivate(field.getModifiers())) {
            // changing 1st letter to upper case
            String name = field.getName();
            String upperCaseName = name.substring(0, 1).toUpperCase()
                    + name.substring(1);
            // and have getter and setter
            try {
                String simpleType = field.getType().getSimpleName();
                //for boolean property methods should be isProperty and setProperty(propertyType)
                if (simpleType.equals("Boolean") || simpleType.equals("boolean")) {
                    if ((cl.getDeclaredMethod("is" + upperCaseName) != null)
                            && (cl.getDeclaredMethod("set" + upperCaseName,
                                    field.getType()) != null)) {
                    }
                    properties.add(name);
                } 
                //for not boolean property methods should be getProperty and setProperty(propertyType)
                else {
                    if ((cl.getDeclaredMethod("get" + upperCaseName) != null)
                            && (cl.getDeclaredMethod("set" + upperCaseName,
                                    field.getType()) != null)) {
                    }
                    properties.add(name);
                }
            } catch (NoSuchMethodException | SecurityException e) {
                // if there is no method nothing bad will happen
            }
        } else {
            // Accessible property that isnt defined by the jre
            if(!field.isSynthetic()) {
                properties.add(field.getName());
            }
        }
    }
    return properties;
}

回答by StackFlowed

You can use inheritance

您可以使用继承

Marker interface

标记界面

public interface ForClasses{
}

Class1 implements ForClasses {
    ...
}
Class2 implements ForClasses{
    ...
}

Then you can do :

然后你可以这样做：

 HashMap<String, ForClasses > hm = new HashMap<String, ForClasses>();

hm can hold both class1 object and class2 object in the map value part....

hm 可以在映射值部分同时保存 class1 对象和 class2 对象....