Android进阶必学系列：Bitmap的高效加载和Cache，可能是全网最细的Android-资源加载机制剖析

于 2024-03-25 22:28:32 发布
阅读量684 收藏 18
点赞数 26
分类专栏： 程序员 文章标签： android
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56169789/article/details/137028215
版权

DiskLruCache.Editor editor = mDiskLruCache.edit(hashKeyFormUrl(urlString));
if (editor != null) {
//参数index取0（因为上面的valueCount取的1）
OutputStream outputStream = editor.newOutputStream(0);
boolean downSuccess = downloadPictureToStream(urlString, outputStream);
if (downSuccess) {
//2、编辑提交，释放编辑器
editor.commit();
}else {
editor.abort();
}
//3、写到文件系统，会检查当前缓存大小，然后写到文件
mDiskLruCache.flush();
}
} catch (IOException e) {
e.printStackTrace();
}

//三、缓存的获取
try {
String key = hashKeyFormUrl(urlString);
DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
FileInputStream inputStream = (FileInputStream)snapshot.getInputStream(0);
// Bitmap bitmap = BitmapFactory.decodeStream(inputStream);
// mIvBitamp.setImageBitmap(bitmap);

//注意，一般需要采样加载，但文件输入流是有序的文件流，采样时两次decodeStream影响文件流的文职属性，导致第二次decode是获取是null
//为解决此问题，可用文件描述符
FileDescriptor fd = inputStream.getFD();

//采样加载（就是前面讲的bitmap的高效加载）
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds=true;
BitmapFactory.decodeFileDescriptor(fd,null,options);
ViewGroup.LayoutParams layoutParams = mIvBitamp.getLayoutParams();
options.inSampleSize = getInSampleSize(layoutParams.width, layoutParams.height, options.outWidth, options.outHeight);
options.inJustDecodeBounds = false;
Bitmap bitmap = BitmapFactory.decodeFileDescriptor(fd, null, options);

//存入内容缓存，绘制到view。（下次先从内存缓存获取，没有就从磁盘缓存获取，在没有就请求网络–“三级缓存”）
mBitmapLruCache.put(key,bitmap);

runOnUiThread(new Runnable() {
@Override
public void run() {
mIvBitamp.setImageBitmap(mBitmapLruCache.get(key));
}
});

} catch (IOException e) {
e.printStackTrace();
}
}

/**

  • 下载图片到文件输入流
    */
    private boolean downloadPictureToStream(String urlString, OutputStream outputStream) {
    URL url = null;
    HttpURLConnection urlConnection = null;
    BufferedInputStream in = null;
    BufferedOutputStream out = null;
    try {
    url = new URL(urlString);
    urlConnection = (HttpURLConnection) url.openConnection();
    in = new BufferedInputStream(urlConnection.getInputStream());
    out = new BufferedOutputStream(outputStream);

int b;
while ((b=in.read()) != -1) {
//写入文件输入流
out.write(b);
}
return true;
} catch (IOException e) {
e.printStackTrace();
}finally {
if (urlConnection != null) {
urlConnection.disconnect();
}
try {
if (in != null) {in.close();}
if (out != null) {out.close();}
} catch (IOException e) {
e.printStackTrace();
}
}
return false;
}

/**

  • 图片的url转成key，使用MD5
    */
    private String hashKeyFormUrl(String url) {
    try {
    MessageDigest digest = MessageDigest.getInstance(“MD5”);
    return byteToHexString(digest.digest(url.getBytes()));
    } catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
    }
    return null;
    }

private String byteToHexString(byte[] bytes) {
StringBuffer stringBuffer = new StringBuffer();
for (int i = 0; i < bytes.length; i++) {
String hex = Integer.toHexString(0XFF & bytes[i]);
if (hex.length()==1) {
stringBuffer.append(0);
}
stringBuffer.append(hex);
}
return stringBuffer.toString();
}

三、ImageLoader

前面说的 Bitmap的高效加载、LruCache、DiskLruCache，是一个图片加载框架必备的功能点。下面就来封装一个ImageLoader。首先罗列 实现的要点：

  • 图片压缩，就是采样加载
  • 内存缓存，LruCache
  • 磁盘缓存，DiskLruCache
  • 网络获取，请求网络url
  • 同步加载，外部子线程同步执行
  • 异步加载，ImageLoader内部线程异步执行

说明，

  1. ”三级缓存“的逻辑：加载时 先从内存缓存获取，有就返回bitmap绘制图片到view，若没有就从磁盘缓存获取；磁盘缓存有就返回bitmap并缓存到内存缓存，没有就请求网络；网络请求回来，就缓存到磁盘缓存，然后从磁盘缓存获取返回。
  2. 同步加载，是在外部的子线程中执行，同步加载方法内部没有开线程，所以加载过程是耗时的 会阻塞 外部的子线程，加载完成后 需要自行切到主线程绘制到view。
  3. 异步加载，外部可在任意线程执行，因为内部实现是在子线程(线程池)加载，并且内部会通过Handler切到主线程，只需要传入view，内部就可直接绘制Bitmap到view。

详细如下

public class ImageLoader {

private static final String TAG = “ImageLoader”;

private static final long KEEP_ALIVE_TIME = 10L;

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

private static final int CORE_THREAD_SIZE = CPU_COUNT + 1;

private static final int THREAD_SIZE = CPU_COUNT * 2 + 1;

private static final int VIEW_TAG_URL = R.id.view_tag_url;

private static final Object object = new Object();

private ThreadPoolExecutor mExecutor;

private Handler mMainHandler;

private Context mApplicationContext;

private static volatile ImageLoader mImageLoader;

private LruCache<String, Bitmap> mLruCache;

private DiskLruCache mDiskLruCache;

/**

  • 磁盘缓存最大容量,50M
    */
    private static final long DISK_LRU_CACHE_MAX_SIZE = 50 * 1024 * 1024;

/**

  • 当前进程的最大内存，取进程内存的1/8
    */
    private static final long MEMORY_CACHE_MAX_SIZE = Runtime.getRuntime().maxMemory() / 8;

public ImageLoader(Context context) {
if (context == null) {
throw new RuntimeException(“context can not be null !”);
}
mApplicationContext = context.getApplicationContext();

initLruCache();
initDiskLruCache();
initAsyncLoad();
}

public static ImageLoader with(Context context){
if (mImageLoader == null) {
synchronized (object) {
if (mImageLoader == null) {
mImageLoader = new ImageLoader(context);
}
}
}
return mImageLoader;
}

private void initAsyncLoad() {
mExecutor = new ThreadPoolExecutor(CORE_THREAD_SIZE, THREAD_SIZE,
KEEP_ALIVE_TIME, TimeUnit.SECONDS,
new LinkedBlockingQueue(), new ThreadFactory() {
private final AtomicInteger count = new AtomicInteger(1);
@Override
public Thread newThread(Runnable runnable) {
return new Thread(runnable, "load bitmap thread "+ count.getAndIncrement());
}
});

mMainHandler = new Handler(Looper.getMainLooper()){
@Override
public void handleMessage(@NonNull Message msg) {
LoadResult result = (LoadResult) msg.obj;
ImageView imageView = result.imageView;
Bitmap bitmap = result.bitmap;
String url = result.url;
if (imageView == null || bitmap == null) {
return;
}

//此判断是 避免 ImageView在列表中复用导致图片错位的问题
if (url.equals(imageView.getTag(VIEW_TAG_URL))) {
imageView.setImageBitmap(bitmap);
}else {
Log.w(TAG, “handleMessage: set image bitmap，but url has changed,ignore!”);
}
}
};
}

private void initLruCache() {

mLruCache = new LruCache<String, Bitmap>((int) MEMORY_CACHE_MAX_SIZE){
@Override
protected int sizeOf(String key, Bitmap value) {
//缓存对象bitmap的大小，单位要和MEMORY_CACHE_MAX_SIZE一致
return value.getByteCount();
}

@Override
protected void entryRemoved(boolean evicted, String key, Bitmap oldValue, Bitmap newValue) {
//移除旧缓存时会调用，可以在这里进行像资源回收的工作。
}
};

}

private void initDiskLruCache() {

File externalCacheDir = mApplicationContext.getExternalCacheDir();
if (externalCacheDir != null) {
long usableSpace = externalCacheDir.getUsableSpace();
if (usableSpace < DISK_LRU_CACHE_MAX_SIZE){
//剩余空间不够了
Log.e(TAG, “initDiskLruCache: “+“UsableSpace=”+usableSpace+” , not enough(target 50M)，cannot creat diskLruCache！”);
return;
}
}

//一、创建DiskLruCache
//第一个参数是要存放的目录，这里选择外部缓存目录（若app卸载此目录也会删除）；
//第二个是版本一般设1；第三个是缓存节点的value数量一般也是1；
//第四个是最大缓存容量这里取50M
try {
this.mDiskLruCache = DiskLruCache.open(mApplicationContext.getExternalCacheDir(), 1, 1, DISK_LRU_CACHE_MAX_SIZE);
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "initDiskLruCache: "+e.getMessage());
}
}

/**

  • 缓存bitmap到内存
  • @param url url
  • @param bitmap bitmap
    */
    private void addBitmapMemoryCache(String url, Bitmap bitmap) {
    String key = UrlKeyTransformer.transform(url);
    if (mLruCache.get(key) == null && bitmap != null) {
    mLruCache.put(key,bitmap);
    }
    }

/**

  • 从内存缓存加载bitmap
  • @param url url
  • @return
    */
    private Bitmap loadFromMemoryCache(String url) {
    return mLruCache.get(UrlKeyTransformer.transform(url));
    }

/**

  • 从磁盘缓存加载bitmap（并添加到内存缓存）
  • @param url url
  • @param requestWidth 要求的宽
  • @param requestHeight 要求的高
  • @return bitmap
    */
    private Bitmap loadFromDiskCache(String url, int requestWidth, int requestHeight) throws IOException {
    if (Looper.myLooper()==Looper.getMainLooper()) {
    Log.w(TAG, “loadFromDiskCache from Main Thread may cause block ！”);
    }

if (mDiskLruCache == null) {
return null;
}
DiskLruCache.Snapshot snapshot = null;
String key = UrlKeyTransformer.transform(url);
snapshot = mDiskLruCache.get(key);
if (snapshot != null) {
FileInputStream inputStream = (FileInputStream)snapshot.getInputStream(0);

//Bitmap bitmap = BitmapFactory.decodeStream(inputStream);

//一般需要采样加载，但文件输入流是有序的文件流，采样时两次decodeStream影响文件流的位置属性，
//导致第二次decode是获取是null，为解决此问题，可用文件描述符。
FileDescriptor fd = inputStream.getFD();
Bitmap bitmap = BitmapSampleDecodeUtil.decodeFileDescriptor(fd, requestWidth, requestHeight);
addBitmapMemoryCache(url,bitmap);
return bitmap;
}

return null;
}

/**

  • 从网路加载图片 到磁盘缓存（然后再从磁盘中采样加载）
  • @param urlString urlString
  • @param requestWidth 要求的宽
  • @param requestHeight 要求的高
  • @return Bitmap
    */
    private Bitmap loadFromHttp(String urlString, int requestWidth, int requestHeight) throws IOException {
    //线程检查，不能是主线程
    if (Looper.myLooper()==Looper.getMainLooper()) {
    throw new RuntimeException(“Do not loadFromHttp from Main Thread!”);
    }

if (mDiskLruCache == null) {
return null;
}

DiskLruCache.Editor editor = null;
editor = mDiskLruCache.edit(UrlKeyTransformer.transform(urlString));
if (editor != null) {
OutputStream outputStream = editor.newOutputStream(0);
if (downloadBitmapToStreamFromHttp(urlString, outputStream)) {
editor.commit();
}else {
editor.abort();
}
mDiskLruCache.flush();
}

return loadFromDiskCache(urlString, requestWidth, requestHeight);
}

/**

  • 从网络下载图片到文件输入流
  • @param urlString
  • @param outputStream
  • @return
    */
    private boolean downloadBitmapToStreamFromHttp(String urlString, OutputStream outputStream) {
    URL url = null;
    HttpURLConnection urlConnection = null;
    BufferedInputStream in = null;
    BufferedOutputStream out = null;
    try {
    url = new URL(urlString);
    urlConnection = (HttpURLConnection) url.openConnection();
    in = new BufferedInputStream(urlConnection.getInputStream());
    out = new BufferedOutputStream(outputStream);

int b;
while ((b=in.read()) != -1) {
//写入文件输入流
out.write(b);
}
return true;
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "downloadBitmapToStreamFromHttp,failed : "+e.getMessage());
}finally {
if (urlConnection != null) {
urlConnection.disconnect();
}
IoUtil.close(in);
IoUtil.close(out);
}
return false;
}

/**

  • 从网络直接下载bitmap（无缓存、无采样）
  • @param urlString
  • @return
    */
    private Bitmap downloadBitmapFromUrlDirectly(String urlString) {
    URL url;
    HttpURLConnection urlConnection = null;
    BufferedInputStream bufferedInputStream = null;
    try {
    url = new URL(urlString);
    urlConnection = (HttpURLConnection) url.openConnection();
    bufferedInputStream = new BufferedInputStream(urlConnection.getInputStream());
    return BitmapFactory.decodeStream(bufferedInputStream);
    } catch (IOException e) {
    e.printStackTrace();
    Log.e(TAG, "downloadBitmapFromUrlDirectly,failed : "+e.getMessage());
    }finally {
    if (urlConnection != null) {
    urlConnection.disconnect();
    }
    IoUtil.close(bufferedInputStream);
    }
    return null;
    }

public Bitmap loadBitmap(String url){
return loadBitmap(url,0,0);
}

/**

  • 同步 加载bitmap
  • 不能在主线程执行。加载时 先从内存缓存获取，有就返回bitmap，若没有就从磁盘缓存获取；
  • 磁盘缓存有就返回bitmap并缓存到内存缓存，没有就请求网络；
  • 网络请求回来，就缓存到磁盘缓存，然后从磁盘缓存获取返回。
  • @return Bitmap
    */
    public Bitmap loadBitmap(String url, int requestWidth, int requestHeight){

Bitmap bitmap = loadFromMemoryCache(url);
if (bitmap != null) {
Log.d(TAG, “loadBitmap: loadFromMemoryCache, url:”+url);
return bitmap;
}

try {
bitmap = loadFromDiskCache(url, requestWidth, requestHeight);
} catch (IOException e) {
e.printStackTrace();
}
if (bitmap != null) {
Log.d(TAG, “loadBitmap: loadFromDiskCache, url:”+url);
return bitmap;
}

try {
bitmap = loadFromHttp(url, requestWidth, requestHeight);
} catch (IOException e) {
e.printStackTrace();
}
if (bitmap != null){
Log.d(TAG, “loadBitmap: loadFromHttp, url:”+url);
return bitmap;
}

if (mDiskLruCache == null) {
Log.d(TAG, “loadBitmap: diskLruCache is null，load bitmap from url directly！”);
bitmap = downloadBitmapFromUrlDirectly(url);
}

return bitmap;
}

public void loadBitmapAsync(final String url, final ImageView imageView){
loadBitmapAsync(url,imageView,0,0);
}

/**

  • 异步 加载bitmap
  • 外部可在任意线程执行，因为内部实现是在子线程(线程池)加载，
  • 并且内部会通过Handler切到主线程，只需要传入view，内部就可直接绘制Bitmap到view。
  • @param url
  • @param imageView
  • @param requestWidth
  • @param requestHeight
    */
    public void loadBitmapAsync(final String url, final ImageView imageView, final int requestWidth, final int requestHeight){
    if (url == null || url.isEmpty() || imageView == null) {
    return;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
img
img
img
img

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
img

最后

现在。**

深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-bI29XOO3-1711376903518)]
[外链图片转存中…(img-vtgxqErl-1711376903519)]
[外链图片转存中…(img-neZHyF6P-1711376903519)]
[外链图片转存中…(img-uw88ImWf-1711376903520)]

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-WenP4Sor-1711376903520)]

最后

想要了解更多关于大厂面试的同学可以**点击这里免费获取《面试文档》**除此之外，我也分享一些免费的优质资源，包括：Android学习PDF+架构视频+源码笔记，高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料 这几块的内容。分享给大家，非常适合近期有面试和想在技术道路上继续精进的朋友。快来获取学习资料吧~

Git小发明
关注
  • 26
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android_Bitmap的高效加载
戚继光的博客
01-10 435
在讲bitmap的高效加载时我们有必要先来了解认识一下这两个重要的类BitmapFactory和Options。它们之前的关系，从源码中我们可以看到Options是BitmapFactory的一个内部类。 public class BitmapFactory { private static final int DECODE_BUFFER_SIZE = 16 * 1024;
android高效加载Bitmap
11-03
归纳总结： 1. 从缓存中读取图片：先从内存缓存中读取。 若是从内存中读取到的Bitmap为空，则在磁盘缓存中读取。 若是从磁盘中读取到的Bitmap为空，则从起始资源中读取 2.开启工作线程，执行从起始资源中读取bitmap的任务 3.计算合适比例，读取适屏的bitmap 4.检查ImageView与任务线程的一致性 5.最后Hanlder更新UI
android 缓存Bitmap
chuyouyinghe的专栏
08-06 473
编写:kesenhoo - 原文:http://developer.android.com/training/displaying-bitmaps/cache-bitmap.html 将单个Bitmap加载到UI是简单直接的，但是如果我们需要一次性加载大量的图片，事情则会变得复杂起来。在大多数情况下（例如在使用ListView，GridView或ViewPager时），屏幕上的图片和因滑动将
Android Bitmap 的高效加载解析
lerendan的博客
02-10 354
一、Bitmap 占用的内存 在 Android 手机运行时 Bitmap 占用的内存计算： Bitmap 内存占用 ≈ 像素数据总大小 = 图片宽 × 图片高× ( 设备dpi / 资源目录dpi ) ^ 2 × 单个像素的字节大小 其中单个像素的字节大小由 Bitmap 的一个可配置的参数 Config 来决定。Bitmap 中存在一个枚举类 Config，定义了 Android 中...
android bitmap的缓存策略
weixin_33889245的博客
06-03 147
在这篇文章中：1.lrucache2.disklrucache3.缓存策略对比与总结不论是android还是ios设备，流量对于用户而言都是宝贵的。在没有wifi的场景下，如果加载批量的图片消耗用户过多流量，被其知晓，又要被念叨一波~如何避免消耗过多的流量呢？当程序第一次从网络加载图片后，就将其缓存到移动设备上，这样再次使用这个图片时，就不用再次从网络上下载为用户节省了流量。目前常用的一种缓存算法...
Android开发中Bitmap高效加载使用详解
08-28
综上所述，通过理解Bitmap的内存占用原理，结合上述策略，可以在Android应用中实现Bitmap的高效加载和使用，有效避免因Bitmap操作不当导致的内存溢出问题。在实际开发中，应根据具体需求灵活运用这些方法，以达到...
Android Bitmap的加载优化与Cache相关介绍
08-31
总结，Android中Bitmap的优化主要包括高效加载（通过采样率控制图片大小）和缓存策略（内存缓存和磁盘缓存）。合理的优化能够显著提升应用的性能，减少内存占用，提高用户体验。在实际开发中，开发者应当结合具体...
安卓学习教材经验Android进阶学习资料安卓面试资料等文档资料合集（22个）.zip
最新发布
04-24
安卓学习教材经验Android进阶学习资料安卓面试资料等文档资料合集（22个）: Android For OpenCV的环境搭建 Android Glide框架 二次封装 Android内存优化——常见内存泄露及优化方案 Android开发社招面试之高级进阶...
Android Bitmap的加载与缓存
08-27
Android Bitmap的加载与缓存 Android Bitmap的加载与缓存是 Android 应用程序中非常重要的一个话题。Bitmap 是 Android 中用来表示图片的对象，它支持多种格式，如 png、jpg 等。然而，图片的体积通常都比较大，而...
android bitmap 重复,Android Bitmap 的高效加载和三级缓存读书笔记
weixin_28858247的博客
05-28 252
本文主要内容出自《Android 开发艺术探索》，作为记录的同时加入个人的理解和思考，同时搜索其它资料和自己动手翻源码来理解实现原理。问题：如何高效加载 Bitmap？解决这个问题的核心思路是根据图片需要显示的大小来缩放图片进行显示，缩放的方式为设置采样率。LruCache 的原理?下文有个人总结的答案，可以参考，建议大家自己总结答案。Android 三级缓存？内存缓存、本地缓存(磁盘缓存)、网络...
Android中Bitmap缓存池(基于2Q算法)
03-16
Android中Bitmap缓存池(基于2Q算法),供大一起共同分享学习。
Android中的Bitmap缓存池使用详解
09-03
主要介绍了Android中的Bitmap缓存池使用详解,本文主要目的是讲解如何使用缓存来提高UI的载入输入和滑动的流畅性,需要的朋友可以参考下
Android进阶知识（二十五）：Bitmap简介及其高效加载
weixin_38196407的博客
06-01 524
Android进阶知识（二十五）：Bitmap简介及其高效加载 一、Bitmap   Bitmap代表一个位图，在Android中指的是一张图片，可以是png、jpg等格式的图片。BitmapDrawable里封装的图片就是Bitmap对象。 Bitmap的创建   在Bitmap类中，Bitmap的构造方法是默认权限，因此开发者无法通过new来创建一个Bitmap对象。Bitmap提供了静态方法createBitmap用于创建Bitmap对象，这些方法可以分为4类（Android API 29）。
android-bitmap的缓存策略，android开发环境搭建步骤
m0_64604636的博客
12-20 508
mmemorycache.put(key, bitmap); } } //获取一个缓存对象 private bitmap getbitmapfrommemcache(string key) { return mmemorycache.get(key); } 上述示例代码中，总容量的大小是当前进程的可用内存的八分之一（官方推荐是八分之一哈，你们可以自己视情况定），sizeof（）方法计算了bitmap的大小，sizeof方法默认返回的是你缓存item数目，源码中直接return 1（这里的源码比较简单，可以自
缓存Bitmap
Travor Philip的blog
02-23 353
在 Android 中处理位图和其他图片相关的任务时， Glide 可以完成大部分复杂工作。如果要自己实现缓存Bitmap可以用以下方法。 应用场景 系统通过循环利用移出屏幕的子视图来限制ListView, GridView之类的视图对内存的占用。垃圾回收器假设程序不会保留任何长期的引用，因此也会释放已加载的位图。但是为了确保能够流畅地加载界面，必须避免每次子视图返回到屏幕上时都要处理图片。采用内存和磁盘缓存会让组件快速重新加载经过处理的图片。 使用内存缓存 使用内存缓存位图。LruCache 类非常适用
Bitmap处理之Bitmap缓存
android leanring
04-27 1235
在ListView和GridView中，如果子View在屏幕中看不到，对应的子View的资源会被自动的释放，如果子View重新在屏幕中显示，就需要去重新加载资源，如果是从网络或者从硬盘中去读取资源，这样导致的后果是滑动的时候，显示的效果不是很流畅，如果能将之前已经加载过的资源 放在缓存中，每次都是从缓存中读取资源，这样显示的效果就会变得很流畅，下面分别介绍两种缓存的形式，内存缓存和硬盘缓存 内存
bitmap缓存——内存缓存
weixin_30516243的博客
07-10 60
1.获取LruCache对象 /** * 获取内存的1/8用作缓存空间 */ private fun getCache(): LruCache<String, Bitmap> { val maxMemory = Runtime.getRuntime().maxMemory()/1024 val cacheS...
Bitmap高效缓存
麦田
06-27 278
本文主要是对慕课网qndroid老师视频教程的总结，视频链接 Bitmap基本概念 Bitmap并不是只属于Android的概念；Bitmap（又称栅格图、点阵图）是使用像素阵列来表示的图像。 对于android而言： 1.Bitmap是Android系统中的图像处理的最重要类之一。 2.通过Bitmap我们可以获取图片的信息。 比如图片宽、高、Alpha值，也可以根据这个Bitmpa再创建新的B...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值