读《Android开发艺术探索》----ImageLoader的实现

最新推荐文章于 2019-06-17 17:03:00 发布
最新推荐文章于 2019-06-17 17:03:00 发布
阅读量1.3k 收藏 4
点赞数 1
分类专栏： Android进阶 文章标签： ImageLoader LruCache DiskLruCache 缓存策略
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011521890/article/details/50477725
版权

bitmap的高效加载和cache存储的策略

1.1 bitmap的高效加载。
----|bitmap的加载图片的四种方式，decodeFile、decodeResource、decodeStream
     decodeByteArray.
----|使用bitmapFactory.options方法进行图片的缩放。
      图片缩放的策略是 采用inSampleSize(采样率)来设置缩放的比例大小。

通过这种方式来高效的加载图片，并不是直接加载原图

package lzl.edu.com.bitmapcachedemo.util;

import android.content.res.Resources;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;

import java.io.FileDescriptor;

/**
 * Created by admin on 2016/1/6.
 * 图片的高效加载。分别是从资源文件中加载和本地文件中加载
 */
public class ImageResizer {
    /**
     * 从资源文件中加载图片。
     * @param res
     * @param resId
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static Bitmap decodeSampleBitmapFromResource(Resources res,int resId,int reqWidth,int reqHeight){

        BitmapFactory.Options options = new BitmapFactory.Options();
        //第一个options设置为true，去加载图片
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeResource(res,resId,options);
        //计算采样率
        options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeResource(res,resId,options);
    }

    /**
     * 从内存卡中加载图片
     * @param fd
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public static Bitmap decodeSampleBitmapFromFile(FileDescriptor fd,int reqWidth,int reqHeight){
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFileDescriptor(fd,null,options);
        options.inSampleSize = calculateInSampleSize(options,reqWidth,reqHeight);
        options.inJustDecodeBounds = false;

        return BitmapFactory.decodeFileDescriptor(fd,null,options);
    }
    /**
     *计算图片的采样率
     * 原理，如果设置的图片宽、高小于原图的宽、高。则inSampleSize呈2的指数缩小
     * @param options
     * @param reqWidth
     * @param reqHeight
     * @return
     */

    private static int calculateInSampleSize(BitmapFactory.Options options,int reqWidth,int reqHeight){
        if(reqHeight==0 || reqWidth ==0){
            return 1;
        }
        //默认的采样率
        int inSampleSize = 1;
        //获取原图的宽高
        int width = options.outWidth;
        int height = options.outHeight;

        if(width > reqWidth || height > reqHeight){
            int halfWidth = width / 2;
            int halfHeight = height / 2;
            while((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth){
                inSampleSize *= 2;
            }
        }
        return inSampleSize;
    }
}

ImageLoader的实现

package lzl.edu.com.bitmapcachedemo.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.Build;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.os.StatFs;
import android.util.Log;
import android.util.LruCache;
import android.widget.ImageView;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileDescriptor;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import lzl.edu.com.bitmapcachedemo.R;

/**
 * Created by admin on 2016/1/6.
 * 图片的高效缓存类。
 * 主要通过LruCache内存缓存和DiskLruCache磁盘缓存来工作。
 * 该类的实现思想：
  通过loadBitmap方法来分别从缓存、磁盘和网络中加载图片(这里是一层一层来判断的，
 * 如果缓存中有这个图片程序变不再向下执行)。
 * 步骤：
 * 1、ImageLoader构造方法，初始化LruCache和DiskLruCache类。
 * 2、分别实现LruCache和DiskLruCache的增加、删除、查找方法。
   3、通过LoadBitmap方法分别从缓存中加载bitmap、磁盘中加载图片、网络中加载图片。
 */
public class ImageLoader {
    private static final String TAG = "ImageLoader";
    private LruCache<String,Bitmap> mMemoryCache;
    private DiskLruCache mDiskLruCache;
    private Context mContext;
    private boolean mIsDiskLruCacheCreated = false;
    private static final int TAG_KEY_URI = R.id.mImageView;
    private static final int IO_BUFFER_SIZE = 8*1024;
    private static final long DISK_CACHE_SIZE = 1024 * 1024 * 50;
    private static final int DISK_CACHE_INDEX = 0;
    private static final int MESSAGE_POST_result = 1;

    //cpu核心数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    //cpu核心线程数
    private static final int CORE_POOL_SIZE = CPU_COUNT +1;
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT *2+1;
    //线程超时时长
    private static final long KEEP_ALIVE = 10l;

    private static final ThreadFactory sThreadFactory = new ThreadFactory() {
        private final AtomicInteger mCount = new AtomicInteger(1);

        @Override
        public Thread newThread(Runnable r) {
            return new Thread(r,"imageLoader#"+mCount.getAndIncrement());
        }
    };
    public static final Executor THREAD_POOL_EXECUTOR = new ThreadPoolExecutor(
            CORE_POOL_SIZE,MAXIMUM_POOL_SIZE,KEEP_ALIVE, TimeUnit.SECONDS,
            new LinkedBlockingDeque<Runnable>(),sThreadFactory);
    private Handler mMainHandler = new Handler(Looper.getMainLooper()){
        @Override
        public void handleMessage(Message msg) {
            LoaderResult result = (LoaderResult) msg.obj;
            ImageView iv = result.imageView;
            Bitmap bitmap = result.bitmap;
            String getUrl = (String) iv.getTag(TAG_KEY_URI);
            if(getUrl.equals(result.url)){
                iv.setImageBitmap(bitmap);
            }else{
                Log.i(TAG,"set image bitmap,but url has changed");
            }
        }
    };
    //无参构造方法，来初始化LruCache|DiskLruCache
    public ImageLoader(Context context){
        mContext = context.getApplicationContext();
        initLruCache();
        initDiskLruCache();
    }

    /**
     * 初始化LruCache
     */
    private void initLruCache(){
        //计算缓存的大小
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        //设置缓存大小为当前进程可用内存的1/8
        int cacheSize = maxMemory / 8;
        mMemoryCache = new LruCache<String, Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };
    }

    /**
     * 初始化DiskLruCache
     */
    private void initDiskLruCache(){
        File diskCacheDir = getDiskCacheDir(mContext,"bitmap");
        if(!diskCacheDir.exists()){ //如果不存在你们 创建目录
            diskCacheDir.mkdir();
        }
        if(getUsableSpace(diskCacheDir) > DISK_CACHE_SIZE) {
            try {
                mDiskLruCache = DiskLruCache.open(diskCacheDir, 1, 1, DISK_CACHE_SIZE);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    public void bindBitmap(String url,ImageView imageView){
        bindBitmap(url,imageView,0,0);
    }
    /**
     * 通过异步方式加载bitmap。
     * 步骤，先从缓存中加载bitmap，如果存在就直接返回，并设置图片。
     * 不存在，就会在线程池中调用loadBitmap方法，来更新UI
     * @param url
     * @param imageView
     * @param reqWidth
     * @param reqHeight
     */
    public void bindBitmap(final String url, final ImageView imageView,final int reqWidth,
                           final int reqHeight){
        imageView.setTag(TAG_KEY_URI,url);
        Bitmap bitmap = loadBitmapFromMemCache(url);
        if(bitmap!=null){
            imageView.setImageBitmap(bitmap);
            return;
        }
        //缓存中不存在bitmap图片
        Runnable loadBitmapTask = new Runnable() {
            @Override
            public void run() {
                //线程池中加载bitmap，调用loadBitmap()方法
                Bitmap bitmap = loadBitmap(url,reqWidth,reqHeight);
                if(bitmap!=null){
                    LoaderResult result = new LoaderResult(imageView,url,bitmap);
                    mMainHandler.obtainMessage(MESSAGE_POST_result,result).sendToTarget();
                }
            }
        };
        THREAD_POOL_EXECUTOR.execute(loadBitmapTask);
    }
    /**
     * 获取磁盘中可用的空间
     * @param path
     * @return
     */
    private long getUsableSpace(File path) {
        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD){
            return path.getUsableSpace();
        }
        final StatFs stats = new StatFs(path.getPath());
        return stats.getBlockSize()*stats.getAvailableBlocks();
    }

    /**
     * 同步加载网络图片
     * 加载图片的顺序：
     * 缓存中加载图片--->磁盘中加载图片--->网络中加载图片
     * @param url
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    public Bitmap loadBitmap(String url,int reqWidth,int reqHeight){
        //从缓冲中加载图片
        Bitmap bitmap = loadBitmapFromMemCache(url);
        if(bitmap!=null){
            return bitmap;
        }
        try {
            //从磁盘中加载bitmap
            bitmap = loadBitmapFromDiskCache(url,reqWidth,reqHeight);
            if(bitmap !=null){
                return bitmap;
            }
            //从网络中加载bitmap
            bitmap = loadBitmapFromHttp(url, reqWidth, reqHeight);
        } catch (IOException e) {
            e.printStackTrace();
        }
        if(bitmap == null && !mIsDiskLruCacheCreated){
        //如果bitmap为空，并且，磁盘中没有缓存bitmap。那么通过url路径来获取bitmap
            bitmap = downloadBitmapFromUrl(url);
        }
        return bitmap;
    }

    /**
     * 通过url路径加载网络图片，
     * 获取bitmap。
     * @param urlString
     * @return
     */
    private Bitmap downloadBitmapFromUrl(String urlString) {
        Bitmap bitmap = null;
        HttpURLConnection conn = null;
        BufferedInputStream bis = null;
        try {
            URL url = new URL(urlString);
            conn = (HttpURLConnection) url.openConnection();
            bis = new BufferedInputStream(conn.getInputStream(),IO_BUFFER_SIZE);
            bitmap = BitmapFactory.decodeStream(bis);
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if(conn!=null)
                conn.disconnect();
            if(bis!=null){
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return bitmap;
    }

    /**
     * 从缓存中加载bitmap
     * @param url
     * @return
     */
    private Bitmap loadBitmapFromMemCache(String url) {
        String key = hashKeyFromUrl(url);
        Log.i(TAG,"从缓存中加载数据");
        return getBitmapFromMemoryCache(key);
    }

    /**
     * LruCache的添加方法
     * 存储到缓存中。
     * @param key
     * @param bitmap
     */
    private void addBitmapToMemoryCache(String key,Bitmap bitmap){
        if(getBitmapFromMemoryCache(key)!=null)
            mMemoryCache.put(key,bitmap);
    }

    /**
     * LruCache的查找方法
     * 从缓冲中查询
     * @param key
     * @return
     */
    private Bitmap getBitmapFromMemoryCache(String key){
        return mMemoryCache.get(key);
    }

    /**
     * 获取磁盘的存储目录，并创建目录
     * @param mContext
     * @param bitmap
     * @return
     */
    private File getDiskCacheDir(Context mContext, String bitmap) {
        boolean externalStorageAvailable = Environment.getExternalStorageState().
                equals(Environment.MEDIA_MOUNTED);
        final String cachePath;
        if(externalStorageAvailable){
            cachePath = mContext.getExternalCacheDir().getPath();
        }else{
            cachePath = mContext.getCacheDir().getPath();
        }
        return new File(cachePath + File.separator+ bitmap);
    }

    /**
     * DiskLruCache添加方法(存储)
     * 将图片写入到本地文件中。
     * @param urlString
     * @param outputStream
     * @return
     */
    private boolean downloadUrlToStream(String urlString, OutputStream outputStream){
        HttpURLConnection conn = null;
        BufferedInputStream in = null;
        BufferedOutputStream out = null;
        try {
            URL url = new URL(urlString);
            conn = (HttpURLConnection) url.openConnection();
            in = new BufferedInputStream(conn.getInputStream(),IO_BUFFER_SIZE);
            out = new BufferedOutputStream(outputStream,IO_BUFFER_SIZE);
            int b;
            while((b = in.read())!=-1){
                out.write(b);
            }
            return true;
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            if(conn !=null)
                conn.disconnect();
            if(in!=null) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(out!=null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return false;
    }

    /**
     * 从网络上加载图片
     * @param urlString
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    private Bitmap loadBitmapFromHttp(String urlString,int reqWidth,int reqHeight) throws IOException {
        Log.i(TAG,"从网络中加载数据");

        if(Looper.myLooper() == Looper.getMainLooper()){
            throw new RuntimeException("不能从主线程中访问网络图片");
        }
        if(mDiskLruCache == null){
            return null;
        }
        //将url转换成key
        String key = hashKeyFromUrl(urlString);
        DiskLruCache.Editor editor = mDiskLruCache.edit(key);
        if(editor!=null){
            OutputStream outputStream = editor.newOutputStream(DISK_CACHE_INDEX);
            if(downloadUrlToStream(urlString,outputStream)){ //存储到本地文件夹中
                editor.commit();
            }else{
                editor.abort();
            }
        }
        mDiskLruCache.flush();
        return loadBitmapFromDiskCache(urlString,reqWidth,reqHeight);
    }

    /**
     * 将url转换成String类型的key值
     * 这里采用url的md5值作为key值
     * @param url
     * @return
     */
    private String hashKeyFromUrl(String url){
        String cacheKey;
        try {
            final MessageDigest mDigest = MessageDigest.getInstance("MD5");
            mDigest.update(url.getBytes());
            cacheKey = bytesToHexString(mDigest.digest());
        } catch (NoSuchAlgorithmException e) {
           cacheKey = String.valueOf(url.hashCode());
        }
        return cacheKey;
    }

    /**
     * 具体将url转换成MD5值的方式。
     * @param digest
     * @return
     */
    private String bytesToHexString(byte[] digest) {
        StringBuilder sb = new StringBuilder();
        for(int i=0;i<digest.length;i++){
            String hex = Integer.toHexString(0xFF & digest[i]);
            if(hex.length() == 1){
                sb.append("0");
            }
            sb.append(hex);
        }
        return sb.toString();
    }

    /**
     * DiskLruCache是查询方法
     * 从磁盘中获取Bitmap
     * @param urlString
     * @param reqWidth
     * @param reqHeight
     * @return
     */
    private Bitmap loadBitmapFromDiskCache(String urlString, int reqWidth, int reqHeight) throws IOException {
        Log.i(TAG,"从磁盘中加载数据");
        if(Looper.myLooper() == Looper.getMainLooper()){
            throw new RuntimeException("不能从主线程中加载图片");
        }
        if(mDiskLruCache == null){
            return null;
        }
        Bitmap bitmap = null;
        String key = hashKeyFromUrl(urlString);
        //通过key值获取磁盘中的输入流
        DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
        if(snapshot !=null){
            FileInputStream fileInputStream = (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
            FileDescriptor descriptor = fileInputStream.getFD();
            //通过写的一个ImageResizer高效加载图片
            bitmap = ImageResizer.decodeSampleBitmapFromFile(descriptor,reqWidth,reqHeight);
            if(bitmap !=null){
                //向缓存中加入图片
                addBitmapToMemoryCache(key,bitmap);
            }
        }
        return bitmap;
    }

    /**
     * 静态方法创建ImageLoader
     * @param context
     * @return
     */
    public static ImageLoader bindBitmap(Context context){
        return new ImageLoader(context);
    }

    private class LoaderResult {
        public ImageView imageView;
        public String url;
        public Bitmap bitmap;
        public LoaderResult(ImageView imageView, String url, Bitmap bitmap) {
            this.bitmap = bitmap;
            this.imageView = imageView;
            this.url = url;
        }
    }
}

这里附上ImageLoader的代码实现和例子点击打开链接


阿卧
关注
专栏目录
Android--Bitmap加载&ImageLoader
Sin的博客
03-17 1800
在Android的初级开发阶段，我们只关注如何实现我们的功能————不管黑猫白猫，抓到老鼠就是好猫。但在这个过程中我们很容易会忽略一些东西，如性能的损失、内存泄漏、代码耦合度高，逻辑混乱以及因此带来的代码混乱。
Android 开发艺术探索笔记（22），kotlin协程和线程的区别
m0_64604042的博客
12-19 280
![这里写图片描述](https://img-blog.csdn.net/20180802151128991?watermark/2/text/aHR0cHM6Ly9ibG9 《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》 【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享 nLmNzZG4ubmV0L3Jpa2thdGhld29ybGQ=/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==
ImageLoader的代码实现和一个例子
01-07
通过学习《Android开发艺术探索》书籍的里面的例子，实现了一个ImageLoader缓存策略的例子。希望与大家一起分享学习。
Android开发艺术探索 - 第7章 Android动画深入分析
Think，Make
06-17 260
Animation resources Property Animation Overview 1.View动画 Tween补间动画 四种动画效果，平移TranslateAnimation、缩放ScaleAnimation、旋转RotateAnimation和透明度AlphaAnimation，xml中对应四种标签的定义方式（res/anim/xxx.xml）：<?xml version=...
android探索
x_nam的专栏
03-16 204
1.      平版电脑系统分析 对于平板设备而言，目前正处于一个飞速发展的节点，有大量的硬件提供商、软件开发商和内容提供商进入这领域，使得我们有了很多选择。同样也伴随着混乱，不同平版电脑的操作系统，进入市场导致这个市场处于“战国”时代。我们如何选择一款操作系统进行内容开发，这就成了我们需要看清的问题。对于这类的问题我在之前分析富客户端解决方案的时候，就提出过考虑问题的策略那就是： 1. ...
Android 开发艺术探索笔记（8）
RikkaTheWorld
07-14 380
Binder连接池 当一个项目很庞大的时候，可能会用到很多的Service和AIDL接口，这会显得很难管理。 这时候我们采用Binder连接池，将所有的AIDL放在一个Service来管理。每个模块只需要创建并实现AIDL及其细节，然后向服务端发送自己的唯一标志。服务端用queryBinder来找到对应的Binder并返回这个对象，当这个模块得到Binder的时候就可以。 步骤是：（假定...
读Android开发艺术探索笔记(LruCache+DiskLruCache实现强大的图片加载)
大后生大大大的博客
11-19 414
LruCache用于实现内存缓存，DiskLruCache充当了存储设备缓存也就是存储到SD卡。 LruCache：     初始化LruCache:         private int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);     private int cache
Android开发艺术探索.任玉刚(带详细书签).pdf
01-25
本书是一本Android进阶类书籍，采用理论、源码和实践相结合的方式来阐述高水准的Android应用开发要点。本书从三个方面来组织内容。第一，介绍Android开发者不容易掌握的一些知识点；第二，结合Android源代码和应用层...
Android开发艺术探索
07-19
　12.2.3 ImageLoader的实现 / 424 　12.3 ImageLoader的使用 / 441 　12.3.1 照片墙效果 / 441 　12.3.2 优化列表的卡顿现象 / 446 　第13章 综合技术 / 448 　13.1 使用CrashHandler来获取应用的crash信息 / 449 ...
实现自己的ImageLoader（4）------同步异步加载与完整demo
yuwang_00的博客
04-05 992
完整demo以及最后异步加载的逻辑
图片加载类ImageLoader原理总结
xiaoyinliuyun的专栏
08-07 604
《Android开发艺术探索》中提供的ImageLoader原理总结
Android 开发艺术探索笔记（16）
RikkaTheWorld
07-23 349
插值器和估值器 TimeInterpolator中文翻译为时间插值器，它的作用是根据时间流逝的百分比来计算出当前属性改变的百分比。系统预置了一些插值器（线性插值器，加减速插值器等）。 TypeEvaluator的中文翻译为类型估值算法，也叫估值器，它的作用是根据当前属性改变的百分比来计算改变后的属性值。系统也预置了一些估值器。 插值器和估值器的作用是让动画进行非匀速运动。 这是一组动画...
ImageLoader的使用（Android开发艺术探索）
RikkaTheWorld
08-03 450
之前在Android开发艺术探索中讲了Bitmap的高效加载，而学到的两种缓存策略LruChache和DiskLruChache可以结合来实现成一个优秀的ImageLoader。 一个优秀的ImageLoader应该具备如下几个功能： - 图片的同步加载 - 图片的异步加载 - 图片压缩 - 内存缓存 - 磁盘缓存 - 网络拉取 我们分步来实现，首先是图片的压缩，还是...
《android开发艺术探索》笔记之Bitmap的加载和Cache
qq_27753689的博客
07-18 477
《Android开发艺术探索》笔记之Bitmap的加载和Cache 首先说一下，这是我第一次写博客。之前有很多人推荐说写博客，看源码，能带你走进Android进阶之路。所以我就来了。我放暑假前，就在图书馆借了一本《Android开发艺术探索》，这也是我看到很多人推荐的。之前我看的Android入门的书是郭婶的《第一行代码》，确实适合入门。进阶的书就选择了《Android开发艺术探索》，其实还
Android 开发艺术探索 精髓获取
IT元老的博客
10-28 1779
第一章 Activity 的生命周期和启动模式      1.1 Activity 的生命周期全面分析 1.1.1 典型情况下的生命周期分析 1. 当用户打开新的Activity或者切换到桌面的时候，回调如下：onPause->onStop。这里有一种特殊情况，如果新Activity采用了透明主题，那么当前Activity不会回调onStop。 2. onStar
《Android开发艺术探索》笔记
xiang_freedom的专栏
02-09 1万+
本笔记整理自: https://www.gitbook.com/book/tom510230/android_ka_fa_yi_shu_tan_suo/details 参考文章：http://szysky.com/tags/#笔记、http://blog.csdn.net/player_android/article/category/6577498 MD文件下载：https://pan.ba
简单例子教你理解ImageLoader
amurocrash的专栏
11-07 1056
图文并茂是现代app的发展趋势，而随着移动互联网的发达，大家也不可能把图片写死在客户端，所以动态加载服务器上的图片成为了app起码的能力之一。当图片较少时，一般使用AsyncTask就能解决问题，但是当同屏包含大量图片的时候，简单的单线程单图片的解决方案就会遇到性能和效率的瓶颈，这时候ImageLoader框架就应运而生了。Github上成熟的框架很多，这里不会纠结于具体的功能，主要通过简单的dem
Android开发艺术探索完结篇——天道酬勤
热门推荐
刘桂林的博客
07-16 1万+
这片文章发布，代表着我已经把本书和看完并且笔记也发布完成了，回忆了一下我看Android群英传，只用了两个月，但是看本书却花了2016年05月04日 - 2018年07月16日，整整两年多，真是惭愧 笔记链接 Android开发艺术探索——新的征程，程序人生路漫漫！ Android开发艺术探索笔记——第一章：Activity的生命周期和启动模式 Android开发艺术探索——第二章：IPC...
《Android开发艺术探索》笔记——Bitmap的加载和Cache（一）
J.D.的博客
08-26 440
看了《Android开发艺术探索》里的图片加载这一章，把里面的东西都写了一遍，现在记录下来，也对其中的一些知识点做一些扩展学习。 完整的代码都在GitHub里。关键词：Bitmap，BitmapFactory，BitmapFactory.Options，inSampleSize，inJustDecodeBounds，LruCache，DiskLruCache。如题所示，本章主要分两个部分来讲，一个
Volley与Universal-ImageLoader：实现Android离线图文缓存
本文将深入探讨Android应用中实现离线缓存的关键技术，尤其是在利用Volley和Universal-ImageLoader库来提高用户体验方面。离线缓存是一种策略，允许在设备连接网络时预先下载和存储数据，以便在网络不稳定或无连接时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值