关闭

Android开发常用工具类

标签: Android工具类
145人阅读 评论(0) 收藏 举报
分类:

1.DeviceUtil:获取设备信息类

import android.content.Context;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;

import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;

public class DeviceUtil {

    private DeviceUtil() {
        throw new UnsupportedOperationException("u can't fuck me...");
    }

    /**
     * 获取设备MAC地址
     * <p>需添加权限 android.permission.ACCESS_WIFI_STATE</p>
     *
     * @param context 上下文
     * @return MAC地址
     */
    public static String getMacAddress(Context context) {
        WifiManager wifi = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        WifiInfo info = wifi.getConnectionInfo();
        String macAddress = info.getMacAddress().replace(":", "");
        return macAddress == null ? "" : macAddress;
    }

    /**
     * 获取设备MAC地址
     * <p>需添加权限 android.permission.ACCESS_WIFI_STATE</p>
     *
     * @return MAC地址
     */
    public static String getMacAddress() {
        String macAddress = null;
        LineNumberReader reader = null;
        try {
            Process pp = Runtime.getRuntime().exec("cat /sys/class/net/wlan0/address");
            InputStreamReader ir = new InputStreamReader(pp.getInputStream());
            reader = new LineNumberReader(ir);
            macAddress = reader.readLine().replace(":", "");
        } catch (IOException ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (reader != null) reader.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return macAddress == null ? "" : macAddress;
    }

    /**
     * 获取设备厂商,如Xiaomi
     *
     * @return 设备厂商
     */
    public static String getManufacturer() {
        return Build.MANUFACTURER;
    }

    /**
     * 获取设备型号,如MI2SC
     *
     * @return 设备型号
     */
    public static String getModel() {
        String model = Build.MODEL;
        if (model != null) {
            model = model.trim().replaceAll("\\s*", "");
        } else {
            model = "";
        }
        return model;
    }
}

2.SharedPrefrences类: 将SharedPrefrences相关操作进行了封装。

import android.content.Context;
import android.content.SharedPreferences;

import java.util.Map;

/**
 * <pre>
 *     author: Blankj
 *     blog  : http://blankj.com
 *     time  : 2016/8/2
 *     desc  : SP相关工具类
 * </pre>
 */
public class SPUtils {

    private SharedPreferences sp;
    private SharedPreferences.Editor editor;

    /**
     * SPUtils构造函数
     *
     * @param context 上下文
     * @param spName  spName
     */
    public SPUtils(Context context, String spName) {
        sp = context.getSharedPreferences(spName, Context.MODE_PRIVATE);
        editor = sp.edit();
        editor.apply();
    }

    /**
     * SP中写入String类型value
     *
     * @param key   键
     * @param value 值
     */
    public void putString(String key, String value) {
        editor.putString(key, value).apply();
    }

    /**
     * SP中读取String
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值{@code null}
     */
    public String getString(String key) {
        return getString(key, null);
    }

    /**
     * SP中读取String
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值{@code defaultValue}
     */
    public String getString(String key, String defaultValue) {
        return sp.getString(key, defaultValue);
    }

    /**
     * SP中写入int类型value
     *
     * @param key   键
     * @param value 值
     */
    public void putInt(String key, int value) {
        editor.putInt(key, value).apply();
    }

    /**
     * SP中读取int
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    public int getInt(String key) {
        return getInt(key, -1);
    }

    /**
     * SP中读取int
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值{@code defaultValue}
     */
    public int getInt(String key, int defaultValue) {
        return sp.getInt(key, defaultValue);
    }

    /**
     * SP中写入long类型value
     *
     * @param key   键
     * @param value 值
     */
    public void putLong(String key, long value) {
        editor.putLong(key, value).apply();
    }

    /**
     * SP中读取long
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    public long getLong(String key) {
        return getLong(key, -1L);
    }

    /**
     * SP中读取long
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值{@code defaultValue}
     */
    public long getLong(String key, long defaultValue) {
        return sp.getLong(key, defaultValue);
    }

    /**
     * SP中写入float类型value
     *
     * @param key   键
     * @param value 值
     */
    public void putFloat(String key, float value) {
        editor.putFloat(key, value).apply();
    }

    /**
     * SP中读取float
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值-1
     */
    public float getFloat(String key) {
        return getFloat(key, -1f);
    }

    /**
     * SP中读取float
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值{@code defaultValue}
     */
    public float getFloat(String key, float defaultValue) {
        return sp.getFloat(key, defaultValue);
    }

    /**
     * SP中写入boolean类型value
     *
     * @param key   键
     * @param value 值
     */
    public void putBoolean(String key, boolean value) {
        editor.putBoolean(key, value).apply();
    }

    /**
     * SP中读取boolean
     *
     * @param key 键
     * @return 存在返回对应值,不存在返回默认值{@code false}
     */
    public boolean getBoolean(String key) {
        return getBoolean(key, false);
    }

    /**
     * SP中读取boolean
     *
     * @param key          键
     * @param defaultValue 默认值
     * @return 存在返回对应值,不存在返回默认值{@code defaultValue}
     */
    public boolean getBoolean(String key, boolean defaultValue) {
        return sp.getBoolean(key, defaultValue);
    }

    /**
     * 获取SP中所有键值对
     *
     * @return Map对象
     */
    public Map<String, ?> getAll() {
        return sp.getAll();
    }

    /**
     * 从SP中移除该key
     *
     * @param key 键
     */
    public void remove(String key) {
        editor.remove(key).apply();
    }

    /**
     * 判断SP中是否存在该key
     *
     * @param key 键
     * @return {@code true}: 存在<br>{@code false}: 不存在
     */
    public boolean contains(String key) {
        return sp.contains(key);
    }

    /**
     * 清除SP中所有数据
     */
    public void clear() {
        editor.clear().apply();
    }


}

3.MobileUtil:使用正则表达式去判断输入的手机号码是否合法

public class MobileUtil {
    public static boolean isMobileNO(String mobiles) {
        Pattern p = Pattern
                .compile("^(13[0-9]|15[012356789]|17[678]|18[0-9]|14[57])[0-9]{8}$");
        Matcher m = p.matcher(mobiles);
        return m.matches();
    }
}

4.StreamUtils:将InputStream对象转化为String对象

public class StreamUtils {
    //把一个inputstream转换为字符串
    public String readStream(InputStream in) throws Exception
    {
        //定义一个内存输出流
        ByteArrayOutputStream baos=new ByteArrayOutputStream();
        int len=-1;
        byte[] buffer=new byte[1024];
        while((len=in.read(buffer))!=-1)
        {
            baos.write(buffer,0,len);

        }
        in.close();
        String content=new String(baos.toByteArray());
        return content;
    }
}

5.LogUtils:对Android系统Log输出日志的封装

/** 
 * LogUtils工具说明:  
 * 1 只输出等级大于等于LEVEL的日志  
 *   所以在开发和产品发布后通过修改LEVEL来选择性输出日志. 
 *   当LEVEL=NOTHING则屏蔽了所有的日志.  
 * 2 v,d,i,w,e均对应两个方法.  
 *   若不设置TAG或者TAG为空则为设置默认TAG 
 *  
 */  
public class LogUtils {  
    public static final int VERBOSE = 1;  
    public static final int DEBUG = 2;  
    public static final int INFO = 3;  
    public static final int WARN = 4;  
    public static final int ERROR = 5;  
    public static final int NOTHING = 6;  
    public static final int LEVEL = VERBOSE;  
    public static final String SEPARATOR = ",";  

    public static void v(String message) {  
        if (LEVEL <= VERBOSE) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            String tag = getDefaultTag(stackTraceElement);  
            Log.v(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void v(String tag, String message) {  
        if (LEVEL <= VERBOSE) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            if (TextUtils.isEmpty(tag)) {  
                tag = getDefaultTag(stackTraceElement);  
            }  
            Log.v(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void d(String message) {  
        if (LEVEL <= DEBUG) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            String tag = getDefaultTag(stackTraceElement);  
            Log.d(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void d(String tag, String message) {  
        if (LEVEL <= DEBUG) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            if (TextUtils.isEmpty(tag)) {  
                tag = getDefaultTag(stackTraceElement);  
            }  
            Log.d(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void i(String message) {  
        if (LEVEL <= INFO) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            String tag = getDefaultTag(stackTraceElement);  
            Log.i(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void i(String tag, String message) {  
        if (LEVEL <= INFO) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            if (TextUtils.isEmpty(tag)) {  
                tag = getDefaultTag(stackTraceElement);  
            }  
            Log.i(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void w(String message) {  
        if (LEVEL <= WARN) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            String tag = getDefaultTag(stackTraceElement);  
            Log.w(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void w(String tag, String message) {  
        if (LEVEL <= WARN) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            if (TextUtils.isEmpty(tag)) {  
                tag = getDefaultTag(stackTraceElement);  
            }  
            Log.w(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    public static void e(String tag, String message) {  
        if (LEVEL <= ERROR) {  
            StackTraceElement stackTraceElement = Thread.currentThread().getStackTrace()[3];  
            if (TextUtils.isEmpty(tag)) {  
                tag = getDefaultTag(stackTraceElement);  
            }  
            Log.e(tag, getLogInfo(stackTraceElement) + message);  
        }  
    }  

    /** 
     * 获取默认的TAG名称.  
     * 比如在MainActivity.java中调用了日志输出.  
     * 则TAG为MainActivity 
     */  
    public static String getDefaultTag(StackTraceElement stackTraceElement) {  
        String fileName = stackTraceElement.getFileName();  
        String stringArray[] = fileName.split("\\.");  
        String tag = stringArray[0];  
        return tag;  
    }  

    /** 
     * 输出日志所包含的信息 
     */  
    public static String getLogInfo(StackTraceElement stackTraceElement) {  
        StringBuilder logInfoStringBuilder = new StringBuilder();  
        // 获取线程名  
        String threadName = Thread.currentThread().getName();  
        // 获取线程ID  
        long threadID = Thread.currentThread().getId();  
        // 获取文件名.即xxx.java  
        String fileName = stackTraceElement.getFileName();  
        // 获取类名.即包名+类名  
        String className = stackTraceElement.getClassName();  
        // 获取方法名称  
        String methodName = stackTraceElement.getMethodName();  
        // 获取生日输出行数  
        int lineNumber = stackTraceElement.getLineNumber();  

        logInfoStringBuilder.append("[ ");  
        logInfoStringBuilder.append("threadID=" + threadID).append(SEPARATOR);  
        logInfoStringBuilder.append("threadName=" + threadName).append(SEPARATOR);  
        logInfoStringBuilder.append("fileName=" + fileName).append(SEPARATOR);  
        logInfoStringBuilder.append("className=" + className).append(SEPARATOR);  
        logInfoStringBuilder.append("methodName=" + methodName).append(SEPARATOR);  
        logInfoStringBuilder.append("lineNumber=" + lineNumber);  
        logInfoStringBuilder.append(" ] ");  
        return logInfoStringBuilder.toString();  
    }  

}  

6.DataCleanManager:清除本地数据缓存

/**
 *  文 件 名:  DataCleanManager.java
 *  描    述:  主要功能有清除内/外缓存,清除数据库,清除sharedPreference,清除files和清除自定义目录
 */

import java.io.File;
import android.content.Context;
import android.os.Environment;

/** * 本应用数据清除管理器 */
public class DataCleanManager {
    /**
     * 清除本应用内部缓存(/data/data/com.xxx.xxx/cache)
     * @param context
     */
    public static void cleanInternalCache(Context context) {
        deleteFilesByDirectory(context.getCacheDir());
    }

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

    /**
     * 清除本应用SharedPreference(/data/data/com.xxx.xxx/shared_prefs) *
     * @param context
     */
    public static void cleanSharedPreference(Context context) {
        deleteFilesByDirectory(new File("/data/data/"
                + context.getPackageName() + "/shared_prefs"));
    }

    /**
     * 按名字清除本应用数据库
     * @param context
     * @param dbName
     */
    public static void cleanDatabaseByName(Context context, String dbName) {
        context.deleteDatabase(dbName);
    }

    /**
     * 清除/data/data/com.xxx.xxx/files下的内容
     * @param context
     */
    public static void cleanFiles(Context context) {
        deleteFilesByDirectory(context.getFilesDir());
    }

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

    /**
     * 清除自定义路径下的文件,使用需小心,请不要误删。而且只支持目录下的文件删除
     * @param filePath
     */
    public static void cleanCustomCache(String filePath) {
        deleteFilesByDirectory(new File(filePath));
    }

    /**
     * 清除本应用所有的数据
     * @param context
     * @param filepath
     */
    public static void cleanApplicationData(Context context, String... filepath) {
        cleanInternalCache(context);
        cleanExternalCache(context);
        cleanDatabases(context);
        cleanSharedPreference(context);
        cleanFiles(context);
        for (String filePath : filepath) {
            cleanCustomCache(filePath);
        }
    }

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

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:12814次
    • 积分:1052
    • 等级:
    • 排名:千里之外
    • 原创:71篇
    • 转载:1篇
    • 译文:16篇
    • 评论:6条
    最新评论