Android工具类整合「建议收藏」

大家好，又见面了，我是你们的朋友全栈君。

Android-JSONUtil工具类
常用的Json工具类，包含Json转换成实体、实体转json字符串、list集合转换成json、数组转换成json

public class JSONUtil { 

private static final String TAG = JSONUtil.class.getSimpleName();
private JSONUtil(){}
private static Gson gson = new Gson();
/** * 传入一个头部，获取头部管控中的所有String信息 * @return */
public static String getHeadContext(String jsonData, String head) {
String jsonObjectString = null;
try {
JSONObject jsonObject = new JSONObject(jsonData);
jsonObjectString = jsonObject.get(head).toString();
// LogUtil.d(TAG, "getHeadContext 只去头部header的数据信息：" + jsonObjectString);
} catch (Exception e) {
e.printStackTrace();
}
return jsonObjectString;
}
/** * 将一个对象转换成一个Json字符串 * @param t * @return */
public static <T> String objectToJson(T t){
if (t instanceof String) {
return t.toString();
} else {
return gson.toJson(t);
}
}
/** * 将Json字符串转换成对应对象 * @param jsonString Json字符串 * @param clazz 对应字节码文件.class * @return */
@SuppressWarnings("unchecked")
public static<T> T jsonToObject(String jsonString, Class<T> clazz){
if (clazz == String.class) {
return (T) jsonString;
} else {
return (T)gson.fromJson(jsonString, clazz);
}
}
/** * 将List集合转换为json字符串 * @param list List集合 * @return */
public static<T> String listToJson(List<T> list){
JSONArray jsonArray = new JSONArray();
JSONObject jsonObject = null;
try {
for (int i = 0; i < list.size(); i++) {
jsonObject = new JSONObject(objectToJson(list.get(i)));
jsonArray.put(jsonObject);
}
} catch (JSONException e) {
e.printStackTrace();
} finally {
if (jsonObject != null) {
jsonObject = null;
}
}
return jsonArray.toString();
}
/** * 将数组转换成json字符串 * @param array 数组 * @return */
public static<T> String arrayToJson(T[] array){
JSONArray jsonArray = new JSONArray();
JSONObject jsonObject = null;
try {
for (int i = 0; i < array.length; i++) {
jsonObject = new JSONObject(objectToJson(array[i]));
jsonArray.put(jsonObject);
}
} catch (JSONException e) {
e.printStackTrace();
} finally {
if (jsonObject != null) {
jsonObject = null;
}
}
return jsonArray.toString();
}
/** * 获取json字符串中的值 * @param json json字符串 * @param key 键值 * @param clazz 所取数据类型，例如：Integer.class，String.class，Double.class，JSONObject.class * @return 存在则返回正确值，不存在返回null */
public static<T> T getJsonObjectValue(String json, String key, Class<T> clazz){
try {
return getJsonObjectValue(new JSONObject(json), key, clazz);
} catch (JSONException e) {
e.printStackTrace();
}
return null;
}
/** * 获取jsonObject对象中的值 * @param jsonObject jsonObject对象 * @param key 键值 * @param clazz 所取数据类型，例如：Integer.class，String.class，Double.class，JSONObject.class * @return 存在则返回正确值，不存在返回null */
@SuppressWarnings("unchecked")
public static<T> T getJsonObjectValue(JSONObject jsonObject, String key, Class<T> clazz){
T t = null;
try {
if (clazz == Integer.class) {
t = (T) Integer.valueOf(jsonObject.getInt(key));
}else if(clazz == Boolean.class){
t = (T) Boolean.valueOf(jsonObject.getBoolean(key));
}else if(clazz == String.class){
t = (T) String.valueOf(jsonObject.getString(key));
}else if(clazz == Double.class){
t = (T) Double.valueOf(jsonObject.getDouble(key));
}else if(clazz == JSONObject.class){
t = (T) jsonObject.getJSONObject(key);
}else if(clazz == JSONArray.class){
t = (T) jsonObject.getJSONArray(key);
}else if(clazz == Long.class){
t = (T) Long.valueOf(jsonObject.getLong(key));
}
} catch (JSONException e) {
e.printStackTrace();
}
return t;
}
/** * json字符串转换为ContentValues * @param json json字符串 * @return */
@SuppressWarnings("rawtypes")
public static ContentValues jsonToContentValues(String json){
ContentValues contentValues = new ContentValues();
try {
JSONObject jsonObject = new JSONObject(json);
Iterator iterator = jsonObject.keys();
String key;
Object value;
while (iterator.hasNext()) {
key = iterator.next().toString();
value = jsonObject.get(key);
String valueString = value.toString();
if (value instanceof String) {
contentValues.put(key, valueString);
}else if(value instanceof Integer){
contentValues.put(key, Integer.valueOf(valueString));
}else if(value instanceof Long){
contentValues.put(key, Long.valueOf(valueString));
}else if(value instanceof Double){
contentValues.put(key, Double.valueOf(valueString));
}else if(value instanceof Float){
contentValues.put(key, Float.valueOf(valueString));
}else if(value instanceof Boolean){
contentValues.put(key, Boolean.valueOf(valueString));
}
}
} catch (JSONException e) {
e.printStackTrace();
throw new Error("Json字符串不合法：" + json);
}
return contentValues;
}
}

Android-LogUtil工具类
Log日志级别打印相关工具类

public class LogUtil { 

private LogUtil(){}
/** * 打印的信息日志信息 */
private final static String INFO = "☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻☻: ";
/** * 打印的错误日志信息 */
private final static String ERROR = "✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖✖: ";
/** * 打印的调试日志信息 */
private final static String DEBUG = "☠☠☠☠☠☠☠☠☠☠☠☠☠☠☠: ";
/** * 打印的全面日志信息 */
private final static String VERBOSE = "▂▂▂▃▃▄▄▅▅▆▆▆▇▇: ";
/** * 打印的警告日志信息 */
private final static String WARN = "!!!!!!!!!!!!!!!!!!!!!!!!!!: ";
/** * 打印information日志 * @param tag 标签 * @param msg 日志信息 */
public static void i(String tag,String msg){
Log.i(tag, INFO + msg);
}
/** * 打印information日志 * @param tag 标签 * @param msg 日志信息 * @param throwable 异常 */
public static void i(String tag, String msg, Throwable throwable){
Log.i(tag, INFO + msg, throwable);
}
/** * 打印verbose日志 * @param tag 标签 * @param msg 日志信息 */
public static void v(String tag, String msg){
Log.v(tag, VERBOSE + msg);
}
/** * 打印verbose日志 * @param tag 标签 * @param msg 日志信息 * @param throwable 异常 */
public static void v(String tag, String msg, Throwable throwable){
Log.v(tag, VERBOSE + msg, throwable);
}
/** * 打印debug信息 * @param tag 标签信息 * @param msg 日志信息 */
public static void d(String tag, String msg){
Log.d(tag, DEBUG + msg);
}
/** * 打印debug日志 * @param tag 标签信息 * @param msg 日志信息 * @param throwable 异常 */
public static void d(String tag, String msg, Throwable throwable){
Log.d(tag, DEBUG + msg, throwable);
}
/** * 打印warn日志 * @param tag 标签信息 * @param msg 日志信息 */
public static void w(String tag, String msg){
Log.w(tag, WARN + msg);
}
/** * 打印warn日志 * @param tag 标签信息 * @param msg 日志信息 * @param throwable 异常 */
public static void w(String tag, String msg, Throwable throwable){
Log.w(tag, WARN + msg, throwable);
}
/** * 打印error日志 * @param tag * @param msg 标签 */
public static void e(String tag, String msg){
Log.e(tag, ERROR + msg);
}
/** * 打印error日志 * @param tag 标签 * @param msg 日志信息 * @param throwable 异常 */
public static void e(String tag, String msg, Throwable throwable){
Log.e(tag, ERROR + msg, throwable);
}
/** * 吐司提示 * @param msg */
public static void toast(Context mContext, String msg) {
Toast.makeText(mContext, msg, Toast.LENGTH_SHORT).show();
}
/** * 吐司提示 long类型 * @param msg */
public static void toastL(Context mContext, String msg) {
Toast.makeText(mContext, msg, Toast.LENGTH_SHORT).show();
}
/** * 吐司提示 自定义时间类型 * @param msg */
public static void toastD(Context mContext, String msg, int duration) {
Toast.makeText(mContext, msg, duration).show();
}
}

Android-MD5Util工具类
MD5 字符串加密 ，文件加密相关工具类

public class MD5Util { 

private static final String TAG = "MD5Util";
/** * 默认的密码字符串组合，用来将字节转换成 16 进制表示的字符,apache校验下载的文件的正确性用的就是默认的这个组合 */
protected static char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
protected static MessageDigest messagedigest = null;
static {
try {
messagedigest = MessageDigest.getInstance("MD5");
} catch (NoSuchAlgorithmException nsaex) {
ELog.e(TAG, MD5Util.class.getName()
+ "init failed ，MessageDigest un support MD5Util。");
nsaex.printStackTrace();
}
}
/** * 生成字符串的md5校验值 * @param s * @return */
public static String getMD5String(String s) {
return getMD5String(s.getBytes());
}
/** * 生成字符串的md5校验值 16位 * @param s * @return */
public static String getMD5String16(String s) {
return getMD5String(s.getBytes()).substring(8, 24);
}
/** * 判断字符串的md5校验码是否与一个已知的md5码相匹配 * @param password 要校验的字符串 * @param md5PwdStr 已知的md5校验码 * @return */
public static boolean checkPassword(String password, String md5PwdStr) {
String s = getMD5String(password);
return s.equals(md5PwdStr);
}
/** * 生成文件的md5校验值 * @param file * @return * @throws IOException */
public static String getFileMD5String(File file) throws IOException {
InputStream fis;
fis = new FileInputStream(file);
byte[] buffer = new byte[1024];
int numRead = 0;
while ((numRead = fis.read(buffer)) > 0) {
messagedigest.update(buffer, 0, numRead);
}
fis.close();
return bufferToHex(messagedigest.digest());
}
public static String getMD5String(byte[] bytes) {
messagedigest.update(bytes);
return bufferToHex(messagedigest.digest());
}
private static String bufferToHex(byte bytes[]) {
return bufferToHex(bytes, 0, bytes.length);
}
private static String bufferToHex(byte bytes[], int m, int n) {
StringBuffer stringbuffer = new StringBuffer(2 * n);
int k = m + n;
for (int l = m; l < k; l++) {
appendHexPair(bytes[l], stringbuffer);
}
return stringbuffer.toString();
}
private static void appendHexPair(byte bt, StringBuffer stringbuffer) {
char c0 = hexDigits[(bt & 0xf0) >> 4];    // 取字节中高 4 位的数字转换, >>> 为逻辑右移，将符号位一起右移,此处未发现两种符号有何不同 
char c1 = hexDigits[bt & 0xf];    // 取字节中低 4 位的数字转换 
stringbuffer.append(c0);
stringbuffer.append(c1);
}
/** * 自测方法 * @param args */
public static void main(String[] args) {
System.out.println(getMD5String("test"));
}
}

Android-MeasureUtil工具类
常用测量相关的工具类：

public class MeasureUtil { 

private MeasureUtil(){}
/** * 获取控件的测量高度 * @param view 控件 * @return 返回测量高度（MeasuredHeight） */
public static int getMeasuredHeight(View view) {
if (view == null) {
throw new IllegalArgumentException("view is null");
}
view.measure(0, 0);
return view.getMeasuredHeight();
}
/** * 控件的高度 * @param view 控件View * @return 返回控件的高度 */
public static int getHeight(View view){
if(view == null){
throw new IllegalArgumentException("view is null");
}
view.measure(0, 0);
return view.getHeight();
}
/** * 获取控件的测量宽度 * @param view 控件 * @return 返回控件的测量宽度 */
public static int getMeasuredWidth(View view){
if(view == null){
throw new IllegalArgumentException("view is null");
}
view.measure(0, 0);
return view.getMeasuredWidth();
}
/** * 获取控件的宽度 * @param view 控件 * @return 返回控件的宽度 */
public static int getWidth(View view){
if(view == null){
throw new IllegalArgumentException("view is null");
}
view.measure(0, 0);
return view.getWidth();
}
/** * 设置高度 * @param view 控件 * @param height 高度 */
public static void setHeight(View view, int height) {
if (view == null || view.getLayoutParams() == null) {
throw new IllegalArgumentException("View LayoutParams is null");
}
ViewGroup.LayoutParams params = view.getLayoutParams();
params.height = height;
view.setLayoutParams(params);
}
/** * 设置View的宽度 * @param view view * @param width 宽度 */
public static void setWidth(View view, int width){
if(view == null || view.getLayoutParams() == null){
throw new IllegalArgumentException("View LayoutParams is null");
}
ViewGroup.LayoutParams params = view.getLayoutParams();
params.width = width;
view.setLayoutParams(params);
}
/** * 设置ListView的实际高度 * @param listView ListView控件 */
public static void setListHeight(ListView listView) {
if (listView == null) {
throw new IllegalArgumentException("ListView is null");
}
Adapter adapter = listView.getAdapter();
if (adapter == null) {
return;
}
int totalHeight = 0;
int size = adapter.getCount();
for (int i = 0; i < size; i++) {
View listItem = adapter.getView(i, null, listView);
listItem.measure(0, 0);
totalHeight += listItem.getMeasuredHeight();
}
ViewGroup.LayoutParams params = listView.getLayoutParams();
params.height = totalHeight + (listView.getDividerHeight() * (size - 1));
LogUtil.d("MeasureUtil", "listview-height--" + params.height);
listView.setLayoutParams(params);
}
/** * 设置GridView的高度， * @param context 应用程序上下文 * @param gv GridView控件 * @param n 行数 * @param m 列数 */
public static void setGridViewHeight(Context context, GridView gv, int n, int m) {
if(gv == null){
throw new IllegalArgumentException("GridView is null");
}
Adapter adapter = gv.getAdapter();
if (adapter == null) {
return;
}
int totalHeight = 0;
int size = adapter.getCount();
for (int i = 0; i < size; i++) {
View listItem = adapter.getView(i, null, gv);
listItem.measure(0, 0);
totalHeight += listItem.getMeasuredHeight() + ScreenUtil.dp2px(context, m);
}
ViewGroup.LayoutParams params = gv.getLayoutParams();
params.height = totalHeight + gv.getPaddingTop() + gv.getPaddingBottom() + 2;
LogUtil.d("MeasureUtil", "gridview-height--" + params.height);
gv.setLayoutParams(params);
}
}

Android-NetworkUtils工具类
网络类型，网络状态，网络制式，等相关工具类

public final class NetworkUtils { 

private NetworkUtils() {
throw new AssertionError();
}
/** * 未找到合适匹配网络类型 */
public static final int TYPE_NO = 0;
/** * 中国移动CMNET网络 * 中国移动GPRS接入方式之一, 主要为PC、笔记本电脑、PDA设立 */
public static final int TYPE_MOBILE_CMNET = 1;
/** * 中国移动CMWAP网络 * 中国移动GPRS接入方式之一,主要为手机WAP上网而设立 */
public static final int TYPE_MOBILE_CMWAP = 2;
/** * 中国联通UNIWAP网络 * 中国联通划分GPRS接入方式之一, 主要为手机WAP上网而设立 */
public static final int TYPE_MOBILE_UNIWAP = 3;
/** * 中国联通UNINET网络 * 中国联通划分GPRS接入方式之一, 主要为PC、笔记本电脑、PDA设立 */
public static final int TYPE_MOBILE_UNINET = 6;
/** * 中国联通3GWAP网络 */
public static final int TYPE_MOBILE_3GWAP = 4;
// 中国联通3HNET网络
public static final int TYPE_MOBLIE_3GNET = 5;
/** * 中国电信CTWAP网络 */
public static final int TYPE_MOBILE_CTWAP = 7;
/** * 中国电信CTNET网络 */
public static final int TYPE_MOBILE_CTNET = 8;
/** * WIFI网络 */
public static final int TYPE_WIFI = 10;
/** * 网络类型 - 无连接 */
public static final int NETWORK_TYPE_NO_CONNECTION = -100000;
/** * 连接模式WIFI网 */
public static final String NETWORK_TYPE_WIFI = "WIFI";
/** * 连接模式快速网 */
public static final String NETWORK_TYPE_FAST = "FAST";
/** * 连接模式慢速网 */
public static final String NETWORK_TYPE_SLOW = "SLOW";
/** * 连接模式wap网 */
public static final String NETWORK_TYPE_WAP = "WAP";
/** * 连接模式unknow */
public static final String NETWORK_TYPE_UNKNOWN = "UNKNOWN";
/** * 无连接 */
public static final String NETWORK_TYPE_DISCONNECT = "DISCONNECT";
/** * 获取当前手机连接的网络类型 * * @param context 上下文 * @return int 网络类型 */
public static int getNetworkState(Context context) {
int returnValue = TYPE_NO;
// 获取ConnectivityManager对象
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
// 获得当前网络信息
NetworkInfo networkInfo = cm.getActiveNetworkInfo();
if (networkInfo != null && networkInfo.isAvailable()) {
// 获取网络类型
int currentNetWork = networkInfo.getType();
// 手机网络类型
if (currentNetWork == ConnectivityManager.TYPE_MOBILE) {
if (networkInfo.getExtraInfo() != null) {
if (networkInfo.getExtraInfo().equals("cmnet")) {
returnValue = TYPE_MOBILE_CMNET;
}
if (networkInfo.getExtraInfo().equals("cmwap")) {
returnValue = TYPE_MOBILE_CMWAP;
}
if (networkInfo.getExtraInfo().equals("uniwap")) {
returnValue = TYPE_MOBILE_UNIWAP;
}
if (networkInfo.getExtraInfo().equals("3gwap")) {
returnValue = TYPE_MOBILE_3GWAP;
}
if (networkInfo.getExtraInfo().equals("3gnet")) {
returnValue = TYPE_MOBLIE_3GNET;
}
if (networkInfo.getExtraInfo().equals("uninet")) {
returnValue = TYPE_MOBILE_UNINET;
}
if (networkInfo.getExtraInfo().equals("ctwap")) {
returnValue = TYPE_MOBILE_CTWAP;
}
if (networkInfo.getExtraInfo().equals("ctnet")) {
returnValue = TYPE_MOBILE_CTNET;
}
}
// WIFI网络类型
} else if (currentNetWork == ConnectivityManager.TYPE_WIFI) {
returnValue = TYPE_WIFI;
}
}
return returnValue;
}
/** * 判断网络是否连接 * * @param context 上下文 * @return boolean 网络连接状态 */
public static boolean isNetworkConnected(Context context) {
if (context != null) {
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getActiveNetworkInfo();
// 获取连接对象
if (null != info && info.isConnected()) {
return info.getState() == State.CONNECTED;
}
}
return false;
}
/** * 打开网络设置界面 * * @param activity Activity */
public static void openNetSetting(Activity activity) {
Intent intent = new Intent("/");
ComponentName cm =
new ComponentName("com.android.settings", "com.android.settings.WirelessSettings");
intent.setComponent(cm);
intent.setAction("android.intent.action.VIEW");
activity.startActivityForResult(intent, 0);
}
/** * 是否是用手机网络连接 * * @param context 上下文 * @return 结果 */
public static boolean isFlowConnect(Context context) {
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (null == cm || null == cm.getActiveNetworkInfo()) {
return false;
}
return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
}
/** * 是否是wifi连接 * * @param context app的context * @return true:是wifi连接 */
public static boolean isWifiConnect(Context context) {
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (null == cm || null == cm.getActiveNetworkInfo()) {
return false;
}
return cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
}
/** * 获取网络连接类型 * * @param context context * @return NetworkType */
public static int getNetworkType(Context context) {
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (null == cm || null == cm.getActiveNetworkInfo()) {
return TYPE_NO;
}
return cm.getActiveNetworkInfo().getType();
}
/** * 获取网络连接类型名称 * * @param context context * @return NetworkTypeName */
public static String getNetworkTypeName(Context context) {
ConnectivityManager cm =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo info = cm.getActiveNetworkInfo();
String type = NETWORK_TYPE_DISCONNECT;
if (cm == null || info == null) {
return type;
}
if (info.isConnected()) {
String typeName = info.getTypeName();
if ("WIFI".equalsIgnoreCase(typeName)) {
type = NETWORK_TYPE_WIFI;
} else if ("MOBILE".equalsIgnoreCase(typeName)) {
String proxyHost = android.net.Proxy.getDefaultHost();
if (StringUtil.isEmpty(proxyHost)) {
type = isFastMobileNetwork(context) ? NETWORK_TYPE_FAST : NETWORK_TYPE_SLOW;
} else {
type = NETWORK_TYPE_WAP;
}
} else {
type = NETWORK_TYPE_UNKNOWN;
}
}
return type;
}
/** * Whether is fast mobile network * * @param context context * @return FastMobileNetwork */
private static boolean isFastMobileNetwork(Context context) {
TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(
Context.TELEPHONY_SERVICE);
if (telephonyManager == null) {
return false;
}
switch (telephonyManager.getNetworkType()) {
case TelephonyManager.NETWORK_TYPE_EVDO_0:
case TelephonyManager.NETWORK_TYPE_EVDO_A:
case TelephonyManager.NETWORK_TYPE_HSDPA:
case TelephonyManager.NETWORK_TYPE_HSPA:
case TelephonyManager.NETWORK_TYPE_HSUPA:
case TelephonyManager.NETWORK_TYPE_UMTS:
case TelephonyManager.NETWORK_TYPE_EHRPD:
case TelephonyManager.NETWORK_TYPE_EVDO_B:
case TelephonyManager.NETWORK_TYPE_HSPAP:
case TelephonyManager.NETWORK_TYPE_LTE:
return true;
default:
return false;
}
}
/** * 获取当前网络的状态 * * @param context 上下文 * @return 当前网络的状态。具体类型可参照NetworkInfo.State.CONNECTED、NetworkInfo.State.CONNECTED.DISCONNECTED等字段。 * 当前没有网络连接时返回null */
public static State getCurrentNetworkState(Context context) {
NetworkInfo info = ((ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
if (null == info) {
return null;
}
return info.getState();
}
/** * 获取当前网络的类型 * * @param context 上下文 * @return 当前网络的类型。具体类型可参照ConnectivityManager中的TYPE_BLUETOOTH、TYPE_MOBILE、TYPE_WIFI等字段。 * 当前没有网络连接时返回NetworkUtils.NETWORK_TYPE_NO_CONNECTION */
public static int getCurrentNetworkType(Context context) {
NetworkInfo info = ((ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
return info != null ? info.getType() : NETWORK_TYPE_NO_CONNECTION;
}
/** * 获取当前网络的具体类型 * * @param context 上下文 * @return 当前网络的具体类型。具体类型可参照TelephonyManager中的NETWORK_TYPE_1xRTT、NETWORK_TYPE_CDMA等字段。 * 当前没有网络连接时返回NetworkUtils.NETWORK_TYPE_NO_CONNECTION */
public static int getCurrentNetworkSubtype(Context context) {
NetworkInfo info = ((ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
return info != null ? info.getSubtype() : NETWORK_TYPE_NO_CONNECTION;
}
/** * 判断当前网络是否已经连接 * * @param context 上下文 * @return 当前网络是否已经连接。false：尚未连接 */
public static boolean isConnectedByState(Context context) {
return getCurrentNetworkState(context) == State.CONNECTED;
}
/** * 判断当前网络是否正在连接 * * @param context 上下文 * @return 当前网络是否正在连接 */
public static boolean isConnectingByState(Context context) {
return getCurrentNetworkState(context) == State.CONNECTING;
}
/** * 判断当前网络是否已经断开 * * @param context 上下文 * @return 当前网络是否已经断开 */
public static boolean isDisconnectedByState(Context context) {
return getCurrentNetworkState(context) == State.DISCONNECTED;
}
/** * 判断当前网络是否正在断开 * * @param context 上下文 * @return 当前网络是否正在断开 */
public static boolean isDisconnectingByState(Context context) {
return getCurrentNetworkState(context) == State.DISCONNECTING;
}
/** * 判断当前网络是否已经暂停 * * @param context 上下文 * @return 当前网络是否已经暂停 */
public static boolean isSuspendedByState(Context context) {
return getCurrentNetworkState(context) == State.SUSPENDED;
}
/** * 判断当前网络是否处于未知状态中 * * @param context 上下文 * @return 当前网络是否处于未知状态中 */
public static boolean isUnknownByState(Context context) {
return getCurrentNetworkState(context) == State.UNKNOWN;
}
/** * 判断当前网络的类型是否是蓝牙 * * @param context 上下文 * @return 当前网络的类型是否是蓝牙。false：当前没有网络连接或者网络类型不是蓝牙 */
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
public static boolean isBluetoothByType(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
return false;
} else {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_BLUETOOTH;
}
}
/** * 判断当前网络的类型是否是虚拟网络 * * @param context 上下文 * @return 当前网络的类型是否是虚拟网络。false：当前没有网络连接或者网络类型不是虚拟网络 */
@TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
public static boolean isDummyByType(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
return false;
} else {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_DUMMY;
}
}
/** * 判断当前网络的类型是否是ETHERNET * * @param context 上下文 * @return 当前网络的类型是否是ETHERNET。false：当前没有网络连接或者网络类型不是ETHERNET */
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
public static boolean isEthernetByType(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
return false;
} else {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_ETHERNET;
}
}
/** * 判断当前网络的类型是否是移动网络 * * @param context 上下文 * @return 当前网络的类型是否是移动网络。false：当前没有网络连接或者网络类型不是移动网络 */
public static boolean isMobileByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE;
}
/** * 判断当前网络的类型是否是MobileDun * * @param context 上下文 * @return 当前网络的类型是否是MobileDun。false：当前没有网络连接或者网络类型不是MobileDun */
public static boolean isMobileDunByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE_DUN;
}
/** * 判断当前网络的类型是否是MobileHipri * * @param context 上下文 * @return 当前网络的类型是否是MobileHipri。false：当前没有网络连接或者网络类型不是MobileHipri */
public static boolean isMobileHipriByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE_HIPRI;
}
/** * 判断当前网络的类型是否是MobileMms * * @param context 上下文 * @return 当前网络的类型是否是MobileMms。false：当前没有网络连接或者网络类型不是MobileMms */
public static boolean isMobileMmsByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE_MMS;
}
/** * 判断当前网络的类型是否是MobileSupl * * @param context 上下文 * @return 当前网络的类型是否是MobileSupl。false：当前没有网络连接或者网络类型不是MobileSupl */
public static boolean isMobileSuplByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_MOBILE_SUPL;
}
/** * 判断当前网络的类型是否是Wimax * * @param context 上下文 * @return 当前网络的类型是否是Wimax。false：当前没有网络连接或者网络类型不是Wimax */
public static boolean isWimaxByType(Context context) {
return getCurrentNetworkType(context) == ConnectivityManager.TYPE_WIMAX;
}
/** * 判断当前网络的具体类型是否是1XRTT * * @param context 上下文 * @return false：当前网络的具体类型是否是1XRTT。false：当前没有网络连接或者具体类型不是1XRTT */
public static boolean is1XRTTBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_1xRTT;
}
/** * 判断当前网络的具体类型是否是CDMA（Either IS95A or IS95B） * * @param context 上下文 * @return false：当前网络的具体类型是否是CDMA。false：当前没有网络连接或者具体类型不是CDMA */
public static boolean isCDMABySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_CDMA;
}
/** * 判断当前网络的具体类型是否是EDGE * * @param context 上下文 * @return false：当前网络的具体类型是否是EDGE。false：当前没有网络连接或者具体类型不是EDGE */
public static boolean isEDGEBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_EDGE;
}
/** * 判断当前网络的具体类型是否是EHRPD * * @param context 上下文 * @return false：当前网络的具体类型是否是EHRPD。false：当前没有网络连接或者具体类型不是EHRPD */
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static boolean isEHRPDBySubtype(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
return false;
} else {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_EHRPD;
}
}
/** * 判断当前网络的具体类型是否是EVDO_0 * * @param context 上下文 * @return false：当前网络的具体类型是否是EVDO_0。false：当前没有网络连接或者具体类型不是EVDO_0 */
public static boolean isEVDO0BySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_EVDO_0;
}
/** * 判断当前网络的具体类型是否是EVDO_A * * @param context 上下文 * @return false：当前网络的具体类型是否是EVDO_A。false：当前没有网络连接或者具体类型不是EVDO_A */
public static boolean isEVDOABySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_EVDO_A;
}
/** * 判断当前网络的具体类型是否是EDGE * * @param context 上下文 * @return false：当前网络的具体类型是否是EVDO_B。false：当前没有网络连接或者具体类型不是EVDO_B */
@TargetApi(Build.VERSION_CODES.GINGERBREAD)
public static boolean isEVDOBBySubtype(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.GINGERBREAD) {
return false;
} else {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_EVDO_B;
}
}
/** * 判断当前网络的具体类型是否是GPRS * * @param context app的context * @return false：当前网络的具体类型是否是GPRS。false：当前没有网络连接或者具体类型不是GPRS */
public static boolean isGPRSBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_GPRS;
}
/** * 判断当前网络的具体类型是否是HSDPA * * @param context 上下文 * @return false：当前网络的具体类型是否是HSDPA。false：当前没有网络连接或者具体类型不是HSDPA */
public static boolean isHSDPABySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_HSDPA;
}
/** * 判断当前网络的具体类型是否是HSPA * * @param context 上下文 * @return false：当前网络的具体类型是否是HSPA。false：当前没有网络连接或者具体类型不是HSPA */
public static boolean isHSPABySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_HSPA;
}
/** * 判断当前网络的具体类型是否是HSPAP * * @param context 上下文 * @return false：当前网络的具体类型是否是HSPAP。false：当前没有网络连接或者具体类型不是HSPAP */
@TargetApi(Build.VERSION_CODES.HONEYCOMB_MR2)
public static boolean isHSPAPBySubtype(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB_MR2) {
return false;
} else {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_HSPAP;
}
}
/** * 判断当前网络的具体类型是否是HSUPA * * @param context 上下文 * @return false：当前网络的具体类型是否是HSUPA。false：当前没有网络连接或者具体类型不是HSUPA */
public static boolean isHSUPABySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_HSUPA;
}
/** * 判断当前网络的具体类型是否是IDEN * * @param context 上下文 * @return false：当前网络的具体类型是否是IDEN。false：当前没有网络连接或者具体类型不是IDEN */
public static boolean isIDENBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_IDEN;
}
/** * 判断当前网络的具体类型是否是LTE * * @param context 上下文 * @return false：当前网络的具体类型是否是LTE。false：当前没有网络连接或者具体类型不是LTE */
@TargetApi(Build.VERSION_CODES.HONEYCOMB)
public static boolean isLTEBySubtype(Context context) {
if (Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB) {
return false;
} else {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_LTE;
}
}
/** * 判断当前网络的具体类型是否是UMTS * * @param context 上下文 * @return false：当前网络的具体类型是否是UMTS。false：当前没有网络连接或者具体类型不是UMTS */
public static boolean isUMTSBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_UMTS;
}
/** * 判断当前网络的具体类型是否是UNKNOWN * * @param context 上下文 * @return false：当前网络的具体类型是否是UNKNOWN。false：当前没有网络连接或者具体类型不是UNKNOWN */
public static boolean isUNKNOWNBySubtype(Context context) {
return getCurrentNetworkSubtype(context) == TelephonyManager.NETWORK_TYPE_UNKNOWN;
}
/** * 判断当前网络是否是中国移动2G网络 * * @param context 上下文 * @return false：不是中国移动2G网络或者当前没有网络连接 */
public static boolean isChinaMobile2G(Context context) {
return isEDGEBySubtype(context);
}
/** * 判断当前网络是否是中国联通2G网络 * * @param context 上下文 * @return false：不是中国联通2G网络或者当前没有网络连接 */
public static boolean isChinaUnicom2G(Context context) {
return isGPRSBySubtype(context);
}
/** * 判断当前网络是否是中国联通3G网络 * * @param context 上下文 * @return false：不是中国联通3G网络或者当前没有网络连接 */
public static boolean isChinaUnicom3G(Context context) {
return isHSDPABySubtype(context) || isUMTSBySubtype(context);
}
/** * 判断当前网络是否是中国电信2G网络 * * @param context 上下文 * @return false：不是中国电信2G网络或者当前没有网络连接 */
public static boolean isChinaTelecom2G(Context context) {
return isCDMABySubtype(context);
}
/** * 判断当前网络是否是中国电信3G网络 * * @param context 上下文 * @return false：不是中国电信3G网络或者当前没有网络连接 */
public static boolean isChinaTelecom3G(Context context) {
return isEVDO0BySubtype(context) || isEVDOABySubtype(context) || isEVDOBBySubtype(context);
}
/** * 获取Wifi的状态，需要ACCESS_WIFI_STATE权限 * * @param context 上下文 * @return 取值为WifiManager中的WIFI_STATE_ENABLED、WIFI_STATE_ENABLING、WIFI_STATE_DISABLED、 * WIFI_STATE_DISABLING、WIFI_STATE_UNKNOWN之一 * @throws Exception 没有找到wifi设备 */
public static int getWifiState(Context context) throws Exception {
WifiManager wifiManager = ((WifiManager) context.getSystemService(Context.WIFI_SERVICE));
if (wifiManager != null) {
return wifiManager.getWifiState();
} else {
throw new Exception("wifi device not found!");
}
}
/** * 判断Wifi是否打开，需要ACCESS_WIFI_STATE权限 * * @param context 上下文 * @return true：打开；false：关闭 * @throws Exception */
public static boolean isWifiOpen(Context context) throws Exception {
int wifiState = getWifiState(context);
return wifiState == WifiManager.WIFI_STATE_ENABLED
|| wifiState == WifiManager.WIFI_STATE_ENABLING ? true : false;
}
/** * 设置Wifi，需要CHANGE_WIFI_STATE权限 * * @param context 上下文 * @param enable wifi状态 * @return 设置是否成功 * @throws Exception 是否授予WiFi权限 */
public static boolean setWifi(Context context, boolean enable) throws Exception {
// 如果当前wifi的状态和要设置的状态不一样
if (isWifiOpen(context) != enable) {
((WifiManager) context.getSystemService(Context.WIFI_SERVICE)).setWifiEnabled(enable);
}
return true;
}
/** * 判断移动网络是否打开，需要ACCESS_NETWORK_STATE权限 * * @param context 上下文 * @return true：打开；false：关闭 */
public static boolean isMobileNetworkOpen(Context context) {
return (((ConnectivityManager) context.getSystemService(
Context.CONNECTIVITY_SERVICE)).getNetworkInfo(
ConnectivityManager.TYPE_MOBILE)).isConnected();
}
/** * 获取本机IP地址 * * @return null：没有网络连接 */
public static String getIpAddress() {
try {
NetworkInterface nerworkInterface;
InetAddress inetAddress;
for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en
.hasMoreElements(); ) {
nerworkInterface = en.nextElement();
for (Enumeration<InetAddress> enumIpAddr = nerworkInterface.getInetAddresses(); enumIpAddr
.hasMoreElements(); ) {
inetAddress = enumIpAddr.nextElement();
if (!inetAddress.isLoopbackAddress()) {
return inetAddress.getHostAddress().toString();
}
}
}
return null;
} catch (SocketException ex) {
ex.printStackTrace();
return null;
}
}
/** * 设置数据流量状态 * * @param context app的context * @param enabled 是否可用 */
public static void setDataEnabled(Context context, boolean enabled) {
ConnectivityManager conMgr =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
Class<?> conMgrClass = null;
Field iConMgrField = null;
Object iConMgr = null;
Class<?> iConMgrClass = null;
Method setMobileDataEnabledMethod = null;
try {
conMgrClass = Class.forName(conMgr.getClass().getName());
iConMgrField = conMgrClass.getDeclaredField("mService");
iConMgrField.setAccessible(true);
iConMgr = iConMgrField.get(conMgr);
iConMgrClass = Class.forName(iConMgr.getClass().getName());
setMobileDataEnabledMethod =
iConMgrClass.getDeclaredMethod("setMobileDataEnabled", Boolean.TYPE);
setMobileDataEnabledMethod.setAccessible(true);
setMobileDataEnabledMethod.invoke(iConMgr, enabled);
} catch (Exception e) {
e.printStackTrace();
}
}
/** * 获取wifi列表 * * @param context app的context * @return wifi列表 */
public static List<ScanResult> getWifiScanResults(Context context) {
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
return wifiManager.startScan() ? wifiManager.getScanResults() : null;
}
/** * 过滤扫描结果 * * @param context app的context * @param bssid 过滤的字符串 * @return 过滤后的wifi列表 */
public static ScanResult getScanResultsByBSSID(Context context, String bssid) {
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
ScanResult scanResult = null;
boolean f = wifiManager.startScan();
if (!f) {
getScanResultsByBSSID(context, bssid);
}
List<ScanResult> list = wifiManager.getScanResults();
if (list != null) {
for (int i = 0; i < list.size(); i++) {
scanResult = list.get(i);
if (scanResult.BSSID.equals(bssid)) {
break;
}
}
}
return scanResult;
}
/** * 获取wifi连接信息 * * @param context app的context * @return wifi信息 */
public static WifiInfo getWifiConnectionInfo(Context context) {
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
return wifiManager.getConnectionInfo();
}
/** * 获得Proxy地址 * * @param context 上下文 * @return Proxy地址 */
public static String getProxy(Context context) {
String proxy = null;
ConnectivityManager connectivityManager =
(ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
if (connectivityManager != null) {
NetworkInfo networkinfo = connectivityManager.getActiveNetworkInfo();
if (networkinfo != null && networkinfo.isAvailable()) {
String stringExtraInfo = networkinfo.getExtraInfo();
if (stringExtraInfo != null
&& ("cmwap".equals(stringExtraInfo) || "uniwap".equals(stringExtraInfo))) {
proxy = "10.0.0.172:80";
} else if (stringExtraInfo != null && "ctwap".equals(stringExtraInfo)) {
proxy = "10.0.0.200:80";
}
}
}
return proxy;
}
// -------------
/** * 判断当前是否有网络连接 * @param context * @return 有网络返回true；无网络返回false */
@SuppressWarnings("null")
public static boolean isNetWorkEnable(Context context){
ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = manager.getActiveNetworkInfo();
if (networkInfo != null || networkInfo.isConnected()) {
if (networkInfo.getState() == State.CONNECTED) {
return true;
}
}
return false;
}
/** * 判断当前网络是否为wifi * @param context * @return 如果为wifi返回true；否则返回false */
@SuppressWarnings("static-access")
public static boolean isWiFiConnected(Context context){
ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
NetworkInfo networkInfo = manager.getActiveNetworkInfo();
return networkInfo.getType() == manager.TYPE_WIFI ? true : false;
}
/** * 判断MOBILE网络是否可用 * @param context * @return * @throws Exception */
public static boolean isMobileDataEnable(Context context){
ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
boolean isMobileDataEnable = false;
isMobileDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).isConnectedOrConnecting();
return isMobileDataEnable;
}
/** * 判断wifi 是否可用 * @param context * @return * @throws Exception */
public static boolean isWifiDataEnable(Context context){
ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
boolean isWifiDataEnable = false;
isWifiDataEnable = manager.getNetworkInfo(
ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();
return isWifiDataEnable;
}
/** * 跳转到网络设置页面 * @param activity */
public static void GoSetting(Activity activity){
Intent intent = new Intent(Settings.ACTION_ACCESSIBILITY_SETTINGS);
activity.startActivity(intent);
}
/** * 打开网络设置界面 */
public static void openSetting(Activity activity) {
Intent intent = new Intent("/");
ComponentName cn = new ComponentName("com.android.settings", "com.android.settings.WirelessSettings");
intent.setComponent(cn);
intent.setAction("android.intent.action.VIEW");
activity.startActivityForResult(intent, 0);
}
}

Android-PhoneUtil工具类
手机组件调用工具类

public class PhoneUtil { 

private static long lastClickTime;
private PhoneUtil() {
throw new Error("Do not need instantiate!");
}
/** * 调用系统发短信界面 * @param activity Activity * @param phoneNumber 手机号码 * @param smsContent 短信内容 */
public static void sendMessage(Context activity, String phoneNumber, String smsContent) {
if (smsContent == null || phoneNumber.length() < 4) {
return;
}
Uri uri = Uri.parse("smsto:" + phoneNumber);
Intent intent = new Intent(Intent.ACTION_SENDTO, uri);
intent.putExtra("sms_body", smsContent);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
activity.startActivity(intent);
}
/** * 判断是否为连击 * @return boolean */
public static boolean isFastDoubleClick() {
long time = System.currentTimeMillis();
long timeD = time - lastClickTime;
if (0 < timeD && timeD < 500) {
return true;
}
lastClickTime = time;
return false;
}
/** * 获取手机型号 * @param context 上下文 * @return String */
public static String getMobileModel(Context context) {
try {
String model = android.os.Build.MODEL;
return model;
} catch (Exception e) {
return "未知！";
}
}
/** * 获取手机品牌 * @param context 上下文 * @return String */
public static String getMobileBrand(Context context) {
try {
// android系统版本号
String brand = android.os.Build.BRAND;
return brand;
} catch (Exception e) {
return "未知";
}
}
/** *拍照打开照相机！ * @param requestcode 返回值 * @param activity 上下文 * @param fileName 生成的图片文件的路径 */
public static void toTakePhoto(int requestcode, Activity activity,String fileName) {
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
intent.putExtra("camerasensortype", 2);// 调用前置摄像头
intent.putExtra("autofocus", true);// 自动对焦
intent.putExtra("fullScreen", false);// 全屏
intent.putExtra("showActionIcons", false);
try {
//创建一个当前任务id的文件，然后里面存放任务的照片和路径！这主文件的名字是用uuid到时候再用任务id去查路径！
File file = new File(fileName);
//如果这个文件不存在就创建一个文件夹！
if (!file.exists()) {
file.mkdirs();
}
Uri uri = Uri.fromFile(file);
intent.putExtra(MediaStore.EXTRA_OUTPUT, uri);
activity.startActivityForResult(intent, requestcode);
} catch (Exception e) {
e.printStackTrace();
}
}
/** *打开相册 * @param requestcode 响应码 * @param activity 上下文 */
public static void toTakePicture(int requestcode, Activity activity){
Intent intent = new Intent(Intent.ACTION_PICK, null);
intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
activity.startActivityForResult(intent, requestcode);
}
}

Android-PreferencesUtil工具类
SharedPreferences工具类，包含常用的数值获取和存储

public class PreferencesUtil { 

private PreferencesUtil(){}
/** * 默认的SharePreference名称 */
private static final String SHARED_NAME = "SharedPreferences";
/** * 查询某个key是否已经存在 * @param context 应用程序上下文 * @param key key关键字 * @return 包含返回true；反之返回false */
public static boolean containsKey(Context context, String key){
SharedPreferences sp = getSharedPreferences(context);
return sp.contains(key);
}
/** * 返回所有的键值对 * @param context 应用程序上下文 * @return */
public static Map<String, ?> getAll(Context context) {
SharedPreferences sp = getSharedPreferences(context);
return sp.getAll();
}
/** * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值 * @param context 应用程序上下文 * @param key key关键字 * @param defaultObject 默认值 * @return 返回获取的String值 */
public static Object get(Context context, String key, Object defaultObject){
SharedPreferences sp = getSharedPreferences(context);
if (defaultObject instanceof String) {
return sp.getString(key, (String) defaultObject);
} else if (defaultObject instanceof Integer) {
return sp.getInt(key, (Integer) defaultObject);
} else if (defaultObject instanceof Boolean) {
return sp.getBoolean(key, (Boolean) defaultObject);
} else if (defaultObject instanceof Float) {
return sp.getFloat(key, (Float) defaultObject);
} else if (defaultObject instanceof Long) {
return sp.getLong(key, (Long) defaultObject);
}
return null;
}
/** * 获取Set<String> 集合 * @param context 应用程序上下文 * @param key key关键字 * @param defValues 默认值 * @return 返回Set<String>值 */
public static Set<String> getStringSet(Context context, String key,  Set<String> defValues){
SharedPreferences sp = getSharedPreferences(context);
return sp.getStringSet(key, defValues);
}
/** * 保存Set<String>集合的值 * @param context 应用程序上下文 * @param key key关键字 * @param value 对应值 * @return 成功返回true，失败返回false */
public static boolean putStringSet(Context context, String key, Set<String> value){
return getEditor(context).putStringSet(key, value).commit();
}
/** * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法 * @param context 应用程序上下文 * @param key key关键字 * @param object 对应值 * @return 成功返回true，失败返回false */
public static void put(Context context, String key, Object object){
if (object instanceof String) {
getEditor(context).putString(key, (String) object);
} else if (object instanceof Integer) {
getEditor(context).putInt(key, (Integer) object);
} else if (object instanceof Boolean) {
getEditor(context).putBoolean(key, (Boolean) object);
} else if (object instanceof Float) {
getEditor(context).putFloat(key, (Float) object);
} else if (object instanceof Long) {
getEditor(context).putLong(key, (Long) object);
} else {
getEditor(context).putString(key, object.toString());
}
SharedPreferencesCompat.apply(getEditor(context));
}
/** * 删除关键字key对应的值 * @param context 应用程序上下文 * @param key 关键字key */
public static void removeKey(Context context, String key){
getEditor(context).remove(key);
SharedPreferencesCompat.apply(getEditor(context));
}
/** * 清除所有的关键字对应的值 * @param context 应用程序上下文 */
public static void clearValues(Context context){
getEditor(context).clear();
SharedPreferencesCompat.apply(getEditor(context));
}
/** * 获取SharedPreferences对象 * @param context 应用程序上下文 * @return 返回SharedPreferences对象 */
private static SharedPreferences getSharedPreferences(Context context){
return context.getSharedPreferences(SHARED_NAME, Context.MODE_PRIVATE);
}
/** * 获取Editor对象 * @param context 应用程序上下文 * @return 返回Editor对象 */
private static Editor getEditor(Context context){
return getSharedPreferences(context).edit();
}
/** * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类 */
private static class SharedPreferencesCompat { 

private static final Method sApplyMethod = findApplyMethod();
/** * 反射查找apply的方法 * @return */
@SuppressWarnings({ "unchecked", "rawtypes" })
private static Method findApplyMethod() {
try {
Class clz = Editor.class;
return clz.getMethod("apply");
} catch (NoSuchMethodException e) {
e.printStackTrace();
}
return null;
}
/** * 如果找到则使用apply执行，否则使用commit * @param editor */
public static void apply(Editor editor) {
try {
if (sApplyMethod != null) {
sApplyMethod.invoke(editor);
return;
}
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
editor.commit();
}
}
}

Android-ReflectUtil工具类
反射工具类：

public class ReflectUtil { 

private ReflectUtil(){}
/** * 设置字段值 * @param t 对应实体 * @param field 字段 * @param fieldName 字段名称 * @param value 字段值 */
public static<T> void setFieldValue(T t,Field field, String fieldName, String value){
String name = field.getName();
//判断该字段是否和目标字段相同
if (!fieldName.equals(name)) {
return;
}
//获取字段的类型
Type type = field.getType();
//获取字段的修饰符号码
int typeCode = field.getModifiers();
//获取字段类型的名称
String typeName = type.toString();
try {
switch (typeName) {
case "class java.lang.String":
if (Modifier.isPublic(typeCode)) {
field.set(t, value);
} else {
Method method = t.getClass().getMethod("set" + getMethodName(fieldName), String.class);
method.invoke(t, value);
}
break;
case "double":
if(Modifier.isPublic(typeCode)){
field.setDouble(t, Double.valueOf(value));
}else{
Method method = t.getClass().getMethod("set" + getMethodName(fieldName),double.class);
method.invoke(t, Double.valueOf(value));
}
break;
case "int":
if(Modifier.isPublic(typeCode)){
field.setInt(t, Integer.valueOf(value));
}else{
Method method = t.getClass().getMethod("set" + getMethodName(fieldName),int.class);
method.invoke(t, Integer.valueOf(value));
}
break;
case "float":
if(Modifier.isPublic(typeCode)){
field.setFloat(t, Float.valueOf(value));
}else{
Method method = t.getClass().getMethod("set" + getMethodName(fieldName), float.class);
method.invoke(t, Float.valueOf(value));
}
break;
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
}
/** * 把字段名称第一个字母换成大写 * @param fieldName 字段名称 * @return * @throws Exception 异常处理 */
private static String getMethodName(String fieldName) throws Exception{
byte[] items = fieldName.getBytes();
items[0] = (byte) ((char)items[0] - 'a' + 'A');
return new String(items);
}
/** * 根据字段名称获取指定Field字段 * @param clazz 实体的字节码文件 * @param filedName 字段的名称 * @return 返回对应的字符按Field或者返回null */
public static Field getField(Class<?> clazz, String filedName){
if (clazz == null || TextUtils.isEmpty(filedName)) {
throw new IllegalArgumentException("params is illegal");
}
Field[] fields = clazz.getDeclaredFields();
return getFieldByName(fields, filedName);
}
/** * 根据字段名称获取指定的Field * @param fields 字段集合 * @param fieldName 字段名称 * @return 返回对应的Field字段或者返回null */
public static Field getFieldByName(Field[] fields, String fieldName){
if (fields == null || fields.length == 0 || TextUtils.isEmpty(fieldName)) {
throw new IllegalArgumentException("params is illegal");
}
for (Field field : fields) {
String name = field.getName();
//判断该字段是否和目标字段相同
if (fieldName.equals(name)) {
return field;
}
}
return null;
}
/** * 判断该字段是否为FieldName对应字段 * @param field Field字段 * @param fieldName 目标字段 * @return 是，返回true；否，返回false */
public static boolean isFiledWithName(Field field, String fieldName){
if(field == null || TextUtils.isEmpty(fieldName)){
throw new IllegalArgumentException("params is illegal");
}
if (fieldName.equals(field.getName())) {
return true;
}
return false;
}
}

Android-RSAUtils工具类
RSA加解密工具类

public class RSAUtils { 

private static final String TAG = "RSAUtils";
private final static String UTF_8 = "UTF-8";
// 10位公共偏移量
private final static String KEY_SUFFIX = "14293300FF";
private static byte[] iv;
static {
try {
iv = "0123456789ABCDEF".getBytes(UTF_8);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}
static String AES_CBC_PKCS5Padding = "AES/CBC/PKCS5Padding";
static String RSA_ECB_PKCS1Padding = "RSA/ECB/PKCS1Padding";
static String MD5 = "MD5";
static int MD5_LEN = 32;
private static String[] TYPES = {AES_CBC_PKCS5Padding,
RSA_ECB_PKCS1Padding};
private static Integer[] MODES = {Cipher.ENCRYPT_MODE, Cipher.DECRYPT_MODE};
public static Key prvKey;
public static Key pubKey;
private static X509Certificate pubCert;
// static String privateFile = RSAUtils.class.getClassLoader().getResource("").getPath() + "pkcs8_private_key.der";
static String privateFile;
// 公钥文件路径
// static String publicFile = RSAUtils.class.getClassLoader().getResource("").getPath() + "rsacert.der";
public static InputStream publicFis;
public static String encode = UTF_8;// 保持平台兼容统一使用utf-8
private static String encryptMD5(String data) throws Exception {
return doEncryptMD5(data, MD5);
}
public static SecretKey getKeyAES(String strKey) throws Exception {
SecretKeySpec key = new SecretKeySpec(strKey.getBytes(encode), "AES");
return key;
}
public static HashMap<String, String> genMap(String acc)
throws RuntimeException {
System.out.println("accept data:" + acc);
HashMap<String, String> tmpMap = new HashMap<String, String>();
if (acc == null || acc.length() < 26) {
throw new RuntimeException("非法数据");
}
// 第一个|在第24位(从0开始算)
if (acc.indexOf("|") == MD5_LEN) {
String md5 = acc.substring(0, MD5_LEN);
acc = acc.substring(MD5_LEN + 1);
tmpMap.put("md5", md5);
// 第二个|在第8位及以后(从0开始算)
int tmpInt = acc.indexOf("|");
if (acc.length() > 9 && tmpInt > 7 && tmpInt % 2 == 0) {
String data = acc.substring(0, tmpInt);
acc = acc.substring(tmpInt + 1);
tmpMap.put("data", data);
// 第二个|后数据长度都在16以上
tmpInt = acc.length();
if (tmpInt > 15) {
tmpMap.put("key", acc);
} else {
throw new RuntimeException("非法key数据");
}
} else {
throw new RuntimeException("非法data数据");
}
} else {
throw new RuntimeException("非法md5数据");
}
return tmpMap;
}
/** * //默认加密 MD5 AES_CBC_PKCS5Padding RSA_ECB_PKCS1Padding（私钥加密） * * @param dataToEncypt 数据 * @param pwd 对称密钥 * @return Map * @throws Exception */
public static HashMap<String, String> defaultEncrypt(byte[] dataToEncypt,
String pwd) throws Exception {
return encrypt(dataToEncypt, pwd, true);
}
/** * //默认加密 MD5 AES_CBC_PKCS5Padding RSA_ECB_PKCS1Padding（私钥加密） * * @param dataToEncypt 数据 * @param pwd 对称密钥 * @param isPrvEncrypt 是否使用私钥加密 * @return Map * @throws Exception */
public static HashMap<String, String> encrypt(byte[] dataToEncypt,
String pwd, boolean isPrvEncrypt) throws Exception {
if (pwd == null || pwd.getBytes(encode).length != 6) {
throw new RuntimeException("非法密钥");
}
Key key = prvKey;
if (!isPrvEncrypt) {
key = pubKey;
}
// md5 key+data
// byte[] md5Byte = encryptMD5(pwd + new String(dataToEncypt, encode));
// String md5Base64 = Base64Utils.encode(md5Byte);
String md5Base64 = doEncryptMD5(pwd + new String(dataToEncypt, encode), MD5);
byte[] encryptData = doCrypt(AES_CBC_PKCS5Padding, Cipher.ENCRYPT_MODE,
new IvParameterSpec(iv), getKeyAES(pwd + KEY_SUFFIX),
dataToEncypt);
// String dataBase64 = Base64Utils.encode(encryptData);
String dataBase64 = doBase64Encode(encryptData);
byte[] encryptKey = doCrypt(RSA_ECB_PKCS1Padding, Cipher.ENCRYPT_MODE,
null, key, pwd.getBytes(encode));
// String keyBase64 = Base64Utils.encode(encryptKey);
String keyBase64 = doBase64Encode(encryptKey);
HashMap<String, String> data = new HashMap<String, String>();
data.put("data", dataBase64);
data.put("key", keyBase64);
data.put("md5", md5Base64);
data.put("send", md5Base64 + "|" + dataBase64 + "|" + keyBase64);
return data;
}
/** * //默认解密 MD5 AES_CBC_PKCS5Padding RSA_ECB_PKCS1Padding（公钥解密） * * @paramdataToEncypt 数据 * @parampwd 对称密钥 * @return Map * @throws Exception */
public static String defaultDecrypt(HashMap<String, String> data)
throws Exception {
return decrypt(data, true);
}
/** * //默认解密 MD5 AES_CBC_PKCS5Padding RSA_ECB_PKCS1Padding（公钥解密） * * @paramdataToEncypt 数据 * @parampwd 对称密钥 * @param isPubDecrypt 是否使用公钥解密 * @return Map * @throws Exception */
public static String decrypt(HashMap<String, String> data,
boolean isPubDecrypt) throws Exception {
Key key = pubKey;
if (!isPubDecrypt) {
key = prvKey;
}
String dataBase64 = data.get("data");
String keyBase64 = data.get("key");
String md5Base64Src = data.get("md5");
// byte[] encryptedKey = Base64Utils.decode(keyBase64);
byte[] encryptedKey = doBase64Decode(keyBase64);
byte[] decryptedKey = doCrypt(RSA_ECB_PKCS1Padding,
Cipher.DECRYPT_MODE, null, key, encryptedKey);
String pwd = new String(decryptedKey, encode);
if (pwd == null || pwd.getBytes(encode).length != 6) {
throw new RuntimeException("伪造密钥");
}
// byte[] encryptedData = Base64Utils.decode(dataBase64);
byte[] encryptedData = doBase64Decode(dataBase64);
byte[] decryptedData = doCrypt(AES_CBC_PKCS5Padding,
Cipher.DECRYPT_MODE, new IvParameterSpec(iv), getKeyAES(pwd
+ KEY_SUFFIX), encryptedData);
String textDecrypt = new String(decryptedData, encode);
// md5 key+data
// byte[] md5Byte = encryptMD5(pwd + textDecrypt);
// String md5Base64 = Base64Utils.encode(md5Byte);
String md5Base64 = doEncryptMD5(pwd + textDecrypt, MD5);
if (!md5Base64.equals(md5Base64Src)) {
throw new RuntimeException("伪造数据");
}
return textDecrypt;
}
public static Key getPubKey() throws CertificateException, IOException {
// 读取公钥
CertificateFactory certificatefactory = CertificateFactory
.getInstance("X.509");
InputStream bais = publicFis;
Certificate cert = certificatefactory.generateCertificate(bais);
bais.close();
pubCert = (X509Certificate) cert;
PublicKey puk = cert.getPublicKey();
return puk;
}
public static Key getPrvKey() throws IOException, NoSuchAlgorithmException,
InvalidKeySpecException {
FileInputStream in = new FileInputStream(privateFile);
ByteArrayOutputStream bout = new ByteArrayOutputStream();
byte[] tmpbuf = new byte[1024];
int count = 0;
while ((count = in.read(tmpbuf)) != -1) {
bout.write(tmpbuf, 0, count);
}
in.close();
// 读取私钥
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PKCS8EncodedKeySpec privateKeySpec = new PKCS8EncodedKeySpec(
bout.toByteArray());
PrivateKey prk = keyFactory.generatePrivate(privateKeySpec);
return prk;
}
public static String doEncryptMD5(String data, String type)
throws Exception {
MessageDigest md = MessageDigest.getInstance("MD5");
md.update(data.getBytes("UTF-8"));
byte b[] = md.digest();
int i;
StringBuffer buf = new StringBuffer("");
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
buf.append("0");
buf.append(Integer.toHexString(i));
}
if (MD5_LEN == 32) {
// 32位加密
return buf.toString().toUpperCase();
} else {
// 16位的加密
return buf.toString().substring(8, 24);
}
}
public static String getPassword() {
String pwd = (new Random().nextInt(1000000) + 1000000 + "")
.substring(1);
return pwd;
}
// pkcs8_der.key文件为私钥 只能保存在服务端
// public_key.der为公钥文件，保存在客户端
public static void main(String[] args) {
try {
prvKey = getPrvKey();
pubKey = getPubKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (InvalidKeySpecException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (CertificateException e) {
e.printStackTrace();
}
String text = "{\"TxnCode\":\"hce1003\",\"TxnStatus\":\"true\",\"ReplyCode\":\"000000\",\"ReplyMsg\":\"交易成功\",\"Data\":\"[{\\\"accountNo\\\":\\\"623091019******3297\\\",\\\"accountType\\\":\\\"1\\\",\\\"certNo\\\":\\\"***\\\",\\\"certType\\\":\\\"101\\\",\\\"customerName\\\":\\\"***\\\",\\\"mobileNo\\\":\\\"***\\\"},{\\\"accountNo\\\":\\\"***\\\",\\\"accountType\\\":\\\"1\\\",\\\"certNo\\\":\\\"***\\\",\\\"certType\\\":\\\"101\\\",\\\"customerName\\\":\\\"***\\\",\\\"mobileNo\\\":\\\"***\\\"}]\"}";
// String text = "c";
// String text = "提起黄飞鸿，我们隐隐约约地知道他是一个真实的历史人物，但恐怕很少有人能在脑海中勾勒出他本人真实的面貌，上了岁数的人大概还依稀记得关德兴那张冷峻硬朗的面庞；三四十岁左右的人想到的应该是风度翩翩的李连杰，关之琳扮演娇美的十三姨，如影随形不离左右；再年轻一点的观众或许更倾心于赵文卓甚至是彭于晏的扮相。“黄飞鸿”这个名字，经过文学和影视作品的塑造，早已由一个平凡的历史人物变成了整个华人世界的偶像，侠之大者、一代宗师的化身。那么，真实历史中的黄飞鸿，究竟是怎样一个人？为什么在他死后，会由一介平凡的岭南武师，变为全体华人心目中的英雄？";
String pwd = getPassword();
// String pwd="663810";
// 加密
HashMap<String, String> data;
try {
data = defaultEncrypt(text.getBytes(encode), pwd);
} catch (Exception e) {
e.printStackTrace();
return;
}
String accept = data.get("send");
// String accept =
// "mQ6uBpadJfNFxFHez3zWwQ==|2xZJpm3xO5gKaID9pYYqfTQ8e64GHo4esj7E51DlyCZM32DJAPUN3RKqLFkfR5rUCA+SsSD8vQOH+iS/Uh7YlCZhatuTOgNqJi6TfLbp4yZx4iTqFRda5jBVD1vNgsUf8jZdoJLY6rg2OhvcOjL+/lGeijdVv5f0RkykAtfKUHWeO5jWk+jUALQqx/ugO46Npna6MoeelUDzIbmdHL2NmZRmDzPvqpkQmUz9Pk8P19R/kWZuVfxVuOzPuaic69Roq1zbNyrKhGfqITQRwSsVOGMQi3qGYfY3Sv/hrbIuwZ4=|eAoqLUr9bC+sfACRZN6UFnm9g8R8h/jtq1k50m5aOB6AhxtaJWN/PiE2iaHBwF8a5z1gqdQdt0HERLFZm6tzvE6N2+RwF/XylK4oxfhLeCGOW85ahpnwlEpVGD86oCq8JRp4fglhaFkt9MAwmfpWGnT6GIlB9OiXFzNkIgrUdIk=";
HashMap<String, String> acceptMap = genMap(accept);
// 解密
try {
defaultDecrypt(acceptMap);
} catch (Exception e) {
e.printStackTrace();
}
}
/** * @param type 算法/加密方式/填充方式 如：AES/CBC/PKCS5Padding * @param mode 加密/或者解密 Cipher.DECRYPT_MODE/Cipher.ENCRYPT_MODE * @param zeroIv 初始化向量 如：new IvParameterSpec(iv) * @param key 密钥 * @param data 需要加密的数据 * @return byte[] * @throws NoSuchAlgorithmException * @throws NoSuchPaddingException * @throws InvalidKeyException * @throws InvalidAlgorithmParameterException * @throws IllegalBlockSizeException * @throws BadPaddingException */
public static byte[] doCrypt(String type, int mode, IvParameterSpec zeroIv,
Key key, byte[] data) throws NoSuchAlgorithmException,
NoSuchPaddingException, InvalidKeyException,
InvalidAlgorithmParameterException, IllegalBlockSizeException,
BadPaddingException {
if (!checkCrypt(type, mode, zeroIv, key, data)) {
throw new RuntimeException("参数非法");
}
if (!pubCertValid()) {
throw new RuntimeException("证书失效");
}
Cipher cipher = Cipher.getInstance(type);
if (type.contains("CBC") && zeroIv != null) {
cipher.init(mode, key, zeroIv);
} else {
cipher.init(mode, key);
}
return cipher.doFinal(data);
}
private static boolean checkCrypt(String type, int mode,
IvParameterSpec zeroIv, Key key, byte[] data)
throws NoSuchAlgorithmException, NoSuchPaddingException,
InvalidKeyException, InvalidAlgorithmParameterException,
IllegalBlockSizeException, BadPaddingException {
if (type == null || !isValid(TYPES, type)) {
return false;
}
if (!isValid(MODES, mode)) {
return false;
}
if (key == null) {
return false;
}
if (type.contains("RSA") && zeroIv != null) {
return false;
}
if (data == null || data.length == 0) {
return false;
}
return true;
}
private static boolean isValid(Object[] ts, Object t) {
if (ts instanceof String[] && t instanceof String) {
String[] strs = (String[]) ts;
String tmp = (String) t;
for (String str : strs) {
if (tmp.equals(str)) {
return true;
}
}
}
if (ts instanceof Integer[] && t instanceof Integer) {
Integer[] ints = (Integer[]) ts;
Integer intT = (Integer) t;
for (Integer str : ints) {
if (intT == str) {
return true;
}
}
}
return false;
}
public static boolean pubCertValid() {
if (pubCert == null) {
return false;
}
try {
pubCert.checkValidity(new Date());
} catch (Exception e) {
System.err.println("证书失效" + e.getMessage());
e.printStackTrace();
return false;
}
return true;
}
public static String doBase64Encode(byte[] abc) throws UnsupportedEncodingException {
String abce = null;
abce = new String(Base64.encode(abc, 0)); // 刘德利修改过
// Base64.getEncoder().encodeToString(abc);
return abce;
}
public static byte[] doBase64Decode(String abc) throws UnsupportedEncodingException {
byte[] abce = null;
abce = Base64.decode(abc,0); // 刘德利修改过
return abce;
}
public static void getPublicKeyFile(Context context) {
if (publicFis == null) {
//获取解密公钥文件
publicFis = context.getResources().openRawResource(R.raw.rsacert);
try {
pubKey = getPubKey();
} catch (IOException e) {
e.printStackTrace();
} catch (CertificateException e) {
e.printStackTrace();
}
}
}

注意：在自测的时候，需要公钥文件：

public static void mainTest() {
String result = "test123456789";
try {
JSONObject jsonObject = new JSONObject(result);
String data = jsonObject.getString("data");
String resultCode = jsonObject.getString("code");
String msg = jsonObject.getString("msg");
LogUtil.i(TAG, "resultCode=====>" + resultCode);
if ("200".equals(resultCode)) {
HashMap<String, String> acceptMap = RSAUtils.genMap(data);
String decryptText = defaultDecrypt(acceptMap);
LogUtil.i(TAG, "解密明文=====>" + decryptText);
// progressLoginRequest(decryptText);
} else {
// 其他情况直接显示后台内容
// LoginActivity.this.showDialog(BaseActivity.MODAL_DIALOG, msg);
LogUtil.d(TAG, "msg:" + msg);
}
} catch (Exception e) {
e.printStackTrace();
}
}

Android-ScreenUtil工具类
屏幕工具类，涉及到屏幕宽度、高度、密度比、(像素、dp、sp)之间的转换等。

public class ScreenUtil { 

private ScreenUtil(){}
/** * 获取屏幕宽度，单位为px * @param context 应用程序上下文 * @return 屏幕宽度，单位px */
public static int getScreenWidth(Context context){
return getDisplayMetrics(context).widthPixels;
}
/** * 获取屏幕高度，单位为px * @param context 应用程序上下文 * @return 屏幕高度，单位px */
public static int getScreenHeight(Context context){
return getDisplayMetrics(context).heightPixels;
}
/** * 获取系统dp尺寸密度值 * @param context 应用程序上下文 * @return */
public static float getDensity(Context context){
return getDisplayMetrics(context).density;
}
/** * 获取系统字体sp密度值 * @param context 应用程序上下文 * @return */
public static float getScaledDensity(Context context){
return getDisplayMetrics(context).scaledDensity;
}
/** * dip转换为px大小 * @param context 应用程序上下文 * @param dpValue dp值 * @return 转换后的px值 */
public static int dp2px(Context context, int dpValue){
return (int) (dpValue * getDensity(context) + 0.5f);
}
/** * px转换为dp值 * @param context 应用程序上下文 * @param pxValue px值 * @return 转换后的dp值 */
public static int px2dp(Context context, int pxValue){
return (int) (pxValue / getDensity(context) + 0.5f);
}
/** * sp转换为px * @param context 应用程序上下文 * @param spValue sp值 * @return 转换后的px值 */
public static int sp2px(Context context, int spValue){
return (int) (spValue * getScaledDensity(context) + 0.5f);
}
/** * px转换为sp * @param context 应用程序上下文 * @param pxValue px值 * @return 转换后的sp值 */
public static int px2sp(Context context, int pxValue){
return (int) (pxValue / getScaledDensity(context) + 0.5f);
}
/** * 获得状态栏的高度 * * @param context * @return */
public static int getStatusHeight(Context context){
int statusHeight = -1;
try {
Class<?> clazz = Class.forName("com.android.internal.R$dimen");
Object object = clazz.newInstance();
int height = Integer.parseInt(clazz.getField("status_bar_height").get(object).toString());
statusHeight = context.getResources().getDimensionPixelSize(height);
} catch (Exception e) {
e.printStackTrace();
}
return statusHeight;
}
/** * 获取当前屏幕截图，包含状态栏 * @param activity * @return */
public static Bitmap snapShotWithStatusBar(Activity activity){
View decorView = activity.getWindow().getDecorView();
decorView.setDrawingCacheEnabled(true);
decorView.buildDrawingCache();
Bitmap bmp = decorView.getDrawingCache();
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bitmap = null;
bitmap = Bitmap.createBitmap(bmp, 0, 0, width, height);
decorView.destroyDrawingCache();
return bitmap;
}
/** * 获取当前屏幕截图，不包含状态栏 * @param activity * @return */
public static Bitmap snapShotWithoutStatusBar(Activity activity){
View decorView = activity.getWindow().getDecorView();
decorView.setDrawingCacheEnabled(true);
decorView.buildDrawingCache();
Bitmap bmp = decorView.getDrawingCache();
Rect frame = new Rect();
activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
int statusHeight = frame.top;
int width = getScreenWidth(activity);
int height = getScreenHeight(activity);
Bitmap bitmap = null;
bitmap = Bitmap.createBitmap(bmp, 0, statusHeight, width, height - statusHeight);
decorView.destroyDrawingCache();
return bitmap;
}
/** * 获取DisplayMetrics对象 * @param context 应用程序上下文 * @return */
public static DisplayMetrics getDisplayMetrics(Context context){
WindowManager manager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
DisplayMetrics metrics = new DisplayMetrics();
manager.getDefaultDisplay().getMetrics(metrics);
return metrics;
}
}

Android-SDCardUtil工具类
SD卡工具类，包含SD卡状态、路径、容量大小

public class SDCardUtil { 

private SDCardUtil(){}
/** * 判断SD卡是否可用 * @return * ture：可用；false：不可用 */
public static boolean isSDCardEnable(){
return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
}
/** * 获取SD卡路径 * @return * SD卡存在返回正常路径；SD卡不存在返回"" */
public static String getSDCradPath(){
if (isSDCardEnable()) {
return Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator;
} else {
return "";
}
}
/** * 获取SD卡路径文件 * @return * SD卡存在返回正常路径；SD卡不存在返回null */
public static File getSDCardFile(){
if(isSDCardEnable()){
return Environment.getExternalStorageDirectory();
}else{
return null;
}
}
/** * 获取SD卡DownloadCache路径 * @return * SD卡存在返回正常路径；SD卡不存在返回"" */
public static String getSDCardDownloadCachePath(){
if(isSDCardEnable()){
return Environment.getDownloadCacheDirectory().getAbsolutePath() + File.separator;
}else{
return "";
}
}
/** * 获取SD卡DownloadCache路径文件 * @return * SD卡存在返回正常路径；SD卡不存在返回null */
public static File getSDCardDownloadCacheFile(){
if(isSDCardEnable()){
return Environment.getDownloadCacheDirectory();
}else{
return null;
}
}
/** * 获取系统存储路径 * @return * SD卡存在返回正常路径；SD卡不存在返回"" */
public static String getSDCardRootPath(){
if(isSDCardEnable()){
return Environment.getRootDirectory().getAbsolutePath() + File.separator;
}else{
return "";
}
}
/** * 获取系统存储路径文件 * @return * SD卡存在返回正常路径；SD卡不存在返回null */
public static File getSDCardRootFile(){
if(isSDCardEnable()){
return Environment.getRootDirectory();
}else{
return null;
}
}
/** * 获取应用程序的/data/data目录 * @param context * @return */
public static String getDataFilePath(Context context){
return context.getFilesDir().getAbsolutePath() + File.separator;
}
/** * /data/data/PackageName/cache的路径 * @param context * @return */
public static String getDataCachePath(Context context){
return context.getCacheDir().getAbsolutePath() + File.separator;
}
/** * 获取SD卡大小 * @return * SD卡存在返回大小；SD卡不存在返回-1 */
@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
public static long getSDCardSize(){
if (isSDCardEnable()) {
StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator);
if (android.os.Build.VERSION.SDK_INT < 18) {
int blockSize = statFs.getBlockSize();
int blockCount = statFs.getBlockCount();
return blockSize * blockCount;
} else {
long blockSize = statFs.getBlockSizeLong();
long blockCount = statFs.getBlockCountLong();
return blockSize * blockCount;
}
}
return -1;
}
/** * 获取SD卡可用大小 * @return * SD卡存在返回大小；SD卡不存在返回-1 */
@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
public static long getSDCardAvailableSize(){
if (isSDCardEnable()) {
StatFs statFs = new StatFs(Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator);
if (android.os.Build.VERSION.SDK_INT < 18) {
int blockSize = statFs.getBlockSize();
int blockCount = statFs.getAvailableBlocks();
return blockSize * blockCount;
} else {
long blockSize = statFs.getBlockSizeLong();
long blockCount = statFs.getAvailableBlocksLong();
return blockSize * blockCount;
}
}
return -1;
}
/** * 获得手机内存总大小 * @return */
@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
public long getRomTotalSize() {
File path = Environment.getDataDirectory();
StatFs statFs = new StatFs(path.getPath());
if (android.os.Build.VERSION.SDK_INT < 18) {
int blockSize = statFs.getBlockSize();
int blockCount = statFs.getBlockCount();
return blockSize * blockCount;
} else {
long blockSize = statFs.getBlockSizeLong();
long blockCount = statFs.getBlockCountLong();
return blockSize * blockCount;
}
}
/** * 获得手机可用内存 * @return */
@SuppressWarnings("deprecation")
@SuppressLint("NewApi")
public long getRomAvailableSize() {
File path = Environment.getDataDirectory();
StatFs statFs = new StatFs(path.getPath());
if (android.os.Build.VERSION.SDK_INT < 18) {
int blockSize = statFs.getBlockSize();
int blockCount = statFs.getAvailableBlocks();
return blockSize * blockCount;
} else {
long blockSize = statFs.getBlockSizeLong();
long blockCount = statFs.getAvailableBlocksLong();
return blockSize * blockCount;
}
}
}

Android-ShortCutUtil工具类
创建删除快捷图标的工具类
注意：需要增加权限
权限: com.android.launcher.permission.INSTALL_SHORTCUT
com.android.launcher.permission.UNINSTALL_SHORTCUT

public class ShortCutUtil { 

private ShortCutUtil() {
throw new Error("Do not need instantiate!");
}
/** * 检测是否存在快捷键 * @param activity Activity * @return 是否存在桌面图标 */
public static boolean hasShortcut(Activity activity) {
boolean isInstallShortcut = false;
ContentResolver cr = activity.getContentResolver();
String AUTHORITY = "com.android.launcher.settings";
Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY
+ "/favorites?notify=true");
Cursor c = cr.query(CONTENT_URI,
new String[]{
"title", "iconResource"}, "title=?",
new String[]{activity.getString(R.string.app_name).trim()},
null);
if (c != null && c.getCount() > 0) {
isInstallShortcut = true;
}
return isInstallShortcut;
}
/** * 为程序创建桌面快捷方式 * @param activity Activity * @param res res */
public static void addShortcut(Activity activity,int res) {
Intent shortcut = new Intent(
"com.android.launcher.action.INSTALL_SHORTCUT");
//快捷方式的名称
shortcut.putExtra(Intent.EXTRA_SHORTCUT_NAME,
activity.getString(R.string.app_name));
//不允许重复创建
shortcut.putExtra("duplicate", false);
Intent shortcutIntent = new Intent(Intent.ACTION_MAIN);
shortcutIntent.setClassName(activity, activity.getClass().getName());
shortcut.putExtra(Intent.EXTRA_SHORTCUT_INTENT, shortcutIntent);
//快捷方式的图标
Intent.ShortcutIconResource iconRes =
Intent.ShortcutIconResource.fromContext(activity, res);
shortcut.putExtra(Intent.EXTRA_SHORTCUT_ICON_RESOURCE, iconRes);
activity.sendBroadcast(shortcut);
}
/** * 删除程序的快捷方式 * @param activity Activity */
public static void delShortcut(Activity activity) {
Intent shortcut = new Intent(
"com.android.launcher.action.UNINSTALL_SHORTCUT");
shortcut.putExtra(Intent.EXTRA_SHORTCUT_NAME,
activity.getString(R.string.app_name));
String appClass = activity.getPackageName() + "."
+ activity.getLocalClassName();
ComponentName cn = new ComponentName(activity.getPackageName(), appClass);
shortcut.putExtra(Intent.EXTRA_SHORTCUT_INTENT, new Intent(
Intent.ACTION_MAIN).setComponent(cn));
activity.sendBroadcast(shortcut);
}
}

Android-SharedPreferences工具类
共享首选项工具类：

public class SPUtil { 

/** * 保存在手机里面的文件名 */
// public static final String FILE_NAME = "share_data";
/** * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法 */
/*public static void put(Context context, String key, Object object) { put(context, FILE_NAME, key, object); }*/
public static void put(Context context, String spFileName, String key, Object object) {
SharedPreferences sp = context.getSharedPreferences(spFileName,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
if (object instanceof String) {
editor.putString(key, (String) object);
} else if (object instanceof Integer) {
editor.putInt(key, (Integer) object);
} else if (object instanceof Boolean) {
editor.putBoolean(key, (Boolean) object);
} else if (object instanceof Float) {
editor.putFloat(key, (Float) object);
} else if (object instanceof Long) {
editor.putLong(key, (Long) object);
} else {
editor.putString(key, object.toString());
}
SharedPreferencesCompat.apply(editor);
}
public static void putString(Context context, String spFileName, String key, String stringData) {
SharedPreferences sp = context.getSharedPreferences(spFileName,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.putString(key, stringData);
editor.commit();
// SharedPreferencesCompat.apply(editor);
}
/** * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值 */
/*public static Object get(Context context, String key, Object defaultObject) { return get(context, FILE_NAME, key, defaultObject); }*/
public static Object get(Context context, String spName, String key, Object defaultObject) {
SharedPreferences sp = context.getSharedPreferences(spName,
Context.MODE_PRIVATE);
if (defaultObject instanceof String) {
return sp.getString(key, (String) defaultObject);
} else if (defaultObject instanceof Integer) {
return sp.getInt(key, (Integer) defaultObject);
} else if (defaultObject instanceof Boolean) {
return sp.getBoolean(key, (Boolean) defaultObject);
} else if (defaultObject instanceof Float) {
return sp.getFloat(key, (Float) defaultObject);
} else if (defaultObject instanceof Long) {
return sp.getLong(key, (Long) defaultObject);
}
return null;
}
public static String getString(Context context, String spName, String key, String stringDataDefault) {
SharedPreferences sp = context.getSharedPreferences(spName,
Context.MODE_PRIVATE);
return sp.getString(key, stringDataDefault);
}
/** * 移除某个key值已经对应的值 */
/*public static void remove(Context context, String key) { remove(context, FILE_NAME, key); }*/
public static void remove(Context context, String spFileName, String key) {
SharedPreferences sp = context.getSharedPreferences(spFileName,
Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.remove(key);
SharedPreferencesCompat.apply(editor);
}
/** * 清除所有数据 */
/*public static void clear(Context context) { clear(context, FILE_NAME); }*/
public static void clear(Context context, String spFileName) {
SharedPreferences sp = context.getSharedPreferences(spFileName, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sp.edit();
editor.clear();
SharedPreferencesCompat.apply(editor);
}
/** * 查询某个key是否已经存在 */
/*public static boolean contains(Context context, String key) { return contains(context, FILE_NAME, key); }*/
public static boolean contains(Context context, String spFileName, String key) {
SharedPreferences sp = context.getSharedPreferences(spFileName, Context.MODE_PRIVATE);
return sp.contains(key);
}
/** * 返回所有的键值对 */
/*public static Map<String, ?> getAll(Context context) { return getAll(context, FILE_NAME); }*/
public static Map<String, ?> getAll(Context context, String spName) {
SharedPreferences sp = context.getSharedPreferences(spName,
Context.MODE_PRIVATE);
return sp.getAll();
}
/** * 创建一个解决SharedPreferencesCompat.apply方法的一个兼容类 */
private static class SharedPreferencesCompat { 

private static final Method sApplyMethod = findApplyMethod();
/** * 反射查找apply的方法 */
@SuppressWarnings({
"unchecked", "rawtypes"})
private static Method findApplyMethod() {
try {
Class clz = SharedPreferences.Editor.class;
return clz.getMethod("apply");
} catch (NoSuchMethodException e) {
}
return null;
}
/** * 如果找到则使用apply执行，否则使用commit */
public static void apply(SharedPreferences.Editor editor) {
try {
if (sApplyMethod != null) {
sApplyMethod.invoke(editor);
return;
}
} catch (IllegalArgumentException e) {
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
}
editor.commit();
}
}

Android-StringHandler工具类
字符串处理类：

public class StringHandler { 

private static final String TAG = "StringHandler";
/** * 根据分隔符截取字符串 * @param str 字符串 * @param separator 分隔符 * @return 截取的字符串数组 */
public static String[] split(String str, String separator) {
if (str == null || str.equals("") || separator == null) {
return null;
}
int index;
ArrayList<String> list = new ArrayList<String>();
while((index = str.indexOf(separator)) != -1) {
list.add(str.substring(0, index));
str = str.substring(index + separator.length());
}
list.add(str);
return list.toArray(new String[list.size()]);
}
/** * 使用StringBuffer追加字符串 * @param str 字符串数组 * @return 完整字符串 */
public static String append(String...str) {
StringBuffer sb = new StringBuffer();
int len = str.length;
for (int i = 0; i < len; i++) {
if (null != str[i]) {
sb.append(str[i]);
}
}
return sb.toString();
}
public static final String MSG_REPLACE_STR = "%s";
public static String replace(String src, String...str) {
if (str == null) {
return src;
}
int count = countStr(src, MSG_REPLACE_STR);
if (count != str.length) {
ELog.w(TAG, "str len error.");
return null;
}
for (int i = 0; i < str.length; i++) {
src = src.replaceFirst(MSG_REPLACE_STR, str[i]);
}
count = 0;
return src;
}
/** * 计算src中包含str的个数 * 可以优化 --> indexOf(a, b) * @return */
public static int countStr(String src, String str) {
int count = 0;
if (src.indexOf(str) == -1) {
return 0;
} else if (src.indexOf(str) != -1) {
count += countStr(src.substring(src.indexOf(str) + str.length()), str);
return count + 1;
}
return 0;
}
/** * 去除字符串中的空格、回车、换行符、制表符 * @param str * @return */
public static String replaceBlank(String str) {
String dest = "";
if (str!=null) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
Matcher m = p.matcher(str);
dest = m.replaceAll("");
}
return dest;
}
/** * 将二进制数据转换为文件 * @param data * @param fileName */
public static boolean data2file(byte[] data, String fileName) {
FileOutputStream out = null;
try {
out = new FileOutputStream(fileName);
out.write(data);
} catch (FileNotFoundException e) {
// e.printStackTrace();
ELog.e(TAG, e.toString());
try {
out.close();
} catch (IOException e1) {
e1.printStackTrace();
}
out = null;
return false;
} catch (IOException e) {
// e.printStackTrace();
ELog.e(TAG, e.toString());
try {
out.close();
} catch (IOException e1) {
e1.printStackTrace();
}
out = null;
return false;
} finally {
if (out != null) {
try {
out.close();
} catch (IOException e) {
ELog.e(TAG, e.toString());
return false;
}
out = null;
}
}
return true;
}
}

Android-StringUtil2工具类
字符串工具类，提供一些字符串相关的便捷方法：

public class StringUtil2 { 

private StringUtil2() {
throw new AssertionError();
}
/** * <pre> * isBlank(null) = true; * isBlank("") = true; * isBlank(" ") = true; * isBlank("a") = false; * isBlank("a ") = false; * isBlank(" a") = false; * isBlank("a b") = false; * </pre> * * @param str 字符串 * @return 如果字符串为空或者长度为0，返回true，否则返回false */
public static boolean isBlank(String str) {
return (str == null || str.trim().length() == 0);
}
/** * <pre> * isEmpty(null) = true; * isEmpty("") = true; * isEmpty(" ") = false; * </pre> * * @param c 字符序列 * @return 如果字符序列为空或者长度为0，返回true，否则返回false */
public static boolean isEmpty(CharSequence c) {
return (c == null || c.length() == 0);
}
/** * 获取字符序列的长度 * <pre> * length(null) = 0; * length(\"\") = 0; * length(\"abc\") = 3; * </pre> * * @param c 字符序列 * @return 如果字符序列为空，返回0，否则返回字符序列的长度 */
public static int length(CharSequence c) {
return c == null ? 0 : c.length();
}
/** * null Object to empty string * 空对象转化成空字符串 * <pre> * nullStrToEmpty(null) = ""; * nullStrToEmpty("") = ""; * nullStrToEmpty("aa") = "aa"; * </pre> * * @param object 对象 * @return String */
public static String nullStrToEmpty(Object object) {
return object == null ?
"" : (object instanceof String ? (String)object : object.toString());
}
/** * @param str str * @return String */
public static String capitalizeFirstLetter(String str) {
if (isEmpty(str)) {
return str;
}
char c = str.charAt(0);
return (!Character.isLetter(c) || Character.isUpperCase(c))
? str
: new StringBuilder(str.length()).append(
Character.toUpperCase(c))
.append(str.substring(1))
.toString();
}
/** * 用utf-8编码 * @param str 字符串 * @return 返回一个utf8的字符串 */
public static String utf8Encode(String str) {
if (!isEmpty(str) || str.getBytes().length != str.length()) {
try {
return URLEncoder.encode(str, "utf-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException(
"UnsupportedEncodingException occurred. ", e);
}
}
return str;
}
/** * @param href 字符串 * @return 返回一个html */
public static String getHrefInnerHtml(String href) {
if (isEmpty(href)) {
return "";
}
String hrefReg = ".*<[\\s]*a[\\s]*.*>(.+?)<[\\s]*/a[\\s]*>.*";
Pattern hrefPattern = Pattern.compile(hrefReg, Pattern.CASE_INSENSITIVE);
Matcher hrefMatcher = hrefPattern.matcher(href);
if (hrefMatcher.matches()) {
return hrefMatcher.group(1);
}
return href;
}
/** * @param source 字符串 * @return 返回htmL到字符串 */
/*public static String htmlEscapeCharsToString(String source) { return StringUtil.isEmpty(source) ? source : source.replaceAll("<", "<") .replaceAll(">", ">") .replaceAll("&", "&") .replaceAll(""", "\""); }*/
/** * @param s 字符串 * @return String */
public static String fullWidthToHalfWidth(String s) {
if (isEmpty(s)) {
return s;
}
char[] source = s.toCharArray();
for (int i = 0; i < source.length; i++) {
if (source[i] == 12288) {
source[i] = ' ';
// } else if (source[i] == 12290) { 

// source[i] = '.';
}
else if (source[i] >= 65281 && source[i] <= 65374) {
source[i] = (char) (source[i] - 65248);
}
else {
source[i] = source[i];
}
}
return new String(source);
}
/** * @param s 字符串 * @return 返回的数值 */
public static String halfWidthToFullWidth(String s) {
if (isEmpty(s)) {
return s;
}
char[] source = s.toCharArray();
for (int i = 0; i < source.length; i++) {
if (source[i] == ' ') {
source[i] = (char) 12288;
// } else if (source[i] == '.') { 

// source[i] = (char)12290;
}
else if (source[i] >= 33 && source[i] <= 126) {
source[i] = (char) (source[i] + 65248);
}
else {
source[i] = source[i];
}
}
return new String(source);
}
/** * @param str 资源 * @return 特殊字符串切换 */
public static String replaceBlanktihuan(String str) {
String dest = "";
if (str != null) {
Pattern p = Pattern.compile("\\s*|\t|\r|\n");
Matcher m = p.matcher(str);
dest = m.replaceAll("");
}
return dest;
}
/** * 判断给定的字符串是否为null或者是空的 * @param string 给定的字符串 */
public static boolean isEmpty(String string) {
return string == null || "".equals(string.trim());
}
/** * 判断给定的字符串是否不为null且不为空 * @param string 给定的字符串 */
public static boolean isNotEmpty(String string) {
return !isEmpty(string);
}
/** * 判断给定的字符串数组中的所有字符串是否都为null或者是空的 * @param strings 给定的字符串 */
public static boolean isEmpty(String... strings) {
boolean result = true;
for (String string : strings) {
if (isNotEmpty(string)) {
result = false;
break;
}
}
return result;
}
/** * 判断给定的字符串数组中是否全部都不为null且不为空 * * @param strings 给定的字符串数组 * @return 是否全部都不为null且不为空 */
public static boolean isNotEmpty(String... strings) {
boolean result = true;
for (String string : strings) {
if (isEmpty(string)) {
result = false;
break;
}
}
return result;
}
/** * 如果字符串是null或者空就返回"" */
public static String filterEmpty(String string) {
return StringUtil.isNotEmpty(string) ? string : "";
}
/** * 在给定的字符串中，用新的字符替换所有旧的字符 * @param string 给定的字符串 * @param oldchar 旧的字符 * @param newchar 新的字符 * @return 替换后的字符串 */
public static String replace(String string, char oldchar, char newchar) {
char chars[] = string.toCharArray();
for (int w = 0; w < chars.length; w++) {
if (chars[w] == oldchar) {
chars[w] = newchar;
break;
}
}
return new String(chars);
}
/** * 把给定的字符串用给定的字符分割 * @param string 给定的字符串 * @param ch 给定的字符 * @return 分割后的字符串数组 */
public static String[] split(String string, char ch) {
ArrayList<String> stringList = new ArrayList<String>();
char chars[] = string.toCharArray();
int nextStart = 0;
for (int w = 0; w < chars.length; w++) {
if (ch == chars[w]) {
stringList.add(new String(chars, nextStart, w - nextStart));
nextStart = w + 1;
if (nextStart ==
chars.length) {    //当最后一位是分割符的话，就再添加一个空的字符串到分割数组中去
stringList.add("");
}
}
}
if (nextStart <
chars.length) {    //如果最后一位不是分隔符的话，就将最后一个分割符到最后一个字符中间的左右字符串作为一个字符串添加到分割数组中去
stringList.add(new String(chars, nextStart,
chars.length - 1 - nextStart + 1));
}
return stringList.toArray(new String[stringList.size()]);
}
/** * 计算给定的字符串的长度，计算规则是：一个汉字的长度为2，一个字符的长度为1 * * @param string 给定的字符串 * @return 长度 */
public static int countLength(String string) {
int length = 0;
char[] chars = string.toCharArray();
for (int w = 0; w < string.length(); w++) {
char ch = chars[w];
if (ch >= '\u0391' && ch <= '\uFFE5') {
length++;
length++;
}
else {
length++;
}
}
return length;
}
private static char[] getChars(char[] chars, int startIndex) {
int endIndex = startIndex + 1;
//如果第一个是数字
if (Character.isDigit(chars[startIndex])) {
//如果下一个是数字
while (endIndex < chars.length &&
Character.isDigit(chars[endIndex])) {
endIndex++;
}
}
char[] resultChars = new char[endIndex - startIndex];
System.arraycopy(chars, startIndex, resultChars, 0, resultChars.length);
return resultChars;
}
/** * 是否全是数字 */
public static boolean isAllDigital(char[] chars) {
boolean result = true;
for (int w = 0; w < chars.length; w++) {
if (!Character.isDigit(chars[w])) {
result = false;
break;
}
}
return result;
}
/** * 删除给定字符串中所有的旧的字符 * * @param string 源字符串 * @param ch 要删除的字符 * @return 删除后的字符串 */
public static String removeChar(String string, char ch) {
StringBuffer sb = new StringBuffer();
for (char cha : string.toCharArray()) {
if (cha != '-') {
sb.append(cha);
}
}
return sb.toString();
}
/** * 删除给定字符串中给定位置处的字符 * * @param string 给定字符串 * @param index 给定位置 */
public static String removeChar(String string, int index) {
String result = null;
char[] chars = string.toCharArray();
if (index == 0) {
result = new String(chars, 1, chars.length - 1);
}
else if (index == chars.length - 1) {
result = new String(chars, 0, chars.length - 1);
}
else {
result = new String(chars, 0, index) +
new String(chars, index + 1, chars.length - index);
;
}
return result;
}
/** * 删除给定字符串中给定位置处的字符 * * @param string 给定字符串 * @param index 给定位置 * @param ch 如果同给定位置处的字符相同，则将给定位置处的字符删除 */
public static String removeChar(String string, int index, char ch) {
String result = null;
char[] chars = string.toCharArray();
if (chars.length > 0 && chars[index] == ch) {
if (index == 0) {
result = new String(chars, 1, chars.length - 1);
}
else if (index == chars.length - 1) {
result = new String(chars, 0, chars.length - 1);
}
else {
result = new String(chars, 0, index) +
new String(chars, index + 1, chars.length - index);
;
}
}
else {
result = string;
}
return result;
}
/** * 对给定的字符串进行空白过滤 * * @param string 给定的字符串 * @return 如果给定的字符串是一个空白字符串，那么返回null；否则返回本身。 */
public static String filterBlank(String string) {
if ("".equals(string)) {
return null;
}
else {
return string;
}
}
/** * 将给定字符串中给定的区域的字符转换成小写 * * @param str 给定字符串中 * @param beginIndex 开始索引（包括） * @param endIndex 结束索引（不包括） * @return 新的字符串 */
public static String toLowerCase(String str, int beginIndex, int endIndex) {
return str.replaceFirst(str.substring(beginIndex, endIndex),
str.substring(beginIndex, endIndex)
.toLowerCase(Locale.getDefault()));
}
/** * 将给定字符串中给定的区域的字符转换成大写 * * @param str 给定字符串中 * @param beginIndex 开始索引（包括） * @param endIndex 结束索引（不包括） * @return 新的字符串 */
public static String toUpperCase(String str, int beginIndex, int endIndex) {
return str.replaceFirst(str.substring(beginIndex, endIndex),
str.substring(beginIndex, endIndex)
.toUpperCase(Locale.getDefault()));
}
/** * 将给定字符串的首字母转为小写 * * @param str 给定字符串 * @return 新的字符串 */
public static String firstLetterToLowerCase(String str) {
return toLowerCase(str, 0, 1);
}
/** * 将给定字符串的首字母转为大写 * * @param str 给定字符串 * @return 新的字符串 */
public static String firstLetterToUpperCase(String str) {
return toUpperCase(str, 0, 1);
}
/** * 将给定的字符串MD5加密 * * @param string 给定的字符串 * @return MD5加密后生成的字符串 */
public static String MD5(String string) {
String result = null;
try {
char[] charArray = string.toCharArray();
byte[] byteArray = new byte[charArray.length];
for (int i = 0; i < charArray.length; i++) {
byteArray[i] = (byte) charArray[i];
}
StringBuffer hexValue = new StringBuffer();
byte[] md5Bytes = MessageDigest.getInstance("MD5")
.digest(byteArray);
for (int i = 0; i < md5Bytes.length; i++) {
int val = ((int) md5Bytes[i]) & 0xff;
if (val < 16) {
hexValue.append("0");
}
hexValue.append(Integer.toHexString(val));
}
result = hexValue.toString();
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
/** * 判断给定的字符串是否以一个特定的字符串开头，忽略大小写 * * @param sourceString 给定的字符串 * @param newString 一个特定的字符串 */
public static boolean startsWithIgnoreCase(String sourceString, String newString) {
int newLength = newString.length();
int sourceLength = sourceString.length();
if (newLength == sourceLength) {
return newString.equalsIgnoreCase(sourceString);
}
else if (newLength < sourceLength) {
char[] newChars = new char[newLength];
sourceString.getChars(0, newLength, newChars, 0);
return newString.equalsIgnoreCase(String.valueOf(newChars));
}
else {
return false;
}
}
/** * 判断给定的字符串是否以一个特定的字符串结尾，忽略大小写 * * @param sourceString 给定的字符串 * @param newString 一个特定的字符串 */
public static boolean endsWithIgnoreCase(String sourceString, String newString) {
int newLength = newString.length();
int sourceLength = sourceString.length();
if (newLength == sourceLength) {
return newString.equalsIgnoreCase(sourceString);
}
else if (newLength < sourceLength) {
char[] newChars = new char[newLength];
sourceString.getChars(sourceLength - newLength, sourceLength,
newChars, 0);
return newString.equalsIgnoreCase(String.valueOf(newChars));
}
else {
return false;
}
}
/** * 检查字符串长度，如果字符串的长度超过maxLength，就截取前maxLength个字符串并在末尾拼上appendString */
public static String checkLength(String string, int maxLength, String appendString) {
if (string.length() > maxLength) {
string = string.substring(0, maxLength);
if (appendString != null) {
string += appendString;
}
}
return string;
}
/** * 检查字符串长度，如果字符串的长度超过maxLength，就截取前maxLength个字符串并在末尾拼上… */
public static String checkLength(String string, int maxLength) {
return checkLength(string, maxLength, "…");
}
}

Android-StringUtil工具类
字符串处理相关的工具类：

public final class StringUtil { 

private static final String ALLCHAR = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
private static final String CHINA_PHONE_REG =
"^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\\d{8}$";
/** * 编译后的正则表达式缓存 */
private static final Map<String, Pattern> PATTERN_CACHE = new ConcurrentHashMap<>();
private static final char CN_CHAR_START = '\u4e00';
private static final char CN_CHAR_END = '\u9fa5';
private static final int SECOND = 2;
private static final int FF = 0xff;
private StringUtil() {
throw new UnsupportedOperationException("StringUtils cannot be instantiated");
}
/** * 字符串是否为空 * * @param str 需要判断的字符串 * @return true :空 */
public static boolean isEmpty(String str) {
return null == str || TextUtils.isEmpty(str);
}
/** * 字符串是否非空 * * @param str 需要判断的字符串 * @return true:非空 */
public static boolean isNotEmpty(String str) {
return !isEmpty(str);
}
/** * 字符串是否相同 * * @param str 需要比较的字符串 * @param equalStr 被比较的字符串 * @return true:相等 */
public static boolean isEqual(String str, String equalStr) {
if (StringUtil.isEmpty(str)) {
return false;
}
return str.equals(equalStr);
}
/** * 字符串从左向右插入字符 * * @param index 要插入的位置 * @param oldString 旧字符串 * @param insertString 要插入的字符串 * @return 最终生成的字符串 */
public static String insertChar(int index, String oldString, String insertString) {
StringBuffer buffer = new StringBuffer(oldString);
for (int i = index; i < buffer.length(); i = i + index + 1) {
buffer.insert(i, insertString);
}
return buffer.toString();
}
/** * 翻转字符串 * * @param str 需要翻转的字符串 * @return 翻转后的字符串 */
public static String reverseString(String str) {
return new StringBuffer(str).reverse().toString();
}
/** * 返回一个定长的随机字符串(只包含大小写字母、数字) * * @param length 随机字符串长度 * @return 随机字符串 */
public static String generateString(int length) {
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < length; i++) {
sb.append(ALLCHAR.charAt(random.nextInt(ALLCHAR.length())));
}
return sb.toString();
}
/** * 判断是否是手机号 * * @param phone 手机号 * @return true 是手机号 */
public static boolean isChinaPhone(String phone) {
if (isEmpty(phone)) {
return false;
}
Pattern pattern = compileRegex(CHINA_PHONE_REG);
Matcher matcher = pattern.matcher(phone);
return matcher.matches();
}
/** * 检测String是否全是中文 * * @param name 需要操作的字符串 * @return true 是全中文 */
public static boolean checkNameChese(String name) {
boolean res = true;
char[] cTemp = name.toCharArray();
for (int i = 0; i < name.length(); i++) {
if (!isChinese(cTemp[i])) {
res = false;
break;
}
}
return res;
}
/** * 判定输入汉字 * * @param c 需要判断的字符 * @return true 是汉字 */
public static boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
return true;
}
return false;
}
/** * 编译一个正则表达式，并且进行缓存,如果缓存已存在则使用缓存 * * @param regex 表达式 * @return 编译后的Pattern */
public static Pattern compileRegex(String regex) {
Pattern pattern = PATTERN_CACHE.get(regex);
if (pattern == null) {
pattern = Pattern.compile(regex);
PATTERN_CACHE.put(regex, pattern);
}
return pattern;
}
/** * 将字符串的第一位转为小写 * * @param str 需要转换的字符串 * @return 转换后的字符串 */
public static String toLowerCaseFirstOne(String str) {
if (Character.isLowerCase(str.charAt(0))) {
return str;
} else {
char[] chars = str.toCharArray();
chars[0] = Character.toLowerCase(chars[0]);
return new String(chars);
}
}
/** * 将字符串的第一位转为大写 * * @param str 需要转换的字符串 * @return 转换后的字符串 */
public static String toUpperCaseFirstOne(String str) {
if (Character.isUpperCase(str.charAt(0))) {
return str;
} else {
char[] chars = str.toCharArray();
chars[0] = Character.toUpperCase(chars[0]);
return new String(chars);
}
}
/** * 下划线命名转为驼峰命名 * * @param str 下划线命名格式 * @return 驼峰命名格式 */
public static String underScoreCase2CamelCase(String str) {
if (!str.contains("_")) {
return str;
}
StringBuilder sb = new StringBuilder();
char[] chars = str.toCharArray();
boolean hitUnderScore = false;
sb.append(chars[0]);
for (int i = 1; i < chars.length; i++) {
char c = chars[i];
if (c == '_') {
hitUnderScore = true;
} else {
if (hitUnderScore) {
sb.append(Character.toUpperCase(c));
hitUnderScore = false;
} else {
sb.append(c);
}
}
}
return sb.toString();
}
/** * 驼峰命名法转为下划线命名 * * @param str 驼峰命名格式 * @return 下划线命名格式 */
public static String camelCase2UnderScoreCase(String str) {
StringBuilder sb = new StringBuilder();
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
char c = chars[i];
if (Character.isUpperCase(c)) {
sb.append("_").append(Character.toLowerCase(c));
} else {
sb.append(c);
}
}
return sb.toString();
}
/** * 将异常栈信息转为字符串 * * @param e 字符串 * @return 异常栈 */
public static String throwable2String(Throwable e) {
StringWriter writer = new StringWriter();
e.printStackTrace(new PrintWriter(writer));
return writer.toString();
}
/** * 字符串连接，将参数列表拼接为一个字符串 * * @param more 追加 * @return 返回拼接后的字符串 */
public static String concat(Object... more) {
return concatSpiltWith("", more);
}
/** * 字符串连接，将参数列表拼接为一个字符串 * * @param split 拼接的字符 * @param more 拼接的参数个数 * @return 回拼接后的字符串 */
@NonNull
public static String concatSpiltWith(String split, Object... more) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < more.length; i++) {
if (i != 0) {
buf.append(split);
}
buf.append(more[i]);
}
return buf.toString();
}
/** * 将字符串转移为ASCII码 * * @param str 字符串 * @return 字符串ASCII码 */
public static String toASCII(String str) {
StringBuffer strBuf = new StringBuffer();
byte[] bGBK = str.getBytes();
for (int i = 0; i < bGBK.length; i++) {
strBuf.append(Integer.toHexString(bGBK[i] & FF));
}
return strBuf.toString();
}
/** * 将字符串转移为Unicode码 * * @param str 字符串 * @return 返回Unicode 的字符串 */
public static String toUnicode(String str) {
StringBuffer strBuf = new StringBuffer();
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
strBuf.append("\\u").append(Integer.toHexString(chars[i]));
}
return strBuf.toString();
}
/** * 将字符串转移为Unicode码 * * @param chars 字符数组 * @return 转移为Unicode码 字符串 */
public static String toUnicodeString(char[] chars) {
StringBuffer strBuf = new StringBuffer();
for (int i = 0; i < chars.length; i++) {
strBuf.append("\\u").append(Integer.toHexString(chars[i]));
}
return strBuf.toString();
}
/** * 是否包含中文字符 * * @param str 要判断的字符串 * @return 是否包含中文字符 */
public static boolean containsChineseChar(String str) {
char[] chars = str.toCharArray();
for (int i = 0; i < chars.length; i++) {
if (chars[i] >= CN_CHAR_START && chars[i] <= CN_CHAR_END) {
return true;
}
}
return false;
}
/** * 对象是否为无效值 * * @param obj 要判断的对象 * @return 是否为有效值（不为null 和 "" 字符串） */
public static boolean isNullOrEmpty(Object obj) {
return obj == null || "".equals(obj.toString());
}
/** * 参数是否是有效数字 （整数或者小数） * * @param obj 参数（对象将被调用string()转为字符串类型） * @return 是否是数字 */
public static boolean isNumber(Object obj) {
if (obj instanceof Number) {
return true;
}
return isInt(obj) || isDouble(obj);
}
/** * 匹配到第一个字符串 * * @param patternStr 正则表达式 * @param text 字符串 * @return 返回字符串 */
public static String matcherFirst(String patternStr, String text) {
Pattern pattern = compileRegex(patternStr);
Matcher matcher = pattern.matcher(text);
String group = null;
if (matcher.find()) {
group = matcher.group();
}
return group;
}
/** * 参数是否是有效整数 * * @param obj 参数（对象将被调用string()转为字符串类型） * @return 是否是整数 */
public static boolean isInt(Object obj) {
if (isNullOrEmpty(obj)) {
return false;
}
if (obj instanceof Integer) {
return true;
}
return obj.toString().matches("[-+]?\\d+");
}
/** * 字符串参数是否是double * * @param obj 参数（对象将被调用string()转为字符串类型） * @return 是否是double */
public static boolean isDouble(Object obj) {
if (isNullOrEmpty(obj)) {
return false;
}
if (obj instanceof Double || obj instanceof Float) {
return true;
}
return compileRegex("[-+]?\\d+\\.\\d+").matcher(obj.toString()).matches();
}
/** * 判断一个对象是否为boolean类型,包括字符串中的true和false * * @param obj 要判断的对象 * @return 是否是一个boolean类型 */
public static boolean isBoolean(Object obj) {
if (obj instanceof Boolean) {
return true;
}
String strVal = String.valueOf(obj);
return "true".equalsIgnoreCase(strVal) || "false".equalsIgnoreCase(strVal);
}
/** * 对象是否为true * * @param obj 判断的对象 * @return true 是 */
public static boolean isTrue(Object obj) {
return "true".equals(String.valueOf(obj));
}
/** * 判断一个数组里是否包含指定对象 * * @param arr 对象数组 * @param obj 要判断的对象 * @return 是否包含 */
public static boolean contains(Object obj, Object... arr) {
if (arr == null || obj == null || arr.length == 0) {
return false;
}
return Arrays.asList(arr).containsAll(Arrays.asList(obj));
}
/** * 将对象转为int值,如果对象无法进行转换,则使用默认值 * * @param object 要转换的对象 * @param defaultValue 默认值 * @return 转换后的值 */
public static int toInt(Object object, int defaultValue) {
int returnValue = defaultValue;
if (object instanceof Number) {
returnValue = ((Number) object).intValue();
}
if (isInt(object)) {
returnValue = Integer.parseInt(object.toString());
}
if (isDouble(object)) {
returnValue = (int) Double.parseDouble(object.toString());
}
return returnValue;
}
/** * 将对象转为int值,如果对象不能转为,将返回0 * * @param object 要转换的对象 * @return 转换后的值 */
public static int toInt(Object object) {
return toInt(object, 0);
}
/** * 将对象转为long类型,如果对象无法转换,将返回默认值 * * @param object 要转换的对象 * @param defaultValue 默认值 * @return 转换后的值 */
public static long toLong(Object object, long defaultValue) {
long returnValue = defaultValue;
if (object instanceof Number) {
returnValue = ((Number) object).longValue();
}
if (isInt(object)) {
returnValue = Long.parseLong(object.toString());
}
if (isDouble(object)) {
returnValue = (long) Double.parseDouble(object.toString());
}
return returnValue;
}
/** * 将对象转为 long值,如果无法转换,则转为0 * * @param object 要转换的对象 * @return 转换后的值 */
public static long toLong(Object object) {
return toLong(object, 0);
}
/** * 将对象转为Double,如果对象无法转换,将使用默认值 * * @param object 要转换的对象 * @param defaultValue 默认值 * @return 转换后的值 */
public static double toDouble(Object object, double defaultValue) {
double returnValue = defaultValue;
if (object instanceof Number) {
returnValue = ((Number) object).doubleValue();
}
if (isNumber(object)) {
returnValue = Double.parseDouble(object.toString());
}
if (null == object) {
returnValue = defaultValue;
}
return returnValue;
}
/** * 将对象转为Double,如果对象无法转换,将使用默认值0 * * @param object 要转换的对象 * @return 转换后的值 */
public static double toDouble(Object object) {
return toDouble(object, 0);
}
/** * 分隔字符串,根据正则表达式分隔字符串,只分隔首个,剩下的的不进行分隔, * 如: 1,2,3,4 将分隔为 ['1','2,3,4'] * * @param str 要分隔的字符串 * @param regex 分隔表达式 * @return 分隔后的数组 */
public static String[] splitFirst(String str, String regex) {
return str.split(regex, SECOND);
}
/** * 将对象转为字符串,如果对象为null,则返回null,而不是"null" * * @param object 要转换的对象 * @return 转换后的对象 */
public static String toString(Object object) {
return toString(object, null);
}
/** * 将对象转为字符串,如果对象为null,则使用默认值 * * @param object 要转换的对象 * @param defaultValue 默认值 * @return 转换后的字符串 */
public static String toString(Object object, String defaultValue) {
if (object == null) {
return defaultValue;
}
return String.valueOf(object);
}
/** * 将对象转为String后进行分割，如果为对象为空或者空字符,则返回null * * @param object 要分隔的对象 * @param regex 分隔规则 * @return 分隔后的对象 */
public static String[] toStringAndSplit(Object object, String regex) {
if (isNullOrEmpty(object)) {
return null;
}
return String.valueOf(object).split(regex);
}
private static final float MESSY_PERCENT = 0.4f;
/** * 是否为乱码 * * @param strName 需要判断的字符串 * @return true 是乱码 */
public static boolean isMessyCode(String strName) {
Pattern p = compileRegex("\\s*|\t*|\r*|\n*");
Matcher m = p.matcher(strName);
String after = m.replaceAll("");
String temp = after.replaceAll("\\p{P}", "");
char[] ch = temp.trim().toCharArray();
float chLength = 0;
float count = 0;
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (!Character.isLetterOrDigit(c)) {
if (!isChinese(c)) {
count = count + 1;
}
chLength++;
}
}
float result = count / chLength;
return result >= MESSY_PERCENT;
}
}

Android-TimeUtil工具类
与时间处理相关的工具类：

public class TimeUtil { 

/** * 获取当前时间 * @return */
public static String getNowTime(){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = new Date(System.currentTimeMillis());
return simpleDateFormat.format(date);
}
/** * 获取当前时间 * @return */
public static String getThisTiem() {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");// HH:mm:ss
// 获取当前时间
Date date = new Date(System.currentTimeMillis());
return simpleDateFormat.format(date);
}
/** * 获取时间戳 * * @return 获取时间戳 */
public static String getTimeString() {
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Calendar calendar = Calendar.getInstance();
return df.format(calendar.getTime());
}
/** * 获取时间戳 * * @return 获取时间戳 */
public static String getTimeString2() {
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Calendar calendar = Calendar.getInstance();
return df.format(calendar.getTime());
}
/** * 时间转换为时间戳 * @param time:需要转换的时间 * @return */
public static String dateToStamp(String time)  {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = null;
try {
date = simpleDateFormat.parse(time);
} catch (ParseException e) {
e.printStackTrace();
}
long ts = date.getTime();
return String.valueOf(ts);
}
/** * 时间戳转换为字符串 * @param time:时间戳 * @return */
public static String times(String time) {
SimpleDateFormat sdr = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分");
@SuppressWarnings("unused")
long lcc = Long.valueOf(time);
int i = Integer.parseInt(time);
String times = sdr.format(new Date(i * 1000L));
return times;
}
/** *获取距现在某一小时的时刻 * @param hour hour=-1为上一个小时，hour=1为下一个小时 * @return */
public static String getLongTime(int hour){
Calendar c = Calendar.getInstance(); // 当时的日期和时间
int h; // 需要更改的小时
h = c.get(Calendar.HOUR_OF_DAY) - hour;
c.set(Calendar.HOUR_OF_DAY, h);
SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Log.v("time",df.format(c.getTime()));
return df.format(c.getTime());
}
/** * 比较时间大小 * @param str1：要比较的时间 * @param str2：要比较的时间 * @return */
public static boolean isDateOneBigger(String str1, String str2) {
boolean isBigger = false;
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
Date dt1 = null;
Date dt2 = null;
try {
dt1 = sdf.parse(str1);
dt2 = sdf.parse(str2);
} catch (ParseException e) {
e.printStackTrace();
}
if (dt1.getTime() > dt2.getTime()) {
isBigger = true;
} else if (dt1.getTime() < dt2.getTime()) {
isBigger = false;
}
return isBigger;
}
/** * 当地时间 ---> UTC时间 * @return */
public static String Local2UTC(){
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
sdf.setTimeZone(TimeZone.getTimeZone("gmt"));
String gmtTime = sdf.format(new Date());
return gmtTime;
}
/** * UTC时间 ---> 当地时间 * @param utcTime UTC时间 * @return */
public static String utc2Local(String utcTime) {
SimpleDateFormat utcFormater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//UTC时间格式
utcFormater.setTimeZone(TimeZone.getTimeZone("UTC"));
Date gpsUTCDate = null;
try {
gpsUTCDate = utcFormater.parse(utcTime);
} catch (ParseException e) {
e.printStackTrace();
}
SimpleDateFormat localFormater = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//当地时间格式
localFormater.setTimeZone(TimeZone.getDefault());
String localTime = localFormater.format(gpsUTCDate.getTime());
return localTime;
}
}

Android-UIUtils
所有与UI相关操纵的工具类，通常情况下是在Activity中使用：

public class UIUtils { 

private static final String TAG = UIUtils.class.getSimpleName();
/** * 通过ID获取颜色值 * @param colorId * @return */
public static int getColor(Context mContext, int colorId) {
return mContext.getResources().getColor(colorId);
}
/** * 通过ID获取View * @param layoutId * @return */
public static View getXmlVIew(Context mContext, int layoutId) {
return View.inflate(mContext, layoutId, null);
}
/** * 通过ID获取 View Item 布局的View * @param mContext * @param layoutId * @return */
public static View getItemView(Context mContext, int layoutId) {
return LayoutInflater.from(mContext).inflate(layoutId, null);
}
/** * dp转换px * @param dp * @return */
public static int dp2px(Context mContext, int dp) {
float density = mContext.getResources().getDisplayMetrics().density;
return (int) (dp*density+0.5);
}
/** * px转换dp * @param px * @return */
public static int px2dp(Context mContext, int px) {
float density = mContext.getResources().getDisplayMetrics().density;
return (int) (px/density+0.5);
}
/** * 通过arrayId获取string.xml里面指定的arrayId字符串数组 * @param arrayId * @return */
public static String[] getStringArray(Context mContext, int arrayId) {
return mContext.getResources().getStringArray(arrayId);
}
/** * 用于跳转Activity * @param cls */
public static void startActivity(Activity activity, Class<?> cls) {
activity.startActivity(new Intent(activity, cls));
}
/** * 用于ForResult方式跳转Activity * @param activity * @param cls * @param requestCode */
public static void startActivityForResult(Activity activity, Class<?> cls, int requestCode) {
activity.startActivityForResult(new Intent(activity, cls), requestCode);
}
/** * 待参数的方式跳转Activity * @param activity * @param cls * @param params * @param <T> */
public static <T extends String> void startActivityForIntentParam(Activity activity, Class<?> cls, Map<String, T> params) {
Intent intent  = new Intent(activity, cls);
for (Map.Entry<String, T> entry : params.entrySet()) {
intent.putExtra(entry.getKey(), entry.getValue());
}
activity.startActivity(intent);
}
/** * 获取其他Activity传过来的参数，转成Map集合 * @param activity * @param params * @return */
public static Map receiveForIntentParam(Activity activity, String ... params) {
Intent intent = activity.getIntent();
Map<String, String> mMap = new HashMap<>();
for (int i = 0; i<params.length; i++) {
mMap.put(params[i], intent.getStringExtra(params[i]));
}
return mMap.size()==0?null:mMap;
}
/** * 设置EditText的hint字体大小 * @param editText * @param dpSize * @param textString */
public static void setEditTextHint(EditText editText, int dpSize,String textString) {
SpannableString ss =  new SpannableString(textString);
AbsoluteSizeSpan ass = new AbsoluteSizeSpan(dpSize, true);
ss.setSpan(ass, 0, ss.length(), Spanned.SPAN_USER);
editText.setHint(new SpannedString(ss));
}
/** * 设置EditText的hint颜色与字体大小 * @param editText * @param color * @param dpSize * @param textString */
public static void setEditTextHint(EditText editText, int color, int dpSize,String textString) {
SpannableString ss =  new SpannableString(textString);
AbsoluteSizeSpan ass = new AbsoluteSizeSpan(dpSize, true);
editText.setHintTextColor(color);
ss.setSpan(ass, 0, ss.length(), Spanned.SPAN_USER);
editText.setHint(new SpannedString(ss));
}
/** * 设置EditText的hint颜色与字体大小 * @param editText * @param color * @param dpSize * @param textString * @param isDip */
public static void setEditTextHint(EditText editText, int color, int dpSize,String textString, boolean isDip) {
SpannableString ss =  new SpannableString(textString);
AbsoluteSizeSpan ass = new AbsoluteSizeSpan(dpSize, isDip);
editText.setHintTextColor(color);
ss.setSpan(ass, 0, ss.length(), Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
editText.setHint(new SpannedString(ss));
}

Android-WebViewUtils工具类

/** * WebView操作处理相关工具类 */
public class WebViewUtils extends WebView{ 

public WebViewUtils(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
}
public WebViewUtils(Context context) {
super(context);
}
public WebViewUtils(Context context, AttributeSet attrs) {
super(context, attrs);
}
/** * 初始化webview * @param url * @param openWay:true :在webview打开，false在手机默认浏览器打开 */
public void initWebView(final ProgressBar progressBar,final String url, final boolean openWay){
this.setWebChromeClient(new WebChromeClient() {
@Override
public void onProgressChanged(WebView view, int newProgress) {
if (newProgress == 100) {
progressBar.setVisibility(View.INVISIBLE);
} else {
if (View.INVISIBLE == progressBar.getVisibility()) {
progressBar.setVisibility(View.VISIBLE);
}
progressBar.setProgress(newProgress);
}
super.onProgressChanged(view, newProgress);
}
});
this.post(new Runnable() {
@Override
public void run() {
WebViewUtils.this.loadUrl(url);
}
});
this.setWebViewClient(new WebViewClient() {
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return openWay;
}
});
}
/** * 得到html并显示到webView中 * @param url 要打开html的路径 * @param web WebView控件 */
public static void getHtml( String url , WebView web){
initSetting(web);
web.getSettings().setJavaScriptCanOpenWindowsAutomatically(true);//设置js可以直接打开窗口，如window.open()，默认为false
web.getSettings().setSupportZoom(true);// 是否可以缩放，默认true
web.getSettings().setBuiltInZoomControls(true);// 是否显示缩放按钮，默认false
web.getSettings().setUseWideViewPort(true);// 设置此属性，可任意比例缩放。大视图模式
web.getSettings().setLoadWithOverviewMode(true);// 和setUseWideViewPort(true)一起解决网页自适应问题
web.getSettings().setAppCacheEnabled(true);// 是否使用缓存
web.getSettings().setDomStorageEnabled(true);// DOM Storage
// w.getSettings().setUserAgentString("User-Agent:Android");//设置用户代理，一般不用
web.loadUrl(url);
web.setWebViewClient(new WebViewClient(){
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
// TODO Auto-generated method stub
//返回值是true的时候控制去WebView打开，为false调用系统浏览器或第三方浏览器
view.loadUrl(url);
return true;
}
});
}
/** * 设置webView初始值信息 * @param web */
private static void initSetting(WebView web) {
// TODO Auto-generated method stub
WebSettings settings = web.getSettings();
// 是否允许执行js，默认为false。设置true时，会提醒可能造成XSS漏洞
settings.setJavaScriptEnabled(true);
/* * LOAD_DEFAULT设置如何缓存 默认使用缓存，当缓存没有，或者缓存过期，才使用网络 * LOAD_CACHE_ELSE_NETWORK 设置默认使用缓存，即使是缓存过期，也使用缓存 * 只有缓存消失，才使用网络 */
settings.setCacheMode(WebSettings.LOAD_DEFAULT);
//是否展示一个缩放按钮（）
settings.setBuiltInZoomControls(true);
}
/** * 设置webView初始值信息并且绑定url等操作 * @param webView * @param url */
public static void initSetting(WebView webView, String url) {
// 登录西安交通发布，查询交通
// webView.loadUrl("https://www.xaglkp.com.cn/BusPage/bus_realtime");
webView.loadUrl(url);
webView.requestFocus();//获取焦点
webView.setHorizontalScrollBarEnabled(false);
webView.setVerticalScrollBarEnabled(false);
webView.setVerticalScrollbarOverlay(true);
//添加客户端支持
webView.setWebViewClient(new WebViewClient(){
//点击不会跳转到浏览器外
@Override
public boolean shouldOverrideUrlLoading(WebView view, String url) {
view.loadUrl(url);
return true;//super.shouldOverrideUrlLoading(view, url);
}
});
WebSettings webSettings = webView.getSettings();
webSettings.setJavaScriptEnabled(true);
//设置可以访问文件
webSettings.setAllowFileAccess(true);
//设置支持缩放
webSettings.setBuiltInZoomControls(true);
webSettings.setUseWideViewPort(true); //设置加载进来的页面自适应手机屏幕（可缩放）
webSettings.setLoadWithOverviewMode(true);
}
/** * 返回Html的上一个页面 * @param webView */
public static void backHtml(WebView webView) {
webView.goBack();// 返回前一个页面
}
}

Android-XmlUtil工具类

/** * XML文件工具类，包含：将xml文件解析成实体集合、获取xml标签值、将标签值解析成实体集合 */
public class XmlUtil { 

　　private XmlUtil(){}
/*- * XML文件解析成实体,不涉及到标签的属性值。 * @param xml xml字符串文件 * @param clazz 对应实体的class文件 * @param tagEntity * 开始解析实体的标签，例如下面的实例中就是student<br> * 　　<person> * 　　<student> * <name>Lucy</name> * <age>21</age> * </student> * 　　</person> * @return 返回解析的对应实体文件 */
public static<T> List<T> xmlToObject(String xml, Class<T> clazz, String tagEntity){
List<T> list = null;
XmlPullParser xmlPullParser = Xml.newPullParser();
InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
try {
xmlPullParser.setInput(inputStream, "utf-8");
Field[] fields = clazz.getDeclaredFields();
int type = xmlPullParser.getEventType();
String lastTag = "";
T t = null;
while (type != XmlPullParser.END_DOCUMENT) {
switch (type) {
case XmlPullParser.START_DOCUMENT:
list = new ArrayList<T>();
break;
case XmlPullParser.START_TAG:
String tagName = xmlPullParser.getName();
if(tagEntity.equals(tagName)){
t = clazz.newInstance();
lastTag = tagEntity;
}else if(tagEntity.equals(lastTag)){
String textValue = xmlPullParser.nextText();
String fieldName = xmlPullParser.getName();
for(Field field : fields){
ReflectUtil.setFieldValue(t,field,fieldName,textValue);
}
}
break;
case XmlPullParser.END_TAG:
tagName = xmlPullParser.getName();
if(tagEntity.equals(tagName)){
list.add(t);
lastTag = "";
}
break;
case XmlPullParser.END_DOCUMENT:
break;
}
}
} catch (XmlPullParserException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return list;
}
/** * 获取xml字符串标签中的属性值 * @param xml 　　xml字符串 * @param clazz 转换成对应的实体 * @param tagName 实体对应xml字符串的起始标签,如下面实例中的person标签<br> * <person name="Lucy" age="12"> * 　　<student> * <name>Lucy</name> * <age>21</age> * </student> * </person> * @return 返回属性值组成的List对象集合。 */
public static<T> List<T> attributeToObject(String xml, Class<T> clazz, String tagName){
if(TextUtils.isEmpty(tagName))return null;
List<T> list = null;
XmlPullParser xmlPullParser = Xml.newPullParser();
InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
try {
xmlPullParser.setInput(inputStream, "utf-8");
int type = xmlPullParser.getEventType();
T t = null;
while(type != XmlPullParser.END_DOCUMENT){
switch(type){
case XmlPullParser.START_DOCUMENT:
list = new ArrayList<T>();
break;
case XmlPullParser.START_TAG:
if(tagName.equals(xmlPullParser.getName())){
t = clazz.newInstance();
Field[] fields = clazz.getDeclaredFields();
for(Field field : fields){
String fieldName = field.getName();
for(int index = 0;index < xmlPullParser.getAttributeCount();index++){
if(fieldName.equals(xmlPullParser.getAttributeName(index))){
ReflectUtil.setFieldValue(t,field,fieldName,xmlPullParser.getAttributeValue(index));
}
}
}
}
break;
case XmlPullParser.END_TAG:
if(tagName.equals(xmlPullParser.getName())){
list.add(t);
}
break;
case XmlPullParser.END_DOCUMENT:
break;
}
type = xmlPullParser.next();
}
}catch(Exception ex){
ex.printStackTrace();
}
return list;
}
/** * 获取Xml文件中的属性值 * @param xml 　　　　　xml文件字符串 * @param tagName 标签名称 * @param attributeName 属性名称 * @return 返回获取的值，或者null */
public static String getTagAttribute(String xml, String tagName, String attributeName){
if(TextUtils.isEmpty(tagName) || TextUtils.isEmpty(attributeName)){
throw new IllegalArgumentException("请填写标签名称或属性名称");
}
XmlPullParser xmlPullParser = Xml.newPullParser();
InputStream inputStream = new ByteArrayInputStream(xml.getBytes());
try {
xmlPullParser.setInput(inputStream, "utf-8");
int type = xmlPullParser.getEventType();
while(type != XmlPullParser.END_DOCUMENT){
switch(type){
case XmlPullParser.START_TAG:
if(tagName.equals(xmlPullParser.getName())){
for(int i=0; i < xmlPullParser.getAttributeCount();i++){
if(attributeName.equals(xmlPullParser.getAttributeName(i))){
return xmlPullParser.getAttributeValue(i);
}
}
}
break;
}
type = xmlPullParser.next();
}
} catch (XmlPullParserException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
}