我可以让这个 java pluck() 方法更安全吗？

Question

我编写了这个实用函数：

public static <T> List<T> pluck(String fieldName, List list) 
        throws NoSuchFieldException, IllegalAccessException {
    if (list.isEmpty()) {
        return new ArrayList<T>();
    }
    Class c = list.get(0).getClass();
    Field f = c.getField(fieldName);
    ArrayList<T> result = Lists.newArrayList();
    for (Object object : list) {
        result.add((T) f.get(object));
    }
    return result;
}

我从 underscore.js 复制了这个想法。用例是：

ArrayList<Person> people = new ArrayList<Person>;
people.add(new Person("Alice", "Applebee"));
people.add(new Person("Bob", "Bedmington"));
people.add(new Person("Charlie", "Chang"));

List<String> firstNames = pluck("firstName", people);

我的问题是，如果调用者得到的类型错误，则不会引发异常，直到调用者尝试从列表中获取对象为止。理想情况下，我想从 pluck 方法本身抛出一个 ClassCastException 。但是，我没有找到在运行时访问列表类型的方法。

我可以使用一些技巧来确保调用者不会得到无效列表吗？

---

编辑：因此，使用我得到的反馈，一个安全的实现是：

public static <T,F> List<F> pluck(String fieldName, Class<F> fieldType, 
        List<T> list, Class<T> listType) 
        throws NoSuchFieldException, IllegalAccessException {
    Field f = listType.getField(fieldName);
    ArrayList<F> result = new ArrayList<F>();
    for (T element : list) {
        result.add(fieldType.cast(f.get(element)));
    }
    return result;
}

但实际上 lambdaj 似乎做了我想要的，所以我想我会使用它。谢谢迈克！

免责声明： LambdaJ (@GoogleCode | @GitHub ) - 自 JDK8 发布以来，该项目不再维护（JSR 335，JEP 126)。

Answer 1

您可以将您的签名更改为如下：

public static <T, F> List<F> pluck(String fieldName, Class<F> fieldType, 
                                           List<T> list, Class<T> listType)

您拥有列表类型和字段类型。

Answer 2

为什么不这样定义签名：

public static <T, U> List<T> pluck(String fieldName, Class<T> fieldType, List<U> list);

这将：

1）强制客户端提供他想要“提取”的字段的类型，以便您可以在方法中进行正确的类型检查。

2) 强制客户端提供一个从中“提取”的通用列表，这样就可以防止另一个错误源（客户端提供包含不同类型对象的列表）。

我认为这是尽可能安全的..

Answer 3

无效列表是什么意思？如果您的意思是他们尝试将其转换为不是的东西，那么请尝试将声明更改为 public static;列表pluck(String fieldName, List列表)。

我对 However, I don't see a way to access the type of the list on run time. 注释感到困惑。然而，如果我理解正确的话：运行时没有“类型”，因为Java中的泛型是通过“擦除”实现的。这意味着编译器会在编译时检查它是否有效，然后将其转换为常规转换，就像我们在泛型之前所做的那样。他们认为这是实现向后和向前兼容性所必需的。

Answer 4

您应该对类型参数使用泛型，并传入返回类型的类对象：

public static <TItem, TResult> List<TResult> pluck(String fieldName, List<TItem> list, Class<TResult> resultType) 
        throws NoSuchFieldException, IllegalAccessException {
    if(list.isEmpty()) return new ArrayList<TResult>();

    Class c = list.get(0).getClass();
    Field f = c.getField(fieldName);
    ArrayList<TResult> result = new ArrayList<TResult>();
    for(Object object : list) {
        result.add(resultType.cast(f.get(object)));
    }
    return result;
}

通常，当您收到有关类型参数不安全强制转换的警告时，您应该查看是否可以将其替换为对 类.cast

Answer 5

你可以尝试 Google 集合库提供的一个，而不是维护一个新的：Collections2.transform 像这样

Collection<Y> yourCollection...
...
Collection<X> expected = Collections2.transform(yourCollection, new Function<Y, X>() {
  public X apply(Y element) {
    return element.getX();
  }
}

Answer 6

通过 Google 的 Guava 集合库，您可以使用 Collections2.transform()。

用法

给定一个接口/类，例如称为Entity，您的类可以实现/扩展它。

public abstract class Entity {
    private long id;

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }
}

public interface Entity {
    long getId();
}

现在您可以检索每个Entity 的 ID 列表。

import com.google.common.base.Function;
import com.google.common.collect.Collections2;

public class Main {
    public static void main(String[] args) {
        List<Entity> entities = ...
        List<Long> ids = pluckIds(entities);
    }

    public static <E extends Entity> List<Long> pluckIds(List<E> list) {
        return new ArrayList<Long>(Collections2.transform(list, new Function<E, Long>() {
            public Long apply(E entity) {
                return entity.getId();
            }
        });
    }
}

这是你能得到的最安全的。这满足适当的 OOP 原则和 Java 5-7。

实现相同的效果

public static <E extends Entity> List<Long> pluckIds(List<E> list) {
    return list.stream().map(e -> e.getId()).collect(Collectors.toList());
}

在 Java 8 中，您可以使用流、映射和 lambda或

public static <T,F> List<F> pluck(String fieldName, Class<F> fieldType, 
        List<T> list, Class<T> listType) throws NoSuchFieldException,
        IllegalAccessException, IllegalArgumentException {
    Field f = listType.getDeclaredField(fieldName);
    f.setAccessible(true);
    return list.stream().map(e -> {
        try { return fieldType.cast(f.get(e)); } catch (Exception e1) { return null; }
    }).collect(Collectors.toList());
}

Answer 7

不确定你在问什么，但你可以尝试：

Class c = list.get(0).getClass();
if (!c.equals(Person.class))
  throw new ClassCastException();

Answer 8

您可以将该列表转换为 java.lang.reflect.ParameterizedType 并检查 getActualTypeArguments() 返回的数组是否包含您需要的类。除此之外，你就不走运了。