Android常用的九种工具类,快看看有没有你还没用上的

Posted 宾有为

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Android常用的九种工具类,快看看有没有你还没用上的相关的知识,希望对你有一定的参考价值。

目录

Glide 图片加载

需要添加Glide依赖implementation 'com.github.bumptech.glide:glide:4.13.0'annotationProcessor 'com.github.bumptech.glide:compiler:4.13.0'

/**
 * Glide 图片加载
 * 图片的url,此处采用本地路径加服务器地址的方式拼接,直接采用全部路径
 */
class ImageLoadUtils private constructor()

    companion object 
        // 单例模式
        val instance: ImageLoadUtils by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED)  ImageLoadUtils() 
    
    
    /**
     * 获取默认的图片
     *
     * glide 默认使用缓存机制,但是加载Gif 图片时会造成oom,所以要关闭缓存机制
     * @return
     */
    fun getDefaultOptions(): RequestOptions? 
        return getOptions(R.drawable.ic_image_holder, R.drawable.ic_image_error)
    

    fun getOptions(@DrawableRes holderRes: Int, @DrawableRes errorRes: Int): RequestOptions? 
        return RequestOptions().centerCrop().error(errorRes).placeholder(holderRes)
    

    /**
     * 加载原图
     */
    fun load(context: Context, url: String, iv: ImageView) 
        if (objectNull(context, url, iv)) return
        Glide.with(context)
            .load(url)
            .apply(getDefaultOptions())
            .into(iv)
    

    /**
     * 加载圆形的图片
     */
    fun loadCircle(context: Context, url: String?, iv: ImageView) 
        Glide.with(context)
            .load(url)
            .apply(RequestOptions.bitmapTransform(CircleCrop()).apply(getDefaultOptions()))
            .into(iv)
    

    /**
     * 加载圆角图片
     */
    fun loadCorner(context: Context, url: String, iv: ImageView, size: Int) 
        if (objectNull(context, url, iv)) return
        Glide.with(context)
            .load(url)
            .skipMemoryCache(true) //圆角半径
            .apply(RequestOptions.bitmapTransform(RoundedCorners(50)))
            .into(iv)
    

    /**
     * 判断图片路径是否为空和是否符合规则
     */
    private fun objectNull(context: Context?, path: String, imageView: ImageView?): Boolean 
        return context == null || TextUtils.isEmpty(path) || imageView == null
    

SharedPreferences 本地缓存

class PreferenceUtil private constructor() 

    companion object 
        // 单例模式
        val instance: PreferenceUtil by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED)  PreferenceUtil() 
    
    
    private val context: Context = MyApplication.getContext()
    val FILE_NAME = "leo_pro"

    /**
     * 保存数据的方法,我们需要拿到保存数据的具体类型,然后根据类型调用不同的保存方法
     *
     * @param key
     * @param obj
     */
    fun put(key: String?, obj: Any) 
        val sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE)
        val editor = sp.edit()
        when (obj) 
            is String -> 
                editor.putString(key, obj)
            
            is Int -> 
                editor.putInt(key, obj)
            
            is Boolean -> 
                editor.putBoolean(key, obj)
            
            is Float -> 
                editor.putFloat(key, obj)
            
            is Long -> 
                editor.putLong(key, obj)
            
            else -> 
                editor.putString(key, obj.toString())
            
        
        SharedPreferencesCompat.apply(editor)
    

    /**
     * 得到保存数据的方法,根据默认值得到保存的数据的具体类型,然后调用相对于的方法获取值
     *
     * @param key
     * @param defaultObject
     * @return
     */
    fun get(key: String?, defaultObject: Any?): Any? 
        val sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE)
        when (defaultObject) 
            is String -> 
                return sp.getString(key, defaultObject as String?)
            
            is Int -> 
                return sp.getInt(key, (defaultObject as Int?)!!)
            
            is Boolean -> 
                return sp.getBoolean(key, (defaultObject as Boolean?)!!)
            
            is Float -> 
                return sp.getFloat(key, (defaultObject as Float?)!!)
            
            is Long -> 
                return sp.getLong(key, (defaultObject as Long?)!!)
            
            else -> return null
        
    

    /**
     * 移除某个key值以及对应的值
     *
     * @param key
     */
    fun remove(key: String?) 
        val sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE)
        val editor = sp.edit()
        editor.remove(key)
        SharedPreferencesCompat.apply(editor)
    

    /**
     * 清除所有数据
     */
    fun clear() 
        val sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE)
        val editor = sp.edit()
        editor.clear()
        SharedPreferencesCompat.apply(editor)
    

    /**
     * 查询某个key是否已经存在
     *
     * @param key 查询的值
     */
    operator fun contains(key: String?): Boolean 
        val sp = context.getSharedPreferences(
            FILE_NAME,
            Context.MODE_PRIVATE
        )
        return sp.contains(key)
    

    /**
     * 返回所有的键值对
     */
    fun getAll(): Map<String?, *>? 
        val sp = context.getSharedPreferences(
            FILE_NAME,
            Context.MODE_PRIVATE
        )
        return sp.all
    

    /**
     * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类
     */
    private object SharedPreferencesCompat 
        private val sApplyMethod = findApplyMethod()

        /**
         * 反射查找apply的方法
         */
        private fun findApplyMethod(): Method? 
            try 
                val clz: Class<*> = SharedPreferences.Editor::class.java
                return clz.getMethod("apply")
             catch (e: NoSuchMethodException) 
            
            return null
        

        /**
         * 如果找到则使用apply执行,否则使用commit
         */
        fun apply(editor: SharedPreferences.Editor) 
            try 
                if (sApplyMethod != null) 
                    sApplyMethod.invoke(editor)
                    return
                
             catch (e: IllegalArgumentException) 
             catch (e: IllegalAccessException) 
             catch (e: InvocationTargetException) 
            
            editor.commit()
        
    


也可以这样封装:

public class PreferenceUtil 
    private var sp: SharedPreferences? = null
    private var editor: SharedPreferences.Editor? = null

    /**
     * 初始化工具类
     */
    fun init(context: Context, spName: String?) 
        sp = context.getSharedPreferences(spName, Context.MODE_PRIVATE)
        editor = sp?.edit()
        editor?.apply()
    

    /**
     * SP中写入String类型value
     *
     * @param key   键
     * @param value 值
     */
    fun put(key: String?, value: String?) 
        editor!!.putString(key, value).apply()
    

    /**
     * SP中读取String
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值`null`
     */
    fun getString(key: String?): String? 
        return getString(key, null)
    

    /**
     * SP中读取String
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getString(key: String?, defaultValue: String?): String? 
        return sp!!.getString(key, defaultValue)
    

    /**
     * SP中写入int类型value
     *
     * @param key   键
     * @param value 值
     */
    fun put(key: String?, value: Int) 
        editor!!.putInt(key, value).apply()
    

    /**
     * SP中读取int
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    fun getInt(key: String?): Int 
        return getInt(key, -1)
    

    /**
     * SP中读取int
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getInt(key: String?, defaultValue: Int): Int 
        return sp!!.getInt(key, defaultValue)
    

    /**
     * SP中写入long类型value
     *
     * @param key   键
     * @param value 值
     */
    fun put(key: String?, value: Long) 
        editor!!.putLong(key, value).apply()
    

    /**
     * SP中读取long
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    fun getLong(key: String?): Long 
        return getLong(key, -1L)
    

    /**
     * SP中读取long
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getLong(key: String?, defaultValue: Long): Long 
        return sp!!.getLong(key, defaultValue)
    

    /**
     * SP中写入float类型value
     *
     * @param key   键
     * @param value 值
     */
    fun put(key: String?, value: Float) 
        editor!!.putFloat(key, value).apply()
    

    /**
     * SP中读取float
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    fun getFloat(key: String?): Float 
        return getFloat(key, -1f)
    

    /**
     * SP中读取float
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getFloat(key: String?, defaultValue: Float): Float 
        return sp!!.getFloat(key, defaultValue)
    

    /**
     * SP中写入boolean类型value
     *
     * @param key   键
     * @param value 值
     */
    fun put(key: String?, value: Boolean) 
        editor!!.putBoolean(key, value).apply()
    

    /**
     * SP中读取boolean
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值`false`
     */
    fun getBoolean(key: String?): Boolean 
        return getBoolean(key, false)
    

    /**
     * SP中读取boolean
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getBoolean(key: String?, defaultValue: Boolean): Boolean 
        return sp!!.getBoolean(key, defaultValue)
    

    /**
     * SP中写入String集合类型value
     *
     * @param key    键
     * @param values 值
     */
    fun put(key: String?, values: Set<String?>?) 
        editor!!.putStringSet(key, values).apply()
    

    /**
     * SP中读取StringSet
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值`null`
     */
    fun getStringSet(key: String?): Set<String?>? 
        return getStringSet(key, null)
    

    /**
     * SP中读取StringSet
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值`defaultValue`
     */
    fun getStringSet(key: String?, defaultValue: Set<String?>?): Set<String?>? 
        return sp!!.getStringSet(key, defaultValue)
    

    /**
     * SP中获取所有键值对
     *
     * @return Map对象
     */
    fun getAll(): Map<String?, *>? 
        return sp!!.all
    

    /**
     * SP中移除该key
     *
     * @param key 键
     */
    fun remove(key: String?) 
        editor!!.remove(key).apply()
    

    /**
     * SP中是否存在该key
     *
     * @param key 键
     * @return `true`: 存在<br></br>`false`: 不存在
     */
    operator fun contains(key: String?): Boolean 
        return sp!!.contains(key)
    

    /**
     * SP中清除所有数据
     */
    fun clear() 
        editor!!.clear().apply()
    

Toast & Snackbar 消息展示

Toastandroid 12 及以上的Android版本Toast将会被限制使用,当应用处于前台时,应首选Snackbar,但Toast很多Application低版本的Android还在使用,这里封装类也加上Toast

/**
 * 防止重复点击toast,一直显示未隐藏
 */
class ShowMessage private constructor()
    private val context: Context = MyApplication.getContext()
    // 之前显示的内容
    private var oldMsg: String? = null
    // Toast对象
    private var toast: Toast? = null
    // Toast对象
    private var snackbar: Snackbar? = null
    // 第一次时间
    private var oneTime: Long = 0
    // 第二次时间
    private var twoTime: Long = 0

    companion object 
        // 单例模式
        val instance: ShowMessage by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED)  ShowMessage() 
    

    /**
     * 显示Toast
     * @param message
     */
    fun showToast(message: String) 
        if (toast == null) 
            toast = Toast.makeText(context, message, Toast.LENGTH_SHORT)
            toast!!.show()
            oneTime = System.currentTimeMillis()
         else 
            twoTime = System.currentTimeMillis()
            if (message == oldMsg) 
                if (twoTime - oneTime > Toast.LENGTH_SHORT) 
                    toast!!.show()
                
             else 
                oldMsg = message
                toast!!.setText(message)
                toast!!.show()
            
        
        oneTime = twoTime
    

    /**
     * 显示Snackbar
     * @param view
     * @param message
     */
    fun showSnackbar(view : View, message: String) 
        if (snackbar == null) 
            snackbar = Snackbar.make(view, message, Snackbar.LENGTH_SHORT)
            snackbar!!.show()
   

以上是关于Android常用的九种工具类,快看看有没有你还没用上的的主要内容,如果未能解决你的问题,请参考以下文章

Android常用的八种工具类,快看看有没有你还没用上的

软件测试人员必备的九种工具

python中常用的九种预处理方法

机器学习博士在获得学位之前需要掌握的九种工具!

机器学习博士在获得学位之前需要掌握的九种工具!

数组的九种遍历方法