Question

假设我们必须有WeakReference列表和“强引用”的情况。但是Java中没有StrongReference类。我的解决方案是

保留对象列表

 List<? extends Object> list =new ArrayList();

当我们从列表中获取元素时，请检查：

if(list.get(i) instanceof WeakReference){
     MyClass myObject =  ((MyClass)((WeakReference) list.get(i)).get());
     if(myObject != null){
       myObject.doSomething();
     }
  }else{
     MyClass myObject =  ((MyClass)list.get(i));
     myObject.doSomething();
  }

是否有更好的解决方案可以在一个集合中保留强弱参考？

Answer 1

我很想抽象出“强或弱参考”的概念：

public interface DualRef<T> {
    T get();
}

然后实现两个子类，一个用于弱引用：

public class WeakDualRef<T> implements DualRef<T> {
    private final WeakReference<T> mRef;
    public WeakDualRef(T object) {
        mRef = new WeakReference<T>(object);
    }
    public WeakDualRef(WeakReference<T> ref) {
        mRef = ref;
    }
    T get() {
        return mRef.get();
    }
}

和另一个强引用：

public class StrongDualRef<T> implements DualRef<T> {
    private final T mRef;
    public StrongDualRef(T object) {
        mRef = object;
    }
    public T get() {
        return mRef;
    }
}

然后您可以将代码实现为：

List<DualRef<MyObject>> list = new ArrayList<DualRef<MyObject>>();

// add mixed instances of WeakDualRef<MyObject> or StringDualRef<MyObject> . . .

MyClass myObject = list.get(i).get();
myObject.doSomething();

所有这些都具有通过正确使用仿制药来保持类型安全的优势。

Answer 2

混合类型不是一个好主意。

List< WeakReference > weakRefs  = new ArrayList<>();
List< MyClass >       myClasses = new ArrayList<>();

用两个循环做两件事。

为什么要混合两种不同类型的对象，它们不会共享任何行为。

Answer 3

我会写这样的东西

Object o = list.get(i);
if (o instanceof WeakReference) o = ((WeakReference) o).get();
if (o instanceof MyClass) ((MyClass) o).doSomething();

一个集合中的强引用和弱引用

3 个答案: