例如使用机器人会lrucache(Example using Androids lrucache)

我需要帮助理解机器人LruCache。 我想用加载图片到我的GridView为了使装载/滚动要好。 使用有人可以张贴的示例代码LruCache请。 提前致谢。

Answer 1:

下面是一类我使用LruCache制成，这是基于演示事半功倍：作为在谷歌I / O 2012 给出的Android好公民 。

退房左右的动画，我在做什么的更多信息TCImageLoader类：

public class TCImageLoader implements ComponentCallbacks2 {
    private TCLruCache cache;

    public TCImageLoader(Context context) {
        ActivityManager am = (ActivityManager) context.getSystemService(
            Context.ACTIVITY_SERVICE);
        int maxKb = am.getMemoryClass() * 1024;
        int limitKb = maxKb / 8; // 1/8th of total ram
        cache = new TCLruCache(limitKb);
    }

    public void display(String url, ImageView imageview, int defaultresource) {
        imageview.setImageResource(defaultresource);
        Bitmap image = cache.get(url);
        if (image != null) {
            imageview.setImageBitmap(image);
        }
        else {
            new SetImageTask(imageview).execute(url);
        }
    }

    private class TCLruCache extends LruCache<String, Bitmap> {

        public TCLruCache(int maxSize) {
            super(maxSize);
        }

        @Override
        protected int sizeOf(ImagePoolKey key, Bitmap value) {
            int kbOfBitmap = value.getByteCount() / 1024;
            return kbOfBitmap;
        }
    }

    private class SetImageTask extends AsyncTask<String, Void, Integer> {
        private ImageView imageview;
        private Bitmap bmp;

        public SetImageTask(ImageView imageview) {
            this.imageview = imageview;
        }

        @Override
        protected Integer doInBackground(String... params) {
            String url = params[0];
            try {
                bmp = getBitmapFromURL(url);
                if (bmp != null) {
                    cache.put(url, bmp);
                }
                else {
                    return 0;
                }
            } catch (Exception e) {
                e.printStackTrace();
                return 0;
            }
            return 1;
        }

        @Override
        protected void onPostExecute(Integer result) {
            if (result == 1) {
                imageview.setImageBitmap(bmp);
            }
            super.onPostExecute(result);
        }

        private Bitmap getBitmapFromURL(String src) {
            try {
                URL url = new URL(src);
                HttpURLConnection connection
                    = (HttpURLConnection) url.openConnection();
                connection.setDoInput(true);
                connection.connect();
                InputStream input = connection.getInputStream();
                Bitmap myBitmap = BitmapFactory.decodeStream(input);
                return myBitmap;
            } catch (IOException e) {
                e.printStackTrace();
                return null;
            }
        }

    }

    @Override
    public void onConfigurationChanged(Configuration newConfig) {
    }

    @Override
    public void onLowMemory() {
    }

    @Override
    public void onTrimMemory(int level) {
        if (level >= TRIM_MEMORY_MODERATE) {
            cache.evictAll();
        }
        else if (level >= TRIM_MEMORY_BACKGROUND) {
            cache.trimToSize(cache.size() / 2);
        }
    }
}

Answer 2:

我发现完美的我是一个工作非常简单的方法...

这是Cache.java类。 在这个类，静态getInstance()方法，使我们在整个应用程序只能创建一个缓存实例。 getLru()方法用于检索缓存的对象，将在后面示出如何使用它。 这个缓存是通用的，这意味着你可以保存任何对象类型进去。 高速缓存内存大小这里设置为1024，可如果它太小被改变：

import android.support.v4.util.LruCache;

public class Cache {

    private static Cache instance;
    private LruCache<Object, Object> lru;

    private Cache() {

        lru = new LruCache<Object, Object>(1024);

    }

    public static Cache getInstance() {

        if (instance == null) {

            instance = new Cache();
        }

        return instance;

    }

    public LruCache<Object, Object> getLru() {
        return lru;
    }
}

这是在你的活动，你的位图保存到缓存中的代码：

public void saveBitmapToCahche(){

        //The imageView that you want to save it's bitmap image resourse
        ImageView imageView = (ImageView) findViewById(R.id.imageViewID);

        //To get the bitmap from the imageView
        Bitmap bitmap = ((BitmapDrawable)imageview.getDrawable()).getBitmap();

        //Saving bitmap to cache. it will later be retrieved using the bitmap_image key
        Cache.getInstance().getLru().put("bitmap_image", bitmap);
    }

这是你从缓存中检索位图的代码，然后设置一个ImageView的这个位图：

public void retrieveBitmapFromCache(){

        //The imageView that you want to set to the retrieved bitmap
        ImageView imageView = (ImageView) findViewById(R.id.imageViewID);

        //To get bitmap from cache using the key. Must cast retrieved cache Object to Bitmap
        Bitmap bitmap = (Bitmap)Cache.getInstance().getLru().get("bitmap_image");

        //Setting imageView to retrieved bitmap from cache
        imageView.setImageBitmap(bitmap));

}

就这样！ 正如你可以看到这是相当容易和简单。

• 例：

在我的应用程序，所有的意见都保存在类变量，使他们能够在类的所有方法中可以看出。 在我的第一个活动，我将图像保存位图缓存在onClickButton()方法，之前，我使用的意图开始一个新的活动。 我还保存在我的缓存的字符串值：

public void onClickButton(View v){

    Bitmap bitmap = ((BitmapDrawable)imageView.getDrawable()).getBitmap();
    String name = textEdit.getText().toString();

    Cache.getInstance().getLru().put("bitmap_image", bitmap);
    Cache.getInstance().getLru().put("name", name);

    Intent i = new Intent(FirstActivity.this, SecondActivity.class);
    startActivity(i);
}

然后，我从第二活动导航到第三个活动也使用意图。 在过去的活动我救其他物体进入我的缓存，然后使用意图回到第一个活动。 当我回来的第一个活动，在onCreate()方法将启动。 在该方法中，检查我的缓存有任何位映射值，或单独的任何字符串值（根据我的应用业务）：

public ImageView imageView;
public EditText editText;

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_first);

        //...Other code...

        //The imageView that you want to save it's bitmap image resourse
        imageView = (ImageView) findViewById(R.id.imageViewID);

        //The editText that I want to save it's text into cache
        editText = (EditText)findViewById(R.id.editTextID);

        if(Cache.getInstance().getLru().get("name")!=null){
             editText.setText(Cache.getInstance().getLru().get("name").toString());
        }
        if(Cache.getInstance().getLru().get("bitmap_image")!=null){
             imageView.setImageBitmap((Bitmap)Cache.getInstance().getLru().get("bitmap_image"));
        }

        //...Other code...
    }

Answer 3:

看看缓存位图 ，其中使用LruCache证明。

代码的网页中的相关部分如下： -

private LruCache mMemoryCache;

@Override
protected void onCreate(Bundle savedInstanceState) {
    ...
    // Get memory class of this device, exceeding this amount will throw an
    // OutOfMemory exception.
    final int memClass = ((ActivityManager) context.getSystemService(
            Context.ACTIVITY_SERVICE)).getMemoryClass();

    // Use 1/8th of the available memory for this memory cache.
    final int cacheSize = 1024 * 1024 * memClass / 8;

    mMemoryCache = new LruCache(cacheSize) {
        @Override
        protected int sizeOf(String key, Bitmap bitmap) {
            // The cache size will be measured in bytes rather than number of items.
            return bitmap.getByteCount();
        }
    };
    ...
}

public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
    if (getBitmapFromMemCache(key) == null) {
        mMemoryCache.put(key, bitmap);
    }
}

public Bitmap getBitmapFromMemCache(String key) {
    return mMemoryCache.get(key);
}

Answer 4:

https://techienotes.info/2015/08/28/caching-bitmaps-in-android-using-lrucache/

此链接有一个完整的有计划的示例应用程序加载使用LruCache图像转换成的GridView。

这个类是使用LruCache并从链接中给出的代码取

public class ImageAdapter extends BaseAdapter{
private String TAG = getClass().getSimpleName();
Context mContext;
ArrayList<Uri> imageList;

private LruCache<String, Bitmap> mLruCache;

public ImageAdapter (Context context){
    mContext = context;

    //Find out maximum memory available to application
    //1024 is used because LruCache constructor takes int in kilobytes
    final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

    // Use 1/4th of the available memory for this memory cache.
    final int cacheSize = maxMemory / 4;
    Log.d(TAG, "max memory " + maxMemory + " cache size " + cacheSize);

    // LruCache takes key-value pair in constructor
    // key is the string to refer bitmap
    // value is the stored bitmap
    mLruCache = new LruCache<String, Bitmap>(cacheSize) {
        @Override
        protected int sizeOf(String key, Bitmap bitmap) {
            // The cache size will be measured in kilobytes
            return bitmap.getByteCount() / 1024;
        }
    };

    imageList  = new ArrayList<Uri>();
    //Change this directory to where the images are stored
    String imagesFolderPath = Environment.getExternalStorageDirectory().getPath()+"/backups/";

    File imageSrcDir = new File (imagesFolderPath);
    // if directory not present, build it
    if (!imageSrcDir.exists()){
        imageSrcDir.mkdirs();
    }

    ArrayList<File> imagesInDir = getImagesFromDirectory(imageSrcDir);

    for (File file: imagesInDir){
        // imageList will hold Uri of all images
        imageList.add(Uri.fromFile(file));
    }
}

@Override
public int getCount() {
    return imageList.size();
}

@Override
public Object getItem(int position) {
    return null;
}

@Override
public long getItemId(int position) {
    return 0;
}

/**
 *
 * @param position The position of the item within the
 *                 adapter's data set of the item whose view we want.
 * @param convertView it is the view to be reused
 * @param parent The parent that this view will eventually be attached to
 * @return a View corresponding to the data at the specified position.
 */
@Override
public View getView(int position, View convertView, ViewGroup parent) {
    ImageView imageView;
    Bitmap thumbnailImage = null;
    if (convertView == null){
        imageView = new ImageView(mContext);
        imageView.setLayoutParams(
                //150,150 is size of imageview to display image
                new GridView.LayoutParams(150, 150));
        imageView.setScaleType(ImageView.ScaleType.CENTER_CROP);
    }
    else {
        imageView = (ImageView)convertView;
    }

    // Use the path as the key to LruCache
    final String imageKey = imageList.get(position).toString();

    //thumbnailImage is fetched from LRU cache
    thumbnailImage = getBitmapFromMemCache(imageKey);

    if (thumbnailImage == null){
        // if asked thumbnail is not present it will be put into cache
        BitmapWorkerTask task = new BitmapWorkerTask(imageView);
        task.execute(imageKey);
    }

    imageView.setImageBitmap(thumbnailImage);
    return imageView;
}

/**
 * This function returns the files from a directory
 * @param parentDirPath source directory in which images are located
 * @return list of Files
 */
private ArrayList<File> getImagesFromDirectory (File parentDirPath){
    ArrayList <File> listOfImages =  new ArrayList<File>();
    File [] fileArray = null;

    if ( parentDirPath.isDirectory() ){//parentDirPath.exists() &&
        //    &&
         //   parentDirPath.canRead()){
        fileArray = parentDirPath.listFiles();
    }

    if (fileArray == null){
        return listOfImages;    // return empty list
    }

    for (File file: fileArray){
        if (file.isDirectory()){
            listOfImages.addAll(getImagesFromDirectory(file));
        }
        else {
            // Only JPEG and PNG formats are included
            // for sake of simplicity
            if (file.getName().endsWith("png") ||
                    file.getName().endsWith("jpg")){
                listOfImages.add(file);
            }
        }
    }
    return listOfImages;
}

/**
 *  This function will return the scaled version of original image.
 *  Loading original images into thumbnail is wastage of computation
 *  and hence we will take put scaled version.
 */
private Bitmap getScaledImage (String imagePath){
    Bitmap bitmap = null;
    Uri imageUri = Uri.parse (imagePath);
    try{
        BitmapFactory.Options options = new BitmapFactory.Options();

        /**
         * inSampleSize flag if set to a value > 1,
         * requests the decoder to sub-sample the original image,
         * returning a smaller image to save memory.
         * This is a much faster operation as decoder just reads
         * every n-th pixel from given image, and thus
         * providing a smaller scaled image.
         * 'n' is the value set in inSampleSize
         * which would be a power of 2 which is downside
         * of this technique.
         */
        options.inSampleSize = 4;

        options.inScaled = true;

        InputStream inputStream = mContext.getContentResolver().openInputStream(imageUri);

        bitmap = BitmapFactory.decodeStream(inputStream, null, options);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    }

    return bitmap;
}

public void addBitmapToMemoryCache(String key, Bitmap bitmap) {
    if (getBitmapFromMemCache(key) == null) {
        mLruCache.put(key, bitmap);
    }
}

public Bitmap getBitmapFromMemCache(String key) {
    return mLruCache.get(key);
}

class BitmapWorkerTask extends AsyncTask<String, Void, Bitmap> {

    private final WeakReference<ImageView> imageViewReference;

    public BitmapWorkerTask(ImageView imageView) {
        // Use a WeakReference to ensure the ImageView can be garbage collected
        imageViewReference = new WeakReference<ImageView>(imageView);
    }

    @Override
    protected Bitmap doInBackground(String... params) {
        final Bitmap bitmap = getScaledImage(params[0]);
        addBitmapToMemoryCache(String.valueOf(params[0]), bitmap);
        return bitmap;
    }

    //  onPostExecute() sets the bitmap fetched by doInBackground();
    @Override
    protected void onPostExecute(Bitmap bitmap) {
        if (imageViewReference != null && bitmap != null) {
            final ImageView imageView = (ImageView)imageViewReference.get();
            if (imageView != null) {
                imageView.setImageBitmap(bitmap);
            }
        }
    }
}
}

Answer 5:

工具类保存并从自己的缓存中检索位图。

package com.roomco.android.utils;

import android.graphics.Bitmap;
import android.support.v4.util.LruCache;


public class MyCache {

      private static MyCache instance;
      private LruCache<Object, Object> lru;

      private MyCache() {

         lru = new LruCache<Object, Object>(1024);

       }

    public static MyCache getInstance() {

        if (instance == null) {
        instance = new MyCache();
       }
       return instance;

    }

   public LruCache<Object, Object> getLru() {
       return lru;
   }

  public void saveBitmapToCahche(String key, Bitmap bitmap){

      MyCache.getInstance().getLru().put(key, bitmap);
  }

  public Bitmap retrieveBitmapFromCache(String key){

      Bitmap bitmap = (Bitmap)MyCache.getInstance().getLru().get(key);
      return bitmap;
  }

}

用法：

//Save bitmap in cache
MyCache.getInstance().saveBitmapToCahche("your_key",bitmap);
// Get bitmap from cache
MyCache.getInstance().retrieveBitmapFromCache("your_key");

文章来源: Example using Androids lrucache