android 对象按属性中文排序 android的类

转载

flyingsmiling 2024-06-01 06:56:41

文章标签 android 对象按属性中文排序 android 日志网络通用方法 文章分类 Android 移动开发

日志

package net.wujingchao.android.utility

import android.util.Log;

public final class L {

    private final static int LEVEL = 5;

    private final static String DEFAULT_TAG = "L";

    private L() {
        throw new UnsupportedOperationException("L cannot instantiated!");
    }

    public static void v(String tag,String msg) {
        if(LEVEL >= 5)Log.v(tag == null ? DEFAULT_TAG:tag,msg == null?"":msg);
    }

    public static void d(String tag,String msg) {
        if(LEVEL >= 4)Log.d(tag == null ? DEFAULT_TAG:tag,msg == null?"":msg);
    }

    public static void i(String tag,String msg) {
        if(LEVEL >= 3)Log.i(tag == null ? DEFAULT_TAG:tag,msg == null?"":msg);
    }

    public static void w(String tag,String msg) {
        if(LEVEL >= 2)Log.w(tag == null ? DEFAULT_TAG:tag,msg == null?"":msg);
    }

    public static void e(String tag,String msg) {
        if(LEVEL >= 1)Log.e(tag == null ? DEFAULT_TAG:tag,msg == null?"":msg);
    }
}
Toast

package net.wujingchao.android.utility        

import android.content.Context;
import android.widget.Toast;

public class T {

    private final static boolean isShow = true;

    private T(){
        throw new UnsupportedOperationException("T cannot be instantiated");
    }

    public static void showShort(Context context,CharSequence text) {
        if(isShow)Toast.makeText(context,text,Toast.LENGTH_SHORT).show();
    }

    public static void showLong(Context context,CharSequence text) {
        if(isShow)Toast.makeText(context,text,Toast.LENGTH_LONG).show();
    }
}
网络

package net.wujingchao.android.utility

import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;

import javax.net.ssl.HttpsURLConnection;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

public class NetworkUtil {
    
    private NetworkUtil() {
        throw new UnsupportedOperationException("NetworkUtil cannot be instantiated");
    }

    /**
     * 判断网络是否连接
     *
     */
    public static boolean isConnected(Context context)  {
        ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (null != connectivity) {
            NetworkInfo info = connectivity.getActiveNetworkInfo();
            if (null != info && info.isConnected()){
                if (info.getState() == NetworkInfo.State.CONNECTED) {
                    return true;
                }
            }
        }
        return false;
    }

    /**
     * 判断是否是wifi连接
     */
    public static boolean isWifi(Context context){
        ConnectivityManager connectivity = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivity == null) return false;
        return connectivity.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;

    }

    /**
     * 打开网络设置界面
     */
    public static void openSetting(Activity activity) {
        Intent intent = new Intent("/");
        ComponentName componentName = new ComponentName("com.android.settings","com.android.settings.WirelessSettings");
        intent.setComponent(componentName);
        intent.setAction("android.intent.action.VIEW");
        activity.startActivityForResult(intent, 0);
    }

    /**
     * 使用SSL不信任的证书
     */
    public static  void useUntrustedCertificate() {
        // Create a trust manager that does not validate certificate chains
        TrustManager[] trustAllCerts = new TrustManager[]{
                new X509TrustManager() {
                    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
                        return null;
                    }
                    public void checkClientTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                    }
                    public void checkServerTrusted(
                            java.security.cert.X509Certificate[] certs, String authType) {
                    }
                }
        };
        // Install the all-trusting trust manager
        try {
            SSLContext sc = SSLContext.getInstance("SSL");
            sc.init(null, trustAllCerts, new java.security.SecureRandom());
            HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
        } catch (Exception e) {
           e.printStackTrace();
        }
    }
}
像素单位转换

package net.wujingchao.android.utility        

import android.content.Context;
import android.util.TypedValue;

        public class DensityUtil {

    private DensityUtil() {
        throw new UnsupportedOperationException("DensityUtil cannot be instantiated");
    }

    public int dip2px(Context context,int dipValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int)(dipValue*scale + 0.5f);
    }

    public int px2dip(Context context,float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int)(pxValue/scale + 0.5f);
    }

    public static float px2sp(Context context, float pxValue){
        return (pxValue / context.getResources().getDisplayMetrics().scaledDensity);
    }

    public static int sp2px(Context context, int spValue){
        return (int) TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
                spValue, context.getResources().getDisplayMetrics());
    }
}
屏幕

package net.wujingchao.android.utility        

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Rect;
import android.util.DisplayMetrics;
import android.view.View;
import android.view.WindowManager;

public class ScreenUtil {

    private ScreenUtil()
    {
        throw new UnsupportedOperationException("ScreenUtil cannot be instantiated");
    }

    public static int getScreenWidth(Context context)
    {
        WindowManager wm = (WindowManager) context
                .getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(outMetrics);
        return outMetrics.widthPixels;
    }

    public static int getScreenHeight(Context context) {
        WindowManager wm = (WindowManager) context
                .getSystemService(Context.WINDOW_SERVICE);
        DisplayMetrics outMetrics = new DisplayMetrics();
        wm.getDefaultDisplay().getMetrics(outMetrics);
        return outMetrics.heightPixels;
    }

    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;
    }

    /**
     * 获取当前屏幕截图，包含状态栏
     */
    public static Bitmap snapShotWithStatusBar(Activity activity){
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bmp = view.getDrawingCache();
        int width = getScreenWidth(activity);
        int height = getScreenHeight(activity);
        Bitmap bp = null;
        bp = Bitmap.createBitmap(bmp, 0, 0, width, height);
        view.destroyDrawingCache();
        return bp;
    }

    /**
     * 获取当前屏幕截图，不包含状态栏
     *
     */
    public static Bitmap snapShotWithoutStatusBar(Activity activity){
        View view = activity.getWindow().getDecorView();
        view.setDrawingCacheEnabled(true);
        view.buildDrawingCache();
        Bitmap bmp = view.getDrawingCache();
        Rect frame = new Rect();
        activity.getWindow().getDecorView().getWindowVisibleDisplayFrame(frame);
        int statusBarHeight = frame.top;
        int width = getScreenWidth(activity);
        int height = getScreenHeight(activity);
        Bitmap bp = null;
        bp = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height
                - statusBarHeight);
        view.destroyDrawingCache();
        return bp;
    }
}
App相关

package net.wujingchao.android.utility        

import android.content.Context;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;

public class AppUtil {

    private AppUtil() {
        throw new UnsupportedOperationException("AppUtil cannot instantiated");
    }

    /**
     * 获取app版本名
     */
    public static String getAppVersionName(Context context){
        PackageManager pm = context.getPackageManager();
        PackageInfo pi;
        try {
            pi = pm.getPackageInfo(context.getPackageName(),0);
            return pi.versionName;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 获取应用程序版本名称信息
     */
    public static String getVersionName(Context context)
    {
        try{
            PackageManager packageManager = context.getPackageManager();
            PackageInfo packageInfo = packageManager.getPackageInfo(
                    context.getPackageName(), 0);
            return packageInfo.versionName;
        }catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 获取app版本号
     */
    public static int getAppVersionCode(Context context){
        PackageManager pm = context.getPackageManager();
        PackageInfo pi;
        try {
            pi = pm.getPackageInfo(context.getPackageName(),0);
            return pi.versionCode;
        } catch (PackageManager.NameNotFoundException e) {
            e.printStackTrace();
        }
        return 0;
    }
}
键盘

package net.wujingchao.android.utility

import android.content.Context;
import android.view.inputmethod.InputMethodManager;
import android.widget.EditText;

public class KeyBoardUtil{

    private KeyBoardUtil(){
        throw new UnsupportedOperationException("KeyBoardUtil cannot be instantiated");
    }

    /**
     * 打卡软键盘
     */
    public static void openKeybord(EditText mEditText, Context mContext){
        InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.showSoftInput(mEditText, InputMethodManager.RESULT_SHOWN);
        imm.toggleSoftInput(InputMethodManager.SHOW_FORCED,InputMethodManager.HIDE_IMPLICIT_ONLY);
    }
    /**
     * 关闭软键盘
     */
    public static void closeKeybord(EditText mEditText, Context mContext) {
        InputMethodManager imm = (InputMethodManager) mContext.getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(mEditText.getWindowToken(), 0);
    }
}
文件上传下载

package net.wujingchao.android.utility

import android.content.Context;
import android.os.Environment;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.File; 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream; 
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.MalformedURLException;
import java.net.ProtocolException;
import java.net.URL;
import java.util.UUID;

import com.mixiaofan.App;

public class DownloadUtil {

         private static final int TIME_OUT = 30*1000; //超时时间

         private static final String CHARSET = "utf-8"; //设置编码

         private DownloadUtil() {
            throw new UnsupportedOperationException("DownloadUtil cannot be instantiated");
         }

    /**
     * @param file  上传文件
     * @param RequestURL 上传文件URL
     * @return 服务器返回的信息，如果出错则返回为null
     */
         public static String uploadFile(File file,String RequestURL) {
                 String BOUNDARY = UUID.randomUUID().toString(); //边界标识 随机生成 String PREFIX = "--" , LINE_END = "\r\n";
         String PREFIX = "--" , LINE_END = "\r\n";
         String CONTENT_TYPE = "multipart/form-data"; //内容类型
                 try {
                         URL url = new URL(RequestURL);
                         HttpURLConnection conn = (HttpURLConnection) url.openConnection();
             conn.setReadTimeout(TIME_OUT);
             conn.setConnectTimeout(TIME_OUT);
             conn.setDoInput(true); //允许输入流
                         conn.setDoOutput(true); //允许输出流
                         conn.setUseCaches(false); //不允许使用缓存 
                         conn.setRequestMethod("POST"); //请求方式 
                         conn.setRequestProperty("Charset", CHARSET);
             conn.setRequestProperty("Cookie", "PHPSESSID=" + App.getSessionId());
                         //设置编码 
                         conn.setRequestProperty("connection", "keep-alive"); 
                         conn.setRequestProperty("Content-Type", CONTENT_TYPE + ";boundary=" + BOUNDARY);
                         if(file!=null) { 
                     /** * 当文件不为空，把文件包装并且上传 */
                     OutputStream outputSteam=conn.getOutputStream();
                     DataOutputStream dos = new DataOutputStream(outputSteam);
                     StringBuffer sb = new StringBuffer();
                     sb.append(PREFIX);
                     sb.append(BOUNDARY); sb.append(LINE_END);
                     /**
                     * 这里重点注意：
                     * name里面的值为服务器端需要key 只有这个key 才可以得到对应的文件
                     * filename是文件的名字，包含后缀名的 比如:abc.png
                     */
                     sb.append("Content-Disposition: form-data; name=\"img\"; filename=\""+file.getName()+"\""+LINE_END);
                     sb.append("Content-Type: application/octet-stream; charset="+CHARSET+LINE_END);
                     sb.append(LINE_END);
                     dos.write(sb.toString().getBytes());
                     InputStream is = new FileInputStream(file);
                     byte[] bytes = new byte[1024];
                     int len;
                     while((len=is.read(bytes))!=-1)
                     {
                        dos.write(bytes, 0, len);
                     }
                     is.close();
                     dos.write(LINE_END.getBytes());
                     byte[] end_data = (PREFIX+BOUNDARY+PREFIX+LINE_END).getBytes();
                     dos.write(end_data);
                     dos.flush();
                     /**
                     * 获取响应码 200=成功
                     * 当响应成功，获取响应的流
                     */
                     ByteArrayOutputStream bos = new ByteArrayOutputStream();
                     InputStream resultStream = conn.getInputStream();
                     len = -1;
                     byte [] buffer = new byte[1024*8];
                     while((len = resultStream.read(buffer)) != -1) {
                         bos.write(buffer,0,len);
                     }
                     resultStream.close();
                     bos.flush();
                     bos.close();
                     String info = new String(bos.toByteArray());
                     int res = conn.getResponseCode();
                     if(res==200){
                        return info;
                     }else {
                         return null;
                     }
                            }
               } catch (MalformedURLException e) {
                    e.printStackTrace();
               } catch (ProtocolException e) {
                    e.printStackTrace();
               } catch (FileNotFoundException e) {
                    e.printStackTrace();
               } catch (IOException e) {
                     e.printStackTrace();
               }
         return null;
         }

     public static byte[] download(String urlStr) {
            HttpURLConnection conn = null;
            InputStream is = null;
            byte[] result = null;
            ByteArrayOutputStream bos = null;
            try {
                URL url = new URL(urlStr);
                conn = (HttpURLConnection) url.openConnection();
                conn.setRequestMethod("GET");
                conn.setConnectTimeout(TIME_OUT);
                conn.setReadTimeout(TIME_OUT);
                conn.setDoInput(true);
                conn.setUseCaches(false);//不使用缓存
                if(conn.getResponseCode() == 200) {
                    is = conn.getInputStream();
                    byte [] buffer = new byte[1024*8];
                    int len;
                    bos = new ByteArrayOutputStream();
                    while((len = is.read(buffer)) != -1) {
                        bos.write(buffer,0,len);
                    }
                    bos.flush();
                    result = bos.toByteArray();
                }
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    if(bos != null){
                        bos.close();
                    }
                    if (is != null) {
                        is.close();
                    }
                    if (conn != null)conn.disconnect();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return result;
        }

    /**
     * 获取缓存文件
     */
     public static File getDiskCacheFile(Context context,String filename,boolean isExternal) {
        if(isExternal && (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED))) {
            return new File(context.getExternalCacheDir(),filename);
        }else {
            return new File(context.getCacheDir(),filename);
        }
    }

    /**
     * 获取缓存文件目录
     */
     public static File getDiskCacheDirectory(Context context) {
        if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            return context.getExternalCacheDir();
        }else {
            return context.getCacheDir();
        }
    }
}
加密

package net.wujingchao.android.utility

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class CipherUtil { 

    private CipherUtil() {

    }

    //字节数组转化为16进制字符串
    public static String byteArrayToHex(byte[] byteArray) {
        char[] hexDigits = {'0','1','2','3','4','5','6','7','8','9', 'A','B','C','D','E','F' };
        char[] resultCharArray =new char[byteArray.length * 2];
        int index = 0;
        for (byte b : byteArray) {
            resultCharArray[index++] = hexDigits[b>>> 4 & 0xf];
            resultCharArray[index++] = hexDigits[b & 0xf];
        }
        return new String(resultCharArray);
    }

    //字节数组md5算法
    public static byte[] md5 (byte [] bytes) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            messageDigest.update(bytes);
            return messageDigest.digest();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }
}
时间

package net.wujingchao.android.utility
import java.text.SimpleDateFormat;
import java.util.Date;


public class DateUtil {

    //转换中文对应的时段
    public static String convertNowHour2CN(Date date) {
        SimpleDateFormat sdf = new SimpleDateFormat("HH");
        String hourString = sdf.format(date);
        int hour = Integer.parseInt(hourString);
        if(hour < 6) {
            return "凌晨";
        }else if(hour >= 6 && hour < 12) {
            return "早上";
        }else if(hour == 12) {
            return "中午";
        }else if(hour > 12 && hour <=18) {
            return "下午";
        }else if(hour >=19) {
            return "晚上";
        }
        return "";
    }

    //剩余秒数转换
    public static String convertSecond2Day(int time) {
        int day = time/86400;
        int hour = (time - 86400*day)/3600;
        int min = (time - 86400*day - 3600*hour)/60;
        int sec = (time - 86400*day - 3600*hour - 60*min);
        StringBuilder sb = new StringBuilder();
        sb.append(day);
        sb.append("天");
        sb.append(hour);
        sb.append("时");
        sb.append(min);
        sb.append("分");
        sb.append(sec);
        sb.append("秒");
        return sb.toString();
    }

}

文章出自：

http://www.eoeandroid.com/thread-570531-1-1.html

正则判断是不是手机号：

public class CommonTools {

	public static boolean isPhoneNumber(String phoneNumber) {
		Pattern p = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0-9]))\\d{8}$");
		Matcher m = p.matcher(phoneNumber);
		return m.matches();
	}
}

SD卡帮助类

package com.serenegiant.vo;
import java.io.File;

import android.os.Environment;
import android.os.StatFs;

/**
 * SD卡相关的辅助类
 * @see SDCardUtils
 */
public class SDCardUtils
{
	private SDCardUtils()
	{
		/* cannot be instantiated */
		throw new UnsupportedOperationException("cannot be instantiated");
	}

	/**
	 * 判断SDCard是否可用
	 * 
	 * @return
	 */
	public static boolean isSDCardEnable()
	{
		return Environment.getExternalStorageState().equals(
				Environment.MEDIA_MOUNTED);

	}

	/**
	 * 获取SD卡路径
	 * 
	 * @return
	 */
	public static String getSDCardPath()
	{
		return Environment.getExternalStorageDirectory().getAbsolutePath()
				+ File.separator;
	}

	/**
	 * 获取SD卡的剩余容量 单位byte
	 * 
	 * @return
	 */
	public static long getSDCardAllSize()
	{
		if (isSDCardEnable())
		{
			StatFs stat = new StatFs(getSDCardPath());
			// 获取空闲的数据块的数量
			long availableBlocks = (long) stat.getAvailableBlocks() - 4;
			// 获取单个数据块的大小（byte）
			long freeBlocks = stat.getAvailableBlocks();
			return freeBlocks * availableBlocks;
		}
		return 0;
	}

	/**
	 * 获取指定路径所在空间的剩余可用容量字节数，单位byte
	 * 
	 * @param filePath
	 * @return 容量字节 SDCard可用空间，内部存储可用空间
	 */
	public static long getFreeBytes(String filePath)
	{
		// 如果是sd卡的下的路径，则获取sd卡可用容量
		if (filePath.startsWith(getSDCardPath()))
		{
			filePath = getSDCardPath();
		} else
		{// 如果是内部存储的路径，则获取内存存储的可用容量
			filePath = Environment.getDataDirectory().getAbsolutePath();
		}
		StatFs stat = new StatFs(filePath);
		long availableBlocks = (long) stat.getAvailableBlocks() - 4;
		return stat.getBlockSize() * availableBlocks;
	}

	/**
	 * 获取系统存储路径
	 * 
	 * @return
	 */
	public static String getRootDirectoryPath()
	{
		return Environment.getRootDirectory().getAbsolutePath()
				+ File.separator;
	}


}

捕获未捕获异常帮助类

package com.serenegiant.vo;


import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.lang.Thread.UncaughtExceptionHandler;

import android.app.Application;

/**
 * 捕获未捕获的异常，这个在manifest中指明application是这个MyApplication
 * @see MyApplication
 * */
public class MyApplication extends Application {

	@Override
	public void onCreate() {
		super.onCreate();

		MyLog.init();
		MyLog.log("MyApplication", "MyApplication onCreate");
		Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler);
	}

	public UncaughtExceptionHandler uncaughtExceptionHandler = new UncaughtExceptionHandler() {

		@Override
		public void uncaughtException(Thread thread, Throwable ex) {
			String info = null;
			ByteArrayOutputStream baos = null;
			PrintStream printStream = null;

			try {
				baos = new ByteArrayOutputStream();
				printStream = new PrintStream(baos);
				ex.printStackTrace(printStream);
				byte[] data = baos.toByteArray();
				info = new String(data);
				data = null;
				// 加后台接口
				MyLog.log("debug---", info);
				// android.os.Process.killProcess(android.os.Process.myPid());
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				try {
					if (printStream != null) {
						printStream.close();
					}

					if (baos != null) {
						baos.close();
					}

				} catch (Exception e) {
					e.printStackTrace();
				}

				android.os.Process.killProcess(android.os.Process.myPid());
			}
		}
	};

}

生成调试日志文件

package com.serenegiant.vo;


import java.io.File;
import java.io.FileWriter;
import java.text.SimpleDateFormat;

import android.util.Log;

/**
 * 日志捕获形成日志文件保存在 SD卡根目录
 * @see MyLog
 * */
public class MyLog {
	public static String path;
	private static final String TAG = "UVCDemos";
	private static boolean DEBUG = true;

	public static void init() {
		SimpleDateFormat sDateFormat = new SimpleDateFormat(
				"yyyy_MM_dd_hh_mm_ss");
		String date = sDateFormat.format(new java.util.Date());

		String dir = "";
		
		if (SDCardUtils.isSDCardEnable()) {
			dir = SDCardUtils.getSDCardPath() + TAG;
		} else {
			dir = SDCardUtils.getRootDirectoryPath();
		}
		 
		Log.e("log", dir);
		File f = new File(dir);
		if (!f.exists()) {
			Log.e("log..", dir);
			Log.i("mkdir",""+f.mkdirs());
		}
		
		path = dir + "/" + date + ".log";
	}

	public static void log(String Tag, String msg) {
		Log.d(TAG, Tag + " : " + msg);

		if (!DEBUG) {
			return;
		}

		FileWriter file;
		try {
			file = new FileWriter(path, true);
			SimpleDateFormat sDateFormat = new SimpleDateFormat(
					"yyyy-MM-dd hh:mm:ss");
			String date = sDateFormat.format(new java.util.Date());
			String s = date + " : " + Tag + " " + msg + "\n";
			file.write(s);
			file.flush();
			file.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

以上几个文件有的有些许关联，请删繁就简根据具体需要选择相应的工具类的使用

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。