Android开发常用工具类（不定期进行更新）

写了几个项目之后，接触到了很多封装得不错的工具类（utils），脑海里渐渐有了抽取封装的意识，所以决定专门写一篇文章来总结一下。以后看到好的工具类时都会集中补充到这里。

Activity跳转的工具类

/**
 *  Activity跳转的工具类
 */
public class ActivityUtils {
    //不用finish当前Activity时直接调用此方法
    public static void startActivity(Activity activity,Class classes){
        startActivity(activity,classes,false);
    }

    //函数的重载
    //需要finish当前Activity时调用此方法，布尔值参数传入true
    public static void startActivity(Activity activity,Class classes,boolean isFinish){
        Intent intent = new Intent(activity,classes);
        activity.startActivity(intent);
        if (isFinish){
            activity.finish();
        }
    }
}

获取当前时间

这个工具类可以获取到当前的时间，并转换成某种格式的字符串。

public class DateUtils {
    public static String getNowDateTime(){
        String pattern = "yyyy-MM-dd HH:mm:ss";//此处修改格式
        SimpleDateFormat format = new SimpleDateFormat(pattern);
        return format.format(new Date());
    }
}

弹出居中显示的Toast

public class MyToast{

    /**
     * 在屏幕中央显示一个Toast
     * @param text
     */
    public static void showToast(Context context, CharSequence text) {
        Toast toast = Toast.makeText(context, text, Toast.LENGTH_SHORT);
        toast.setGravity(Gravity.CENTER, 0, 0);
        toast.show();
    }
}

MD5加密工具类

能对字符串进行MD5加密，并返回加密后的字符串。

/**
 * MD5加密工具类
 */
public class Md5Util {
    /**
     * 给指定字符串按照md5算法去加密
     *
     * @param psd 需要加密的密码   加盐处理
     * @return md5后的字符串
     */
    public static String encoder(String psd) {
        try {
            //加盐处理
            psd = psd + "mobilesafe";
            //1,指定加密算法类型
            MessageDigest digest = MessageDigest.getInstance("MD5");
            //2,将需要加密的字符串中转换成byte类型的数组,然后进行随机哈希过程
            byte[] bs = digest.digest(psd.getBytes());
//          System.out.println(bs.length);
            //3,循环遍历bs,然后让其生成32位字符串,固定写法
            //4,拼接字符串过程
            StringBuffer stringBuffer = new StringBuffer();
            for (byte b : bs) {
                int i = b & 0xff;
                //int类型的i需要转换成16机制字符
                String hexString = Integer.toHexString(i);
//              System.out.println(hexString);
                if (hexString.length() < 2) {
                    hexString = "0" + hexString;
                }
                stringBuffer.append(hexString);
            }
            //5,打印测试
            System.out.println(stringBuffer.toString());
            return stringBuffer.toString();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }
}

缓存清理工具类

/**
 * Created by Lindroid on 2017/2/18.
 * 緩存清理工具
 */
public class ClearCacheUtil {

    /**
     * 獲取內部緩存大小
     * @param context
     * @return
     */
    public static String getInternalCache(Context context) {
        try {
            long cacheSize = getFolderSize(context.getCacheDir());
            return getFormatSize(cacheSize);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

    /**
     * 獲取外部緩存大小
     * @param context
     * @return
     */
    public static String getExternalCache(Context context) {
        try {
            long cacheSize = getFolderSize(context.getExternalCacheDir());
            return getFormatSize(cacheSize);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }


    /**
     * 獲取全部緩存大小
     * @param context
     * @return
     */
    public static String getAllCacheSize(Context context){
        try {
            long cacheSize = getFolderSize(context.getCacheDir()) + getFolderSize(context.getExternalCacheDir());
            return getFormatSize(cacheSize);
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }


    /**
     * 清除內部cache
     *
     * @param context
     */
    public static void clearInternalCache(Context context) {
        deleteFilesByDirectory(context.getCacheDir());
    }

    /**
     * * 清除外部cache下的内容(/mnt/sdcard/android/data/com.xxx.xxx/cache)
     *
     * @param context
     */
    public static void clearExternalCache(Context context) {
        if (Environment.getExternalStorageState().equals(
                Environment.MEDIA_MOUNTED)) {
            deleteFilesByDirectory(context.getExternalCacheDir());
        }
    }

    /**
     * 清除全部緩存
     */
    public static void clearAllCache(Context context) {
        clearInternalCache(context);
        clearExternalCache(context);
    }

    /**
     * * 清除本应用所有数据库(/data/data/com.xxx.xxx/databases) * *
     *
     * @param context
     */
    public static void clearDatabases(Context context) {
        deleteFilesByDirectory(new File("/data/data/"
                + context.getPackageName() + "/databases"));
    }

    /**
     * * 删除方法 这里只会删除某个文件夹下的文件，如果传入的directory是个文件，将不做处理 * *
     *
     * @param directory
     */
    private static void deleteFilesByDirectory(File directory) {
        if (directory != null && directory.exists() && directory.isDirectory()) {
            for (File item : directory.listFiles()) {
                item.delete();
            }
        }
    }

    /**
     * 获取文件大小
     */
    //Context.getExternalFilesDir() --> SDCard/Android/data/你的应用的包名/files/ 目录，一般放一些长时间保存的数据
    //Context.getExternalCacheDir() --> SDCard/Android/data/你的应用包名/cache/目录，一般存放临时缓存数据
    public static long getFolderSize(File file) throws Exception {
        long size = 0;
        try {
            File[] fileList = file.listFiles();
            for (int i = 0; i < fileList.length; i++) {
                // 如果下面还有文件
                if (fileList[i].isDirectory()) {
                    size = size + getFolderSize(fileList[i]);
                } else {
                    size = size + fileList[i].length();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return size;
    }

    /**
     * 格式化单位
     *
     * @param size
     * @return
     */
    public static String getFormatSize(double size) {
        double kiloByte = size / 1024;
        if (kiloByte < 1) {
//            return size + "Byte";
            return "0K";
        }

        double megaByte = kiloByte / 1024;
        if (megaByte < 1) {
            BigDecimal result1 = new BigDecimal(Double.toString(kiloByte));
            return result1.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "K";

        }

        double gigaByte = megaByte / 1024;
        if (gigaByte < 1) {
            BigDecimal result2 = new BigDecimal(Double.toString(megaByte));
            return result2.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "M";
        }

        double teraBytes = gigaByte / 1024;
        if (teraBytes < 1) {
            BigDecimal result3 = new BigDecimal(Double.toString(gigaByte));
            return result3.setScale(2, BigDecimal.ROUND_HALF_UP)
                    .toPlainString() + "GB";
        }
        BigDecimal result4 = new BigDecimal(teraBytes);
        return result4.setScale(2, BigDecimal.ROUND_HALF_UP).toPlainString()
                + "TB";
    }
}

自定义Toast

/**
 * 自定义Toast
 */
public class MyToast {
    private static Toast mToast;
    public static void showToast(Context context, String text){

        View view = View.inflate(context, R.layout.my_toast, null);
        LinearLayout ll = (LinearLayout) view.findViewById(R.id.ll_my_toast);
        TextView tv = (TextView) view.findViewById(R.id.tv_my_toast);
        tv.setText(text);
        if(mToast==null){
            mToast = new Toast(context);
            mToast.setDuration(Toast.LENGTH_SHORT);
            mToast.setView(view);
            mToast.setGravity(Gravity.CENTER, 0, 0);
        }else{
            mToast.setView(view);
        }
        mToast.show();
        Animation shake = AnimationUtils.loadAnimation(context, R.anim.scale);
        ll.startAnimation(shake);
    }
}