加载Bitmap（ImageLoader）

最新推荐文章于 2022-03-27 00:15:02 发布
最新推荐文章于 2022-03-27 00:15:02 发布
阅读量672 收藏 1
点赞数
分类专栏： 安卓

添加DiskLruCache的依赖：

compile 'com.jakewharton:disklrucache:2.0.2'

图片压缩

package com.example.bitmap_demo;

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

/**
 * <p>文件描述：<p>
 * <p>创建时间：2019/3/10<p>
 */
public class ImageResizer {
    private static final String TAG = "vera ImageResizer";
    public Bitmap decodeSampledBitmapFromResource(Resources res,int resId,int reqWidth,int reqHeight){
//        可以通过BitmapFactory.Options来按照一定的采样率加载缩小后的图片
        final BitmapFactory.Options options=new BitmapFactory.Options();
//        当inJustDecodeBounds设置为true时，BitmapFactory只会解析图片的原始大小，并不会真正加载图片
        options.inJustDecodeBounds=true;
        BitmapFactory.decodeResource(res,resId,options);
//        设置采样率
        options.inSampleSize=calculateInSampleSize(options,reqWidth,reqHeight);
        options.inJustDecodeBounds=false;
        return BitmapFactory.decodeResource(res,resId,options);
    }

    private int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        if(reqWidth==0||reqHeight==0)return 1;
        final int rawHeight=options.outHeight;
        final int rawWidth=options.outWidth;
        Log.e(TAG, "calculateInSampleSize: origin width:"+rawWidth+"origin height:"+rawHeight );
        int inSampleSize=1;

        if(rawHeight>reqHeight||rawWidth>reqWidth){
            final int halfWidth=rawWidth/2;
            final int halfHeight=rawHeight/2;
//            如果改为||的话会导致所缩放后的图片小于ImageView所期望的大小，这样图片会被拉伸导致图片模糊。
            while((halfHeight/inSampleSize)>=reqHeight&&
                    (halfWidth/inSampleSize)>reqWidth){
                inSampleSize*=2;
            }
        }
//        如果图片原始大小本来就小于ImageView期望的大小，返回1.
        Log.e(TAG, "calculateInSampleSize: "+inSampleSize );
        return inSampleSize;

    }
    public Bitmap decodeSampledBitmapFromFileDescriptor(FileDescriptor fd,int reqWidth,int reqHeight){
        final 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);
    }

}

在ImageLoader的构造函数中初始化LruCache和DiskLruCache：

package com.example.bitmap_demo;

import android.content.Context;
import android.graphics.Bitmap;
import android.os.Build;
import android.os.Environment;
import android.os.StatFs;
import android.util.LruCache;

import com.jakewharton.disklrucache.DiskLruCache;

import java.io.File;
import java.io.IOException;

/**
 * <p>文件描述：<p>
 * <p>创建时间：2019/3/10<p>
 */
public class ImageLoader {
    private  boolean mIsDiskLruCacheCreated=false;
    private Context mContext;

    private LruCache<String , Bitmap> mLruCache;//内存缓存

    private DiskLruCache mDiskLruCache;//磁盘缓存

    private static final int DISK_CACHE_SIZE = 50*1024*1024;//50M

    public ImageLoader(Context context) {
        mContext = context;
        int maxMemory= (int) (Runtime.getRuntime().maxMemory()/1024);//单位是kb，当前进程可用内存
        int cacheSize=maxMemory/8;
        mLruCache=new LruCache<String,Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes()*value.getHeight()/1024;//单位是kb，返回Bitmap对象的大小
            }
        };
        File diskCacheDir=getDiskCacheDir(mContext,"bitmap"); //在sd card中的位置
        if(!diskCacheDir.exists()){
            diskCacheDir.mkdirs();
        }
//        如果磁盘剩余空间小于DISK_CACHE_SIZE无法创建DiskLruCache
        if(getUsableSpace(diskCacheDir)>DISK_CACHE_SIZE){

            try {
                mDiskLruCache=DiskLruCache.open(diskCacheDir,1,1,DISK_CACHE_SIZE);
            } catch (IOException e) {
                e.printStackTrace();
            }
            mIsDiskLruCacheCreated=true;
        }
    }

    private long getUsableSpace(File diskCacheDir) {
        if(Build.VERSION.SDK_INT>= Build.VERSION_CODES.GINGERBREAD){
            return diskCacheDir.getUsableSpace();
        }
        final StatFs statFs=new StatFs(diskCacheDir.getPath());
        return statFs.getBlockSize()*statFs.getAvailableBlocks();
    }

    private File getDiskCacheDir(Context context, String Name) {
        boolean externalStorageAvailable= Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
        final String cachePath;
        if(externalStorageAvailable){
            cachePath=context.getExternalCacheDir().getPath();
        }else{
            cachePath=context.getCacheDir().getPath();
        }
        return new File(cachePath+File.separator+Name);
    }


}

内存缓存的添加和获取：

    private void addBitmapToMemoryCache(String key,Bitmap bitmap){
        if(getBitmapFromMemoryCache(key)==null){
            mLruCache.put(key,bitmap);
        }
    }
    private Bitmap getBitmapFromMemoryCache(String key){
        return mLruCache.get(key);
    }

磁盘缓存的添加和获取：

    private Bitmap loadBitmapFromHttp(String url,int reqWidth,int reqHeight) throws IOException {
        if(Looper.myLooper()==Looper.getMainLooper()){
            throw new RuntimeException("can not visit network from ui thread.");
        }
        if(mDiskLruCache==null)return null;
        String key= hashKeyFormUrl(url);
        DiskLruCache.Editor editor=mDiskLruCache.edit(key);
        if (editor!=null){
            OutputStream outputStream=editor.newOutputStream(DISK_CACHE_INDEX);
            if(downloadUrlToStream(url,outputStream)){
                editor.commit();
            }else{
                editor.abort();
            }
            mDiskLruCache.flush();
        }
        return loadBitmapFromDiskCache(url,reqWidth,reqHeight);
    }

    private Bitmap loadBitmapFromDiskCache(String url, int reqWidth, int reqHeight) throws IOException {
        if(Looper.myLooper()==Looper.getMainLooper())
            Log.e(TAG, "loadBitmapFromDiskCache: load bitmap from UI thread,it's not recommended");
        if (mDiskLruCache==null)return null;
        Bitmap bitmap=null;
        String key= hashKeyFormUrl(url);
        DiskLruCache.Snapshot snapshot=mDiskLruCache.get(key);
        if(snapshot!=null){
            FileInputStream fileInputStream= (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
            FileDescriptor fileDescripto=fileInputStream.getFD();
            bitmap=mImageResizer.decodeSampledBitmapFromFileDescriptor(fileDescripto,reqWidth,reqHeight);
            if (bitmap!=null)addBitmapToMemoryCache(key,bitmap);
        }
        return bitmap;
    }

    //有了文件输出流，图片就可以通过这个文件输出流写入到文件系统上
    private boolean downloadUrlToStream(String urlString, OutputStream outputStream) {
        HttpURLConnection urlConnection=null;
        BufferedOutputStream out=null;
        BufferedInputStream in=null;
        try {
            final URL url=new URL(urlString);
            urlConnection= (HttpURLConnection) url.openConnection();
            in=new BufferedInputStream(urlConnection.getInputStream(),IO_BUFFER_SIZE);
            out=new BufferedOutputStream(outputStream,IO_BUFFER_SIZE);
            int b;
            while((b=in.read())!=-1)out.write(b);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(urlConnection!=null)urlConnection.disconnect();
            try {
                out.close();
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return false;

    }

    //图片的url可能会有特殊字符
    private String hashKeyFormUrl(String url) {
        String cacheKey;
        try {
            final MessageDigest messageDigest=MessageDigest.getInstance("MD5");
            messageDigest.update(url.getBytes());
            cacheKey=bytesToHexString(messageDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey=String.valueOf(url.hashCode());
        }
        return cacheKey;
    }

    private String bytesToHexString(byte[] bytes) {
        StringBuilder stringBuilder=new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex=Integer.toHexString(0xFF&bytes[i]);
            if(hex.length()==1)stringBuilder.append('0');
            stringBuilder.append(hex);
        }
        return stringBuilder.toString();
    }

同步加载和异步加载接口的设计：

    /**
     * 同步加载接口需要外部在线程中调用，因为同步加载可能很耗时
     */
    public Bitmap loadBitmap(String uri,int reqWidth,int reqHeight){
        Bitmap bitmap=loadBitmapFromMemCache(uri);//首先尝试从内存获取图片
        if (bitmap!=null){
            Log.e(TAG, "loadBitmap:loadBitmapFromMemCache,url: "+uri );
            return bitmap;
        }
        try {
            bitmap=loadBitmapFromDiskCache(uri,reqWidth,reqHeight);//再尝试从磁盘获取
            if (bitmap!=null){
                Log.e(TAG, "loadBitmap:loadBitmapFromDiskCache,url: "+uri );
                return bitmap;
            }
            bitmap=loadBitmapFromHttp(uri,reqWidth,reqHeight);//再尝试从网络拉取
            Log.e(TAG, "loadBitmap: loadBitmapFromHttp"+uri );
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (bitmap==null&&!mIsDiskLruCacheCreated){
            Log.e(TAG, "loadBitmap: encounter error,DiskLruCache is not created." );
            bitmap=downloadBitmapFromUrl(uri);
        }
        return bitmap;
    }


    /**
     * 异步加载
     */
    public void bindBitmap(final String uri, final ImageView imageView,final int reqWidth,final int reqHeight){

        imageView.setTag(TAG_KEY_URI,uri);
        Bitmap bitmap=loadBitmapFromMemCache(uri);
        if(bitmap!=null){
            imageView.setImageBitmap(bitmap);
            return;
        }
//        如果没用从内存中获取到图片，就去线程池中调用loadBitmap（）方法。
        Runnable loadBitmapTask=new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap1=loadBitmap(uri,reqWidth,reqHeight);
                if (bitmap1!=null){
//                    图片加载成功之后，封装成一个LoadResult对象
                    LoaderResult result=new LoaderResult(imageView,uri,bitmap1);
                    //                    通过Handler向主线程发送消息，在主线程中给imageVIew设置照片
                    mMainHandler.obtainMessage(MESSAGE_POST_RESULT,result).sendToTarget();
                }
            }
        };
        THREAD_POOL_EXECUTOR.execute(loadBitmapTask);
    }

完整的ImageLoader：

package com.example.bitmap_demo;

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.support.annotation.NonNull;
import android.util.Log;
import android.util.LruCache;
import android.widget.ImageView;

import com.jakewharton.disklrucache.DiskLruCache;

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 java.util.function.BiFunction;

/**
 * <p>文件描述：<p>
 * <p>创建时间：2019/3/10<p>
 */
public class ImageLoader {
    private static final String TAG = "vera";
    private static final int IO_BUFFER_SIZE = 8*1024;//8kb
    private static final int TAG_KEY_URI =R.id.imageloader_uri;
    private static final int MESSAGE_POST_RESULT = 1;
    private  boolean mIsDiskLruCacheCreated=false;
    private Context mContext;

    private LruCache<String , Bitmap> mLruCache;//内存缓存

    private DiskLruCache mDiskLruCache;//磁盘缓存

    private ImageResizer mImageResizer=new ImageResizer();

    private static final int DISK_CACHE_SIZE = 50*1024*1024;//50M
    private int DISK_CACHE_INDEX;

    private static final int CPU_COUNT=Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE=CPU_COUNT+1;
    private static final int MAX_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(@NonNull Runnable r) {
            return new Thread(r,"ImageLoader#"+mCount.getAndDecrement());
        }
    };

    public static final Executor THREAD_POOL_EXECUTOR=new ThreadPoolExecutor(
            CORE_POOL_SIZE,MAX_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 imageView=result.imageView;
            String uri= (String) imageView.getTag(TAG_KEY_URI);
            if (uri.equals(result.uri)){
                imageView.setImageBitmap(result.bitmap);
            }else {
                Log.e(TAG, "handleMessage: set image bitmap,but url has changed,ignores!" );
            }
        }
    };
    public ImageLoader(Context context) {
        mContext = context;
        int maxMemory= (int) (Runtime.getRuntime().maxMemory()/1024);//单位是kb，当前进程可用内存
        int cacheSize=maxMemory/8;
        mLruCache=new LruCache<String,Bitmap>(cacheSize){
            @Override
            protected int sizeOf(String key, Bitmap value) {
                return value.getRowBytes()*value.getHeight()/1024;//单位是kb，返回Bitmap对象的大小
            }
        };
        File diskCacheDir=getDiskCacheDir(mContext,"bitmap"); //在sd card中的位置
        if(!diskCacheDir.exists()){
            diskCacheDir.mkdirs();
        }
//        如果磁盘剩余空间小于DISK_CACHE_SIZE无法创建DiskLruCache
        if(getUsableSpace(diskCacheDir)>DISK_CACHE_SIZE){

            try {
                mDiskLruCache=DiskLruCache.open(diskCacheDir,1,1,DISK_CACHE_SIZE);
            } catch (IOException e) {
                e.printStackTrace();
            }
            mIsDiskLruCacheCreated=true;
        }
    }

    public static ImageLoader build(Context context){
        return new ImageLoader(context);
    }
    private long getUsableSpace(File diskCacheDir) {
        if(Build.VERSION.SDK_INT>= Build.VERSION_CODES.GINGERBREAD){
            return diskCacheDir.getUsableSpace();
        }
        final StatFs statFs=new StatFs(diskCacheDir.getPath());
        return statFs.getBlockSize()*statFs.getAvailableBlocks();
    }

    private File getDiskCacheDir(Context context, String Name) {
        boolean externalStorageAvailable= Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
        final String cachePath;
        if(externalStorageAvailable){
            cachePath=context.getExternalCacheDir().getPath();
        }else{
            cachePath=context.getCacheDir().getPath();
        }
        return new File(cachePath+File.separator+Name);
    }

    private void addBitmapToMemoryCache(String key,Bitmap bitmap){
        if(getBitmapFromMemoryCache(key)==null){
            mLruCache.put(key,bitmap);
        }
    }
    private Bitmap getBitmapFromMemoryCache(String key){
        return mLruCache.get(key);
    }

    private Bitmap loadBitmapFromHttp(String url,int reqWidth,int reqHeight) throws IOException {
        if(Looper.myLooper()==Looper.getMainLooper()){
            throw new RuntimeException("can not visit network from ui thread.");
        }
        if(mDiskLruCache==null)return null;
        String key= hashKeyFormUrl(url);
        DiskLruCache.Editor editor=mDiskLruCache.edit(key);
        if (editor!=null){
            OutputStream outputStream=editor.newOutputStream(DISK_CACHE_INDEX);
            if(downloadUrlToStream(url,outputStream)){
                editor.commit();
            }else{
                editor.abort();
            }
            mDiskLruCache.flush();
        }
        return loadBitmapFromDiskCache(url,reqWidth,reqHeight);
    }

    private Bitmap loadBitmapFromDiskCache(String url, int reqWidth, int reqHeight) throws IOException {
        if(Looper.myLooper()==Looper.getMainLooper())
            Log.e(TAG, "loadBitmapFromDiskCache: load bitmap from UI thread,it's not recommended");
        if (mDiskLruCache==null)return null;
        Bitmap bitmap=null;
        String key= hashKeyFormUrl(url);
        DiskLruCache.Snapshot snapshot=mDiskLruCache.get(key);
        if(snapshot!=null){
            FileInputStream fileInputStream= (FileInputStream) snapshot.getInputStream(DISK_CACHE_INDEX);
            FileDescriptor fileDescripto=fileInputStream.getFD();
            bitmap=mImageResizer.decodeSampledBitmapFromFileDescriptor(fileDescripto,reqWidth,reqHeight);
            if (bitmap!=null)addBitmapToMemoryCache(key,bitmap);
        }
        return bitmap;
    }

    //有了文件输出流，图片就可以通过这个文件输出流写入到文件系统上
    private boolean downloadUrlToStream(String urlString, OutputStream outputStream) {
        HttpURLConnection urlConnection=null;
        BufferedOutputStream out=null;
        BufferedInputStream in=null;
        try {
            final URL url=new URL(urlString);
            urlConnection= (HttpURLConnection) url.openConnection();
            in=new BufferedInputStream(urlConnection.getInputStream(),IO_BUFFER_SIZE);
            out=new BufferedOutputStream(outputStream,IO_BUFFER_SIZE);
            int b;
            while((b=in.read())!=-1)out.write(b);
            return true;
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(urlConnection!=null)urlConnection.disconnect();
            try {
                out.close();
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        return false;

    }

    //图片的url可能会有特殊字符
    private String hashKeyFormUrl(String url) {
        String cacheKey;
        try {
            final MessageDigest messageDigest=MessageDigest.getInstance("MD5");
            messageDigest.update(url.getBytes());
            cacheKey=bytesToHexString(messageDigest.digest());
        } catch (NoSuchAlgorithmException e) {
            cacheKey=String.valueOf(url.hashCode());
        }
        return cacheKey;
    }

    private String bytesToHexString(byte[] bytes) {
        StringBuilder stringBuilder=new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex=Integer.toHexString(0xFF&bytes[i]);
            if(hex.length()==1)stringBuilder.append('0');
            stringBuilder.append(hex);
        }
        return stringBuilder.toString();
    }
    /**
     * 同步加载接口需要外部在线程中调用，因为同步加载可能很耗时
     */
    public Bitmap loadBitmap(String uri,int reqWidth,int reqHeight){
        Bitmap bitmap=loadBitmapFromMemCache(uri);//首先尝试从内存获取图片
        if (bitmap!=null){
            Log.e(TAG, "loadBitmap:loadBitmapFromMemCache,url: "+uri );
            return bitmap;
        }
        try {
            bitmap=loadBitmapFromDiskCache(uri,reqWidth,reqHeight);//再尝试从磁盘获取
            if (bitmap!=null){
                Log.e(TAG, "loadBitmap:loadBitmapFromDiskCache,url: "+uri );
                return bitmap;
            }
            bitmap=loadBitmapFromHttp(uri,reqWidth,reqHeight);//再尝试从网络拉取
            Log.e(TAG, "loadBitmap: loadBitmapFromHttp"+uri );
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (bitmap==null&&!mIsDiskLruCacheCreated){
            Log.e(TAG, "loadBitmap: encounter error,DiskLruCache is not created." );
            bitmap=downloadBitmapFromUrl(uri);
        }
        return bitmap;
    }

    /**
     * 异步加载
     */
    public void bindBitmap(final String uri, final ImageView imageView,final int reqWidth,final int reqHeight){

        imageView.setTag(TAG_KEY_URI,uri);
        Bitmap bitmap=loadBitmapFromMemCache(uri);
        if(bitmap!=null){
            imageView.setImageBitmap(bitmap);
            return;
        }
//        如果没用从内存中获取到图片，就去线程池中调用loadBitmap（）方法。
        Runnable loadBitmapTask=new Runnable() {
            @Override
            public void run() {
                Bitmap bitmap1=loadBitmap(uri,reqWidth,reqHeight);
                if (bitmap1!=null){
//                    图片加载成功之后，封装成一个LoadResult对象
                    LoaderResult result=new LoaderResult(imageView,uri,bitmap1);
                    //                    通过Handler向主线程发送消息，在主线程中给imageVIew设置照片
                    mMainHandler.obtainMessage(MESSAGE_POST_RESULT,result).sendToTarget();
                }
            }
        };
        THREAD_POOL_EXECUTOR.execute(loadBitmapTask);
    }
    private Bitmap downloadBitmapFromUrl(String urlString) {
        Bitmap bitmap=null;
        HttpURLConnection urlConnection=null;
        BufferedInputStream in=null;
        try {
            final URL url=new URL(urlString);
            urlConnection= (HttpURLConnection) url.openConnection();
            in=new BufferedInputStream(urlConnection.getInputStream(),IO_BUFFER_SIZE);
            bitmap= BitmapFactory.decodeStream(in);
        } catch (IOException e) {
            Log.e(TAG, "downloadBitmapFromUrl: error " +e);
        }finally {
            if(urlConnection!=null)urlConnection.disconnect();
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
       return bitmap;

    }

    private Bitmap loadBitmapFromMemCache(String url) {
        final String key=hashKeyFormUrl(url);
        Bitmap bitmap=getBitmapFromMemoryCache(key);
        return bitmap;
    }

    private static class LoaderResult {
        public ImageView imageView;
        public String uri;
        public Bitmap bitmap;

        public LoaderResult(ImageView imageView, String uri, Bitmap bitmap) {
            this.imageView = imageView;
            this.uri = uri;
            this.bitmap = bitmap;
        }
    }
}
Android--Bitmap加载&ImageLoader
Sin的博客
03-17 1846
在Android的初级开发阶段，我们只关注如何实现我们的功能————不管黑猫白猫，抓到老鼠就是好猫。但在这个过程中我们很容易会忽略一些东西，如性能的损失、内存泄漏、代码耦合度高，逻辑混乱以及因此带来的代码混乱。
Bitmap高效加载和Cache（一）
戚继光的博客
01-09 1573
Bitmap是我们开发当中无法避开的，因为它而引起的一系列问题也让人头疼不已，虽然现在我们可以利用开源库来极大程度地避免OOM的产生，但我们还是有必要来花点时间来搞清楚Bitmap。我们从以下几个方面一次来分析Bitmap，首先我们加载一张图片所占用的内存是由哪些方面因素决定的？再就是我们如何对这些影响内存的因素进行合理化的调整。内存是如何被占用的我们在运行时可以通过Bitmap.getByteCo
加载Bitmap相关
JustinNick的博客
07-10 230
在实际开发中，考虑到应用是在有限的内存下工作的，理想情况是我们只需要在内存中加载一个低分辨率的照片即可。为了更便于显示，这个低分辨率的照片应该是与其对应的UI控件大小相匹配的。加载一个超过屏幕分辨率的高分辨率照片不仅没有任何显而易见的好处，还会占用宝贵的内存资源，另外在快速滑动图片时容易产生额外的效率问题。所以我们一般会通过加载经过等比例缩放的图片，从而避免超出程序的内存限制。 B...
Bitmap的加载和ImageLoader的封装
梦否
09-21 383
这篇博客主要是解决如何高效加载Bitmap的问题，因为Android中加载Bitmap的时候容易出现内存泄漏问题，故而如何高效加载比较重要。 文章目录1. 基础知识2. 高效加载Bitmap3. ImageLoader实现3.1 内存缓存3.2 磁盘缓存3.3 从网络请求图片3.4 整合为一个完整流程4. 用例测试5. 完整代码5.1 目录结构：5.1.1 Utils.java5.1.2 DiskLruCacheHelper.java5.1.3 ImageLoader.java5.1.4 MImageVie
高效加载Bitmap
qq_20369621的博客
09-27 299
一、概述 在Android开发中，我们经常与Bitmap打交道，而对Bitmap的不恰当的操作经常会导致OOM（Out of Memory）。这篇文章我们会介绍如何高效地在Android开发中使用Bitmap，在保证图片显示质量的前提下尽可能占用更小的内存。 1. 什么是Bitmap Android中的Bitmap对象是对位图的抽象，它可以从文件系统、资源文件夹、网络等各种不同的来源获取。位图可以看做是像素点的集合，本质上就是通过一系列二进制位来描述一张图片，具有不同色彩格式的位图使用...
Bitmap的高效加载
朝夕旭潇的博客
05-25 1087
在介绍Bitmap的高效加载之前，先说一下如何加载一个Bitmap,Bitmap在Android中指的是一张图片，可以是png格式也可以是jpg等其他常见的图片格式。那么如何加载一个图片呢？BirmapFactory类提供了四类方法：decodeFile、decodeResourse、decodeStream和decodeByteArray，分别用于支持从文件系统、资源、输入流以及子数组中加载出一
分享一个轻量级图片加载类 ImageLoader
09-01
【ImageLoader图片加载库详解】 在Android开发中，图片加载是一个常见的需求，尤其在处理大量图片展示时，如网格布局、瀑布流等。为了优化性能和用户体验，开发者通常会使用图片加载库。本文将深入解析一个轻量级的...
轻量级图片加载类ImageLoader实现与内存优化
本文档分享了一个轻量级的图片加载类ImageLoader，旨在提供一个简洁且易于使用的解决方案，特别是针对本地图片缓存加载需求。作者在项目实践中意识到现有的第三方库如nostra13的-Image-Loader、xUtil和Facebook的...
Android图片加载框架ImageLoader应用与实践
标题《ImageLoader》和描述《Android Universal ImageLoader 网络图片加载和本地图片加载》所涉及的知识点主要集中在Android平台上图片加载库的使用与实现上。在移动应用开发中，图片加载是一个常见且重要的功能，它...
imageloader本地加载图片
04-10
imageloader加载本地图片，利用线程池，缓存，LIFO，防止大量图片加载导致OOM（代码中加有注释理解）
Android加载网络图片缓存处理库的使用-Universal-ImageLoader
08-06
完美使用ImageLoader加载网络图片
《Android开发艺术探索》之Bitmap的加载和Cache（十四）
云瀚的自习室
06-29 563
第12章 Bitmap的加载和Cache 本章的主题是Bitmap的加载和Cache，主要包含三个方面： 首先讲述如何有效的加载一个Bitmap，Bitmap由于特殊性以及Android对单个应用所施加的内存限制，比如16MB，这导致加载...
Bitmap+ImageLoader图片显示
01-16 693
 import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.os.AsyncTask; import android.view.View; import android.view.ViewGroup;
【学习】Android中Bitmap的加载和Cache
PanicLin的博客
03-27 448
学习于《Android开发艺术探索》，本文讲解了Android中Bitmap如何高效加载和Cache机制
Python: 实现bitmap数据结构
weixin_33924220的博客
02-17 360
为什么80%的码农都做不了架构师？>>> ...
android之bitmap详解
热门推荐
gaohongijj的专栏
10-05 1万+
主要介绍加载位图的5中方式： package com.ghg.BitmapLoad; import java.io.BufferedInputStream; import java.io.BufferedReader; import java.io.ByteArrayOutputStream; import java.io.FileInputStream; import java.io
Bitmap的三级缓存----封装BitmapLoader
NELA的博客
09-06 994
BitMap的三级缓存方式！ 并处理由复用和线程引起的图片错位问题。Universal Image Loader 框架的使用！！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值