android缓存工具类

最新推荐文章于 2024-05-15 09:34:39 发布
最新推荐文章于 2024-05-15 09:34:39 发布
阅读量690 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/canvas18/article/details/8776505
版权
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import android.graphics.Bitmap;
 
/**
  * <p>Bitmap缓存池</p>
  *
  * <p>基于2Q改进算法缓存</p>
  * <p>http://www.vldb.org/conf/1994/P439.PDF</p>
  *
  * 使用：
  *    LCache static lCache = new LCache();
  *   
  *    ...
  *   
  *   
  *    String imgUrl = "http://monstar.ch/uploads/img/201212/22085340_Zun9.jpg";
  *    if(lCache.isCached(imgUrl)){
  *        Bitmap tBitmap = lCache.get(imgUrl);
  *    }else{
  *        //从服务端获取图像
  *        Bitmap tBitmap = 服务端获取的Bitmap
  *        
  *        lCache.put(imgUrl,tBitmap);
  *    }
  *
  * @author lei.guoting
  */
public class LCache{
        private static final int DEFAULT_MAX_SIZE = ( int )( 1024 * 1024 * 3 .5f);       //默认缓存池大小  3.5M
        private static final int DEFAULT_IN_QUEUE_MAX_SIZE = 40 ;                     //fInCacheQue队列默认大小
        private static final int DEFAULT_OUT_QUEUE_MAX_SIZE = 60 ;                   //fOutCacheQue队列默认大小
        private static final int DEFAULT_CACHE_QUEUE_MAX_SIZE = 0 ;                   //finalCacheQue队列默认大小
         
        private final HashMap<String,Ref> cache;            //缓存池
    private final Queue<String> fInCacheQue;            //一级缓存，Ain
    private final Queue<String> fOutCacheQue;          //清楚一级缓存记录，Aout
    private final Queue<String> finalCacheQue;          //最终缓存，Am
     
    private final int cacheMaxSize;
    private int size;
    private int curBitmapSize;
         
        /**
          * 构建默认大小的Cache
          */
        public LCache() {
                this (DEFAULT_MAX_SIZE);
        }
         
        /**
          * 构建指定大小的Cache
          *
          * @param cacheMaxSize Cache最大容量
          */
        public LCache( int cacheMaxSize){
                if ( 0 >= cacheMaxSize){
                        throw new IllegalArgumentException( "cacheMaxSize must be greater than 0" );
                }
                 
                this .cacheMaxSize = cacheMaxSize;
                this .cache = new HashMap<String,Ref>();
                this .fInCacheQue = new Queue<String>(DEFAULT_IN_QUEUE_MAX_SIZE);
                this .fOutCacheQue = new Queue<String>(DEFAULT_OUT_QUEUE_MAX_SIZE);
                this .finalCacheQue = new Queue<String>(DEFAULT_CACHE_QUEUE_MAX_SIZE);
        }
         
        /**
          *
          * @param key key值
          * <a href="\"http://www.eoeandroid.com/home.php?mod=space&uid=7300\"" target="\"_blank\"">@return</a>  true-key对应的Bitmap在该缓存池中
          *          false-key对应的Bitmap不在该缓存池中
          */
        public synchronized boolean isCached(String key){
                return this .cache.containsKey(key);
        }
         
        /**
          * 获取缓存池中Bitmap
          *
          * @param key key值
          * @return   Bitmap
          */
        public Bitmap get(String key){
                if ( null == key){
                        throw new NullPointerException( "The key can not be null" );
                }
                 
                if ( "" .equals(key)){
                        throw new IllegalArgumentException( "The key dons't value" );
                }
                 
                return this .getFromCache(key);
        }
         
        /**
          * 将Bitmap缓存到该缓存池中
          *
          * @param key
          * @param mBitmap
          */
    public synchronized void put(String key,Bitmap mBitmap){
            if ( this .cache.containsKey(key)){
                    return ;
            }
             
         if ( this .fOutCacheQue.contains(key)){
                this .finalCacheQue.addToHead(key);
                this .fOutCacheQue.remove(key);
                this .reclaimCache(key,mBitmap);
         }
         
         else {
                this .fInCacheQue.addToHead(key);
                this .reclaimCache(key,mBitmap);
                if ( this .fInCacheQue.isOverflow()){
                        String tKey = this .fInCacheQue.removeFromTail();
                        this .clearCache(tKey);
                        this .fOutCacheQue.addToHead(tKey);
                        this .fOutCacheQue.trim();
                }
         }
    }
     
    private void reclaimCache(String key, Bitmap mBitmap){
            if ( this .hasFreeCache(mBitmap)){
             this .putIntoCache(key, mBitmap);
            }
             
            else if ( this .fInCacheQue.isOverflow()){
                    do {
                            String tKey = this .fInCacheQue.removeFromTail();
                            this .clearCache(tKey);
                            this .fOutCacheQue.addToHead(key);
                    } while ( this .cacheMaxSize < ( this .size + this .curBitmapSize));                   
                    this .fOutCacheQue.trim();
                    this .putIntoCache(key, mBitmap);                   
            }
             
            else {
                    do {
                            String tKey = this .finalCacheQue.removeFromTail();
                            this .clearCache(tKey);
                    } while ( this .cacheMaxSize < ( this .size + this .curBitmapSize));                    
                    this .putIntoCache(key, mBitmap);
            }
    }
     
    private void putIntoCache(String key, Bitmap mBitmap){
            this .cache.put(key, new Ref(mBitmap, this .curBitmapSize));
                this .size += this .curBitmapSize;
                this .curBitmapSize = 0 ;
    }
     
    private boolean hasFreeCache(Bitmap mBitmap){
            boolean hasFreeCache = true ;
            this .curBitmapSize = this .sizeOf(mBitmap);
            if ( this .cacheMaxSize < ( this .size + this .curBitmapSize)){
                    hasFreeCache = false ;
            }
             
            return hasFreeCache;
    }
     
    private void clearCache(String key){
            Ref  tRef = this .cache.remove(key);
         if ( null != tRef){
                this .size -= tRef.getSize();
                if ( null != tRef.getBitmap()){
                    tRef.getBitmap().recycle();       
                }
         }
    }
     
    private Bitmap getFromCache(String key){
            Bitmap tBitmap = null ;
            synchronized ( this ){
                    if ( this .finalCacheQue.contains(key)){
                        this .finalCacheQue.moveToHead(key);
                }
                    tBitmap = this .cache.get(key).getBitmap();
            }
             
            return   tBitmap;
    }
         
        /**
          * Bitmap 存储大小
          *
          * @param mBitmap
          * @return
          */
        private int sizeOf (Bitmap mBitmap){
                int weight = 0 ;
                switch (mBitmap.getConfig()){
                case ALPHA_8 :
                        weight = 1 ;
                        break ;
                case ARGB_4444 :
                        weight = 2 ;
                        break ;
                case ARGB_8888 :
                        weight = 4 ;
                        break ;
                case RGB_565 :
                        weight = 2 ;
                        break ;
                default :
                        weight = 1 ;
                        break ;
                }
 
                return (mBitmap.getWidth() * mBitmap.getHeight() * weight);
        }
         
        public synchronized void destory(){
                this .cache.clear();
                this .finalCacheQue.clear();
                this .fInCacheQue.clear();
                this .fOutCacheQue.clear();
        }
         
         
        /**
          * 队列
          */
        class Queue<T>{
             private int capacity;
                 
             private final List<T> list;
             
             /**
              * @param capacity  队列最大容量，可为0；如果capacity为0，当前队列无大小限制
              */
                public Queue( int capacity){
                        this .capacity = capacity;
                        if ( 0 < this .capacity){
                                this .list = new ArrayList<T>( this .capacity);
                        } else {
                                this .list = new LinkedList<T>();
                        }
                         
                }
                 
                /**
                  * 队列容量
                  *
                  * @return 队列容量
                  */
                public int capacity(){
                        return this .capacity;
                }
                 
                /**
                  * 队列当前大小
                  *
                  * @return 队列大小
                  */
                public int size(){
                        return this .list.size();
                }
                 
                /**
                  * 该队列中是否有key值
                  *
                  * @param key
                  * @return true 存在key值，false 不存在key值
                  */
                public boolean contains(T key){
                        return this .list.contains(key);
                }
                 
                /**
                  * 队列是否溢出
                  *
                  * @return
                  */
                public boolean isOverflow(){
                        if ( 0 == capacity){
                                return false ;
                        }
                         
                        else {
                                return ( this .list.size() > this .capacity);       
                        }
                }
                 
                /**
                  * 将队列中key移动到队列头
                  *
                  * @param key 值
                  */
                public void moveToHead(T key){
                        this .list.remove(key);
                        this .list.add(key);
                }
                 
                /**
                  * 将key添加到队列头
                  *
                  * @param key 值
                  */
                public void addToHead(T key){
                        this .list.add(key);
                }
                 
                /**
                  * 删除队列最后一个值
                  *
                  * @return 当前删除队列值
                  */
                public T removeFromTail(){
                        T tKey = null ;
                        if ( 0 < this .list.size()){
                                tKey = this .list.remove( 0 );
                        }
                        return tKey;
                }
                 
                /**
                  * 删除队列中key值
                  *
                  * @param key  key值
                  * @return   删除成功返回当前key，删除失败返回null
                  */
                public T remove(T key){
                        if ( this .list.remove(key)){
                                return key;
                        }
                        return null ;
                }
                 
                /**
                  * 将Queue中超过capacity的长度截取掉
                  *      如果list.size <= capacity, 什么都不做
                  */
                public void trim(){
                        if (( 0 == capacity) || ( this .list.size() <= this .capacity)){
                                return ;
                        }
                         
                        int tNum = this .list.size() - this .capacity;
                        for ( int idx = 0 ; idx < tNum; idx ++){
                                this .removeFromTail();
                        }
                }
                 
                public void clear(){
                        this .list.clear();
                }
        }
         
        class Ref{
                //private SoftReference<Bitmap> softReference;
                private Bitmap mBitmap;
                private int size;
                 
                public Ref(Bitmap mBitmap, int size){
                        //this.softReference = new SoftReference<Bitmap>(mBitmap);
                        this .mBitmap = mBitmap;
                        this .size = size;
                }
                 
                public int getSize(){
                        return size;
                }
                 
                public Bitmap getBitmap(){
                        //return softReference.get();
                        return this .mBitmap;
                }
        }
}
canvas18
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android 数据缓存工具类
09-06
Android 数据缓存工具类，实现json数据缓存，字符串缓存等，带过期时间
Android缓存工具类
CocaCoca_的博客
05-15 539
以用户管理为例，记录用户登录信息： 1.用户管理类 /** * 用户管理类 */ public class UserManager { public static final String CACHE_KEY_CURRENT_USER = "current_user"; /** * 设置当前登录用户信息(登录成功后调用) * * @p
2024年安卓最全Android中图片的三级缓存介绍及实现(1)，2024年最新大厂面试题java
最新发布
2401_84123201的博客
05-15 280
因为文件太多，全部展示会影响篇幅，暂时就先列举这些部分截图18 /**19 * 判断网络连接是否通畅22 */= null) {30 }31 }3233 /**34 * 根据path下载网络上的数据35 * @param path 路径36 * @return 返回下载内容的byte数据形式37 */=-1) {53 }55 }58 }60 }6162 }还有操作外部存储的工具类：26。
Android 缓存的工具类
qq_31433193的博客
11-15 416
/* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * Y...
Android缓存中的四种类型
ModestLearners的博客
10-14 697
 a.强引用  ---什么是强引用？ 在某个函数中创建了一个对象，那该对象存储在堆空间，能过这个对象的引用才能对这个对象进行操作（实例化对象的变量） 实例化的变量是分配在栈空间中，这就是强引用 ---强引用的特点？ 直接访问目录对象强引用所指向的对象在任何时候都不会被系统回收，jvm宁愿抛出oom异常，也不会回收强引用所指向的对象强引用可能会导致内存泄露 b.
android 缓存工具类,缓存工具类
weixin_29543211的博客
05-25 432
安卓开发一般都需要进行数据缓存，常用操作老司机已为你封装完毕，经常有小伙伴问怎么判断缓存是否可用，那我告诉你，你可以用这份工具进行存储和查询，具体可以查看源码，现在为你开车，Demo传送门。站点put : 保存String数据到缓存中getAsString : 读取String数据getAsJSONObject : 读取JSONObject数据getAsJSONArray : 读取JSONArra...
android缓存工具类源码
04-25
android 缓存 工具类 源码，为用户节省流量，把信息存放到数据库，三种缓存策略：（1）LRU算法，固定缓存图片数量(max_num)，当图片数量超出max_num时，将缓存中最近用的最少的图片删除。 （2）FTU算法，固定每张...
Android 缓存管理工具框架库
04-05
作者jczmdeveloper，源码XCCacheManager，　...到手机存储或者SD卡存储中，即实现Disk级别的缓存，这里我们借助DiskLruCache这个辅助工具类来实现。顾名思义，这个工具类的作用就是使用Lru算法 来存储信息到Disk上。
Android 清理缓存工具类
10-21
获取和清理App缓存的工具类，直接拷贝到项目中即可使用。
Android开发常用工具类
08-27
在Android开发过程中，工具类（Utility Class）是开发者不可或缺的好帮手。它们通常包含一系列静态方法，用于执行特定任务，如日期时间处理、网络请求、数据解析等，从而提高代码的复用性和效率。以下是一些Android...
Android 缓存池工具类
男儿不展风云志，空有天生八尺躯
03-19 349
前言 今天看到一个不错的缓存池，分享给大家。 代码地址：androidx.core.util.Pools Pool /** * Interface for managing a pool of objects. * * @param <T> The pooled type. */ public interface Pool<T> { /** * @return An instance from
Android-一个封装DiskLruCache的缓存工具类
08-13
一个封装DiskLruCache的缓存工具类
android 设置缓存工具类
MrZhao_PerfectCode的博客
10-09 550
android 设置缓存工具类 /** * Copyright (c) 2012-2013, Michael Yang 杨福海 (www.yangfuhai.com). * &lt;p/&gt; * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file ex...
android 缓存工具类
Lance_小超
01-22 1917
先不废话 上工具类的源代码:Achche.java 自己拷贝到util里就好package com.eagersoft.youzy.expert.util;import android.content.Context; import android.graphics.Bitmap; import android.graphics.BitmapFactory; import android.gra
安卓一个简易的缓存工具类
weixin_37912278的博客
09-11 330
在安卓开发中开发者经常会使用到SharedPreferences来进行缓存，如果每次都写command的话会非常浪费时间并增加开发效率，本人自己写了一个缓存工具类目前使用的情况非常好，在此分享给大家，具体代码如下 public class PrefUtils { //主要用来保存判断状态 可以运用到保存Checkbox等复选框状态中 public static b...
缓存统一管理工具类--android
杨筱毅的专栏
07-22 2346
import android.content.Context; import android.os.Environment; import android.support.annotation.Nullable; import com.lidroid.xutils.db.annotation.NotNull; import junit.framework.Assert; import .R; imp
安卓缓存使用工具类
weixin_42401291的博客
11-21 308
ACache: Android缓存字符串，对象等其他数据 ACache是一个为android制定的 轻量级的 开源缓存框架。轻量到只有一个java文件（由十几个类精简而来）。 1、它可以缓存什么东西？ 普通的字符串、json、序列化的java对象，和 字节数字。 2、它有什么特色？ 特色主要是： 1：轻，轻到只有一个JAVA文件。 2：可配置，可以配置缓存路径，缓存大小，缓存数量等。 3：可以设置缓存超时时间，缓存超时自动失效，并被删除。 4：多进程的支持。 下面附上完整代码： .
android 图片缓存工具类,Android图片缓存工具类
weixin_39548606的博客
05-26 122
public class ImageCache {static private ImageCache cache;// 一个Cache实例private Hashtable ImageRefs;// 用于Chche内容的存储private ReferenceQueue q;// 垃圾Reference的队列// 继承SoftReference，使得每一个实例都具有可识别的标识。private cl...
Android 撸一个缓存工具类
weixin_34029949的博客
07-19 205
近两周一直在忙公司的移动项目，所以没怎么有时间学习和总结写博客。谢谢一些关心我的朋友和读者。 前言 在开发过程中，我们不可避免需要缓存许许多多的数据。例如：用户登陆后的信息；用户的状态；一些浏览的历史纪录等等；这时候我们就会经常需要读写缓存。 所以今天想通过安卓一个轻量级的存储类SharedPreferences和通过Gson去实现一个单例的安卓缓存工具类；这样有利于帮助我们更好的提高开发效率...
android studio cache 工具类
02-02
Android Studio Cache 工具类是一个用于管理和操作 Android Studio 缓存的工具类。它提供了一些方法来清理、获取和设置 Android Studio 缓存。 以下是一个简单的 Android Studio Cache 工具类的示例： ```java ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值