返回带有动态对象的 HashMap 的 Java 方法

Question

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

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

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

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

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

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

现在，我有这些方法:

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

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

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

我想要这样的东西:

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())

    ...
}

有什么想法吗？ ...

Answer 1

使用 Hashmap<String, List<String>>可能是最简单的方法。但是，如果您真的想在对象中使用这些，您可以使用接口(interface)来做一些事情。

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

    ...
}

---

反射

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

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