我正在创建“ SpecialList”，并且需要实现map功能。该列表应该是惰性的，并且只有在求值时才会产生值。

toString（）返回“？”如果该值尚不可用；否则返回值的字符串表示形式。

get（）。如果该值已经可用，则返回该值；否则，计算该值并将其返回。对于相同的值，只应执行一次计算。

这就是我所拥有的：

public <U> SpecialList<U> map(Function<T,U> mapper) {
    if (!this.isAvailable) {
        return new SpecialList<U>(this.supplier);
    }
    return new SpecialList<U>(mapper,value);
}

// private constructor
private SpecialList(CachedSupplier<T> s) {
    this.supplier = s;
    this.isAvailable = false;
}

但是，它告诉我没有有效的构造函数，因为T不能转换为U。

SpecialList.java:65: error: no suitable constructor found for SpecialList(SpecialList<T>.CachedSupplier<T>)
            return new SpecialList<U>(this.supplier);
                   ^
    constructor SpecialList.SpecialList(U) is not applicable
      (argument mismatch; SpecialList<T>.CachedSupplier<T> cannot be converted to U)
    constructor SpecialList.SpecialList(Supplier<U>) is not applicable
      (argument mismatch; SpecialList<T>.CachedSupplier<T> cannot be converted to Supplier<U>)

返回后，'U'不会变成T吗？

我该如何解决这个问题？对于方法级别的泛型类型，我还是不太清楚。但是我被告知需要为地图方法添加。

下面是我的完整代码：

class SpecialList<T> {
    class CachedSupplier<T> {
        private Supplier<? extends T> supplier;
        private T value;
        boolean isAvailable;

        public CachedSupplier(Supplier<? extends T> supplier) {
            this.supplier = supplier;
        }

        public T get() {
            if (!isAvailable) {
                value = supplier.get();
                isAvailable = true;
            }
            return value;
        }
    }

    private CachedSupplier<T> supplier;
    private T value;
    boolean isAvailable;

    private SpecialList(T value) {
        this.value = value;
        this.isAvailable = true;
    }

    private SpecialList(Supplier<T> s) {
        this.supplier = new CachedSupplier<T>(s);
        this.isAvailable = false;
    }

    private SpecialList(CachedSupplier<T> s) {
        this.supplier = s;
        this.isAvailable = false;
    }

    private <R> SpecialList(Function<T,R> mapper,T v) {
        this.supplier = new CachedSupplier<T>(() -> mapper.apply(v));
        this.isAvailable = false;
    }

    public static <T> SpecialList<T> of(T value) {
        return new SpecialList<>(value);
    }

    public static <T> SpecialList<T> of(Supplier<T> supplier) {
        return new SpecialList<>(supplier);
    }

    public <R> SpecialList<R> map(Function<? super T,? extends R> mapper) {
        if (!this.isAvailable) {
            return new SpecialList<>(this.supplier);
        }
        return new SpecialList<R>(mapper,value);
    }

    public T get() {
        if(this.isAvailable) {
            return this.value;
        } else {
            this.value = this.supplier.get();
            this.isAvailable = true;
            return this.value;
        }
    }
}

我仍然对通用类型等感到困惑，所以请让我知道是否有任何奇怪的事情/我可以改善！

谢谢