更新：如果您正在寻找2020年由Kotlin Coroutines支持的解决方案，请尝试Coil。

Coil是Coroutine Image Loader的缩写。

特征

快速：Coil执行许多优化，包括内存和磁盘缓存、在内存中对图像进行下采样、重新使用位图、自动暂停/取消请求等。轻量级：Coil为您的APK添加了约2000个方法（适用于已经使用OkHttp和Coroutines的应用程序），这与毕加索不相上下，明显少于Glide和Fresco。易于使用：Coil的API利用了Kotlin的语言特性，以实现简单和最小的样板。现代：Coil首先是Kotlin，它使用了包括Coroutines、OkHttp、Okio和AndroidX Lifecycles在内的现代库。

渐变设置：

线圈在mavenCentral（）上可用。

implementation("io.coil-kt:coil:1.0.0")

快速入门

要将图像加载到ImageView中，请使用加载扩展函数：

// URL
imageView.load("https://www.example.com/image.jpg")

// Resource
imageView.load(R.drawable.image)

// File
imageView.load(File("/path/to/image.jpg"))

或在后台线程上

// Coil (suspends the current coroutine; non-blocking and thread safe)
val request = ImageRequest.Builder(context)
    .data(url)
    .size(width, height)
    .build()
val drawable = context.imageLoader.execute(request).drawable

您也可以从Picasso/Glide迁移

此处提供完整文档

我遇到了这个问题，并实现了lruCache。我相信你需要API 12或更高版本，或者使用兼容的v4库。lurCache是快速内存，但它也有预算，所以如果你担心，你可以使用磁盘缓存。。。这都在缓存位图中描述。

现在我将提供我的实现，它是我从任何地方调用的单例，如下所示：

//Where the first is a string and the other is a imageview to load.

DownloadImageTask.getInstance().loadBitmap(avatarURL, iv_avatar);

以下是理想的代码，在检索web图像时，缓存并在适配器的getView中调用上述代码：

public class DownloadImageTask {

    private LruCache<String, Bitmap> mMemoryCache;

    /* Create a singleton class to call this from multiple classes */

    private static DownloadImageTask instance = null;

    public static DownloadImageTask getInstance() {
        if (instance == null) {
            instance = new DownloadImageTask();
        }
        return instance;
    }

    //Lock the constructor from public instances
    private DownloadImageTask() {

        // Get max available VM memory, exceeding this amount will throw an
        // OutOfMemory exception. Stored in kilobytes as LruCache takes an
        // int in its constructor.
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);

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

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

    public void loadBitmap(String avatarURL, ImageView imageView) {
        final String imageKey = String.valueOf(avatarURL);

        final Bitmap bitmap = getBitmapFromMemCache(imageKey);
        if (bitmap != null) {
            imageView.setImageBitmap(bitmap);
        } else {
            imageView.setImageResource(R.drawable.ic_launcher);

            new DownloadImageTaskViaWeb(imageView).execute(avatarURL);
        }
    }

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

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

    /* A background process that opens a http stream and decodes a web image. */

    class DownloadImageTaskViaWeb extends AsyncTask<String, Void, Bitmap> {
        ImageView bmImage;

        public DownloadImageTaskViaWeb(ImageView bmImage) {
            this.bmImage = bmImage;
        }

        protected Bitmap doInBackground(String... urls) {

            String urldisplay = urls[0];
            Bitmap mIcon = null;
            try {
                InputStream in = new java.net.URL(urldisplay).openStream();
                mIcon = BitmapFactory.decodeStream(in);

            } 
            catch (Exception e) {
                Log.e("Error", e.getMessage());
                e.printStackTrace();
            }

            addBitmapToMemoryCache(String.valueOf(urldisplay), mIcon);

            return mIcon;
        }

        /* After decoding we update the view on the main UI. */
        protected void onPostExecute(Bitmap result) {
            bmImage.setImageBitmap(result);
        }
    }
}

以下是我创建的用于保存应用程序当前显示的图像的内容。请注意，这里使用的“Log”对象是我对Android中最终Log类的自定义包装。

package com.wilson.android.library;

/*
 Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
*/
import java.io.IOException;

public class DrawableManager {
    private final Map<String, Drawable> drawableMap;

    public DrawableManager() {
        drawableMap = new HashMap<String, Drawable>();
    }

    public Drawable fetchDrawable(String urlString) {
        if (drawableMap.containsKey(urlString)) {
            return drawableMap.get(urlString);
        }

        Log.d(this.getClass().getSimpleName(), "image url:" + urlString);
        try {
            InputStream is = fetch(urlString);
            Drawable drawable = Drawable.createFromStream(is, "src");


            if (drawable != null) {
                drawableMap.put(urlString, drawable);
                Log.d(this.getClass().getSimpleName(), "got a thumbnail drawable: " + drawable.getBounds() + ", "
                        + drawable.getIntrinsicHeight() + "," + drawable.getIntrinsicWidth() + ", "
                        + drawable.getMinimumHeight() + "," + drawable.getMinimumWidth());
            } else {
              Log.w(this.getClass().getSimpleName(), "could not get thumbnail");
            }

            return drawable;
        } catch (MalformedURLException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        } catch (IOException e) {
            Log.e(this.getClass().getSimpleName(), "fetchDrawable failed", e);
            return null;
        }
    }

    public void fetchDrawableOnThread(final String urlString, final ImageView imageView) {
        if (drawableMap.containsKey(urlString)) {
            imageView.setImageDrawable(drawableMap.get(urlString));
        }

        final Handler handler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message message) {
                imageView.setImageDrawable((Drawable) message.obj);
            }
        };

        Thread thread = new Thread() {
            @Override
            public void run() {
                //TODO : set imageView to a "pending" image
                Drawable drawable = fetchDrawable(urlString);
                Message message = handler.obtainMessage(1, drawable);
                handler.sendMessage(message);
            }
        };
        thread.start();
    }

    private InputStream fetch(String urlString) throws MalformedURLException, IOException {
        DefaultHttpClient httpClient = new DefaultHttpClient();
        HttpGet request = new HttpGet(urlString);
        HttpResponse response = httpClient.execute(request);
        return response.getEntity().getContent();
    }
}

除了异步加载数据缓存外，您可能需要UI缓存，如setViewCacheSize

除了加载可见项数据外，您可能需要加载近似的可见项数据

AndroidX分页库是另一个选项，例如，您可以从SQLite数据库加载、缓存和显示10000000个项目到RecyclerView。参考PagedList

例子：假设列表视图可见项为[6,7,8,9,10]，您可能需要加载[6,7,8,10]并预加载项[1，2，3，4，5]和[11，12，13，14，15]，因为用户可能会滚动到前页或后页

我这样做的方式是启动一个线程，在后台下载图像，并为每个列表项传递一个回调。当图像下载完成后，它将调用回调，以更新列表项的视图。

然而，当您回收视图时，这种方法不太有效。

你必须试试这个通用加载器。我在做了很多关于延迟加载的RnD之后使用了这个。

通用图像加载器

特征

多线程图像加载（异步或同步）ImageLoader配置的广泛定制（线程执行器、下载器、解码器、内存和磁盘缓存、显示图像选项等）每个显示图像调用都有许多自定义选项（存根图像、缓存开关、解码选项、位图处理和显示等）内存和/或磁盘上的图像缓存（设备的文件系统或SD卡）收听加载过程（包括下载进度）

Android 2.0+支持