1

我正在使用泛型来存储对任意对象的引用。

class Option<TypeT>{
    TypeT o;

    Option(TypeT t){
        this.o = o;
    }
    TypeT getReferencedObject(){
        return o;
    }
}

我想使用 lambdaJ 从集合中提取这些对象。现在我正在使用非常丑陋的双重铸造(List<TypeT>)(List<?>)，我正在寻找更好/更清洁的解决方案。问题出在on( sth ).getReferencedObject()语句中，不能像这样参数化on(Option<String>.class).getReferencedObject()

List<Option<String>> options = Arrays.asList(new Option<String>("AAA"), new Option<String>("BBB"));
List<String> string = (List<String>)(List<?>) extract(options, on(Option.class).getReferencedObject());
4

1 回答 1

3

这个问题源于语言本身的限制——具体的参数化类型没有类文字，这是 Java 使用类型擦除来实现泛型的结果。

具体参数化类型的示例是Option<String>. 没有Option<String>.class，只有Option.class。

参数化类型可以在运行时由ParameterizedType实例表示，可以使用反射来获取。一些库利用这一点来以类型安全的方式表示泛型类型，例如 Guava 的TypeToken<T>.

但不幸的是，这在这里没有帮助。原因是 LambdaJ 的on方法使用动态代理来表示指定的类型。这是为了调用这样的东西：

on(Option.class).getReferencedObject()

可以在幕后发挥其 LambdaJ 的魔力。创建这样的代理最终归结为对 Java API 的调用Proxy.newProxyInstance，或者像net.sf.cglib.proxy.Enhancer. 在任何一种情况下，Class实例都专门用于表示代理的接口/类。所以总结起来，on除了冷硬什么都不能接受Class<T>。

你能做什么？你的选择是有限的...

1）坚持你所拥有的：

我们知道这很丑陋，而且绝对容易出错，但它确实有效：

@SuppressWarnings("unchecked") //okay because options is a List<Option<String>>
List<String> strings =
    (List<String>)(List<?>)extract(options, on(Option.class).getReferencedObject());

出于好奇，我尝试了这个：

@SuppressWarnings("unchecked") //not really okay, but let's see what happens
Class<Option<String>> onWhat = (Class<Option<String>>)(Class<?>)Option.class;
List<String> strings = extract(options, on(onWhat).getReferencedObject());

但这给了我一个运行时异常：

java.lang.ClassCastException:net.sf.cglib.empty.Object$$EnhancerByCGLIB$$9d9c54e1不能转换为java.lang.String

2）使用番石榴：

List<String> strings = Lists.transform(
        options,
        new Function<Option<String>, String>() {
            @Override
            public String apply(Option<String> option) {
                return option.getReferencedObject();
            }
        }
);

这看起来相当嘈杂，但Function至少可以抽象出来：

class Option<T> {

    ...

    public static final class Functions {

        //Impl note: Effective Java item 27
        private static final Function<?, ?> GET_REFERENCED_OBJECT =
                new Function<Option<?>, Object>() {
                    @Override
                    public Object apply(Option<?> option) {
                        return option.getReferencedObject();
                    }
                };

        private Functions() { }

        public static <T> Function<Option<T>, T> getReferencedObject() {
            //okay for any T, since Option<T>.getReferencedObject must return a T
            @SuppressWarnings("unchecked")
            final Function<Option<T>, T> withNarrowedTypes =
                    (Function<Option<T>, T>)GET_REFERENCED_OBJECT;
            return withNarrowedTypes;
        }
    }
}

这使呼叫站点更清洁：

List<String> strings = Lists.transform(
        options,
        Option.Functions.<String>getReferencedObject()
);

请注意，它会Lists.transform返回原始. 如果你想要一份像 LambdaJ 的回报一样的副本，制作一个很容易：Listextract

List<String> strings = Lists.newArrayList(Lists.transform(
        options,
        Option.Functions.<String>getReferencedObject()
));

这一切都更加冗长，但它为您提供了泛型类型安全，并且您可以在幕后放弃动态代理巫术。

3）使用Ol'Plain n' Simple（并等待Java 8）：

List<String> strings = new ArrayList<>(options.size());
for (Option<String> option : options) {
    strings.add(option.getReferencedObject());
}

一个经常被忽视但令人愉快的可行选择！

于 2013-04-24T22:45:06.883 回答