我是這樣做的..首先創建抽象softCache類:如果你希望它是一個視圖類
public class ViewCache extends SoftCache<View>{
public ViewCache(Class<View> typeParameterClass) {
super(typeParameterClass);
}
@Override
public View runWhenCacheEmpty() {
return mFragment.getActivity().getLayoutInflater()
.inflate(R.layout.mypagelayout, null);
}
}
然後在構造函數實例化這樣的:
public abstract class SoftCache<T> {
private Stack<Reference<T>> mRecyclingStack;
final Class<T> classType;
public SoftCache(Class<T> typeParameterClass) {
this.classType = typeParameterClass;
mRecyclingStack = new Stack<Reference<T>>();
}
/* implement this to create new object of type T if cache is empty */
public abstract T runWhenCacheEmpty();
/*
* retrieves last item from cache or creates a new T object if cache is
* empty
*/
public T get() {
T itemCached = null;
if (mRecyclingStack.isEmpty()) {
itemCached = runWhenCacheEmpty();
} else {
SoftReference<T> softRef = (SoftReference<T>) mRecyclingStack
.pop();
Object obj = softRef.get();
/*
* if referent object is empty(due to GC) then create a new
* object
*/
if (obj == null) {
itemCached = runWhenCacheEmpty();
}
/*
* otherwise restore from cache by casting the referent as the
* class Type that was passed to constructor
*/
else {
itemCached = (classType.cast(softRef.get()));
}
}
return itemCached;
}
現在從SoftCache繼承,所以我們可以實現runWhenCacheEmpty方法
SoftCache<View> myViewCache = new ViewCache(View.class);
現在
在destroyItem視圖保存到緩存::例如(但它可以用於任何類型的類工作)
@Override
public void destroyItem(final ViewGroup container, final int position, final Object object) {
final View v = (View) object;
if(v.getId() == R.id.mypagelayout)
myViewCache.put(v); //this saves it
}
現在方法instantiateItem利用它只是這樣的:
@Override
public Object instantiateItem(final ViewGroup container, final int position) {
View MyPageView=myViewCache.get();
}
更新:如果你要使用不同的佈局緩存或不喜歡把它擴大,我想出了一個解決方案,你可以使用多個佈局相同的高速緩存,你會獲取你把佈局中使用的佈局ID:
public class SoftViewCache {
private HashMap<Integer,ArrayList<SoftReference<View>>> multiMap;
public SoftViewCache() {
multiMap= new HashMap<Integer, ArrayList<SoftReference<View>>>();
}
/*
* retrieves cached item or return null if cache is
* empty
*/
public View get(int id) {
View itemCached = null;
if (!multiMap.containsKey(id)) {
return null;
}
else {
/*get the referent object and check if its already been GC if not we re-use*/
SoftReference<View> softRef =multiMap.get(id).get(0);
Object obj = softRef.get();
/*
* if referent object is empty(due to GC) then caller must create a new
* object
*/
if (null == obj) {
return null;
}
/*
* otherwise restore from cache
*/
else {
itemCached = (softRef.get());
}
}
return itemCached;
}
/* saves a view object to the cache by reference, we use a multiMap to allow
* duplicate IDs*/
public void put(View item) {
SoftReference<View> ref = new SoftReference<View>(item);
int key = item.getId();
/*check if we already have a reuseable layouts saved if so just add to the list
* of reusable layouts*/
if (multiMap.containsKey(key)) {
multiMap.get(key).add(ref);
} else {
/*otherwise we have no reusable layouts lets create a list of reusable layouts
* and add it to the multiMap*/
ArrayList<SoftReference<View>> list = new ArrayList<SoftReference<View>>();
list.add(ref);
multiMap.put(key, list);
}
}
}
非常感謝您! – penguin86