一、尽量使用BitmapFactory.decodeStream

　　BitmapFactory.decodeResource来设置图片资源要消耗更多的内存，如果程序中的图片资源很多的话，那这个内存就很客观啦。主要因为是BitmapFactory.decodeResource是通过Java层来createBitmap来完成图片的加载，增加了java层的内存消耗。而BitmapFactory.decodeStream则是直接调用了JNI，避免了java层的消耗。同时，在加载图片时，图片Config参数也可以有效减少内存的消耗。比如图片存储的位数及options.inSampleSize图片的尺寸等。

二、对图片进行压缩

1. InputStream is = this.getResources().openRawResource(R.drawable.pic1);          BitmapFactory.Options options=new BitmapFactory.Options();          options.inJustDecodeBounds = false;          options.inSampleSize = 10;   //width，hight设为原来的十分一          Bitmap btp =BitmapFactory.decodeStream(is,null,options); 2. if(!bmp.isRecycle() ){        bmp.recycle()   //回收图片所占的内存                  system.gc()  //提醒系统及时回收      }

Android远程图片获取和本地缓存

异步下载

大家都知道，在android应用中UI线程5秒没响应的话就会抛出无响应异常，对于远程获取大的资源来说，这种异常还是很容易就会抛出来的，那么怎么避免这种问题的产生。在android中提供两种方法来做这件事情：

启动一个新的线程来获取资源，完成后通过Handler机制发送消息，并在UI线程中处理消息，从而达到在异步线程中获取图片，然后通过Handler Message来更新UI线程的过程。

使用android中提供的AsyncTask来完成。

具体的做法这里就不介绍了，查下API就可以了，或者是google、baidu下。这里主要来说本地缓存。

本地缓存

对于图片资源来说，你不可能让应用每次获取的时候都重新到远程去下载(ListView)，这样会浪费资源，但是你又不能让所有图片资源都放到内存中去(虽然这样加载会比较快)，因为图片资源往往会占用很大的内存空间，容易导致OOM。那么如果下载下来的图片保存到SDCard中，下次直接从SDCard上去获取呢?这也是一种做法，我看了下，还是有不少应用采用这种方式的。采用LRU等一些算法可以保证sdcard被占用的空间只有一小部分，这样既保证了图片的加载、节省了流量、又使SDCard的空间只占用了一小部分。另外一种做法是资源直接保存在内存中，然后设置过期时间和LRU规则。

sdcard保存：

在sdcard上开辟一定的空间，需要先判断sdcard上剩余空间是否足够，如果足够的话就可以开辟一些空间，比如10M

当需要获取图片时，就先从sdcard上的目录中去找，如果找到的话，使用该图片，并更新图片最后被使用的时间。如果找不到，通过URL去download

去服务器端下载图片，如果下载成功了，放入到sdcard上，并使用，如果失败了，应该有重试机制。比如3次。

下载成功后保存到sdcard上，需要先判断10M空间是否已经用完，如果没有用完就保存，如果空间不足就根据LRU规则删除一些最近没有被用户的资源。

关键代码：

保存图片到SD卡上

privatevoidsaveBmpToSd(Bitmapbm,Stringurl){
if(bm==null){
Log.w(TAG,"tryingtosavenullbitmap");
return;
}
//判断sdcard上的空间
if(FREE_SD_SPACE_NEEDED_TO_CACHE>freeSpaceOnSd()){
Log.w(TAG,"Lowfreespaceonsd,donotcache");
return;
}
Stringfilename=convertUrlToFileName(url);
Stringdir=getDirectory(filename);
Filefile=newFile(dir+"/"+filename);
try{
file.createNewFile();
OutputStreamoutStream=newFileOutputStream(file);
bm.compress(Bitmap.CompressFormat.JPEG,100,outStream);
outStream.flush();
outStream.close();
Log.i(TAG,"Imagesavedtosd");
}catch(FileNotFoundExceptione){
Log.w(TAG,"FileNotFoundException");
}catch(IOExceptione){
Log.w(TAG,"IOException");
}
}

计算sdcard上的空间：

/**
*计算sdcard上的剩余空间
*@return
*/
privateintfreeSpaceOnSd(){
StatFsstat=newStatFs(Environment.getExternalStorageDirectory().getPath());
doublesdFreeMB=((double)stat.getAvailableBlocks()*(double)stat.getBlockSize())/MB;
return(int)sdFreeMB;
}

修改文件的最后修改时间

/**
*修改文件的最后修改时间
*@paramdir
*@paramfileName
*/
privatevoidupdateFileTime(Stringdir,StringfileName){
Filefile=newFile(dir,fileName);
longnewModifiedTime=System.currentTimeMillis();
file.setLastModified(newModifiedTime);
}

本地缓存优化

/**
*计算存储目录下的文件大小，当文件总大小大于规定的CACHE_SIZE或者sdcard剩余空间小于FREE_SD_SPACE_NEEDED_TO_CACHE的规定
*那么删除40%最近没有被使用的文件
*@paramdirPath
*@paramfilename
*/
privatevoidremoveCache(StringdirPath){
Filedir=newFile(dirPath);
File[]files=dir.listFiles();
if(files==null){
return;
}
intdirSize=0;
for(inti=0;i<files.length;i++){
if(files[i].getName().contains(WHOLESALE_CONV)){
dirSize+=files[i].length();
}
}
if(dirSize>CACHE_SIZE*MB||FREE_SD_SPACE_NEEDED_TO_CACHE>freeSpaceOnSd()){
intremoveFactor=(int)((0.4*files.length)+1);
Arrays.sort(files,newFileLastModifSort());
Log.i(TAG,"Clearsomeexpiredcachefiles");
for(inti=0;i<removeFactor;i++){
if(files[i].getName().contains(WHOLESALE_CONV)){
files[i].delete();
}
}
}
}
/**
*删除过期文件
*@paramdirPath
*@paramfilename
*/
privatevoidremoveExpiredCache(StringdirPath,Stringfilename){
Filefile=newFile(dirPath,filename);
if(System.currentTimeMillis()-file.lastModified()>mTimeDiff){
Log.i(TAG,"Clearsomeexpiredcachefiles");
file.delete();
}
}

文件使用时间排序

/**
*TODO根据文件的最后修改时间进行排序*
*/
classFileLastModifSortimplementsComparator<File>{
publicintcompare(Filearg0,Filearg1){
if(arg0.lastModified()>arg1.lastModified()){
return1;
}elseif(arg0.lastModified()==arg1.lastModified()){
return0;
}else{
return-1;
}
}
}

内存保存：

在内存中保存的话，只能保存一定的量，而不能一直往里面放，需要设置数据的过期时间、LRU等算法。这里有一个方法是把常用的数据放到一个缓存中(A)，不常用的放到另外一个缓存中(B)。当要获取数据时先从A中去获取，如果A中不存在那么再去B中获取。B中的数据主要是A中LRU出来的数据，这里的内存回收主要针对B内存，从而保持A中的数据可以有效的被命中。

先定义A缓存：

privatefinalHashMap<String,Bitmap>mHardBitmapCache=newLinkedHashMap<String,Bitmap>(HARD_CACHE_CAPACITY/2,0.75f,true){
@Override
protectedbooleanremoveEldestEntry(LinkedHashMap.Entry<String,Bitmap>eldest){
if(size()>HARD_CACHE_CAPACITY){
//当map的size大于30时，把最近不常用的key放到mSoftBitmapCache中，从而保证mHardBitmapCache的效率
mSoftBitmapCache.put(eldest.getKey(),newSoftReference<Bitmap>(eldest.getValue()));
returntrue;
}else
returnfalse;
}
};

再定于B缓存：

/**
*当mHardBitmapCache的key大于30的时候，会根据LRU算法把最近没有被使用的key放入到这个缓存中。
*Bitmap使用了SoftReference，当内存空间不足时，此cache中的bitmap会被垃圾回收掉
*/
privatefinalstaticConcurrentHashMap<String,SoftReference<Bitmap>>mSoftBitmapCache=newConcurrentHashMap<String,SoftReference<Bitmap>>(HARD_CACHE_CAPACITY/2);

从缓存中获取数据：

/**
*从缓存中获取图片
*/
privateBitmapgetBitmapFromCache(Stringurl){
//先从mHardBitmapCache缓存中获取
synchronized(mHardBitmapCache){
finalBitmapbitmap=mHardBitmapCache.get(url);
if(bitmap!=null){
//如果找到的话，把元素移到linkedhashmap的最前面，从而保证在LRU算法中是最后被删除
mHardBitmapCache.remove(url);
mHardBitmapCache.put(url,bitmap);
returnbitmap;
}
}
//如果mHardBitmapCache中找不到，到mSoftBitmapCache中找
SoftReference<Bitmap>bitmapReference=mSoftBitmapCache.get(url);
if(bitmapReference!=null){
finalBitmapbitmap=bitmapReference.get();
if(bitmap!=null){
returnbitmap;
}else{
mSoftBitmapCache.remove(url);
}
}
returnnull;
}

如果缓存中不存在，那么就只能去服务器端去下载：

/**
*异步下载图片
*/
classImageDownloaderTaskextendsAsyncTask<String,Void,Bitmap>{
privatestaticfinalintIO_BUFFER_SIZE=4*1024;
privateStringurl;
privatefinalWeakReference<ImageView>imageViewReference;
publicImageDownloaderTask(ImageViewimageView){
imageViewReference=newWeakReference<ImageView>(imageView);
}
@Override
protectedBitmapdoInBackground(String...params){
finalAndroidHttpClientclient=AndroidHttpClient.newInstance("Android");
url=params[0];
finalHttpGetgetRequest=newHttpGet(url);
try{
HttpResponseresponse=client.execute(getRequest);
finalintstatusCode=response.getStatusLine().getStatusCode();
if(statusCode!=HttpStatus.SC_OK){
Log.w(TAG,"从"+url+"中下载图片时出错!,错误码:"+statusCode);
returnnull;
}
finalHttpEntityentity=response.getEntity();
if(entity!=null){
InputStreaminputStream=null;
OutputStreamoutputStream=null;
try{
inputStream=entity.getContent();
finalByteArrayOutputStreamdataStream=newByteArrayOutputStream();
outputStream=newBufferedOutputStream(dataStream,IO_BUFFER_SIZE);
copy(inputStream,outputStream);
outputStream.flush();
finalbyte[]data=dataStream.toByteArray();
finalBitmapbitmap=BitmapFactory.decodeByteArray(data,0,data.length);
returnbitmap;
}finally{
if(inputStream!=null){
inputStream.close();
}
if(outputStream!=null){
outputStream.close();
}
entity.consumeContent();
}
}
}catch(IOExceptione){
getRequest.abort();
Log.w(TAG,"I/Oerrorwhileretrievingbitmapfrom"+url,e);
}catch(IllegalStateExceptione){
getRequest.abort();
Log.w(TAG,"IncorrectURL:"+url);
}catch(Exceptione){
getRequest.abort();
Log.w(TAG,"Errorwhileretrievingbitmapfrom"+url,e);
}finally{
if(client!=null){
client.close();
}
}
returnnull;
}

这是两种做法，还有一些应用在下载的时候使用了线程池和消息队列MQ，对于图片下载的效率要更好一些。有兴趣的同学可以看下。

总结

对于远程图片等相对比较大的资源一定要在异步线程中去获取本地做缓存

Android加载图片出现内存溢出攻略

Android远程图片获取和本地缓存

更多相关文章

随机推荐