Question

这些是我的项目的类。 Bean类是Employe和Computer的超级类型，并且不是无法使用的。

abstract Class Bean{
   private HashMap<String, String> fields = null;
   protected Bean(Map<String, Object> row) {
        //fill HashMap fields
   }
}
public class Employe extends Bean {
    public Employe (Map<String, Object> row) {
        super(row);
   }
}

public class Computer extends Bean {
    public Computer (Map<String, Object> row) {
        super(row);
    }
}

如何使用泛型的循环更加通用？

我会在实用程序方法riusable中使用泛型一次写下面两个循环。

//Loop 1

List<Map<String, Object>> employeRows = //from query on database

List<Employe> employList = new ArrayList<Employe>();

for (Map<String, Object> row : employeRows) {
    Employe e = new Employe(row);
    employList .add(e);
}

//Loop 2

List<Map<String, Object>> computerRows = //from query on database

List<Computer> computerList = new ArrayList<Computer>();

for (Map<String, Object> row : computerRows ) {
    Computer c = new Computer(row);
    computerList.add(c);
}

这个伪代码是我想要实现的一个例子：

List<Employe> = Utility.toList(employeRows, ...);
List<Computer> = Utility.toList(computerList, ...);

Answer 1

如果您使用的是Java 7或更低版本，则可以使用工厂模式。但是，如果您已经使用Java 8，则可以使用streams和lambda / method reference实现此目的。

以下是使用Java 8的方法：

public static <T> List<T> toList(List<Map<String, Object>> rows, Function<Map<String, Object>, T> mapper) {
    return rows.stream().map(mapper).collect(Collectors.toList());
}

然后通过将构造函数作为方法引用传递来调用此方法：

List<Map<String, Object>> employeRows = new ArrayList<Map<String, Object>>();
List<Map<String, Object>> computerRows = new ArrayList<Map<String, Object>>();

List<Employe> employList = toList(employeRows, Employe::new);
List<Computer> computerList = toList(computerRows, Computer::new);

Answer 2

使用工厂模式，一个抽象工厂

interface ObjectCreater<T> {
  T create(Map<String, Object> row);
}

和两个实现，例如为员工

class EmployeeCreater implements ObjectCreator<T> {
  T create(Map<String, Object> row) {
     return new Employee(row); // or the constructor logic inlined
  }
}

定义一个方法（= Utility.toList（））：

List<T> toList(List<Map<String, Object>> row, ObjectCreator<T> creator) {
  // the upper loop using the factory instead of the Constructor
}

如何使用泛型的循环更通用？

2 个答案: