Android进阶必学系列：Bitmap的高效加载和Cache，android音视频开发面试题

最新推荐文章于 2024-04-03 01:27:17 发布
最新推荐文章于 2024-04-03 01:27:17 发布
阅读量1.3k 收藏
点赞数
分类专栏： 程序员 文章标签： 面试 android 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_63935510/article/details/121260136
版权

}
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

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

浏览器打开：qq.cn.hn/FTe 免费领取

.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;
    }

// 标记当前imageView要绘制图片的url
imageView.setTag(VIEW_TAG_URL, url);

mExecutor.execute(new Runnable() {
@Override
public void run() {

Bitmap loadBitmap = loadBitmap(url, requestWidth, requestHeight);

Message message = Message.obtain();
message.obj = new LoadResult(loadBitmap, url, imageView);
mMainHandler.sendMessage(message);
}
});
}

}

/**

  • Bitmap采样压缩加载工具
  • @author hufeiyang
    */
    public class BitmapSampleDecodeUtil {

private static final String TAG = “BitmapSampleDecodeUtil”;

/**

  • 对资源图片的采样
  • @param resources resources
  • @param resourcesId 资源id
  • @param requestWidth view的宽
  • @param requestHeight view的高
  • @return 采样后的bitmap
    */
    public static Bitmap decodeSampleResources(Resources resources, int resourcesId, int requestWidth, int requestHeight){
    if (resources == null || resourcesId<=0) {
    return null;
    }

//1、inJustDecodeBounds设为true，并加载图片
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeResource(resources, resourcesId, options);

//2、获取原始宽高信息
int outWidth = options.outWidth;
int outHeight = options.outHeight;

//3、原始宽高信息 和 view的大小 计算并设置采样率
options.inSampleSize = getInSampleSize(requestWidth, requestHeight, outWidth, outHeight);

//4、inJustDecodeBounds设为false，并加载图片
options.inJustDecodeBounds = false;

return BitmapFactory.decodeResource(resources, resourcesId, options);
}

/**

  • 对文件描述符的采样加载
  • @param fileDescriptor fileDescriptor
  • @param requestWidth view的宽
  • @param requestHeight view的高
  • 注意，文件输入流是有序的文件流，采样时两次decodeStream影响文件流的文职属性，导致第二次decode是获取是null。
  • 为解决此问题，可用本方法对文件流的文件描述符 加载。
    */
    public static Bitmap decodeFileDescriptor(FileDescriptor fileDescriptor, int requestWidth, int requestHeight){

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

BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds=true;
BitmapFactory.decodeFileDescriptor(fileDescriptor,null,options);
options.inSampleSize = getInSampleSize(requestWidth, requestHeight, options.outWidth, options.outHeight);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFileDescriptor(fileDescriptor, null, options);
}

/**

  • 计算采样率
  • @param width view的宽
  • @param height view的高
  • @param outWidth 图片原始的宽
  • @param outHeight 图片原始的高
  • @return
    */
    private static int getInSampleSize(int width, int height, int outWidth, int outHeight) {
    int inSampleSize = 1;

if (width==0 || height ==0){
return inSampleSize;
}

if (outWidth>width || outHeight>height){
int halfWidth = outWidth / 2;
int halfHeight = outHeight / 2;
//保证采样后的宽高都不小于目标快高，否则会拉伸而模糊
while (halfWidth/inSampleSize >=width
&& halfHeight/inSampleSize>=height){
inSampleSize *=2;
}
}

Log.d(TAG, “getInSampleSize: inSampleSize=”+inSampleSize);
return inSampleSize;
}
}

/**

  • 图片的url转成key
  • @author hufeiyang
    */
    public class UrlKeyTransformer {

/**

  • 图片的url转成key
  • @param url
  • @return MD5转换后的key
    */
    public static String transform(String url) {
    if (url == null || url.isEmpty()) {
    return null;
    }
    try {
    MessageDigest digest = MessageDigest.getInstance(“MD5”);
    return byteToHexString(digest.digest(url.getBytes()));
    } catch (NoSuchAlgorithmException e) {
    e.printStackTrace();
    }
    return null;
    }

private static 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();
}
}

public class LoadResult {

public Bitmap bitmap;

/**

  • bitmap对应的url
    */
    public String url;

public ImageView imageView;

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

m0_63935510
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android开发中Bitmap高效加载使用详解
08-28
在Android开发中，我们经常与Bitmap打交道，而对Bitmap的不恰当的操作经常会导致OOM（Out of Memory）。这篇文章我们会介绍如何高效地在Android开发中使用Bitmap，在保证图片显示质量的前提下尽可能占用更小的内存。
Android Bitmap的加载优化与Cache相关介绍
08-31
总结，Android中Bitmap的优化主要包括高效加载（通过采样率控制图片大小）和缓存策略（内存缓存和磁盘缓存）。合理的优化能够显著提升应用的性能，减少内存占用，提高用户体验。在实际开发中，开发者应当结合具体...
Android Studio中BitmapDrawable的使用2-1
hou09tian的博客
10-22 2369
ResourcesCompat类保存了指定ID的可绘制资源，getDrawable是该类的方法，返回可绘制资源，第一个参数指定了该项目的资源，第二个参数是要获取的可绘制资源的ID，第三个参数是可绘制资源的主题（theme），null表示不指定主题。之后，在弹出的对话框中，设置资源文件的文件名（图4①），并且将资源文件的类型设置为“bitmap”（图4②），如图4所示。点击图4中的“OK”按键之后，就打开了新建的可绘制资源文件，此时会发现文件中的“bitmap”标签是红色的，如图5所示。
Android之 Bitmap使用
qq_29848853的博客
04-23 3993
Bitmap使用
Android进阶：Bitmap的高效加载和Cache，学习Binder前必须要了解的知识点
2201_75604580的博客
04-03 230
针对Android程序员，我这边给大家整理了一些资料，包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！Android前沿技术大纲全套体系化高级架构视频Android高级架构资料、源码、笔记、视频。
android bitmap 加载,Android进阶之Bitmap的高效加载
weixin_42536058的博客
05-28 376
一、Bitmap的加载BitmapFactory提供了四个方法：docodeFilesdecodeResourcedecodeStreamdecodeByteArray二、Bitmap的高效加载采用Bitmap.Options来加载所需尺寸的图片，主要使用它的inSampleSize参数，当inSampleSize大于1缩放。(inSampleSize会向下去2的指数)高效加载图片的流程：将Bit...
Bitmap
shanglizhangrui的专栏
09-28 431
原文地址：http://blog.csdn.net/weihan1314/article/details/8012283 1 Bitmap加载方式 在介绍Bitmap--OOM 异常时，首先介绍一下Bitmap有哪几种加载方式。通常Bitmap的加载方式有Resource资源加载、本地（SDcard）加载、网络加载等加载方式。 1.1 Resource资源
安卓学习教材经验Android进阶学习资料安卓面试资料等文档资料合集（22个）.zip
最新发布
04-24
初中级Android开发社招面试之Bitmap.pdf 初中级Android开发社招面试之Fragment篇.pdf 初中级Android开发社招面试之Handler.pdf 初中级Android开发社招面试之JNI.pdf 初中级Android开发社招面试之Service及...
2023年Android高级开发工程师面试题及答案
02-11
在Android开发领域，面试往往涉及多个关键知识点，包括性能优化、内存管理、异常处理和用户体验。以下是对2023年Android高级开发工程师面试题及答案的详细解析： 1. **性能优化** - **性能分析**：Android应用的...
获取Bitmap的几种方式总结
热门推荐
繁星点点~
07-24 2万+
从获取方式分： （1）以文件流的方式 假设在sdcard下有 test.png图片 FileInputStream fis = new FileInputStream("/sdcard/test.png");  Bitmap bitmap=BitmapFactory.decodeStream(fis); （2）以R文件的方式 假设 res/drawable下有 test
AndroidStudio实时预览生成的bitmap
u010029439的博客
11-14 2079
把鼠标停在bitmap上，下面会出现一个加号，加号后面是地址。点击这个地址，进入bitmap的具体信息里面，然后点击最上面一行。
Android Bitmap进阶
刘酸酸的博客
11-24 611
上一篇当中介绍了关于Bitmap的基础介绍，而这一篇我们打算从性能方面和Bitmap的矩阵对象变换这两个方面去重新的认识一下我们的Bitmap对象，为什么选择说性能呢，因为大家都知道并且在我的上一篇博客当中我也介绍过，Bitmap是把图片的数据直接储存在内存当中的，那我们可以试想一下，既然是加载在内存当中的，那么这个肯定会很危险，如果我们加载特别大的图片的话，我们的程序可能就会挂掉
Bitmap处理 之三在子线程处理位图
hello_12413的专栏
09-08 1382
有效地展示大位图，不应该在主UI线程上执行如果源数据从磁盘读取或网络位置(或真正内存以外的任何来源)。加载数据需要的时间是不可预测的,取决于多种因素(阅读从磁盘或网络,速度大小的图像,CPU,等等)。如果其中一个任务阻塞UI线程,系统应用程序没有响应,用户选择关闭。So为了用户体验，通过在后台线程处理位图，这里使用AsyncTask,并且展示如何处理并发问题。使用异步任务（AsyncTask）Asy
Bitmap 处理之不要在UI主线程中处理Bitmap
android leanring
04-27 3650
原文链接 http://developer.android.com/intl/zh-CN/training/displaying-bitmaps/process-bitmap.html 在使用BitmapFactory.decode*解析图片时，最好不要在UI主线程中处理，因为图片的来源是未知的，有可能是从硬盘读取的，也有可能是是网络的图片资源，这时在解析图片时，会有一些不可控的因素，如(网
Android 超清大尺寸图片压缩转Base64中卡顿/速度优化问题整理（在子线程压缩Bitmap卡的主线程进度条走不动了。。。）
UrasakiNakajima的博客
04-04 4589
最近遇到需求是前后端传输图片使用的是Base64，但是前端（Android 端）图片很大（尺寸很大4480 × 2520，质量也很大7-10M），需要压缩到一定尺寸（1280 × 960，当然还可以压得更小），然后传给后端，本来认为是一个简单的压缩，可是在子线程压缩过程中发现很卡，卡的主线程的进度条都走不动了，一开始用的模拟器测试的，以为模拟器性能比较差，可是换成手机测试，还是子线程压缩过程中很卡，卡的主线程的进度条都走不动了。为了解决这个问题，请看以下步骤： 1、先申请读写权限，要允许权限才可以进行之后
Android DiskLruCache磁盘缓存
qq_39431405的博客
11-22 541
一 概述 记得在很早之前，我有写过一篇文章Android高效加载大图、多图解决方案，有效避免程序OOM，这篇文章是翻译自Android Doc的，其中防止多图OOM的核心解决思路就是使用LruCache技术。但LruCache只是管理了内存中图片的存储与释放，如果图片从内存中被移除的话，那么又需要从网络上重新加载一次图片，这显然非常耗时。对此，Google又提供了一套硬盘缓存的解决方案：DiskLruCache(非Google官方编写，但获得官方认证)。只可惜，Android Doc中并没有对DiskLru
Android音视频开发学习思路(2)1
08-04
"Android音视频开发学习思路第二部分，主要探讨如何在Android平台上通过不同的API来绘制图片，包括ImageView、SurfaceView以及自定义View的方式。同时，提到了AudioRecord对象的构造，作为音视频开发的基础知识。" ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值