一些常用的android工具类

最新推荐文章于 2025-07-09 11:05:34 发布

原创最新推荐文章于 2025-07-09 11:05:34 发布 · 374 阅读

1 ·

CC 4.0 BY-SA版权

安卓综合开发专栏收录该内容

9 篇文章

订阅专栏

本文汇总了一系列Android开发中常用的工具类，包括SharedPreferences封装、单位转换、应用信息获取、设备信息获取、Toast显示、网络状态检查等功能，旨在提高开发效率。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

本篇文章为大家分享一些常用的android工具类，通过这些工具类可以更加方便高效，提高大家的工作效率，如果大家看了这篇文章，觉得有什么不足或是其他的一些工具方法，欢迎在评论提出

第一个工具类封装了SharedPreferences，代码和具体的使用方法如下所示

public class SharedPreferencesUtils {  
    /** 
     * 保存在手机里面的文件名 
     */  
    private static final String FILE_NAME = "share_date";  
      
      
    /** 
     * 保存数据的方法，我们需要拿到保存数据的具体类型，然后根据类型调用不同的保存方法 
     * @param context 
     * @param key 
     * @param object  
     */  
    public static void setParam(Context context , String key, Object object){  
          
        String type = object.getClass().getSimpleName();  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);  
        SharedPreferences.Editor editor = sp.edit();  
          
        if("String".equals(type)){  
            editor.putString(key, (String)object);  
        }  
        else if("Integer".equals(type)){  
            editor.putInt(key, (Integer)object);  
        }  
        else if("Boolean".equals(type)){  
            editor.putBoolean(key, (Boolean)object);  
        }  
        else if("Float".equals(type)){  
            editor.putFloat(key, (Float)object);  
        }  
        else if("Long".equals(type)){  
            editor.putLong(key, (Long)object);  
        }  
          
        editor.commit();  
    }  
      
      
    /** 
     * 得到保存数据的方法，我们根据默认值得到保存的数据的具体类型，然后调用相对于的方法获取值 
     * @param context 
     * @param key 
     * @param defaultObject 
     * @return 
     */  
    public static Object getParam(Context context , String key, Object defaultObject){  
        String type = defaultObject.getClass().getSimpleName();  
        SharedPreferences sp = context.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE);  
          
        if("String".equals(type)){  
            return sp.getString(key, (String)defaultObject);  
        }  
        else if("Integer".equals(type)){  
            return sp.getInt(key, (Integer)defaultObject);  
        }  
        else if("Boolean".equals(type)){  
            return sp.getBoolean(key, (Boolean)defaultObject);  
        }  
        else if("Float".equals(type)){  
            return sp.getFloat(key, (Float)defaultObject);  
        }  
        else if("Long".equals(type)){  
            return sp.getLong(key, (Long)defaultObject);  
        }  
          
        return null;  
    }  
}

使用方法如下

保存一个String数据：SharedPreferencesUtils.setParam(mContext, "fruit", "apple");

获取数据：SharedPreferencesUtils.getParam(mContext, "fruit", "");

第二个工具类是一个单位转换工具类，如下

public class DisplayUtils {

    /**
     * convert px to its equivalent dp
     * 
     * 将px转换为与之相等的dp
     */
    public static int px2dp(Context context, float pxValue) {
        final float scale =  context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }


    /**
     * convert dp to its equivalent px
     * 
     * 将dp转换为与之相等的px
     */
    public static int dp2px(Context context, float dipValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dipValue * scale + 0.5f);
    }


    /**
     * convert px to its equivalent sp 
     * 
     * 将px转换为sp
     */
    public static int px2sp(Context context, float pxValue) {
        final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
        return (int) (pxValue / fontScale + 0.5f);
    }


    /**
     * convert sp to its equivalent px
     * 
     * 将sp转换为px
     */
    public static int sp2px(Context context, float spValue) {
        final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
        return (int) (spValue * fontScale + 0.5f);
    }
}

第三个方法是一个获取app信息工具类，代码如下

import java.util.ArrayList;
import java.util.List;

import android.content.pm.LauncherActivityInfo;
import android.content.pm.LauncherApps;
import android.os.UserHandle;

import com.magcomm.datausage.MainActivity;

public class AppInfoUtils {

        private AppInfoUtils() {
                /* cannot be instantiated */
                throw new UnsupportedOperationException("cannot be instantiated");

        }

        /**
         * 获取应用程序名称
         * 
         * @param context
         * @return
         */
        public static String getAppName(Context context) {
                try {
                        PackageManager packageManager = context.getPackageManager();
                        PackageInfo packageInfo = packageManager.getPackageInfo(
                                        context.getPackageName(), 0);
                        int labelRes = packageInfo.applicationInfo.labelRes;
                        return context.getResources().getString(labelRes);
                } catch (NameNotFoundException e) {
                        e.printStackTrace();
                }
                return null;
        }

        /**
         * 获取应用程序版本名称信息
         * 
         * @param context
         * [url=home.php?mod=space&uid=309376]@return[/url] 当前应用的版本名称
         */
        public static String getVersionName(Context context) {
                try {
                        PackageManager packageManager = context.getPackageManager();
                        PackageInfo packageInfo = packageManager.getPackageInfo(
                                        context.getPackageName(), 0);
                        return packageInfo.versionName;

                } catch (NameNotFoundException e) {
                        e.printStackTrace();
                }
                return null;
        }

        /**
         * 获取application节点下的meta信息
         * 
         * @param context
         * @param params
         *            想要获取的参数
         * @return
         */
        public static String getMetaInfo(Context context, String params) {

                String packageName = context.getPackageName();
                // 获取application里面的meta信息
                try {
                        ApplicationInfo appInfo = context.getPackageManager()
                                        .getApplicationInfo(packageName,
                                                        PackageManager.GET_META_DATA);
                        return appInfo.metaData.getString(params);
                } catch (Exception e) {
                        System.out.println("获取渠道失败:" + e);
                        e.printStackTrace();
                }
                return null;
        }

        /**
         * 获取启动Activity的intent
         * 
         * @param context
         * @return
         */
        public static Intent getLaunchIntent(Context context) {
                String packageName = context.getPackageName();
                PackageManager pm = context.getPackageManager();
                Intent intent = pm.getLaunchIntentForPackage(packageName);
                return intent;
        }
        
        public static List<String> getLauncherAppPackageName(Context context){
        	
        	LauncherApps apps = (LauncherApps)context.getSystemService("launcherapps");
            UserHandle mUserHandle = android.os.Process.myUserHandle();
            
            List<LauncherActivityInfo> activityInfos = apps.getActivityList(null, mUserHandle);
            
            List<String> launcherPackageNamesList = new ArrayList<String>();
            
            for (LauncherActivityInfo activityInfo : activityInfos) {
    			String name = activityInfo.getApplicationInfo().packageName;
    			launcherPackageNamesList.add(name);
    		}
            
            return launcherPackageNamesList;
        	
        }
}

获取当前手机的相关信息

public class PhoneInfoUtils {

        private Context context;

        private String deviceId;
        private String imei;
        private String imsi;
        private String manufacture;
        private String model;
        private int screenWidth;
        private int screenHeight;
        private String version_release;
        private String phoneNumber;

        public PhoneInfoUtils(Context context) {
                this.context = context;
        }
        

        public void getPhoneInfo() {
                TelephonyManager tm = (TelephonyManager) context
                                .getSystemService(Context.TELEPHONY_SERVICE);

                deviceId = Settings.Secure.getString(context.getContentResolver(),
                                Settings.Secure.ANDROID_ID);
                imsi = tm.getSubscriberId();
                imei = tm.getDeviceId();

                // 手机制造商
                manufacture = Build.MANUFACTURER;

                model = Build.MODEL; // 手机型号

                DisplayMetrics dm = context.getResources().getDisplayMetrics();
                screenWidth = dm.widthPixels;
                screenHeight = dm.heightPixels;

                version_release = Build.VERSION.RELEASE; // 系统版本号

                phoneNumber = tm.getLine1Number(); // 获取手机号码
        }

        @Override
        public String toString() {
                return "PhoneInfoUtils [deviceId=" + deviceId + ", imei=" + imei
                                + ", imsi=" + imsi + ", manufacture=" + manufacture
                                + ", model=" + model + ", screenWidth=" + screenWidth
                                + ", screenHeight=" + screenHeight + ", version_release="
                                + version_release + ", phoneNumber=" + phoneNumber + "]";
        }

}

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

跟网络相关的工具类

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

Log的统一管理工具类

public class L {

	private L() {
		/* cannot be instantiated */
		throw new UnsupportedOperationException("cannot be instantiated");
	}

	public static boolean isDebug = true;// 是否需要打印bug，可以在application的onCreate函数里面初始化
	private static final String TAG = "myTag";

	// 下面四个是默认tag的函数
	public static void i(String msg) {
		if (isDebug)
			Log.i(TAG, msg);
	}

	public static void d(String msg) {
		if (isDebug)
			Log.d(TAG, msg);
	}

	public static void e(String msg) {
		if (isDebug)
			Log.e(TAG, msg);
	}

	public static void v(String msg) {
		if (isDebug)
			Log.v(TAG, msg);
	}

	// 下面是传入自定义tag的函数
	public static void i(String tag, String msg) {
		if (isDebug)
			Log.i(tag, msg);
	}

	public static void d(String tag, String msg) {
		if (isDebug)
			Log.i(tag, msg);
	}

	public static void e(String tag, String msg) {
		if (isDebug)
			Log.i(tag, msg);
	}

	public static void v(String tag, String msg) {
		if (isDebug)
			Log.i(tag, msg);
	}
}

SD卡存储相关工具类

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();
	}
	
	
	/**
	 * 获取SD卡空余存储
	 * 
	 * @return
	 */
	public String getSDCardStorage() {
		return FormetFileSize(getSDCardAllSize());
	}
	
	/** 
     * 获得SD卡总存储
     *  
     * @return 
     */  
    private String getSDTotalSize() {  
        File path = Environment.getExternalStorageDirectory();  
        StatFs stat = new StatFs(path.getPath());  
        long blockSize = stat.getBlockSize();  
        long totalBlocks = stat.getBlockCount();  
        return FormetFileSize(blockSize * totalBlocks);  
    }  
	
	
	/**
     * 转换文件大小
     * 
     * @param blockSize
     * @return
     */
    public String FormetFileSize(long blockSize) { 
        DecimalFormat df = new DecimalFormat("#.00"); 
        String blockSizeString = ""; 
        if (blockSize < 1024) { 
        	blockSizeString = df.format((double) blockSize) + "B"; 
        } else if (blockSize < 1048576) { 
        	blockSizeString = df.format((double) blockSize / 1024) + "K"; 
        } else if (blockSize < 1073741824) { 
        	blockSizeString = df.format((double) blockSize / 1048576) + "M"; 
        } else { 
        	blockSizeString = df.format((double) blockSize / 1073741824) + "G"; 
        } 
        return blockSizeString; 
    } 

}

文章中的大部分的工具类都是从网上收集而来，做了一些筛选，保留了一些平常大多能用到的工具类，后续发现有其它的好的工具方法，会补充上来