Java 8，匿名递归嵌套方法

Question

My goal is to migrate the method getAllFields into init by re writing it as an anonymous function, I know it's quite possible using functional programming.

public void init(){

}

public static Field[] getAllFields(Class klass) {
    List<Field> fields = new ArrayList<Field>();
    fields.addAll(Arrays.asList(klass.getDeclaredFields()));
    if (klass.getSuperclass() != null) {
        fields.addAll(Arrays.asList(getAllFields(klass.getSuperclass())));
    }
    return fields.toArray(new Field[] {});
}

I've tried using Function and also BiFunction but got lost abit. Can any one give a snippet for how to implement such case?

Answer 1

This is not (yet) directly possible. In Java 9, the Stream class will have an iterate method, which allows to implement this as follows:

Field[] allFields = Stream
    .iterate((klass, Objects::nonNull, Class::getSuperclass)
    .flatMap(c -> Stream.of(c.getDeclaredFields()))
    .toArray(Field[]::new);

However, the getAllFields method that you already have is a nice, clean implementation of the desired functionality, and the name makes unambiguously clear what this method does . The functional implementation would be far more difficult to understand.

Answer 2

This getAllFields implementation is horribly inefficient, creating multiple ArrayList instances and arrays, repeatedly copying the entire data between them back and forth. Thankfully, class hierarchies rarely are that deep that this becomes a bottleneck.

Still, you can implement this with a straight-forward loop, which is simpler and more efficient:

public static Field[] getAllFields(Class<?> klass) {
    List<Field> fields = new ArrayList<>();
    for(; klass!=null; klass=klass.getSuperclass())
        Collections.addAll(fields, klass.getDeclaredFields());
    return fields.toArray(new Field[0]);
}

There is not the slightest benefit from using recursion here.

With a loop, you can easily create a Function if you really wish:

public void init(){
    Function<Class<?>,Field[]> f = klass -> {
        List<Field> fields = new ArrayList<>();
        for(; klass!=null; klass=klass.getSuperclass())
            Collections.addAll(fields, klass.getDeclaredFields());
        return fields.toArray(new Field[0]);
    };
    Field[] someFields = f.apply(SomeClass.class);
}

Though, of course, there isn't even a reason to put the loop into a Function at all. You only wanted to have a function here due to your wish to use that inefficient recursive implementation, but lambda expressions don't support accessing themself at all. They only can access the field to which the instance implementing the functional interface got stored, if it was stored in a field, which you don't want. With a local lambda expression, recursion is impossible.

With the straight-forward loop, you can just write

public void init(){
    List<Field> fields = new ArrayList<>();
    for(Class<?> klass=SomeClass.class; klass!=null; klass=klass.getSuperclass())
        Collections.addAll(fields, klass.getDeclaredFields());
    Field[] someFields = fields.toArray(new Field[0]);
}

though, actually, there is rarely a real reason for copying the contents of fields into an array, you could just work with the List<Field> instead.

That said, encapsulating the loop into a named method describing its purpose, like getAllFields , is actually a good thing. If you don't want to expose it, declare it private instead of public .