Question

我有Class使用泛型和递归来创建ImmutableList以提高性能，这种方法有一种我无法使用的方法理解：

public <E2> ImmutableList<E2> transform(Function<? super E, ? extends E2> fn) {
        return tail == null
            ? new ImmutableList<E2>()
            : new ImmutableList<E2>(fn.apply(head), tail.transform(fn));
    }

这个语法对我来说是新的<E2>之后public的剂量是多少？这个参数的含义是多少？ Function<? super E, ? extends E2> fn

这是洞类：

public final class ImmutableList<E> {

    public final E head;
    public final ImmutableList<E> tail;

    public ImmutableList() {
        this.head = null;
        this.tail = null;
    }

    private ImmutableList(E head, ImmutableList<E> tail) {
        this.head = head;
        this.tail = tail;
    }

    public ImmutableList<E> prepend(E element) {
        return new ImmutableList<E>(element, this);
    }

    public <E2> ImmutableList<E2> transform(Function<? super E, ? extends E2> fn) {
        return tail == null
            ? new ImmutableList<E2>()
            : new ImmutableList<E2>(fn.apply(head), tail.transform(fn));
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((head == null) ? 0 : head.hashCode());
        result = prime * result + ((tail == null) ? 0 : tail.hashCode());
        return result;
    }

    @Override
    @SuppressWarnings("rawtypes")
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (!(obj instanceof ImmutableList))
            return false;
        ImmutableList other = (ImmutableList) obj;
        if (head == null) {
            if (other.head != null)
                return false;
        } else if (!head.equals(other.head))
            return false;
        if (tail == null) {
            if (other.tail != null)
                return false;
        } else if (!tail.equals(other.tail))
            return false;
        return true;
    }

}

这是功能界面：

public interface Function<A, B> {
    B apply(A value);
}

Answer 1

transform接受从Function到E的{{1}}（或更准确地说，来自E2或{{1}的超级类型{}}到E或子类型E）。 E2是一个名为E2的方法的接口。 Function接受apply()类型的参数，并返回fn.apply()类型的参数。

E将该函数应用于执行它的列表的所有元素，因此它会从执行它的输入E2生成transform。

ImmutableList<E2>是一个泛型类型参数，表示ImmutableList<E>方法返回的列表中包含的元素的类型。

这个通用函数有什么作用？

1 个答案: