程序博客网 > 最小的windows平板

Android知识大全

来源：互联网 发布：最小的windows平板 编辑：程序博客网 时间：2024/05/02 04:22
@ayw2016-11-24 11:36字数 174355 阅读20

tools

系统 基础知识 tool

Windows系统相关

项目默认路径Kies3下载的临时文件C:\Users\kevin\AppData\Local\Tempwindows10的hosts文件C:\Windows\System32\drivers\etcWindows检测笔记本电池健康情况命令powercfg –energyJDKC:\Program Files\Java\jdk1.8.0_91\JREC:\Program Files\Java\jre1.8.0_91vimvimtutor
windows10默认的host文件内容
  1. # Copyright (c) 1993-2009 Microsoft Corp.
  2. #
  3. # This is a sample HOSTS file used by Microsoft TCP/IP for Windows.
  4. #
  5. # This file contains the mappings of IP addresses to host names. Each
  6. # entry should be kept on an individual line. The IP address should
  7. # be placed in the first column followed by the corresponding host name.
  8. # The IP address and the host name should be separated by at least one
  9. # space.
  10. #
  11. # Additionally, comments (such as these) may be inserted on individual
  12. # lines or following the machine name denoted by a '#' symbol.
  13. #
  14. # For example:
  15. #
  16. #      102.54.94.97     rhino.acme.com          # source server
  17. #       38.25.63.10     x.acme.com              # x client host
  19. # localhost name resolution is handled within DNS itself.
  20. #   127.0.0.1       localhost
  21. #   ::1             localhost

Chrome相关

插件

  • Momentu
  • Save to Pocket
  • OneTab
  • Page Ruler
  • Octotree
  • Postman
  • ChromeADB
  • Vysor
  • Dribbble New Tab
  • Clearly
  • LastPass

Android Utils 相关

ActivityUtils

  2. package com.blankj.utilcode.utils;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.os.Bundle;
  8. /**
  9.  * <pre>
  10.  *     author: Blankj
  11.  *     blog  : http://blankj.com
  12.  *     time  : 2016/9/23
  13.  *     desc  : Activity工具类
  14.  * </pre>
  15.  */
  16. public class ActivityUtils {
  18.     private ActivityUtils() {
  19.         throw new UnsupportedOperationException("u can't fuck me...");
  20.     }
  22.     /**
  23.      * 判断是否存在指定Activity
  24.      *
  25.      * @param context     上下文
  26.      * @param packageName 包名
  27.      * @param className   activity全路径类名
  28.      * @return {@code true}: 是<br>{@code false}: 否
  29.      */
  30.     public static boolean isExistActivity(Context context, String packageName, String className) {
  31.         Intent intent = new Intent();
  32.         intent.setClassName(packageName, className);
  33.         return !(context.getPackageManager().resolveActivity(intent, 0) == null ||
  34.                 intent.resolveActivity(context.getPackageManager()) == null ||
  35.                 context.getPackageManager().queryIntentActivities(intent, 0).size() == 0);
  36.     }
  38.     /**
  39.      * 打开指定的Activity
  40.      *
  41.      * @param context     上下文
  42.      * @param packageName 包名
  43.      * @param className   全类名
  44.      */
  45.     public static void launchActivity(Context context, String packageName, String className) {
  46.         launchActivity(context, packageName, className, null);
  47.     }
  49.     /**
  50.      * 打开指定的Activity
  51.      *
  52.      * @param context     上下文
  53.      * @param packageName 包名
  54.      * @param className   全类名
  55.      * @param bundle      bundle
  56.      */
  57.     public static void launchActivity(Context context, String packageName, String className, Bundle bundle) {
  58.         context.startActivity(IntentUtils.getComponentNameIntent(packageName, className, bundle));
  59.     }
  60. }

AppUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.ActivityManager;
  4. import android.content.ComponentName;
  5. import android.content.Context;
  6. import android.content.Intent;
  7. import android.content.pm.ApplicationInfo;
  8. import android.content.pm.PackageInfo;
  9. import android.content.pm.PackageManager;
  10. import android.graphics.drawable.Drawable;
  11. import android.net.Uri;
  12. import android.os.Build;
  13. import android.webkit.MimeTypeMap;
  15. import java.io.File;
  16. import java.util.ArrayList;
  17. import java.util.List;
  19. /**
  20.  * <pre>
  21.  *     author: Blankj
  22.  *     blog  : http://blankj.com
  23.  *     time  : 2016/8/2
  24.  *     desc  : App相关工具类
  25.  * </pre>
  26.  */
  27. public class AppUtils {
  29.     private AppUtils() {
  30.         throw new UnsupportedOperationException("u can't fuck me...");
  31.     }
  33.     /**
  34.      * 获取安装App(支持6.0)的意图
  35.      *
  36.      * @param filePath 文件路径
  37.      * @return 意图
  38.      */
  39.     public static Intent getInstallAppIntent(String filePath) {
  40.         return getInstallAppIntent(FileUtils.getFileByPath(filePath));
  41.     }
  43.     /**
  44.      * 获取安装App(支持6.0)的意图
  45.      *
  46.      * @param file 文件
  47.      * @return 意图
  48.      */
  49.     public static Intent getInstallAppIntent(File file) {
  50.         if (file == null) return null;
  51.         Intent intent = new Intent(Intent.ACTION_VIEW);
  52.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  53.         String type;
  54.         if (Build.VERSION.SDK_INT < 23) {
  55.             type = "application/vnd.android.package-archive";
  56.         } else {
  57.             type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(FileUtils.getFileExtension(file));
  58.         }
  59.         return intent.setDataAndType(Uri.fromFile(file), type);
  60.     }
  62.     /**
  63.      * 获取卸载App的意图
  64.      *
  65.      * @param packageName 包名
  66.      * @return 意图
  67.      */
  68.     public Intent getUninstallAppIntent(String packageName) {
  69.         Intent intent = new Intent(Intent.ACTION_DELETE);
  70.         intent.setData(Uri.parse("package:" + packageName));
  71.         return intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  72.     }
  74.     /**
  75.      * 获取打开App的意图
  76.      *
  77.      * @param context     上下文
  78.      * @param packageName 包名
  79.      * @return 意图
  80.      */
  81.     public static Intent getLaunchAppItent(Context context, String packageName) {
  82.         return getIntentByPackageName(context, packageName);
  83.     }
  85.     /**
  86.      * 获取App信息的意图
  87.      *
  88.      * @param packageName 包名
  89.      * @return 意图
  90.      */
  91.     public static Intent getAppInfoIntent(String packageName) {
  92.         Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
  93.         return intent.setData(Uri.parse("package:" + packageName));
  94.     }
  96.     /**
  97.      * 获取App信息分享的意图
  98.      *
  99.      * @param info 分享信息
  100.      * @return 意图
  101.      */
  102.     public static Intent getShareInfoIntent(String info) {
  103.         Intent intent = new Intent(Intent.ACTION_SEND);
  104.         intent.setType("text/plain");
  105.         return intent.putExtra(Intent.EXTRA_TEXT, info);
  106.     }
  108.     /**
  109.      * 判断App是否安装
  110.      *
  111.      * @param context     上下文
  112.      * @param packageName 包名
  113.      * @return {@code true}: 已安装<br>{@code false}: 未安装
  114.      */
  115.     public static boolean isInstallApp(Context context, String packageName) {
  116.         return getIntentByPackageName(context, packageName) != null;
  117.     }
  119.     /**
  120.      * 根据包名获取意图
  121.      *
  122.      * @param context     上下文
  123.      * @param packageName 包名
  124.      * @return Intent
  125.      */
  126.     private static Intent getIntentByPackageName(Context context, String packageName) {
  127.         return context.getPackageManager().getLaunchIntentForPackage(packageName);
  128.     }
  130.     /**
  131.      * 封装App信息的Bean类
  132.      */
  133.     public static class AppInfo {
  135.         private String name;
  136.         private Drawable icon;
  137.         private String packageName;
  138.         private String packagePath;
  139.         private String versionName;
  140.         private int versionCode;
  141.         private boolean isSD;
  142.         private boolean isUser;
  144.         public Drawable getIcon() {
  145.             return icon;
  146.         }
  148.         public void setIcon(Drawable icon) {
  149.             this.icon = icon;
  150.         }
  152.         public boolean isSD() {
  153.             return isSD;
  154.         }
  156.         public void setSD(boolean SD) {
  157.             isSD = SD;
  158.         }
  160.         public boolean isUser() {
  161.             return isUser;
  162.         }
  164.         public void setUser(boolean user) {
  165.             isUser = user;
  166.         }
  168.         public String getName() {
  169.             return name;
  170.         }
  172.         public void setName(String name) {
  173.             this.name = name;
  174.         }
  176.         public String getPackageName() {
  177.             return packageName;
  178.         }
  180.         public void setPackageName(String packagName) {
  181.             this.packageName = packagName;
  182.         }
  184.         public String getPackagePath() {
  185.             return packagePath;
  186.         }
  188.         public void setPackagePath(String packagePath) {
  189.             this.packagePath = packagePath;
  190.         }
  192.         public int getVersionCode() {
  193.             return versionCode;
  194.         }
  196.         public void setVersionCode(int versionCode) {
  197.             this.versionCode = versionCode;
  198.         }
  200.         public String getVersionName() {
  201.             return versionName;
  202.         }
  204.         public void setVersionName(String versionName) {
  205.             this.versionName = versionName;
  206.         }
  208.         /**
  209.          * @param name        名称
  210.          * @param icon        图标
  211.          * @param packageName 包名
  212.          * @param packagePath 包路径
  213.          * @param versionName 版本号
  214.          * @param versionCode 版本Code
  215.          * @param isSD        是否安装在SD卡
  216.          * @param isUser      是否是用户程序
  217.          */
  218.         public AppInfo(String name, Drawable icon, String packageName, String packagePath,
  219.                        String versionName, int versionCode, boolean isSD, boolean isUser) {
  220.             this.setName(name);
  221.             this.setIcon(icon);
  222.             this.setPackageName(packageName);
  223.             this.setPackagePath(packagePath);
  224.             this.setVersionName(versionName);
  225.             this.setVersionCode(versionCode);
  226.             this.setSD(isSD);
  227.             this.setUser(isUser);
  228.         }
  230. //        @Override
  231. //        public String toString() {
  232. //            return getName() + "\n"
  233. //                    + getIcon() + "\n"
  234. //                    + getPackageName() + "\n"
  235. //                    + getPackagePath() + "\n"
  236. //                    + getVersionName() + "\n"
  237. //                    + getVersionCode() + "\n"
  238. //                    + isSD() + "\n"
  239. //                    + isUser() + "\n";
  240. //        }
  241.     }
  243.     /**
  244.      * 获取当前App信息
  245.      * <p>AppInfo（名称，图标，包名，版本号，版本Code，是否安装在SD卡，是否是用户程序）</p>
  246.      *
  247.      * @param context 上下文
  248.      * @return 当前应用的AppInfo
  249.      */
  250.     public static AppInfo getAppInfo(Context context) {
  251.         PackageManager pm = context.getPackageManager();
  252.         PackageInfo pi = null;
  253.         try {
  254.             pi = pm.getPackageInfo(context.getApplicationContext().getPackageName(), 0);
  255.         } catch (PackageManager.NameNotFoundException e) {
  256.             e.printStackTrace();
  257.         }
  258.         return pi != null ? getBean(pm, pi) : null;
  259.     }
  261.     /**
  262.      * 得到AppInfo的Bean
  263.      *
  264.      * @param pm 包的管理
  265.      * @param pi 包的信息
  266.      * @return AppInfo类
  267.      */
  268.     private static AppInfo getBean(PackageManager pm, PackageInfo pi) {
  269.         ApplicationInfo ai = pi.applicationInfo;
  270.         String name = ai.loadLabel(pm).toString();
  271.         Drawable icon = ai.loadIcon(pm);
  272.         String packageName = pi.packageName;
  273.         String packagePath = ai.sourceDir;
  274.         String versionName = pi.versionName;
  275.         int versionCode = pi.versionCode;
  276.         boolean isSD = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
  277.         boolean isUser = (ApplicationInfo.FLAG_SYSTEM & ai.flags) != ApplicationInfo.FLAG_SYSTEM;
  278.         return new AppInfo(name, icon, packageName, packagePath, versionName, versionCode, isSD, isUser);
  279.     }
  281.     /**
  282.      * 获取所有已安装App信息
  283.      * <p>{@link #getBean(PackageManager, PackageInfo)}（名称，图标，包名，包路径，版本号，版本Code，是否安装在SD卡，是否是用户程序）</p>
  284.      * <p>依赖上面的getBean方法</p>
  285.      *
  286.      * @param context 上下文
  287.      * @return 所有已安装的AppInfo列表
  288.      */
  289.     public static List<AppInfo> getAllAppsInfo(Context context) {
  290.         List<AppInfo> list = new ArrayList<>();
  291.         PackageManager pm = context.getPackageManager();
  292.         // 获取系统中安装的所有软件信息
  293.         List<PackageInfo> installedPackages = pm.getInstalledPackages(0);
  294.         for (PackageInfo pi : installedPackages) {
  295.             if (pi != null) {
  296.                 list.add(getBean(pm, pi));
  297.             }
  298.         }
  299.         return list;
  300.     }
  302.     /**
  303.      * 判断当前App处于前台还是后台
  304.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.GET_TASKS"/>}</p>
  305.      * <p>并且必须是系统应用该方法才有效</p>
  306.      *
  307.      * @param context 上下文
  308.      * @return {@code true}: 后台<br>{@code false}: 前台
  309.      */
  310.     public static boolean isAppBackground(Context context) {
  311.         ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
  312.         @SuppressWarnings("deprecation")
  313.         List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
  314.         if (!tasks.isEmpty()) {
  315.             ComponentName topActivity = tasks.get(0).topActivity;
  316.             if (!topActivity.getPackageName().equals(context.getPackageName())) {
  317.                 return true;
  318.             }
  319.         }
  320.         return false;
  321.     }
  322. }

BarUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.os.Build;
  6. import android.util.TypedValue;
  7. import android.view.Window;
  8. import android.view.WindowManager;
  10. import java.lang.reflect.Method;
  12. /**
  13.  * <pre>
  14.  *     author: Blankj
  15.  *     blog  : http://blankj.com
  16.  *     time  : 2016/9/23
  17.  *     desc  : 栏相关工具类
  18.  * </pre>
  19.  */
  20. public class BarUtils {
  21.     private BarUtils() {
  22.         throw new UnsupportedOperationException("u can't fuck me...");
  23.     }
  25.     /**
  26.      * 设置透明状态栏(api大于19方可使用)
  27.      * <p>可在Activity的onCreat()中调用</p>
  28.      * <p>需在顶部控件布局中加入以下属性让内容出现在状态栏之下</p>
  29.      * <p>android:clipToPadding="true"</p>
  30.      * <p>android:fitsSystemWindows="true"</p>
  31.      *
  32.      * @param activity activity
  33.      */
  34.     public static void setTransparentStatusBar(Activity activity) {
  35.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  36.             //透明状态栏
  37.             activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS);
  38.             //透明导航栏
  39.             activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
  40.         }
  41.     }
  43.     /**
  44.      * 隐藏状态栏
  45.      * <p>也就是设置全屏，一定要在setContentView之前调用，否则报错</p>
  46.      * <p>此方法Activity可以继承AppCompatActivity</p>
  47.      * <p>启动的时候状态栏会显示一下再隐藏，比如QQ的欢迎界面</p>
  48.      * <p>在配置文件中Activity加属性android:theme="@android:style/Theme.NoTitleBar.Fullscreen"</p>
  49.      * <p>如加了以上配置Activity不能继承AppCompatActivity，会报错</p>
  50.      *
  51.      * @param activity activity
  52.      */
  53.     public static void hideStatusBar(Activity activity) {
  54.         activity.requestWindowFeature(Window.FEATURE_NO_TITLE);
  55.         activity.getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
  56.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);
  57.     }
  59.     /**
  60.      * 获取状态栏高度
  61.      *
  62.      * @param context 上下文
  63.      * @return 状态栏高度
  64.      */
  65.     public static int getStatusBarHeight(Context context) {
  66.         int result = 0;
  67.         int resourceId = context.getResources()
  68.                 .getIdentifier("status_bar_height", "dimen", "android");
  69.         if (resourceId > 0) {
  70.             result = context.getResources().getDimensionPixelSize(resourceId);
  71.         }
  72.         return result;
  73.     }
  75.     /**
  76.      * 判断状态栏是否存在
  77.      *
  78.      * @param activity activity
  79.      * @return {@code true}: 存在<br>{@code false}: 不存在
  80.      */
  81.     public static boolean isStatusBarExists(Activity activity) {
  82.         WindowManager.LayoutParams params = activity.getWindow().getAttributes();
  83.         return (params.flags & WindowManager.LayoutParams.FLAG_FULLSCREEN) != WindowManager.LayoutParams.FLAG_FULLSCREEN;
  84.     }
  86.     /**
  87.      * 获取ActionBar高度
  88.      *
  89.      * @param activity activity
  90.      * @return ActionBar高度
  91.      */
  92.     public static int getActionBarHeight(Activity activity) {
  93.         TypedValue tv = new TypedValue();
  94.         if (activity.getTheme().resolveAttribute(android.R.attr.actionBarSize, tv, true)) {
  95.             return TypedValue.complexToDimensionPixelSize(tv.data, activity.getResources().getDisplayMetrics());
  96.         }
  97.         return 0;
  98.     }
  100.     /**
  101.      * 显示通知栏
  102.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.EXPAND_STATUS_BAR"/>}</p>
  103.      *
  104.      * @param context        上下文
  105.      * @param isSettingPanel {@code true}: 打开设置<br>{@code false}: 打开通知
  106.      */
  107.     public static void showNotificationBar(Context context, boolean isSettingPanel) {
  108.         String methodName = (Build.VERSION.SDK_INT <= 16) ? "expand"
  109.                 : (isSettingPanel ? "expandSettingsPanel" : "expandNotificationsPanel");
  110.         invokePanels(context, methodName);
  111.     }
  113.     /**
  114.      * 隐藏通知栏
  115.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.EXPAND_STATUS_BAR"/>}</p>
  116.      *
  117.      * @param context 上下文
  118.      */
  119.     public static void hideNotificationBar(Context context) {
  120.         String methodName = (Build.VERSION.SDK_INT <= 16) ? "collapse" : "collapsePanels";
  121.         invokePanels(context, methodName);
  122.     }
  124.     /**
  125.      * 反射唤醒通知栏
  126.      *
  127.      * @param context    上下文
  128.      * @param methodName 方法名
  129.      */
  130.     private static void invokePanels(Context context, String methodName) {
  131.         try {
  132.             Object service = context.getSystemService("statusbar");
  133.             Class<?> statusBarManager = Class.forName("android.app.StatusBarManager");
  134.             Method expand = statusBarManager.getMethod(methodName);
  135.             expand.invoke(service);
  136.         } catch (Exception e) {
  137.             e.printStackTrace();
  138.         }
  139.     }
  140. }

CameraUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.Activity;
  4. import android.content.ContentResolver;
  5. import android.content.Intent;
  6. import android.database.Cursor;
  7. import android.graphics.Bitmap;
  8. import android.net.Uri;
  9. import android.os.Bundle;
  10. import android.provider.MediaStore;
  12. import java.io.File;
  13. import java.io.IOException;
  15. /**
  16.  * <pre>
  17.  *     author: Blankj
  18.  *     blog  : http://blankj.com
  19.  *     time  : 2016/9/19
  20.  *     desc  : 相机相关工具类
  21.  * </pre>
  22.  */
  23. public class CameraUtils {
  25.     private CameraUtils() {
  26.         throw new UnsupportedOperationException("u can't fuck me...");
  27.     }
  29.     /**
  30.      * 获取打开照程序界面的Intent
  31.      */
  32.     public static Intent getOpenCameraIntent() {
  33.         return new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  34.     }
  36.     /**
  37.      * 获取跳转至相册选择界面的Intent
  38.      */
  39.     public static Intent getImagePickerIntent() {
  40.         Intent intent = new Intent(Intent.ACTION_PICK, null);
  41.         return intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI, "image/*");
  42.     }
  44.     /**
  45.      * 获取[跳转至相册选择界面,并跳转至裁剪界面，默认可缩放裁剪区域]的Intent
  46.      */
  47.     public static Intent getImagePickerIntent(int outputX, int outputY, Uri fromFileURI,
  48.                                               Uri saveFileURI) {
  49.         return getImagePickerIntent(1, 1, outputX, outputY, true, fromFileURI, saveFileURI);
  50.     }
  52.     /**
  53.      * 获取[跳转至相册选择界面,并跳转至裁剪界面，默认可缩放裁剪区域]的Intent
  54.      */
  55.     public static Intent getImagePickerIntent(int aspectX, int aspectY, int outputX, int outputY, Uri fromFileURI,
  56.                                               Uri saveFileURI) {
  57.         return getImagePickerIntent(aspectX, aspectY, outputX, outputY, true, fromFileURI, saveFileURI);
  58.     }
  60.     /**
  61.      * 获取[跳转至相册选择界面,并跳转至裁剪界面，可以指定是否缩放裁剪区域]的Intent
  62.      *
  63.      * @param aspectX     裁剪框尺寸比例X
  64.      * @param aspectY     裁剪框尺寸比例Y
  65.      * @param outputX     输出尺寸宽度
  66.      * @param outputY     输出尺寸高度
  67.      * @param canScale    是否可缩放
  68.      * @param fromFileURI 文件来源路径URI
  69.      * @param saveFileURI 输出文件路径URI
  70.      */
  71.     public static Intent getImagePickerIntent(int aspectX, int aspectY, int outputX, int outputY, boolean canScale,
  72.                                               Uri fromFileURI, Uri saveFileURI) {
  73.         Intent intent = new Intent(Intent.ACTION_PICK);
  74.         intent.setDataAndType(fromFileURI, "image/*");
  75.         intent.putExtra("crop", "true");
  76.         intent.putExtra("aspectX", aspectX <= 0 ? 1 : aspectX);
  77.         intent.putExtra("aspectY", aspectY <= 0 ? 1 : aspectY);
  78.         intent.putExtra("outputX", outputX);
  79.         intent.putExtra("outputY", outputY);
  80.         intent.putExtra("scale", canScale);
  81.         // 图片剪裁不足黑边解决
  82.         intent.putExtra("scaleUpIfNeeded", true);
  83.         intent.putExtra("return-data", false);
  84.         intent.putExtra(MediaStore.EXTRA_OUTPUT, saveFileURI);
  85.         intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
  86.         // 去除人脸识别
  87.         return intent.putExtra("noFaceDetection", true);
  88.     }
  90.     /**
  91.      * 获取[跳转至相册选择界面,并跳转至裁剪界面，默认可缩放裁剪区域]的Intent
  92.      */
  93.     public static Intent getCameraIntent(Uri saveFileURI) {
  94.         Intent mIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  95.         return mIntent.putExtra(MediaStore.EXTRA_OUTPUT, saveFileURI);
  96.     }
  98.     /**
  99.      * 获取[跳转至裁剪界面,默认可缩放]的Intent
  100.      */
  101.     public static Intent getCropImageIntent(int outputX, int outputY, Uri fromFileURI,
  102.                                             Uri saveFileURI) {
  103.         return getCropImageIntent(1, 1, outputX, outputY, true, fromFileURI, saveFileURI);
  104.     }
  106.     /**
  107.      * 获取[跳转至裁剪界面,默认可缩放]的Intent
  108.      */
  109.     public static Intent getCropImageIntent(int aspectX, int aspectY, int outputX, int outputY, Uri fromFileURI,
  110.                                             Uri saveFileURI) {
  111.         return getCropImageIntent(aspectX, aspectY, outputX, outputY, true, fromFileURI, saveFileURI);
  112.     }
  115.     /**
  116.      * 获取[跳转至裁剪界面]的Intent
  117.      */
  118.     public static Intent getCropImageIntent(int aspectX, int aspectY, int outputX, int outputY, boolean canScale,
  119.                                             Uri fromFileURI, Uri saveFileURI) {
  120.         Intent intent = new Intent("com.android.camera.action.CROP");
  121.         intent.setDataAndType(fromFileURI, "image/*");
  122.         intent.putExtra("crop", "true");
  123.         // X方向上的比例
  124.         intent.putExtra("aspectX", aspectX <= 0 ? 1 : aspectX);
  125.         // Y方向上的比例
  126.         intent.putExtra("aspectY", aspectY <= 0 ? 1 : aspectY);
  127.         intent.putExtra("outputX", outputX);
  128.         intent.putExtra("outputY", outputY);
  129.         intent.putExtra("scale", canScale);
  130.         // 图片剪裁不足黑边解决
  131.         intent.putExtra("scaleUpIfNeeded", true);
  132.         intent.putExtra("return-data", false);
  133.         // 需要将读取的文件路径和裁剪写入的路径区分，否则会造成文件0byte
  134.         intent.putExtra(MediaStore.EXTRA_OUTPUT, saveFileURI);
  135.         // true-->返回数据类型可以设置为Bitmap，但是不能传输太大，截大图用URI，小图用Bitmap或者全部使用URI
  136.         intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
  137.         // 取消人脸识别功能
  138.         intent.putExtra("noFaceDetection", true);
  139.         return intent;
  140.     }
  142.     /**
  143.      * 获得选中相册的图片
  144.      *
  145.      * @param context 上下文
  146.      * @param data    onActivityResult返回的Intent
  147.      * @return bitmap
  148.      */
  149.     public static Bitmap getChoosedImage(Activity context, Intent data) {
  150.         if (data == null) return null;
  151.         Bitmap bm = null;
  152.         ContentResolver cr = context.getContentResolver();
  153.         Uri originalUri = data.getData();
  154.         try {
  155.             bm = MediaStore.Images.Media.getBitmap(cr, originalUri);
  156.         } catch (IOException e) {
  157.             e.printStackTrace();
  158.         }
  159.         return bm;
  160.     }
  162.     /**
  163.      * 获得选中相册的图片路径
  164.      *
  165.      * @param context 上下文
  166.      * @param data    onActivityResult返回的Intent
  167.      * @return
  168.      */
  169.     public static String getChoosedImagePath(Activity context, Intent data) {
  170.         if (data == null) return null;
  171.         String path = "";
  172.         ContentResolver resolver = context.getContentResolver();
  173.         Uri originalUri = data.getData();
  174.         if (null == originalUri) return null;
  175.         String[] projection = {MediaStore.Images.Media.DATA};
  176.         Cursor cursor = resolver.query(originalUri, projection, null, null, null);
  177.         if (null != cursor) {
  178.             try {
  179.                 int column_index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
  180.                 cursor.moveToFirst();
  181.                 path = cursor.getString(column_index);
  182.             } catch (IllegalArgumentException e) {
  183.                 e.printStackTrace();
  184.             } finally {
  185.                 try {
  186.                     if (!cursor.isClosed()) {
  187.                         cursor.close();
  188.                     }
  189.                 } catch (Exception e) {
  190.                     e.printStackTrace();
  191.                 }
  192.             }
  193.         }
  194.         return StringUtils.isEmpty(path) ? originalUri.getPath() : null;
  195.     }
  197.     /**
  198.      * 获取拍照之后的照片文件（JPG格式）
  199.      *
  200.      * @param data     onActivityResult回调返回的数据
  201.      * @param filePath 文件路径
  202.      * @return 文件
  203.      */
  204.     public static File getTakePictureFile(Intent data, String filePath) {
  205.         if (data == null) return null;
  206.         Bundle extras = data.getExtras();
  207.         if (extras == null) return null;
  208.         Bitmap photo = extras.getParcelable("data");
  209.         File file = new File(filePath);
  210.         if (ImageUtils.save(photo, file, Bitmap.CompressFormat.JPEG)) return file;
  211.         return null;
  212.     }
  213. }

ConstUtils

  1. package com.blankj.utilcode.utils;
  3. /**
  4.  * <pre>
  5.  *     author: Blankj
  6.  *     blog  : http://blankj.com
  7.  *     time  : 2016/8/11
  8.  *     desc  : 常量相关工具类
  9.  * </pre>
  10.  */
  11. public class ConstUtils {
  13.     private ConstUtils() {
  14.         throw new UnsupportedOperationException("u can't fuck me...");
  15.     }
  17.     /******************** 存储相关常量 ********************/
  18.     /**
  19.      * Byte与Byte的倍数
  20.      */
  21.     public static final int BYTE = 1;
  22.     /**
  23.      * KB与Byte的倍数
  24.      */
  25.     public static final int KB = 1024;
  26.     /**
  27.      * MB与Byte的倍数
  28.      */
  29.     public static final int MB = 1048576;
  30.     /**
  31.      * GB与Byte的倍数
  32.      */
  33.     public static final int GB = 1073741824;
  35.     public enum MemoryUnit {
  36.         BYTE,
  37.         KB,
  38.         MB,
  39.         GB
  40.     }
  42.     /******************** 时间相关常量 ********************/
  43.     /**
  44.      * 毫秒与毫秒的倍数
  45.      */
  46.     public static final int MSEC = 1;
  47.     /**
  48.      * 秒与毫秒的倍数
  49.      */
  50.     public static final int SEC = 1000;
  51.     /**
  52.      * 分与毫秒的倍数
  53.      */
  54.     public static final int MIN = 60000;
  55.     /**
  56.      * 时与毫秒的倍数
  57.      */
  58.     public static final int HOUR = 3600000;
  59.     /**
  60.      * 天与毫秒的倍数
  61.      */
  62.     public static final int DAY = 86400000;
  64.     public enum TimeUnit {
  65.         MSEC,
  66.         SEC,
  67.         MIN,
  68.         HOUR,
  69.         DAY
  70.     }
  72.     /******************** 正则相关常量 ********************/
  73.     /**
  74.      * 正则：手机号（简单）
  75.      */
  76.     public static final String REGEX_MOBILE_SIMPLE = "^[1]\\d{10}$";
  77.     /**
  78.      * 正则：手机号（精确）
  79.      * <p>移动：134(0-8)、135、136、137、138、139、147、150、151、152、157、158、159、178、182、183、184、187、188</p>
  80.      * <p>联通：130、131、132、145、155、156、175、176、185、186</p>
  81.      * <p>电信：133、153、173、177、180、181、189</p>
  82.      * <p>全球星：1349</p>
  83.      * <p>虚拟运营商：170</p>
  84.      */
  85.     public static final String REGEX_MOBILE_EXACT = "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|(147))\\d{8}$";
  86.     /**
  87.      * 正则：电话号码
  88.      */
  89.     public static final String REGEX_TEL = "^0\\d{2,3}[- ]?\\d{7,8}";
  90.     /**
  91.      * 正则：身份证号码15位
  92.      */
  93.     public static final String REGEX_IDCARD15 = "^[1-9]\\d{7}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}$";
  94.     /**
  95.      * 正则：身份证号码18位
  96.      */
  97.     public static final String REGEX_IDCARD18 = "^[1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9Xx])$";
  98.     /**
  99.      * 正则：邮箱
  100.      */
  101.     public static final String REGEX_EMAIL = "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*$";
  102.     /**
  103.      * 正则：URL
  104.      */
  105.     public static final String REGEX_URL = "http(s)?://([\\w-]+\\.)+[\\w-]+(/[\\w-./?%&=]*)?";
  106.     /**
  107.      * 正则：汉字
  108.      */
  109.     public static final String REGEX_CHZ = "^[\\u4e00-\\u9fa5]+$";
  110.     /**
  111.      * 正则：用户名，取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位
  112.      */
  113.     public static final String REGEX_USERNAME = "^[\\w\\u4e00-\\u9fa5]{6,20}(?<!_)$";
  114.     /**
  115.      * 正则：yyyy-MM-dd格式的日期校验，已考虑平闰年
  116.      */
  117.     public static final String REGEX_DATE = "^(?:(?!0000)[0-9]{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1[0-9]|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:[0-9]{2}(?:0[48]|[2468][048]|[13579][26])|(?:0[48]|[2468][048]|[13579][26])00)-02-29)$";
  118.     /**
  119.      * 正则：IP地址
  120.      */
  121.     public static final String REGEX_IP = "((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)";
  122. }

ConvertUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.content.res.Resources;
  5. import android.graphics.Bitmap;
  6. import android.graphics.BitmapFactory;
  7. import android.graphics.drawable.BitmapDrawable;
  8. import android.graphics.drawable.Drawable;
  10. import java.io.ByteArrayInputStream;
  11. import java.io.ByteArrayOutputStream;
  12. import java.io.IOException;
  13. import java.io.InputStream;
  14. import java.io.OutputStream;
  15. import java.io.UnsupportedEncodingException;
  16. import java.util.Locale;
  18. import static com.blankj.utilcode.utils.ConstUtils.BYTE;
  19. import static com.blankj.utilcode.utils.ConstUtils.GB;
  20. import static com.blankj.utilcode.utils.ConstUtils.KB;
  21. import static com.blankj.utilcode.utils.ConstUtils.MB;
  23. /**
  24.  * <pre>
  25.  *     author: Blankj
  26.  *     blog  : http://blankj.com
  27.  *     time  : 2016/8/13
  28.  *     desc  : 转换相关工具类
  29.  * </pre>
  30.  */
  31. public class ConvertUtils {
  33.     static final char hexDigits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
  35.     /**
  36.      * byteArr转hexString
  37.      * <p>例如：</p>
  38.      * bytes2HexString(new byte[] { 0, (byte) 0xa8 }) returns 00A8
  39.      *
  40.      * @param bytes byte数组
  41.      * @return 16进制大写字符串
  42.      */
  43.     public static String bytes2HexString(byte[] bytes) {
  44.         char[] ret = new char[bytes.length << 1];
  45.         for (int i = 0, j = 0; i < bytes.length; i++) {
  46.             ret[j++] = hexDigits[bytes[i] >>> 4 & 0x0f];
  47.             ret[j++] = hexDigits[bytes[i] & 0x0f];
  48.         }
  49.         return new String(ret);
  50.     }
  52.     /**
  53.      * hexString转byteArr
  54.      * <p>例如：</p>
  55.      * hexString2Bytes("00A8") returns { 0, (byte) 0xA8 }
  56.      *
  57.      * @param hexString 十六进制字符串
  58.      * @return 字节数组
  59.      */
  60.     public static byte[] hexString2Bytes(String hexString) {
  61.         int len = hexString.length();
  62.         if (len % 2 != 0) {
  63.             throw new IllegalArgumentException("长度不是偶数");
  64.         }
  65.         char[] hexBytes = hexString.toUpperCase().toCharArray();
  66.         byte[] ret = new byte[len >>> 1];
  67.         for (int i = 0; i < len; i += 2) {
  68.             ret[i >> 1] = (byte) (hex2Dec(hexBytes[i]) << 4 | hex2Dec(hexBytes[i + 1]));
  69.         }
  70.         return ret;
  71.     }
  73.     /**
  74.      * hexChar转int
  75.      *
  76.      * @param hexChar hex单个字节
  77.      * @return 0..15
  78.      */
  79.     private static int hex2Dec(char hexChar) {
  80.         if (hexChar >= '0' && hexChar <= '9') {
  81.             return hexChar - '0';
  82.         } else if (hexChar >= 'A' && hexChar <= 'F') {
  83.             return hexChar - 'A' + 10;
  84.         } else {
  85.             throw new IllegalArgumentException();
  86.         }
  87.     }
  89.     /**
  90.      * charArr转byteArr
  91.      *
  92.      * @param chars 字符数组
  93.      * @return 字节数组
  94.      */
  95.     public static byte[] chars2Bytes(char[] chars) {
  96.         int len = chars.length;
  97.         byte[] bytes = new byte[len];
  98.         for (int i = 0; i < len; i++) {
  99.             bytes[i] = (byte) (chars[i]);
  100.         }
  101.         return bytes;
  102.     }
  104.     /**
  105.      * byteArr转charArr
  106.      *
  107.      * @param bytes 字节数组
  108.      * @return 字符数组
  109.      */
  110.     public static char[] bytes2Chars(byte[] bytes) {
  111.         int len = bytes.length;
  112.         char[] chars = new char[len];
  113.         for (int i = 0; i < len; i++) {
  114.             chars[i] = (char) (bytes[i] & 0xff);
  115.         }
  116.         return chars;
  117.     }
  119.     /**
  120.      * 字节数转以unit为单位的size
  121.      *
  122.      * @param byteNum 字节数
  123.      * @param unit    <ul>
  124.      *                <li>{@link ConstUtils.MemoryUnit#BYTE}: 字节</li>
  125.      *                <li>{@link ConstUtils.MemoryUnit#KB}  : 千字节</li>
  126.      *                <li>{@link ConstUtils.MemoryUnit#MB}  : 兆</li>
  127.      *                <li>{@link ConstUtils.MemoryUnit#GB}  : GB</li>
  128.      *                </ul>
  129.      * @return 以unit为单位的size
  130.      */
  131.     public static double byte2Size(long byteNum, ConstUtils.MemoryUnit unit) {
  132.         if (byteNum < 0) return -1;
  133.         switch (unit) {
  134.             default:
  135.             case BYTE:
  136.                 return (double) byteNum / BYTE;
  137.             case KB:
  138.                 return (double) byteNum / KB;
  139.             case MB:
  140.                 return (double) byteNum / MB;
  141.             case GB:
  142.                 return (double) byteNum / GB;
  143.         }
  144.     }
  146.     /**
  147.      * 以unit为单位的size转字节数
  148.      *
  149.      * @param size 大小
  150.      * @param unit <ul>
  151.      *             <li>{@link ConstUtils.MemoryUnit#BYTE}: 字节</li>
  152.      *             <li>{@link ConstUtils.MemoryUnit#KB}  : 千字节</li>
  153.      *             <li>{@link ConstUtils.MemoryUnit#MB}  : 兆</li>
  154.      *             <li>{@link ConstUtils.MemoryUnit#GB}  : GB</li>
  155.      *             </ul>
  156.      * @return 字节数
  157.      */
  158.     public static long size2Byte(long size, ConstUtils.MemoryUnit unit) {
  159.         if (size < 0) return -1;
  160.         switch (unit) {
  161.             default:
  162.             case BYTE:
  163.                 return size * BYTE;
  164.             case KB:
  165.                 return size * KB;
  166.             case MB:
  167.                 return size * MB;
  168.             case GB:
  169.                 return size * GB;
  170.         }
  171.     }
  173.     /**
  174.      * 字节数转合适大小
  175.      * <p>保留3位小数</p>
  176.      *
  177.      * @param byteNum 字节数
  178.      * @return 1...1024 unit
  179.      */
  180.     public static String byte2FitSize(long byteNum) {
  181.         if (byteNum < 0) {
  182.             return "shouldn't be less than zero!";
  183.         } else if (byteNum < KB) {
  184.             return String.format(Locale.getDefault(), "%.3fB", (double) byteNum);
  185.         } else if (byteNum < MB) {
  186.             return String.format(Locale.getDefault(), "%.3fKB", (double) byteNum / KB);
  187.         } else if (byteNum < GB) {
  188.             return String.format(Locale.getDefault(), "%.3fMB", (double) byteNum / MB);
  189.         } else {
  190.             return String.format(Locale.getDefault(), "%.3fGB", (double) byteNum / GB);
  191.         }
  192.     }
  194.     /**
  195.      * inputStream转outputStream
  196.      *
  197.      * @param is 输入流
  198.      * @return outputStream子类
  199.      */
  200.     public static ByteArrayOutputStream input2OutputStream(InputStream is) {
  201.         if (is == null) return null;
  202.         try {
  203.             ByteArrayOutputStream os = new ByteArrayOutputStream();
  204.             byte[] b = new byte[KB];
  205.             int len;
  206.             while ((len = is.read(b, 0, KB)) != -1) {
  207.                 os.write(b, 0, len);
  208.             }
  209.             return os;
  210.         } catch (IOException e) {
  211.             e.printStackTrace();
  212.             return null;
  213.         } finally {
  214.             FileUtils.closeIO(is);
  215.         }
  216.     }
  218.     /**
  219.      * outputStream转inputStream
  220.      *
  221.      * @param out 输出流
  222.      * @return inputStream子类
  223.      */
  224.     public ByteArrayInputStream output2InputStream(OutputStream out) {
  225.         if (out == null) return null;
  226.         return new ByteArrayInputStream(((ByteArrayOutputStream) out).toByteArray());
  227.     }
  229.     /**
  230.      * inputStream转byteArr
  231.      *
  232.      * @param is 输入流
  233.      * @return 字节数组
  234.      */
  235.     public static byte[] inputStream2Bytes(InputStream is) {
  236.         return input2OutputStream(is).toByteArray();
  237.     }
  239.     /**
  240.      * byteArr转inputStream
  241.      *
  242.      * @param bytes 字节数组
  243.      * @return 输入流
  244.      */
  245.     public static InputStream bytes2InputStream(byte[] bytes) {
  246.         return new ByteArrayInputStream(bytes);
  247.     }
  249.     /**
  250.      * outputStream转byteArr
  251.      *
  252.      * @param out 输出流
  253.      * @return 字节数组
  254.      */
  255.     public static byte[] outputStream2Bytes(OutputStream out) {
  256.         if (out == null) return null;
  257.         return ((ByteArrayOutputStream) out).toByteArray();
  258.     }
  260.     /**
  261.      * outputStream转byteArr
  262.      *
  263.      * @param bytes 字节数组
  264.      * @return 字节数组
  265.      */
  266.     public static OutputStream bytes2OutputStream(byte[] bytes) {
  267.         ByteArrayOutputStream os = null;
  268.         try {
  269.             os = new ByteArrayOutputStream();
  270.             os.write(bytes);
  271.             return os;
  272.         } catch (IOException e) {
  273.             e.printStackTrace();
  274.             return null;
  275.         } finally {
  276.             FileUtils.closeIO(os);
  277.         }
  278.     }
  280.     /**
  281.      * inputStream转string按编码
  282.      *
  283.      * @param is          输入流
  284.      * @param charsetName 编码格式
  285.      * @return 字符串
  286.      */
  287.     public static String inputStream2String(InputStream is, String charsetName) {
  288.         if (is == null || StringUtils.isSpace(charsetName)) return null;
  289.         try {
  290.             return new String(inputStream2Bytes(is), charsetName);
  291.         } catch (UnsupportedEncodingException e) {
  292.             e.printStackTrace();
  293.             return null;
  294.         }
  295.     }
  297.     /**
  298.      * string转inputStream按编码
  299.      *
  300.      * @param string      字符串
  301.      * @param charsetName 编码格式
  302.      * @return 输入流
  303.      */
  304.     public static InputStream string2InputStream(String string, String charsetName) {
  305.         if (string == null || StringUtils.isSpace(charsetName)) return null;
  306.         try {
  307.             return new ByteArrayInputStream(string.getBytes(charsetName));
  308.         } catch (UnsupportedEncodingException e) {
  309.             e.printStackTrace();
  310.             return null;
  311.         }
  312.     }
  314.     /**
  315.      * outputStream转string按编码
  316.      *
  317.      * @param out         输出流
  318.      * @param charsetName 编码格式
  319.      * @return 字符串
  320.      */
  321.     public static String outputStream2String(OutputStream out, String charsetName) {
  322.         if (out == null) return null;
  323.         try {
  324.             return new String(outputStream2Bytes(out), charsetName);
  325.         } catch (UnsupportedEncodingException e) {
  326.             e.printStackTrace();
  327.             return null;
  328.         }
  329.     }
  331.     /**
  332.      * string转outputStream按编码
  333.      *
  334.      * @param string      字符串
  335.      * @param charsetName 编码格式
  336.      * @return 输入流
  337.      */
  338.     public static OutputStream string2OutputStream(String string, String charsetName) {
  339.         if (string == null || StringUtils.isSpace(charsetName)) return null;
  340.         try {
  341.             return bytes2OutputStream(string.getBytes(charsetName));
  342.         } catch (UnsupportedEncodingException e) {
  343.             e.printStackTrace();
  344.             return null;
  345.         }
  346.     }
  348.     /**
  349.      * bitmap转byteArr
  350.      *
  351.      * @param bitmap bitmap对象
  352.      * @param format 格式
  353.      * @return 字节数组
  354.      */
  355.     public static byte[] bitmap2Bytes(Bitmap bitmap, Bitmap.CompressFormat format) {
  356.         if (bitmap == null) return null;
  357.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  358.         bitmap.compress(format, 100, baos);
  359.         return baos.toByteArray();
  360.     }
  362.     /**
  363.      * byteArr转bitmap
  364.      *
  365.      * @param bytes 字节数组
  366.      * @return bitmap对象
  367.      */
  368.     public static Bitmap bytes2Bitmap(byte[] bytes) {
  369.         return (bytes == null || bytes.length == 0) ? null : BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
  370.     }
  372.     /**
  373.      * drawable转bitmap
  374.      *
  375.      * @param drawable drawable对象
  376.      * @return bitmap对象
  377.      */
  378.     public static Bitmap drawable2Bitmap(Drawable drawable) {
  379.         return drawable == null ? null : ((BitmapDrawable) drawable).getBitmap();
  380.     }
  382.     /**
  383.      * bitmap转drawable
  384.      *
  385.      * @param res    resources对象
  386.      * @param bitmap bitmap对象
  387.      * @return drawable对象
  388.      */
  389.     public static Drawable bitmap2Drawable(Resources res, Bitmap bitmap) {
  390.         return bitmap == null ? null : new BitmapDrawable(res, bitmap);
  391.     }
  393.     /**
  394.      * drawable转byteArr
  395.      *
  396.      * @param drawable drawable对象
  397.      * @param format   格式
  398.      * @return 字节数组
  399.      */
  400.     public static byte[] drawable2Bytes(Drawable drawable, Bitmap.CompressFormat format) {
  401.         return bitmap2Bytes(drawable2Bitmap(drawable), format);
  402.     }
  404.     /**
  405.      * byteArr转drawable
  406.      *
  407.      * @param res   resources对象
  408.      * @param bytes 字节数组
  409.      * @return drawable对象
  410.      */
  411.     public static Drawable bytes2Drawable(Resources res, byte[] bytes) {
  412.         return bitmap2Drawable(res, bytes2Bitmap(bytes));
  413.     }
  415.     /**
  416.      * dp转px
  417.      *
  418.      * @param context 上下文
  419.      * @param dpValue dp值
  420.      * @return px值
  421.      */
  422.     public static int dp2px(Context context, float dpValue) {
  423.         final float scale = context.getResources().getDisplayMetrics().density;
  424.         return (int) (dpValue * scale + 0.5f);
  425.     }
  427.     /**
  428.      * px转dp
  429.      *
  430.      * @param context 上下文
  431.      * @param pxValue px值
  432.      * @return dp值
  433.      */
  434.     public static int px2dp(Context context, float pxValue) {
  435.         final float scale = context.getResources().getDisplayMetrics().density;
  436.         return (int) (pxValue / scale + 0.5f);
  437.     }
  439.     /**
  440.      * sp转px
  441.      *
  442.      * @param context 上下文
  443.      * @param spValue sp值
  444.      * @return px值
  445.      */
  446.     public static int sp2px(Context context, float spValue) {
  447.         final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
  448.         return (int) (spValue * fontScale + 0.5f);
  449.     }
  451.     /**
  452.      * px转sp
  453.      *
  454.      * @param context 上下文
  455.      * @param pxValue px值
  456.      * @return sp值
  457.      */
  458.     public static int px2sp(Context context, float pxValue) {
  459.         final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
  460.         return (int) (pxValue / fontScale + 0.5f);
  461.     }
  462. }

DeviceUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.net.wifi.WifiInfo;
  5. import android.net.wifi.WifiManager;
  6. import android.os.Build;
  8. import java.io.IOException;
  9. import java.io.InputStreamReader;
  10. import java.io.LineNumberReader;
  12. /**
  13.  * <pre>
  14.  *     author: Blankj
  15.  *     blog  : http://blankj.com
  16.  *     time  : 2016/8/1
  17.  *     desc  : 设备相关工具类
  18.  * </pre>
  19.  */
  20. public class DeviceUtils {
  22.     private DeviceUtils() {
  23.         throw new UnsupportedOperationException("u can't fuck me...");
  24.     }
  26.     /**
  27.      * 获取设备MAC地址
  28.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>}</p>
  29.      *
  30.      * @param context 上下文
  31.      * @return MAC地址
  32.      */
  33.     public static String getMacAddress(Context context) {
  34.         WifiManager wifi = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
  35.         WifiInfo info = wifi.getConnectionInfo();
  36.         if (info != null) {
  37.             String macAddress = info.getMacAddress();
  38.             if (macAddress != null) {
  39.                 return macAddress.replace(":", "");
  40.             }
  41.         }
  42.         return null;
  43.     }
  45.     /**
  46.      * 获取设备MAC地址
  47.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>}</p>
  48.      *
  49.      * @return MAC地址
  50.      */
  52.     public static String getMacAddress() {
  53.         String macAddress = null;
  54.         LineNumberReader lnr = null;
  55.         InputStreamReader isr = null;
  56.         try {
  57.             Process pp = Runtime.getRuntime().exec("cat /sys/class/net/wlan0/address");
  58.             isr = new InputStreamReader(pp.getInputStream());
  59.             lnr = new LineNumberReader(isr);
  60.             macAddress = lnr.readLine().replace(":", "");
  61.         } catch (IOException e) {
  62.             e.printStackTrace();
  63.         } finally {
  64.             FileUtils.closeIO(lnr, isr);
  65.         }
  66.         return macAddress == null ? "" : macAddress;
  67.     }
  69.     /**
  70.      * 获取设备厂商，如Xiaomi
  71.      *
  72.      * @return 设备厂商
  73.      */
  74.     public static String getManufacturer() {
  75.         return Build.MANUFACTURER;
  76.     }
  78.     /**
  79.      * 获取设备型号，如MI2SC
  80.      *
  81.      * @return 设备型号
  82.      */
  83.     public static String getModel() {
  84.         String model = Build.MODEL;
  85.         if (model != null) {
  86.             model = model.trim().replaceAll("\\s*", "");
  87.         } else {
  88.             model = "";
  89.         }
  90.         return model;
  91.     }
  92. }

EncodeUtils

  1. package com.blankj.utilcode.utils;
  3. import android.os.Build;
  4. import android.text.Html;
  5. import android.util.Base64;
  7. import java.io.UnsupportedEncodingException;
  8. import java.net.URLDecoder;
  9. import java.net.URLEncoder;
  11. /**
  12.  * <pre>
  13.  *     author: Blankj
  14.  *     blog  : http://blankj.com
  15.  *     time  : 2016/8/7
  16.  *     desc  : 编码解码相关工具类
  17.  * </pre>
  18.  */
  19. public class EncodeUtils {
  21.     private EncodeUtils() {
  22.         throw new UnsupportedOperationException("u can't fuck me...");
  23.     }
  25.     /**
  26.      * URL编码
  27.      * <p>若想自己指定字符集,可以使用{@link #urlEncode(String input, String charset)}方法</p>
  28.      *
  29.      * @param input 要编码的字符
  30.      * @return 编码为UTF-8的字符串
  31.      */
  32.     public static String urlEncode(String input) {
  33.         return urlEncode(input, "UTF-8");
  34.     }
  36.     /**
  37.      * URL编码
  38.      * <p>若系统不支持指定的编码字符集,则直接将input原样返回</p>
  39.      *
  40.      * @param input   要编码的字符
  41.      * @param charset 字符集
  42.      * @return 编码为字符集的字符串
  43.      */
  44.     public static String urlEncode(String input, String charset) {
  45.         try {
  46.             return URLEncoder.encode(input, charset);
  47.         } catch (UnsupportedEncodingException e) {
  48.             return input;
  49.         }
  50.     }
  52.     /**
  53.      * URL解码
  54.      * <p>若想自己指定字符集,可以使用 {@link #urlDecode(String input, String charset)}方法</p>
  55.      *
  56.      * @param input 要解码的字符串
  57.      * @return URL解码后的字符串
  58.      */
  59.     public static String urlDecode(String input) {
  60.         return urlDecode(input, "UTF-8");
  61.     }
  63.     /**
  64.      * URL解码
  65.      * <p>若系统不支持指定的解码字符集,则直接将input原样返回</p>
  66.      *
  67.      * @param input   要解码的字符串
  68.      * @param charset 字符集
  69.      * @return URL解码为指定字符集的字符串
  70.      */
  71.     public static String urlDecode(String input, String charset) {
  72.         try {
  73.             return URLDecoder.decode(input, charset);
  74.         } catch (UnsupportedEncodingException e) {
  75.             return input;
  76.         }
  77.     }
  79.     /**
  80.      * Base64编码
  81.      *
  82.      * @param input 要编码的字符串
  83.      * @return Base64编码后的字符串
  84.      */
  85.     public static byte[] base64Encode(String input) {
  86.         return base64Encode(input.getBytes());
  87.     }
  89.     /**
  90.      * Base64编码
  91.      *
  92.      * @param input 要编码的字节数组
  93.      * @return Base64编码后的字符串
  94.      */
  95.     public static byte[] base64Encode(byte[] input) {
  96.         return Base64.encode(input, Base64.NO_WRAP);
  97.     }
  99.     /**
  100.      * Base64编码
  101.      *
  102.      * @param input 要编码的字节数组
  103.      * @return Base64编码后的字符串
  104.      */
  105.     public static String base64Encode2String(byte[] input) {
  106.         return Base64.encodeToString(input, Base64.NO_WRAP);
  107.     }
  109.     /**
  110.      * Base64解码
  111.      *
  112.      * @param input 要解码的字符串
  113.      * @return Base64解码后的字符串
  114.      */
  115.     public static byte[] base64Decode(String input) {
  116.         return Base64.decode(input, Base64.NO_WRAP);
  117.     }
  119.     /**
  120.      * Base64解码
  121.      *
  122.      * @param input 要解码的字符串
  123.      * @return Base64解码后的字符串
  124.      */
  125.     public static byte[] base64Decode(byte[] input) {
  126.         return Base64.decode(input, Base64.NO_WRAP);
  127.     }
  129.     /**
  130.      * Base64URL安全编码
  131.      * <p>将Base64中的URL非法字符�?,/=转为其他字符, 见RFC3548</p>
  132.      *
  133.      * @param input 要Base64URL安全编码的字符串
  134.      * @return Base64URL安全编码后的字符串
  135.      */
  136.     public static byte[] base64UrlSafeEncode(String input) {
  137.         return Base64.encode(input.getBytes(), Base64.URL_SAFE);
  138.     }
  140.     /**
  141.      * Html编码
  142.      *
  143.      * @param input 要Html编码的字符串
  144.      * @return Html编码后的字符串
  145.      */
  146.     public static String htmlEncode(String input) {
  147.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) {
  148.             return Html.escapeHtml(input);
  149.         } else {
  150.             // 参照Html.escapeHtml()中代码
  151.             StringBuilder out = new StringBuilder();
  152.             for (int i = 0, len = input.length(); i < len; i++) {
  153.                 char c = input.charAt(i);
  154.                 if (c == '<') {
  155.                     out.append("&lt;");
  156.                 } else if (c == '>') {
  157.                     out.append("&gt;");
  158.                 } else if (c == '&') {
  159.                     out.append("&amp;");
  160.                 } else if (c >= 0xD800 && c <= 0xDFFF) {
  161.                     if (c < 0xDC00 && i + 1 < len) {
  162.                         char d = input.charAt(i + 1);
  163.                         if (d >= 0xDC00 && d <= 0xDFFF) {
  164.                             i++;
  165.                             int codepoint = 0x010000 | (int) c - 0xD800 << 10 | (int) d - 0xDC00;
  166.                             out.append("&#").append(codepoint).append(";");
  167.                         }
  168.                     }
  169.                 } else if (c > 0x7E || c < ' ') {
  170.                     out.append("&#").append((int) c).append(";");
  171.                 } else if (c == ' ') {
  172.                     while (i + 1 < len && input.charAt(i + 1) == ' ') {
  173.                         out.append("&nbsp;");
  174.                         i++;
  175.                     }
  176.                     out.append(' ');
  177.                 } else {
  178.                     out.append(c);
  179.                 }
  180.             }
  181.             return out.toString();
  182.         }
  183.     }
  185.     /**
  186.      * Html解码
  187.      *
  188.      * @param input 待解码的字符串
  189.      * @return Html解码后的字符串
  190.      */
  191.     public static String htmlDecode(String input) {
  192.         return Html.fromHtml(input).toString();
  193.     }
  194. }

EncryptUtils

  1. package com.blankj.utilcode.utils;
  3. import java.io.File;
  4. import java.io.FileInputStream;
  5. import java.io.IOException;
  6. import java.nio.MappedByteBuffer;
  7. import java.nio.channels.FileChannel;
  8. import java.security.MessageDigest;
  9. import java.security.NoSuchAlgorithmException;
  10. import java.security.SecureRandom;
  12. import javax.crypto.Cipher;
  13. import javax.crypto.spec.SecretKeySpec;
  15. import static com.blankj.utilcode.utils.ConvertUtils.*;
  17. /**
  18.  * <pre>
  19.  *     author: Blankj
  20.  *     blog  : http://blankj.com
  21.  *     time  : 2016/8/2
  22.  *     desc  : 加密解密相关的工具类
  23.  * </pre>
  24.  */
  25. public class EncryptUtils {
  27.     private EncryptUtils() {
  28.         throw new UnsupportedOperationException("u can't fuck me...");
  29.     }
  31.     /*********************** 哈希加密相关 ***********************/
  32.     /**
  33.      * MD2加密
  34.      *
  35.      * @param data 明文字符串
  36.      * @return 16进制密文
  37.      */
  38.     public static String encryptMD2ToString(String data) {
  39.         return encryptMD2ToString(data.getBytes());
  40.     }
  42.     /**
  43.      * MD2加密
  44.      *
  45.      * @param data 明文字节数组
  46.      * @return 16进制密文
  47.      */
  48.     public static String encryptMD2ToString(byte[] data) {
  49.         return bytes2HexString(encryptMD2(data));
  50.     }
  52.     /**
  53.      * MD2加密
  54.      *
  55.      * @param data 明文字节数组
  56.      * @return 密文字节数组
  57.      */
  58.     public static byte[] encryptMD2(byte[] data) {
  59.         return encryptAlgorithm(data, "MD2");
  60.     }
  62.     /**
  63.      * MD5加密
  64.      *
  65.      * @param data 明文字符串
  66.      * @return 16进制密文
  67.      */
  68.     public static String encryptMD5ToString(String data) {
  69.         return encryptMD5ToString(data.getBytes());
  70.     }
  72.     /**
  73.      * MD5加密
  74.      *
  75.      * @param data 明文字符串
  76.      * @param salt 盐
  77.      * @return 16进制加盐密文
  78.      */
  79.     public static String encryptMD5ToString(String data, String salt) {
  80.         return bytes2HexString(encryptMD5((data + salt).getBytes()));
  81.     }
  83.     /**
  84.      * MD5加密
  85.      *
  86.      * @param data 明文字节数组
  87.      * @return 16进制密文
  88.      */
  89.     public static String encryptMD5ToString(byte[] data) {
  90.         return bytes2HexString(encryptMD5(data));
  91.     }
  93.     /**
  94.      * MD5加密
  95.      *
  96.      * @param data 明文字节数组
  97.      * @param salt 盐字节数组
  98.      * @return 16进制加盐密文
  99.      */
  100.     public static String encryptMD5ToString(byte[] data, byte[] salt) {
  101.         byte[] dataSalt = new byte[data.length + salt.length];
  102.         System.arraycopy(data, 0, dataSalt, 0, data.length);
  103.         System.arraycopy(salt, 0, dataSalt, data.length, salt.length);
  104.         return bytes2HexString(encryptMD5(dataSalt));
  105.     }
  107.     /**
  108.      * MD5加密
  109.      *
  110.      * @param data 明文字节数组
  111.      * @return 密文字节数组
  112.      */
  113.     public static byte[] encryptMD5(byte[] data) {
  114.         return encryptAlgorithm(data, "MD5");
  115.     }
  117.     /**
  118.      * MD5加密文件
  119.      *
  120.      * @param filePath 文件路径
  121.      * @return 文件的16进制密文
  122.      */
  123.     public static String encryptMD5File2String(String filePath) {
  124.         return encryptMD5File2String(new File(filePath));
  125.     }
  127.     /**
  128.      * MD5加密文件
  129.      *
  130.      * @param filePath 文件路径
  131.      * @return 文件的MD5校验码
  132.      */
  133.     public static byte[] encryptMD5File(String filePath) {
  134.         return encryptMD5File(new File(filePath));
  135.     }
  137.     /**
  138.      * MD5加密文件
  139.      *
  140.      * @param file 文件
  141.      * @return 文件的16进制密文
  142.      */
  143.     public static String encryptMD5File2String(File file) {
  144.         return encryptMD5File(file) != null ? bytes2HexString(encryptMD5File(file)) : "";
  145.     }
  147.     /**
  148.      * MD5加密文件
  149.      *
  150.      * @param file 文件
  151.      * @return 文件的MD5校验码
  152.      */
  153.     public static byte[] encryptMD5File(File file) {
  154.         FileInputStream fis = null;
  155.         try {
  156.             fis = new FileInputStream(file);
  157.             FileChannel channel = fis.getChannel();
  158.             MappedByteBuffer buffer = channel.map(FileChannel.MapMode.READ_ONLY, 0, file.length());
  159.             MessageDigest md = MessageDigest.getInstance("MD5");
  160.             md.update(buffer);
  161.             return md.digest();
  162.         } catch (NoSuchAlgorithmException | IOException e) {
  163.             e.printStackTrace();
  164.         } finally {
  165.             FileUtils.closeIO(fis);
  166.         }
  167.         return null;
  168.     }
  170.     /**
  171.      * SHA1加密
  172.      *
  173.      * @param data 明文字符串
  174.      * @return 16进制密文
  175.      */
  176.     public static String encryptSHA1ToString(String data) {
  177.         return encryptSHA1ToString(data.getBytes());
  178.     }
  180.     /**
  181.      * SHA1加密
  182.      *
  183.      * @param data 明文字节数组
  184.      * @return 16进制密文
  185.      */
  186.     public static String encryptSHA1ToString(byte[] data) {
  187.         return bytes2HexString(encryptSHA1(data));
  188.     }
  190.     /**
  191.      * SHA1加密
  192.      *
  193.      * @param data 明文字节数组
  194.      * @return 密文字节数组
  195.      */
  196.     public static byte[] encryptSHA1(byte[] data) {
  197.         return encryptAlgorithm(data, "SHA-1");
  198.     }
  200.     /**
  201.      * SHA224加密
  202.      *
  203.      * @param data 明文字符串
  204.      * @return 16进制密文
  205.      */
  206.     public static String encryptSHA224ToString(String data) {
  207.         return encryptSHA224ToString(data.getBytes());
  208.     }
  210.     /**
  211.      * SHA224加密
  212.      *
  213.      * @param data 明文字节数组
  214.      * @return 16进制密文
  215.      */
  216.     public static String encryptSHA224ToString(byte[] data) {
  217.         return bytes2HexString(encryptSHA224(data));
  218.     }
  220.     /**
  221.      * SHA224加密
  222.      *
  223.      * @param data 明文字节数组
  224.      * @return 密文字节数组
  225.      */
  226.     public static byte[] encryptSHA224(byte[] data) {
  227.         return encryptAlgorithm(data, "SHA-224");
  228.     }
  230.     /**
  231.      * SHA256加密
  232.      *
  233.      * @param data 明文字符串
  234.      * @return 16进制密文
  235.      */
  236.     public static String encryptSHA256ToString(String data) {
  237.         return encryptSHA256ToString(data.getBytes());
  238.     }
  240.     /**
  241.      * SHA256加密
  242.      *
  243.      * @param data 明文字节数组
  244.      * @return 16进制密文
  245.      */
  246.     public static String encryptSHA256ToString(byte[] data) {
  247.         return bytes2HexString(encryptSHA256(data));
  248.     }
  250.     /**
  251.      * SHA256加密
  252.      *
  253.      * @param data 明文字节数组
  254.      * @return 密文字节数组
  255.      */
  256.     public static byte[] encryptSHA256(byte[] data) {
  257.         return encryptAlgorithm(data, "SHA-256");
  258.     }
  260.     /**
  261.      * SHA384加密
  262.      *
  263.      * @param data 明文字符串
  264.      * @return 16进制密文
  265.      */
  266.     public static String encryptSHA384ToString(String data) {
  267.         return encryptSHA384ToString(data.getBytes());
  268.     }
  270.     /**
  271.      * SHA384加密
  272.      *
  273.      * @param data 明文字节数组
  274.      * @return 16进制密文
  275.      */
  276.     public static String encryptSHA384ToString(byte[] data) {
  277.         return bytes2HexString(encryptSHA384(data));
  278.     }
  280.     /**
  281.      * SHA384加密
  282.      *
  283.      * @param data 明文字节数组
  284.      * @return 密文字节数组
  285.      */
  286.     public static byte[] encryptSHA384(byte[] data) {
  287.         return encryptAlgorithm(data, "SHA-384");
  288.     }
  290.     /**
  291.      * SHA512加密
  292.      *
  293.      * @param data 明文字符串
  294.      * @return 16进制密文
  295.      */
  296.     public static String encryptSHA512ToString(String data) {
  297.         return encryptSHA512ToString(data.getBytes());
  298.     }
  300.     /**
  301.      * SHA512加密
  302.      *
  303.      * @param data 明文字节数组
  304.      * @return 16进制密文
  305.      */
  306.     public static String encryptSHA512ToString(byte[] data) {
  307.         return bytes2HexString(encryptSHA512(data));
  308.     }
  310.     /**
  311.      * SHA512加密
  312.      *
  313.      * @param data 明文字节数组
  314.      * @return 密文字节数组
  315.      */
  316.     public static byte[] encryptSHA512(byte[] data) {
  317.         return encryptAlgorithm(data, "SHA-512");
  318.     }
  320.     /**
  321.      * 对data进行algorithm算法加密
  322.      *
  323.      * @param data      明文字节数组
  324.      * @param algorithm 加密算法
  325.      * @return 密文字节数组
  326.      */
  327.     private static byte[] encryptAlgorithm(byte[] data, String algorithm) {
  328.         try {
  329.             MessageDigest md = MessageDigest.getInstance(algorithm);
  330.             md.update(data);
  331.             return md.digest();
  332.         } catch (NoSuchAlgorithmException e) {
  333.             e.printStackTrace();
  334.         }
  335.         return new byte[0];
  336.     }
  338.     /************************ DES加密相关 ***********************/
  339.     /**
  340.      * DES转变
  341.      * <p>法算法名称/加密模式/填充方式</p>
  342.      * <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
  343.      * <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
  344.      */
  345.     public static String DES_Transformation = "DES/ECB/NoPadding";
  346.     private static final String DES_Algorithm = "DES";
  348.     /**
  349.      * @param data           数据
  350.      * @param key            秘钥
  351.      * @param algorithm      采用何种DES算法
  352.      * @param transformation 转变
  353.      * @param isEncrypt      是否加密
  354.      * @return 密文或者明文，适用于DES，3DES，AES
  355.      */
  356.     public static byte[] DESTemplet(byte[] data, byte[] key, String algorithm, String transformation, boolean isEncrypt) {
  357.         try {
  358.             SecretKeySpec keySpec = new SecretKeySpec(key, algorithm);
  359.             Cipher cipher = Cipher.getInstance(transformation);
  360.             SecureRandom random = new SecureRandom();
  361.             cipher.init(isEncrypt ? Cipher.ENCRYPT_MODE : Cipher.DECRYPT_MODE, keySpec, random);
  362.             return cipher.doFinal(data);
  363.         } catch (Throwable e) {
  364.             e.printStackTrace();
  365.         }
  366.         return null;
  367.     }
  369.     /**
  370.      * DES加密后转为Base64编码
  371.      *
  372.      * @param data 明文
  373.      * @param key  8字节秘钥
  374.      * @return Base64密文
  375.      */
  376.     public static byte[] encryptDES2Base64(byte[] data, byte[] key) {
  377.         return EncodeUtils.base64Encode(encryptDES(data, key));
  378.     }
  380.     /**
  381.      * DES加密后转为16进制
  382.      *
  383.      * @param data 明文
  384.      * @param key  8字节秘钥
  385.      * @return 16进制密文
  386.      */
  387.     public static String encryptDES2HexString(byte[] data, byte[] key) {
  388.         return bytes2HexString(encryptDES(data, key));
  389.     }
  391.     /**
  392.      * DES加密
  393.      *
  394.      * @param data 明文
  395.      * @param key  8字节秘钥
  396.      * @return 密文
  397.      */
  398.     public static byte[] encryptDES(byte[] data, byte[] key) {
  399.         return DESTemplet(data, key, DES_Algorithm, DES_Transformation, true);
  400.     }
  402.     /**
  403.      * DES解密Base64编码密文
  404.      *
  405.      * @param data Base64编码密文
  406.      * @param key  8字节秘钥
  407.      * @return 明文
  408.      */
  409.     public static byte[] decryptBase64DES(byte[] data, byte[] key) {
  410.         return decryptDES(EncodeUtils.base64Decode(data), key);
  411.     }
  413.     /**
  414.      * DES解密16进制密文
  415.      *
  416.      * @param data 16进制密文
  417.      * @param key  8字节秘钥
  418.      * @return 明文
  419.      */
  420.     public static byte[] decryptHexStringDES(String data, byte[] key) {
  421.         return decryptDES(hexString2Bytes(data), key);
  422.     }
  424.     /**
  425.      * DES解密
  426.      *
  427.      * @param data 密文
  428.      * @param key  8字节秘钥
  429.      * @return 明文
  430.      */
  431.     public static byte[] decryptDES(byte[] data, byte[] key) {
  432.         return DESTemplet(data, key, DES_Algorithm, DES_Transformation, false);
  433.     }
  435.     /************************ 3DES加密相关 ***********************/
  436.     /**
  437.      * 3DES转变
  438.      * <p>法算法名称/加密模式/填充方式</p>
  439.      * <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
  440.      * <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
  441.      */
  442.     public static String TripleDES_Transformation = "DESede/ECB/NoPadding";
  443.     private static final String TripleDES_Algorithm = "DESede";
  446.     /**
  447.      * 3DES加密后转为Base64编码
  448.      *
  449.      * @param data 明文
  450.      * @param key  24字节秘钥
  451.      * @return Base64密文
  452.      */
  453.     public static byte[] encrypt3DES2Base64(byte[] data, byte[] key) {
  454.         return EncodeUtils.base64Encode(encrypt3DES(data, key));
  455.     }
  457.     /**
  458.      * 3DES加密后转为16进制
  459.      *
  460.      * @param data 明文
  461.      * @param key  24字节秘钥
  462.      * @return 16进制密文
  463.      */
  464.     public static String encrypt3DES2HexString(byte[] data, byte[] key) {
  465.         return bytes2HexString(encrypt3DES(data, key));
  466.     }
  468.     /**
  469.      * 3DES加密
  470.      *
  471.      * @param data 明文
  472.      * @param key  24字节密钥
  473.      * @return 密文
  474.      */
  475.     public static byte[] encrypt3DES(byte[] data, byte[] key) {
  476.         return DESTemplet(data, key, TripleDES_Algorithm, TripleDES_Transformation, true);
  477.     }
  479.     /**
  480.      * 3DES解密Base64编码密文
  481.      *
  482.      * @param data Base64编码密文
  483.      * @param key  24字节秘钥
  484.      * @return 明文
  485.      */
  486.     public static byte[] decryptBase64_3DES(byte[] data, byte[] key) {
  487.         return decrypt3DES(EncodeUtils.base64Decode(data), key);
  488.     }
  490.     /**
  491.      * 3DES解密16进制密文
  492.      *
  493.      * @param data 16进制密文
  494.      * @param key  24字节秘钥
  495.      * @return 明文
  496.      */
  497.     public static byte[] decryptHexString3DES(String data, byte[] key) {
  498.         return decrypt3DES(hexString2Bytes(data), key);
  499.     }
  501.     /**
  502.      * 3DES解密
  503.      *
  504.      * @param data 密文
  505.      * @param key  24字节密钥
  506.      * @return 明文
  507.      */
  508.     public static byte[] decrypt3DES(byte[] data, byte[] key) {
  509.         return DESTemplet(data, key, TripleDES_Algorithm, TripleDES_Transformation, false);
  510.     }
  512.     /************************ AES加密相关 ***********************/
  513.     /**
  514.      * AES转变
  515.      * <p>法算法名称/加密模式/填充方式</p>
  516.      * <p>加密模式有：电子密码本模式ECB、加密块链模式CBC、加密反馈模式CFB、输出反馈模式OFB</p>
  517.      * <p>填充方式有：NoPadding、ZerosPadding、PKCS5Padding</p>
  518.      */
  519.     public static String AES_Transformation = "AES/ECB/NoPadding";
  520.     private static final String AES_Algorithm = "AES";
  523.     /**
  524.      * AES加密后转为Base64编码
  525.      *
  526.      * @param data 明文
  527.      * @param key  16、24、32字节秘钥
  528.      * @return Base64密文
  529.      */
  530.     public static byte[] encryptAES2Base64(byte[] data, byte[] key) {
  531.         return EncodeUtils.base64Encode(encryptAES(data, key));
  532.     }
  534.     /**
  535.      * AES加密后转为16进制
  536.      *
  537.      * @param data 明文
  538.      * @param key  16、24、32字节秘钥
  539.      * @return 16进制密文
  540.      */
  541.     public static String encryptAES2HexString(byte[] data, byte[] key) {
  542.         return bytes2HexString(encryptAES(data, key));
  543.     }
  545.     /**
  546.      * AES加密
  547.      *
  548.      * @param data 明文
  549.      * @param key  16、24、32字节秘钥
  550.      * @return 密文
  551.      */
  552.     public static byte[] encryptAES(byte[] data, byte[] key) {
  553.         return DESTemplet(data, key, AES_Algorithm, AES_Transformation, true);
  554.     }
  556.     /**
  557.      * AES解密Base64编码密文
  558.      *
  559.      * @param data Base64编码密文
  560.      * @param key  16、24、32字节秘钥
  561.      * @return 明文
  562.      */
  563.     public static byte[] decryptBase64AES(byte[] data, byte[] key) {
  564.         return decryptAES(EncodeUtils.base64Decode(data), key);
  565.     }
  567.     /**
  568.      * AES解密16进制密文
  569.      *
  570.      * @param data 16进制密文
  571.      * @param key  16、24、32字节秘钥
  572.      * @return 明文
  573.      */
  574.     public static byte[] decryptHexStringAES(String data, byte[] key) {
  575.         return decryptAES(hexString2Bytes(data), key);
  576.     }
  578.     /**
  579.      * AES解密
  580.      *
  581.      * @param data 密文
  582.      * @param key  16、24、32字节秘钥
  583.      * @return 明文
  584.      */
  585.     public static byte[] decryptAES(byte[] data, byte[] key) {
  586.         return DESTemplet(data, key, AES_Algorithm, AES_Transformation, false);
  587.     }
  588. }

FileUtils

  1. package com.blankj.utilcode.utils;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.BufferedReader;
  6. import java.io.Closeable;
  7. import java.io.File;
  8. import java.io.FileInputStream;
  9. import java.io.FileNotFoundException;
  10. import java.io.FileOutputStream;
  11. import java.io.FileReader;
  12. import java.io.FileWriter;
  13. import java.io.FilenameFilter;
  14. import java.io.IOException;
  15. import java.io.InputStream;
  16. import java.io.InputStreamReader;
  17. import java.io.OutputStream;
  18. import java.util.ArrayList;
  19. import java.util.Collections;
  20. import java.util.List;
  22. import static com.blankj.utilcode.utils.ConstUtils.*;
  24. /**
  25.  * <pre>
  26.  *     author: Blankj
  27.  *     blog  : http://blankj.com
  28.  *     time  : 2016/8/11
  29.  *     desc  : 文件相关工具类
  30.  * </pre>
  31.  */
  32. public class FileUtils {
  34.     private FileUtils() {
  35.         throw new UnsupportedOperationException("u can't fuck me...");
  36.     }
  38.     /**
  39.      * 根据文件路径获取文件
  40.      *
  41.      * @param filePath 文件路径
  42.      * @return 文件
  43.      */
  44.     public static File getFileByPath(String filePath) {
  45.         return StringUtils.isSpace(filePath) ? null : new File(filePath);
  46.     }
  48.     /**
  49.      * 判断文件是否存在
  50.      *
  51.      * @param filePath 文件路径
  52.      * @return {@code true}: 存在<br>{@code false}: 不存在
  53.      */
  54.     public static boolean isFileExists(String filePath) {
  55.         return isFileExists(getFileByPath(filePath));
  56.     }
  58.     /**
  59.      * 判断文件是否存在
  60.      *
  61.      * @param file 文件
  62.      * @return {@code true}: 存在<br>{@code false}: 不存在
  63.      */
  64.     public static boolean isFileExists(File file) {
  65.         return file != null && file.exists();
  66.     }
  68.     /**
  69.      * 判断是否是目录
  70.      *
  71.      * @param dirPath 目录路径
  72.      * @return {@code true}: 是<br>{@code false}: 否
  73.      */
  74.     public static boolean isDir(String dirPath) {
  75.         return isDir(getFileByPath(dirPath));
  76.     }
  78.     /**
  79.      * 判断是否是目录
  80.      *
  81.      * @param file 文件
  82.      * @return {@code true}: 是<br>{@code false}: 否
  83.      */
  84.     public static boolean isDir(File file) {
  85.         return isFileExists(file) && file.isDirectory();
  86.     }
  88.     /**
  89.      * 判断是否是文件
  90.      *
  91.      * @param filePath 文件路径
  92.      * @return {@code true}: 是<br>{@code false}: 否
  93.      */
  94.     public static boolean isFile(String filePath) {
  95.         return isFile(getFileByPath(filePath));
  96.     }
  98.     /**
  99.      * 判断是否是文件
  100.      *
  101.      * @param file 文件
  102.      * @return {@code true}: 是<br>{@code false}: 否
  103.      */
  104.     public static boolean isFile(File file) {
  105.         return isFileExists(file) && file.isFile();
  106.     }
  108.     /**
  109.      * 判断目录是否存在，不存在则判断是否创建成功
  110.      *
  111.      * @param dirPath 文件路径
  112.      * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
  113.      */
  114.     public static boolean createOrExistsDir(String dirPath) {
  115.         return createOrExistsDir(getFileByPath(dirPath));
  116.     }
  118.     /**
  119.      * 判断目录是否存在，不存在则判断是否创建成功
  120.      *
  121.      * @param file 文件
  122.      * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
  123.      */
  124.     public static boolean createOrExistsDir(File file) {
  125.         // 如果存在，是目录则返回true，是文件则返回false，不存在则返回是否创建成功
  126.         return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
  127.     }
  129.     /**
  130.      * 判断文件是否存在，不存在则判断是否创建成功
  131.      *
  132.      * @param filePath 文件路径
  133.      * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
  134.      */
  135.     public static boolean createOrExistsFile(String filePath) {
  136.         return createOrExistsFile(getFileByPath(filePath));
  137.     }
  139.     /**
  140.      * 判断文件是否存在，不存在则判断是否创建成功
  141.      *
  142.      * @param file 文件
  143.      * @return {@code true}: 存在或创建成功<br>{@code false}: 不存在或创建失败
  144.      */
  145.     public static boolean createOrExistsFile(File file) {
  146.         if (file == null) return false;
  147.         // 如果存在，是文件则返回true，是目录则返回false
  148.         if (file.exists()) return file.isFile();
  149.         if (!createOrExistsDir(file.getParentFile())) return false;
  150.         try {
  151.             return file.createNewFile();
  152.         } catch (IOException e) {
  153.             e.printStackTrace();
  154.             return false;
  155.         }
  156.     }
  158.     /**
  159.      * 判断文件是否存在，存在则在创建之前删除
  160.      *
  161.      * @param filePath 文件路径
  162.      * @return {@code true}: 创建成功<br>{@code false}: 创建失败
  163.      */
  164.     public static boolean createFileByDeleteOldFile(String filePath) {
  165.         return createFileByDeleteOldFile(getFileByPath(filePath));
  166.     }
  168.     /**
  169.      * 判断文件是否存在，存在则在创建之前删除
  170.      *
  171.      * @param file 文件
  172.      * @return {@code true}: 创建成功<br>{@code false}: 创建失败
  173.      */
  174.     public static boolean createFileByDeleteOldFile(File file) {
  175.         if (file == null) return false;
  176.         // 文件存在并且删除失败返回false
  177.         if (file.exists() && file.isFile() && !file.delete()) return false;
  178.         // 创建目录失败返回false
  179.         if (!createOrExistsDir(file.getParentFile())) return false;
  180.         try {
  181.             return file.createNewFile();
  182.         } catch (IOException e) {
  183.             e.printStackTrace();
  184.             return false;
  185.         }
  186.     }
  188.     /**
  189.      * 复制或移动目录
  190.      *
  191.      * @param srcDirPath  源目录路径
  192.      * @param destDirPath 目标目录路径
  193.      * @param isMove      是否移动
  194.      * @return {@code true}: 复制或移动成功<br>{@code false}: 复制或移动失败
  195.      */
  196.     private static boolean copyOrMoveDir(String srcDirPath, String destDirPath, boolean isMove) {
  197.         return copyOrMoveDir(getFileByPath(srcDirPath), getFileByPath(destDirPath), isMove);
  198.     }
  200.     /**
  201.      * 复制或移动目录
  202.      *
  203.      * @param srcDir  源目录
  204.      * @param destDir 目标目录
  205.      * @param isMove  是否移动
  206.      * @return {@code true}: 复制或移动成功<br>{@code false}: 复制或移动失败
  207.      */
  208.     private static boolean copyOrMoveDir(File srcDir, File destDir, boolean isMove) {
  209.         if (srcDir == null || destDir == null) return false;
  210.         // 如果目标目录在源目录中则返回false，看不懂的话好好想想递归怎么结束
  211.         // srcPath : F:\\MyGithub\\AndroidUtilCode\\utilcode\\src\\test\\res
  212.         // destPath: F:\\MyGithub\\AndroidUtilCode\\utilcode\\src\\test\\res1
  213.         // 为防止以上这种情况出现出现误判，须分别在后面加个路径分隔符
  214.         String srcPath = srcDir.getPath() + File.separator;
  215.         String destPath = destDir.getPath() + File.separator;
  216.         if (destPath.contains(srcPath)) return false;
  217.         // 源文件不存在或者不是目录则返回false
  218.         if (!srcDir.exists() || !srcDir.isDirectory()) return false;
  219.         // 目标目录不存在返回false
  220.         if (!createOrExistsDir(destDir)) return false;
  221.         File[] files = srcDir.listFiles();
  222.         for (File file : files) {
  223.             File oneDestFile = new File(destPath + file.getName());
  224.             if (file.isFile()) {
  225.                 // 如果操作失败返回false
  226.                 if (!copyOrMoveFile(file, oneDestFile, isMove)) return false;
  227.             } else if (file.isDirectory()) {
  228.                 // 如果操作失败返回false
  229.                 if (!copyOrMoveDir(file, oneDestFile, isMove)) return false;
  230.             }
  231.         }
  232.         return !isMove || deleteDir(srcDir);
  233.     }
  235.     /**
  236.      * 复制或移动文件
  237.      *
  238.      * @param srcFilePath  源文件路径
  239.      * @param destFilePath 目标文件路径
  240.      * @param isMove       是否移动
  241.      * @return {@code true}: 复制或移动成功<br>{@code false}: 复制或移动失败
  242.      */
  243.     private static boolean copyOrMoveFile(String srcFilePath, String destFilePath, boolean isMove) {
  244.         return copyOrMoveFile(getFileByPath(srcFilePath), getFileByPath(destFilePath), isMove);
  245.     }
  247.     /**
  248.      * 复制或移动文件
  249.      *
  250.      * @param srcFile  源文件
  251.      * @param destFile 目标文件
  252.      * @param isMove   是否移动
  253.      * @return {@code true}: 复制或移动成功<br>{@code false}: 复制或移动失败
  254.      */
  255.     private static boolean copyOrMoveFile(File srcFile, File destFile, boolean isMove) {
  256.         if (srcFile == null || destFile == null) return false;
  257.         // 源文件不存在或者不是文件则返回false
  258.         if (!srcFile.exists() || !srcFile.isFile()) return false;
  259.         // 目标文件存在且是文件则返回false
  260.         if (destFile.exists() && destFile.isFile()) return false;
  261.         // 目标目录不存在返回false
  262.         if (!createOrExistsDir(destFile.getParentFile())) return false;
  263.         try {
  264.             return writeFileFromIS(destFile, new FileInputStream(srcFile), false)
  265.                     && !(isMove && !deleteFile(srcFile));
  266.         } catch (FileNotFoundException e) {
  267.             e.printStackTrace();
  268.             return false;
  269.         }
  270.     }
  272.     /**
  273.      * 复制目录
  274.      *
  275.      * @param srcDirPath  源目录路径
  276.      * @param destDirPath 目标目录路径
  277.      * @return {@code true}: 复制成功<br>{@code false}: 复制失败
  278.      */
  279.     public static boolean copyDir(String srcDirPath, String destDirPath) {
  280.         return copyDir(getFileByPath(srcDirPath), getFileByPath(destDirPath));
  281.     }
  283.     /**
  284.      * 复制目录
  285.      *
  286.      * @param srcDir  源目录
  287.      * @param destDir 目标目录
  288.      * @return {@code true}: 复制成功<br>{@code false}: 复制失败
  289.      */
  290.     public static boolean copyDir(File srcDir, File destDir) {
  291.         return copyOrMoveDir(srcDir, destDir, false);
  292.     }
  294.     /**
  295.      * 复制文件
  296.      *
  297.      * @param srcFilePath  源文件路径
  298.      * @param destFilePath 目标文件路径
  299.      * @return {@code true}: 复制成功<br>{@code false}: 复制失败
  300.      */
  301.     public static boolean copyFile(String srcFilePath, String destFilePath) {
  302.         return copyFile(getFileByPath(srcFilePath), getFileByPath(destFilePath));
  303.     }
  305.     /**
  306.      * 复制文件
  307.      *
  308.      * @param srcFile  源文件
  309.      * @param destFile 目标文件
  310.      * @return {@code true}: 复制成功<br>{@code false}: 复制失败
  311.      */
  312.     public static boolean copyFile(File srcFile, File destFile) {
  313.         return copyOrMoveFile(srcFile, destFile, false);
  314.     }
  316.     /**
  317.      * 移动目录
  318.      *
  319.      * @param srcDirPath  源目录路径
  320.      * @param destDirPath 目标目录路径
  321.      * @return {@code true}: 移动成功<br>{@code false}: 移动失败
  322.      */
  323.     public static boolean moveDir(String srcDirPath, String destDirPath) {
  324.         return moveDir(getFileByPath(srcDirPath), getFileByPath(destDirPath));
  325.     }
  327.     /**
  328.      * 移动目录
  329.      *
  330.      * @param srcDir  源目录
  331.      * @param destDir 目标目录
  332.      * @return {@code true}: 移动成功<br>{@code false}: 移动失败
  333.      */
  334.     public static boolean moveDir(File srcDir, File destDir) {
  335.         return copyOrMoveDir(srcDir, destDir, true);
  336.     }
  338.     /**
  339.      * 移动文件
  340.      *
  341.      * @param srcFilePath  源文件路径
  342.      * @param destFilePath 目标文件路径
  343.      * @return {@code true}: 移动成功<br>{@code false}: 移动失败
  344.      */
  345.     public static boolean moveFile(String srcFilePath, String destFilePath) {
  346.         return moveFile(getFileByPath(srcFilePath), getFileByPath(destFilePath));
  347.     }
  349.     /**
  350.      * 移动文件
  351.      *
  352.      * @param srcFile  源文件
  353.      * @param destFile 目标文件
  354.      * @return {@code true}: 移动成功<br>{@code false}: 移动失败
  355.      */
  356.     public static boolean moveFile(File srcFile, File destFile) {
  357.         return copyOrMoveFile(srcFile, destFile, true);
  358.     }
  360.     /**
  361.      * 删除目录
  362.      *
  363.      * @param dirPath 目录路径
  364.      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
  365.      */
  366.     public static boolean deleteDir(String dirPath) {
  367.         return deleteDir(getFileByPath(dirPath));
  368.     }
  370.     /**
  371.      * 删除目录
  372.      *
  373.      * @param dir 目录
  374.      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
  375.      */
  376.     public static boolean deleteDir(File dir) {
  377.         if (dir == null) return false;
  378.         // 目录不存在返回true
  379.         if (!dir.exists()) return true;
  380.         // 不是目录返回false
  381.         if (!dir.isDirectory()) return false;
  382.         // 现在文件存在且是文件夹
  383.         File[] files = dir.listFiles();
  384.         for (File file : files) {
  385.             if (file.isFile()) {
  386.                 if (!deleteFile(file)) return false;
  387.             } else if (file.isDirectory()) {
  388.                 if (!deleteDir(file)) return false;
  389.             }
  390.         }
  391.         return dir.delete();
  392.     }
  394.     /**
  395.      * 删除文件
  396.      *
  397.      * @param srcFilePath 文件路径
  398.      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
  399.      */
  400.     public static boolean deleteFile(String srcFilePath) {
  401.         return deleteFile(getFileByPath(srcFilePath));
  402.     }
  404.     /**
  405.      * 删除文件
  406.      *
  407.      * @param file 文件
  408.      * @return {@code true}: 删除成功<br>{@code false}: 删除失败
  409.      */
  410.     public static boolean deleteFile(File file) {
  411.         return file != null && (!file.exists() || file.isFile() && file.delete());
  412.     }
  414.     /**
  415.      * 获取目录下所有文件
  416.      *
  417.      * @param dirPath     目录路径
  418.      * @param isRecursive 是否递归进子目录
  419.      * @return 文件链表
  420.      */
  421.     public static List<File> listFilesInDir(String dirPath, boolean isRecursive) {
  422.         return listFilesInDir(getFileByPath(dirPath), isRecursive);
  423.     }
  425.     /**
  426.      * 获取目录下所有文件
  427.      *
  428.      * @param dir         目录
  429.      * @param isRecursive 是否递归进子目录
  430.      * @return 文件链表
  431.      */
  432.     public static List<File> listFilesInDir(File dir, boolean isRecursive) {
  433.         if (isRecursive) return listFilesInDir(dir);
  434.         if (dir == null || !isDir(dir)) return null;
  435.         List<File> list = new ArrayList<>();
  436.         Collections.addAll(list, dir.listFiles());
  437.         return list;
  438.     }
  440.     /**
  441.      * 获取目录下所有文件包括子目录
  442.      *
  443.      * @param dirPath 目录路径
  444.      * @return 文件链表
  445.      */
  446.     public static List<File> listFilesInDir(String dirPath) {
  447.         return listFilesInDir(getFileByPath(dirPath));
  448.     }
  450.     /**
  451.      * 获取目录下所有文件包括子目录
  452.      *
  453.      * @param dir 目录
  454.      * @return 文件链表
  455.      */
  456.     public static List<File> listFilesInDir(File dir) {
  457.         if (dir == null || !isDir(dir)) return null;
  458.         List<File> list = new ArrayList<>();
  459.         File[] files = dir.listFiles();
  460.         for (File file : files) {
  461.             list.add(file);
  462.             if (file.isDirectory()) {
  463.                 list.addAll(listFilesInDir(file));
  464.             }
  465.         }
  466.         return list;
  467.     }
  469.     /**
  470.      * 获取目录下所有后缀名为suffix的文件
  471.      * <p>大小写忽略</p>
  472.      *
  473.      * @param dirPath     目录路径
  474.      * @param suffix      后缀名
  475.      * @param isRecursive 是否递归进子目录
  476.      * @return 文件链表
  477.      */
  478.     public static List<File> listFilesInDirWithFilter(String dirPath, String suffix, boolean isRecursive) {
  479.         return listFilesInDirWithFilter(getFileByPath(dirPath), suffix, isRecursive);
  480.     }
  482.     /**
  483.      * 获取目录下所有后缀名为suffix的文件
  484.      * <p>大小写忽略</p>
  485.      *
  486.      * @param dir         目录
  487.      * @param suffix      后缀名
  488.      * @param isRecursive 是否递归进子目录
  489.      * @return 文件链表
  490.      */
  491.     public static List<File> listFilesInDirWithFilter(File dir, String suffix, boolean isRecursive) {
  492.         if (isRecursive) return listFilesInDirWithFilter(dir, suffix);
  493.         if (dir == null || !isDir(dir)) return null;
  494.         List<File> list = new ArrayList<>();
  495.         File[] files = dir.listFiles();
  496.         for (File file : files) {
  497.             if (file.getName().toUpperCase().endsWith(suffix.toUpperCase())) {
  498.                 list.add(file);
  499.             }
  500.         }
  501.         return list;
  502.     }
  504.     /**
  505.      * 获取目录下所有后缀名为suffix的文件包括子目录
  506.      * <p>大小写忽略</p>
  507.      *
  508.      * @param dirPath 目录路径
  509.      * @param suffix  后缀名
  510.      * @return 文件链表
  511.      */
  512.     public static List<File> listFilesInDirWithFilter(String dirPath, String suffix) {
  513.         return listFilesInDirWithFilter(getFileByPath(dirPath), suffix);
  514.     }
  516.     /**
  517.      * 获取目录下所有后缀名为suffix的文件包括子目录
  518.      * <p>大小写忽略</p>
  519.      *
  520.      * @param dir    目录
  521.      * @param suffix 后缀名
  522.      * @return 文件链表
  523.      */
  524.     public static List<File> listFilesInDirWithFilter(File dir, String suffix) {
  525.         if (dir == null || !isDir(dir)) return null;
  526.         List<File> list = new ArrayList<>();
  527.         File[] files = dir.listFiles();
  528.         for (File file : files) {
  529.             if (file.getName().toUpperCase().endsWith(suffix.toUpperCase())) {
  530.                 list.add(file);
  531.             }
  532.             if (file.isDirectory()) {
  533.                 list.addAll(listFilesInDirWithFilter(file, suffix));
  534.             }
  535.         }
  536.         return list;
  537.     }
  539.     /**
  540.      * 获取目录下所有符合filter的文件
  541.      *
  542.      * @param dirPath     目录路径
  543.      * @param filter      过滤器
  544.      * @param isRecursive 是否递归进子目录
  545.      * @return 文件链表
  546.      */
  547.     public static List<File> listFilesInDirWithFilter(String dirPath, FilenameFilter filter, boolean isRecursive) {
  548.         return listFilesInDirWithFilter(getFileByPath(dirPath), filter, isRecursive);
  549.     }
  551.     /**
  552.      * 获取目录下所有符合filter的文件
  553.      *
  554.      * @param dir         目录
  555.      * @param filter      过滤器
  556.      * @param isRecursive 是否递归进子目录
  557.      * @return 文件链表
  558.      */
  559.     public static List<File> listFilesInDirWithFilter(File dir, FilenameFilter filter, boolean isRecursive) {
  560.         if (isRecursive) return listFilesInDirWithFilter(dir, filter);
  561.         if (dir == null || !isDir(dir)) return null;
  562.         List<File> list = new ArrayList<>();
  563.         File[] files = dir.listFiles();
  564.         for (File file : files) {
  565.             if (filter.accept(file.getParentFile(), file.getName())) {
  566.                 list.add(file);
  567.             }
  568.         }
  569.         return list;
  570.     }
  572.     /**
  573.      * 获取目录下所有符合filter的文件包括子目录
  574.      *
  575.      * @param dirPath 目录路径
  576.      * @param filter  过滤器
  577.      * @return 文件链表
  578.      */
  579.     public static List<File> listFilesInDirWithFilter(String dirPath, FilenameFilter filter) {
  580.         return listFilesInDirWithFilter(getFileByPath(dirPath), filter);
  581.     }
  583.     /**
  584.      * 获取目录下所有符合filter的文件包括子目录
  585.      *
  586.      * @param dir    目录
  587.      * @param filter 过滤器
  588.      * @return 文件链表
  589.      */
  590.     public static List<File> listFilesInDirWithFilter(File dir, FilenameFilter filter) {
  591.         if (dir == null || !isDir(dir)) return null;
  592.         List<File> list = new ArrayList<>();
  593.         File[] files = dir.listFiles();
  594.         for (File file : files) {
  595.             if (filter.accept(file.getParentFile(), file.getName())) {
  596.                 list.add(file);
  597.             }
  598.             if (file.isDirectory()) {
  599.                 list.addAll(listFilesInDirWithFilter(file, filter));
  600.             }
  601.         }
  602.         return list;
  603.     }
  605.     /**
  606.      * 获取目录下指定文件名的文件包括子目录
  607.      * <p>大小写忽略</p>
  608.      *
  609.      * @param dirPath  目录路径
  610.      * @param fileName 文件名
  611.      * @return 文件链表
  612.      */
  613.     public static List<File> searchFileInDir(String dirPath, String fileName) {
  614.         return searchFileInDir(getFileByPath(dirPath), fileName);
  615.     }
  617.     /**
  618.      * 获取目录下指定文件名的文件包括子目录
  619.      * <p>大小写忽略</p>
  620.      *
  621.      * @param dir      目录
  622.      * @param fileName 文件名
  623.      * @return 文件链表
  624.      */
  625.     public static List<File> searchFileInDir(File dir, String fileName) {
  626.         if (dir == null || !isDir(dir)) return null;
  627.         List<File> list = new ArrayList<>();
  628.         File[] files = dir.listFiles();
  629.         for (File file : files) {
  630.             if (file.getName().toUpperCase().equals(fileName.toUpperCase())) {
  631.                 list.add(file);
  632.             }
  633.             if (file.isDirectory()) {
  634.                 list.addAll(listFilesInDirWithFilter(file, fileName));
  635.             }
  636.         }
  637.         return list;
  638.     }
  640.     /**
  641.      * 将输入流写入文件
  642.      *
  643.      * @param filePath 路径
  644.      * @param is       输入流
  645.      * @param append   是否追加在文件末
  646.      * @return {@code true}: 写入成功<br>{@code false}: 写入失败
  647.      */
  648.     public static boolean writeFileFromIS(String filePath, InputStream is, boolean append) {
  649.         return writeFileFromIS(getFileByPath(filePath), is, append);
  650.     }
  652.     /**
  653.      * 将输入流写入文件
  654.      *
  655.      * @param file   文件
  656.      * @param is     输入流
  657.      * @param append 是否追加在文件末
  658.      * @return {@code true}: 写入成功<br>{@code false}: 写入失败
  659.      */
  660.     public static boolean writeFileFromIS(File file, InputStream is, boolean append) {
  661.         if (file == null || is == null) return false;
  662.         if (!createOrExistsFile(file)) return false;
  663.         OutputStream os = null;
  664.         try {
  665.             os = new BufferedOutputStream(new FileOutputStream(file, append));
  666.             byte data[] = new byte[KB];
  667.             int len;
  668.             while ((len = is.read(data, 0, KB)) != -1) {
  669.                 os.write(data, 0, len);
  670.             }
  671.             return true;
  672.         } catch (IOException e) {
  673.             e.printStackTrace();
  674.             return false;
  675.         } finally {
  676.             closeIO(is, os);
  677.         }
  678.     }
  680.     /**
  681.      * 将字符串写入文件
  682.      *
  683.      * @param filePath 文件路径
  684.      * @param content  写入内容
  685.      * @param append   是否追加在文件末
  686.      * @return {@code true}: 写入成功<br>{@code false}: 写入失败
  687.      */
  688.     public static boolean writeFileFromString(String filePath, String content, boolean append) {
  689.         return writeFileFromString(getFileByPath(filePath), content, append);
  690.     }
  692.     /**
  693.      * 将字符串写入文件
  694.      *
  695.      * @param file    文件
  696.      * @param content 写入内容
  697.      * @param append  是否追加在文件末
  698.      * @return {@code true}: 写入成功<br>{@code false}: 写入失败
  699.      */
  700.     public static boolean writeFileFromString(File file, String content, boolean append) {
  701.         if (file == null || content == null) return false;
  702.         if (!createOrExistsFile(file)) return false;
  703.         FileWriter fileWriter = null;
  704.         try {
  705.             fileWriter = new FileWriter(file, append);
  706.             fileWriter.write(content);
  707.             return true;
  708.         } catch (IOException e) {
  709.             e.printStackTrace();
  710.             return false;
  711.         } finally {
  712.             closeIO(fileWriter);
  713.         }
  714.     }
  716.     /**
  717.      * 指定编码按行读取文件到List
  718.      *
  719.      * @param filePath    文件路径
  720.      * @param charsetName 编码格式
  721.      * @return 文件行链表
  722.      */
  723.     public static List<String> readFile2List(String filePath, String charsetName) {
  724.         return readFile2List(getFileByPath(filePath), charsetName);
  725.     }
  727.     /**
  728.      * 指定编码按行读取文件到List
  729.      *
  730.      * @param file        文件
  731.      * @param charsetName 编码格式
  732.      * @return 文件行链表
  733.      */
  734.     public static List<String> readFile2List(File file, String charsetName) {
  735.         return readFile2List(file, 0, 0x7FFFFFFF, charsetName);
  736.     }
  738.     /**
  739.      * 指定编码按行读取文件到List
  740.      *
  741.      * @param filePath    文件路径
  742.      * @param st          需要读取的开始行数
  743.      * @param end         需要读取的结束行数
  744.      * @param charsetName 编码格式
  745.      * @return 包含制定行的list
  746.      */
  747.     public static List<String> readFile2List(String filePath, int st, int end, String
  748.             charsetName) {
  749.         return readFile2List(getFileByPath(filePath), st, end, charsetName);
  750.     }
  752.     /**
  753.      * 指定编码按行读取文件到List
  754.      *
  755.      * @param file        文件
  756.      * @param st          需要读取的开始行数
  757.      * @param end         需要读取的结束行数
  758.      * @param charsetName 编码格式
  759.      * @return 包含从start行到end行的list
  760.      */
  761.     public static List<String> readFile2List(File file, int st, int end, String charsetName) {
  762.         if (file == null) return null;
  763.         if (st > end) return null;
  764.         BufferedReader reader = null;
  765.         try {
  766.             String line;
  767.             int curLine = 1;
  768.             List<String> list = new ArrayList<>();
  769.             if (StringUtils.isSpace(charsetName)) {
  770.                 reader = new BufferedReader(new FileReader(file));
  771.             } else {
  772.                 reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charsetName));
  773.             }
  774.             while ((line = reader.readLine()) != null) {
  775.                 if (curLine > end) break;
  776.                 if (st <= curLine && curLine <= end) list.add(line);
  777.                 ++curLine;
  778.             }
  779.             return list;
  780.         } catch (IOException e) {
  781.             e.printStackTrace();
  782.             return null;
  783.         } finally {
  784.             closeIO(reader);
  785.         }
  786.     }
  788.     /**
  789.      * 指定编码按行读取文件到字符串中
  790.      *
  791.      * @param filePath    文件路径
  792.      * @param charsetName 编码格式
  793.      * @return 字符串
  794.      */
  795.     public static String readFile2String(String filePath, String charsetName) {
  796.         return readFile2String(getFileByPath(filePath), charsetName);
  797.     }
  799.     /**
  800.      * 指定编码按行读取文件到字符串中
  801.      *
  802.      * @param file        文件
  803.      * @param charsetName 编码格式
  804.      * @return 字符串
  805.      */
  806.     public static String readFile2String(File file, String charsetName) {
  807.         if (file == null) return null;
  808.         BufferedReader reader = null;
  809.         try {
  810.             StringBuilder sb = new StringBuilder();
  811.             if (StringUtils.isSpace(charsetName)) {
  812.                 reader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
  813.             } else {
  814.                 reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), charsetName));
  815.             }
  816.             String line;
  817.             while ((line = reader.readLine()) != null) {
  818.                 sb.append(line).append("\r\n");// windows系统换行为\r\n，Linux为\n
  819.             }
  820.             // 要去除最后的换行符
  821.             return sb.delete(sb.length() - 2, sb.length()).toString();
  822.         } catch (IOException e) {
  823.             e.printStackTrace();
  824.             return null;
  825.         } finally {
  826.             closeIO(reader);
  827.         }
  828.     }
  830.     /**
  831.      * 指定编码按行读取文件到字符数组中
  832.      *
  833.      * @param filePath 文件路径
  834.      * @return StringBuilder对象
  835.      */
  836.     public static byte[] readFile2Bytes(String filePath) {
  837.         return readFile2Bytes(getFileByPath(filePath));
  838.     }
  840.     /**
  841.      * 指定编码按行读取文件到字符数组中
  842.      *
  843.      * @param file 文件
  844.      * @return StringBuilder对象
  845.      */
  846.     public static byte[] readFile2Bytes(File file) {
  847.         if (file == null) return null;
  848.         try {
  849.             return ConvertUtils.inputStream2Bytes(new FileInputStream(file));
  850.         } catch (FileNotFoundException e) {
  851.             e.printStackTrace();
  852.             return null;
  853.         }
  854.     }
  856.     /**
  857.      * 简单获取文件编码格式
  858.      *
  859.      * @param filePath 文件路径
  860.      * @return 文件编码
  861.      */
  862.     public static String getFileCharsetSimple(String filePath) {
  863.         return getFileCharsetSimple(getFileByPath(filePath));
  864.     }
  866.     /**
  867.      * 简单获取文件编码格式
  868.      *
  869.      * @param file 文件
  870.      * @return 文件编码
  871.      */
  872.     public static String getFileCharsetSimple(File file) {
  873.         int p = 0;
  874.         InputStream is = null;
  875.         try {
  876.             is = new BufferedInputStream(new FileInputStream(file));
  877.             p = (is.read() << 8) + is.read();
  878.         } catch (IOException e) {
  879.             e.printStackTrace();
  880.         } finally {
  881.             closeIO(is);
  882.         }
  883.         switch (p) {
  884.             case 0xefbb:
  885.                 return "UTF-8";
  886.             case 0xfffe:
  887.                 return "Unicode";
  888.             case 0xfeff:
  889.                 return "UTF-16BE";
  890.             default:
  891.                 return "GBK";
  892.         }
  893.     }
  895.     /**
  896.      * 获取文件行数
  897.      *
  898.      * @param filePath 文件路径
  899.      * @return 文件行数
  900.      */
  901.     public static int getFileLines(String filePath) {
  902.         return getFileLines(getFileByPath(filePath));
  903.     }
  905.     /**
  906.      * 获取文件行数
  907.      *
  908.      * @param file 文件
  909.      * @return 文件行数
  910.      */
  911.     public static int getFileLines(File file) {
  912.         int count = 1;
  913.         InputStream is = null;
  914.         try {
  915.             is = new BufferedInputStream(new FileInputStream(file));
  916.             byte[] buffer = new byte[KB];
  917.             int readChars;
  918.             while ((readChars = is.read(buffer, 0, KB)) != -1) {
  919.                 for (int i = 0; i < readChars; ++i) {
  920.                     if (buffer[i] == '\n') ++count;
  921.                 }
  922.             }
  923.         } catch (IOException e) {
  924.             e.printStackTrace();
  925.         } finally {
  926.             closeIO(is);
  927.         }
  928.         return count;
  929.     }
  931.     /**
  932.      * 获取文件大小
  933.      *
  934.      * @param filePath 文件路径
  935.      * @return 文件大小
  936.      */
  937.     public static String getFileSize(String filePath) {
  938.         return getFileSize(getFileByPath(filePath));
  939.     }
  941.     /**
  942.      * 获取文件大小
  943.      * <p>例如：getFileSize(file, ConstUtils.MB); 返回文件大小单位为MB</p>
  944.      *
  945.      * @param file 文件
  946.      * @return 文件大小
  947.      */
  948.     public static String getFileSize(File file) {
  949.         if (!isFileExists(file)) return "";
  950.         return ConvertUtils.byte2FitSize(file.length());
  951.     }
  953.     /**
  954.      * 获取文件的MD5校验码
  955.      *
  956.      * @param filePath 文件
  957.      * @return 文件的MD5校验码
  958.      */
  959.     public static String getFileMD5(String filePath) {
  960.         return getFileMD5(getFileByPath(filePath));
  961.     }
  963.     /**
  964.      * 获取文件的MD5校验码
  965.      *
  966.      * @param file 文件
  967.      * @return 文件的MD5校验码
  968.      */
  969.     public static String getFileMD5(File file) {
  970.         return EncryptUtils.encryptMD5File2String(file);
  971.     }
  973.     /**
  974.      * 关闭IO
  975.      *
  976.      * @param closeables closeable
  977.      */
  978.     public static void closeIO(Closeable... closeables) {
  979.         if (closeables == null) return;
  980.         try {
  981.             for (Closeable closeable : closeables) {
  982.                 if (closeable != null) {
  983.                     closeable.close();
  984.                 }
  985.             }
  986.         } catch (IOException e) {
  987.             e.printStackTrace();
  988.         }
  989.     }
  991.     /**
  992.      * 获取全路径中的最长目录
  993.      *
  994.      * @param file 文件
  995.      * @return filePath最长目录
  996.      */
  997.     public static String getDirName(File file) {
  998.         if (file == null) return null;
  999.         return getDirName(file.getPath());
  1000.     }
  1002.     /**
  1003.      * 获取全路径中的最长目录
  1004.      *
  1005.      * @param filePath 文件路径
  1006.      * @return filePath最长目录
  1007.      */
  1008.     public static String getDirName(String filePath) {
  1009.         if (StringUtils.isSpace(filePath)) return filePath;
  1010.         int lastSep = filePath.lastIndexOf(File.separator);
  1011.         return lastSep == -1 ? "" : filePath.substring(0, lastSep + 1);
  1012.     }
  1014.     /**
  1015.      * 获取全路径中的文件名
  1016.      *
  1017.      * @param file 文件
  1018.      * @return 文件名
  1019.      */
  1020.     public static String getFileName(File file) {
  1021.         if (file == null) return null;
  1022.         return getFileName(file.getPath());
  1023.     }
  1025.     /**
  1026.      * 获取全路径中的文件名
  1027.      *
  1028.      * @param filePath 文件路径
  1029.      * @return 文件名
  1030.      */
  1031.     public static String getFileName(String filePath) {
  1032.         if (StringUtils.isSpace(filePath)) return filePath;
  1033.         int lastSep = filePath.lastIndexOf(File.separator);
  1034.         return lastSep == -1 ? filePath : filePath.substring(lastSep + 1);
  1035.     }
  1037.     /**
  1038.      * 获取全路径中的不带拓展名的文件名
  1039.      *
  1040.      * @param file 文件
  1041.      * @return 不带拓展名的文件名
  1042.      */
  1043.     public static String getFileNameNoExtension(File file) {
  1044.         if (file == null) return null;
  1045.         return getFileNameNoExtension(file.getPath());
  1046.     }
  1048.     /**
  1049.      * 获取全路径中的不带拓展名的文件名
  1050.      *
  1051.      * @param filePath 文件路径
  1052.      * @return 不带拓展名的文件名
  1053.      */
  1054.     public static String getFileNameNoExtension(String filePath) {
  1055.         if (StringUtils.isSpace(filePath)) return filePath;
  1056.         int lastPoi = filePath.lastIndexOf('.');
  1057.         int lastSep = filePath.lastIndexOf(File.separator);
  1058.         if (lastSep == -1) {
  1059.             return (lastPoi == -1 ? filePath : filePath.substring(0, lastPoi));
  1060.         }
  1061.         if (lastPoi == -1 || lastSep > lastPoi) {
  1062.             return filePath.substring(lastSep + 1);
  1063.         }
  1064.         return filePath.substring(lastSep + 1, lastPoi);
  1065.     }
  1067.     /**
  1068.      * 获取全路径中的文件拓展名
  1069.      *
  1070.      * @param file 文件
  1071.      * @return 文件拓展名
  1072.      */
  1073.     public static String getFileExtension(File file) {
  1074.         if (file == null) return null;
  1075.         return getFileExtension(file.getPath());
  1076.     }
  1078.     /**
  1079.      * 获取全路径中的文件拓展名
  1080.      *
  1081.      * @param filePath 文件路径
  1082.      * @return 文件拓展名
  1083.      */
  1084.     public static String getFileExtension(String filePath) {
  1085.         if (StringUtils.isSpace(filePath)) return filePath;
  1086.         int lastPoi = filePath.lastIndexOf('.');
  1087.         int lastSep = filePath.lastIndexOf(File.separator);
  1088.         if (lastPoi == -1 || lastSep >= lastPoi) return "";
  1089.         return filePath.substring(lastPoi);
  1090.     }
  1091. }

ImageUtils

  1. package com.blankj.utilcode.utils;
  3. import android.annotation.TargetApi;
  4. import android.content.Context;
  5. import android.content.res.Resources;
  6. import android.graphics.Bitmap;
  7. import android.graphics.Bitmap.CompressFormat;
  8. import android.graphics.Bitmap.Config;
  9. import android.graphics.BitmapFactory;
  10. import android.graphics.BitmapShader;
  11. import android.graphics.Canvas;
  12. import android.graphics.Color;
  13. import android.graphics.ColorMatrix;
  14. import android.graphics.ColorMatrixColorFilter;
  15. import android.graphics.LinearGradient;
  16. import android.graphics.Matrix;
  17. import android.graphics.Paint;
  18. import android.graphics.PorterDuff;
  19. import android.graphics.PorterDuffColorFilter;
  20. import android.graphics.PorterDuffXfermode;
  21. import android.graphics.Rect;
  22. import android.graphics.RectF;
  23. import android.graphics.Shader;
  24. import android.graphics.drawable.BitmapDrawable;
  25. import android.graphics.drawable.Drawable;
  26. import android.hardware.camera2.params.BlackLevelPattern;
  27. import android.media.ExifInterface;
  28. import android.os.Build;
  29. import android.renderscript.Allocation;
  30. import android.renderscript.Element;
  31. import android.renderscript.RenderScript;
  32. import android.renderscript.ScriptIntrinsicBlur;
  34. import java.io.BufferedInputStream;
  35. import java.io.BufferedOutputStream;
  36. import java.io.ByteArrayInputStream;
  37. import java.io.ByteArrayOutputStream;
  38. import java.io.File;
  39. import java.io.FileDescriptor;
  40. import java.io.FileInputStream;
  41. import java.io.FileNotFoundException;
  42. import java.io.FileOutputStream;
  43. import java.io.IOException;
  44. import java.io.InputStream;
  45. import java.io.OutputStream;
  46. import java.util.Date;
  48. /**
  49.  * <pre>
  50.  *     author: Blankj
  51.  *     blog  : http://blankj.com
  52.  *     time  : 2016/8/12
  53.  *     desc  : 图片相关工具类
  54.  * </pre>
  55.  */
  56. public class ImageUtils {
  58.     private ImageUtils() {
  59.         throw new UnsupportedOperationException("u can't fuck me...");
  60.     }
  62.     /**
  63.      * bitmap转byteArr
  64.      *
  65.      * @param bitmap bitmap对象
  66.      * @param format 格式
  67.      * @return 字节数组
  68.      */
  69.     public static byte[] bitmap2Bytes(Bitmap bitmap, CompressFormat format) {
  70.         return ConvertUtils.bitmap2Bytes(bitmap, format);
  71.     }
  73.     /**
  74.      * byteArr转bitmap
  75.      *
  76.      * @param bytes 字节数组
  77.      * @return bitmap对象
  78.      */
  79.     public static Bitmap bytes2Bitmap(byte[] bytes) {
  80.         return ConvertUtils.bytes2Bitmap(bytes);
  81.     }
  83.     /**
  84.      * drawable转bitmap
  85.      *
  86.      * @param drawable drawable对象
  87.      * @return bitmap对象
  88.      */
  89.     public static Bitmap drawable2Bitmap(Drawable drawable) {
  90.         return ConvertUtils.drawable2Bitmap(drawable);
  91.     }
  93.     /**
  94.      * bitmap转drawable
  95.      *
  96.      * @param res    resources对象
  97.      * @param bitmap bitmap对象
  98.      * @return drawable对象
  99.      */
  100.     public static Drawable bitmap2Drawable(Resources res, Bitmap bitmap) {
  101.         return ConvertUtils.bitmap2Drawable(res, bitmap);
  102.     }
  104.     /**
  105.      * drawable转byteArr
  106.      *
  107.      * @param drawable drawable对象
  108.      * @param format   格式
  109.      * @return 字节数组
  110.      */
  111.     public static byte[] drawable2Bytes(Drawable drawable, CompressFormat format) {
  112.         return ConvertUtils.drawable2Bytes(drawable, format);
  113.     }
  115.     /**
  116.      * byteArr转drawable
  117.      *
  118.      * @param res   resources对象
  119.      * @param bytes 字节数组
  120.      * @return drawable对象
  121.      */
  122.     public static Drawable bytes2Drawable(Resources res, byte[] bytes) {
  123.         return ConvertUtils.bytes2Drawable(res, bytes);
  124.     }
  126.     /**
  127.      * 计算采样大小
  128.      *
  129.      * @param options   选项
  130.      * @param maxWidth  最大宽度
  131.      * @param maxHeight 最大高度
  132.      * @return 采样大小
  133.      */
  134.     private static int calculateInSampleSize(BitmapFactory.Options options, int maxWidth, int maxHeight) {
  135.         if (maxWidth == 0 || maxHeight == 0) return 1;
  136.         int height = options.outHeight;
  137.         int width = options.outWidth;
  138.         int inSampleSize = 1;
  139.         while ((height >>= 1) >= maxHeight && (width >>= 1) >= maxWidth) {
  140.             inSampleSize <<= 1;
  141.         }
  142.         return inSampleSize;
  143.     }
  145.     /**
  146.      * 获取bitmap
  147.      *
  148.      * @param file 文件
  149.      * @return bitmap
  150.      */
  151.     public static Bitmap getBitmap(File file) {
  152.         if (file == null) return null;
  153.         InputStream is = null;
  154.         try {
  155.             is = new BufferedInputStream(new FileInputStream(file));
  156.             return BitmapFactory.decodeStream(is);
  157.         } catch (FileNotFoundException e) {
  158.             e.printStackTrace();
  159.             return null;
  160.         } finally {
  161.             FileUtils.closeIO(is);
  162.         }
  163.     }
  165.     /**
  166.      * 获取bitmap
  167.      *
  168.      * @param file      文件
  169.      * @param maxWidth  最大宽度
  170.      * @param maxHeight 最大高度
  171.      * @return bitmap
  172.      */
  173.     public static Bitmap getBitmap(File file, int maxWidth, int maxHeight) {
  174.         if (file == null) return null;
  175.         InputStream is = null;
  176.         try {
  177.             BitmapFactory.Options options = new BitmapFactory.Options();
  178.             options.inJustDecodeBounds = true;
  179.             is = new BufferedInputStream(new FileInputStream(file));
  180.             BitmapFactory.decodeStream(is, null, options);
  181.             options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  182.             options.inJustDecodeBounds = false;
  183.             return BitmapFactory.decodeStream(is, null, options);
  184.         } catch (FileNotFoundException e) {
  185.             e.printStackTrace();
  186.             return null;
  187.         } finally {
  188.             FileUtils.closeIO(is);
  189.         }
  190.     }
  192.     /**
  193.      * 获取bitmap
  194.      *
  195.      * @param filePath 文件路径
  196.      * @return bitmap
  197.      */
  198.     public static Bitmap getBitmap(String filePath) {
  199.         if (StringUtils.isSpace(filePath)) return null;
  200.         return BitmapFactory.decodeFile(filePath);
  201.     }
  203.     /**
  204.      * 获取bitmap
  205.      *
  206.      * @param filePath  文件路径
  207.      * @param maxWidth  最大宽度
  208.      * @param maxHeight 最大高度
  209.      * @return bitmap
  210.      */
  211.     public static Bitmap getBitmap(String filePath, int maxWidth, int maxHeight) {
  212.         if (StringUtils.isSpace(filePath)) return null;
  213.         BitmapFactory.Options options = new BitmapFactory.Options();
  214.         options.inJustDecodeBounds = true;
  215.         BitmapFactory.decodeFile(filePath, options);
  216.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  217.         options.inJustDecodeBounds = false;
  218.         return BitmapFactory.decodeFile(filePath, options);
  219.     }
  221.     /**
  222.      * 获取bitmap
  223.      *
  224.      * @param is 输入流
  225.      * @return bitmap
  226.      */
  227.     public Bitmap getBitmap(InputStream is) {
  228.         if (is == null) return null;
  229.         return BitmapFactory.decodeStream(is);
  230.     }
  232.     /**
  233.      * 获取bitmap
  234.      *
  235.      * @param is        输入流
  236.      * @param maxWidth  最大宽度
  237.      * @param maxHeight 最大高度
  238.      * @return bitmap
  239.      */
  240.     public static Bitmap getBitmap(InputStream is, int maxWidth, int maxHeight) {
  241.         if (is == null) return null;
  242.         BitmapFactory.Options options = new BitmapFactory.Options();
  243.         options.inJustDecodeBounds = true;
  244.         BitmapFactory.decodeStream(is, null, options);
  245.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  246.         options.inJustDecodeBounds = false;
  247.         return BitmapFactory.decodeStream(is, null, options);
  248.     }
  250.     /**
  251.      * 获取bitmap
  252.      *
  253.      * @param data   数据
  254.      * @param offset 偏移量
  255.      * @return bitmap
  256.      */
  257.     public Bitmap getBitmap(byte[] data, int offset) {
  258.         if (data.length == 0) return null;
  259.         return BitmapFactory.decodeByteArray(data, offset, data.length);
  260.     }
  262.     /**
  263.      * 获取bitmap
  264.      *
  265.      * @param data      数据
  266.      * @param offset    偏移量
  267.      * @param maxWidth  最大宽度
  268.      * @param maxHeight 最大高度
  269.      * @return bitmap
  270.      */
  271.     public static Bitmap getBitmap(byte[] data, int offset, int maxWidth, int maxHeight) {
  272.         if (data.length == 0) return null;
  273.         BitmapFactory.Options options = new BitmapFactory.Options();
  274.         options.inJustDecodeBounds = true;
  275.         BitmapFactory.decodeByteArray(data, offset, data.length, options);
  276.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  277.         options.inJustDecodeBounds = false;
  278.         return BitmapFactory.decodeByteArray(data, offset, data.length, options);
  279.     }
  281.     /**
  282.      * 获取bitmap
  283.      *
  284.      * @param context 上下文
  285.      * @param resId   资源id
  286.      * @return bitmap
  287.      */
  288.     public static Bitmap getBitmap(Context context, int resId) {
  289.         if (context == null) return null;
  290.         InputStream is = context.getResources().openRawResource(resId);
  291.         return BitmapFactory.decodeStream(is);
  292.     }
  294.     /**
  295.      * 获取bitmap
  296.      *
  297.      * @param context   上下文
  298.      * @param resId     资源id
  299.      * @param maxWidth  最大宽度
  300.      * @param maxHeight 最大高度
  301.      * @return bitmap
  302.      */
  303.     public static Bitmap getBitmap(Context context, int resId, int maxWidth, int maxHeight) {
  304.         if (context == null) return null;
  305.         BitmapFactory.Options options = new BitmapFactory.Options();
  306.         options.inJustDecodeBounds = true;
  307.         InputStream is = context.getResources().openRawResource(resId);
  308.         BitmapFactory.decodeStream(is, null, options);
  309.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  310.         options.inJustDecodeBounds = false;
  311.         return BitmapFactory.decodeStream(is, null, options);
  312.     }
  314.     /**
  315.      * 获取bitmap
  316.      *
  317.      * @param res 资源对象
  318.      * @param id  资源id
  319.      * @return bitmap
  320.      */
  321.     public static Bitmap getBitmap(Resources res, int id) {
  322.         if (res == null) return null;
  323.         return BitmapFactory.decodeResource(res, id);
  324.     }
  326.     /**
  327.      * 获取bitmap
  328.      *
  329.      * @param res       资源对象
  330.      * @param id        资源id
  331.      * @param maxWidth  最大宽度
  332.      * @param maxHeight 最大高度
  333.      * @return bitmap
  334.      */
  335.     public static Bitmap getBitmap(Resources res, int id, int maxWidth, int maxHeight) {
  336.         if (res == null) return null;
  337.         BitmapFactory.Options options = new BitmapFactory.Options();
  338.         options.inJustDecodeBounds = true;
  339.         BitmapFactory.decodeResource(res, id, options);
  340.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  341.         options.inJustDecodeBounds = false;
  342.         return BitmapFactory.decodeResource(res, id, options);
  343.     }
  345.     /**
  346.      * 获取bitmap
  347.      *
  348.      * @param fd 文件描述
  349.      * @return bitmap
  350.      */
  351.     public static Bitmap getBitmap(FileDescriptor fd) {
  352.         if (fd == null) return null;
  353.         return BitmapFactory.decodeFileDescriptor(fd);
  354.     }
  356.     /**
  357.      * 获取bitmap
  358.      *
  359.      * @param fd        文件描述
  360.      * @param maxWidth  最大宽度
  361.      * @param maxHeight 最大高度
  362.      * @return bitmap
  363.      */
  364.     public static Bitmap getBitmap(FileDescriptor fd, int maxWidth, int maxHeight) {
  365.         if (fd == null) return null;
  366.         BitmapFactory.Options options = new BitmapFactory.Options();
  367.         options.inJustDecodeBounds = true;
  368.         BitmapFactory.decodeFileDescriptor(fd, null, options);
  369.         options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
  370.         options.inJustDecodeBounds = false;
  371.         return BitmapFactory.decodeFileDescriptor(fd, null, options);
  372.     }
  374.     /**
  375.      * 缩放图片
  376.      *
  377.      * @param src       源图片
  378.      * @param newWidth  新宽度
  379.      * @param newHeight 新高度
  380.      * @return 缩放后的图片
  381.      */
  382.     public static Bitmap scale(Bitmap src, int newWidth, int newHeight) {
  383.         return scale(src, newWidth, newHeight, false);
  384.     }
  386.     /**
  387.      * 缩放图片
  388.      *
  389.      * @param src       源图片
  390.      * @param newWidth  新宽度
  391.      * @param newHeight 新高度
  392.      * @param recycle   是否回收
  393.      * @return 缩放后的图片
  394.      */
  395.     public static Bitmap scale(Bitmap src, int newWidth, int newHeight, boolean recycle) {
  396.         if (isEmptyBitmap(src)) return null;
  397.         Bitmap ret = Bitmap.createScaledBitmap(src, newWidth, newHeight, true);
  398.         if (recycle && !src.isRecycled()) src.recycle();
  399.         return ret;
  400.     }
  402.     /**
  403.      * 缩放图片
  404.      *
  405.      * @param src         源图片
  406.      * @param scaleWidth  缩放宽度倍数
  407.      * @param scaleHeight 缩放高度倍数
  408.      * @return 缩放后的图片
  409.      */
  410.     public static Bitmap scale(Bitmap src, float scaleWidth, float scaleHeight) {
  411.         return scale(src, scaleWidth, scaleHeight, false);
  412.     }
  414.     /**
  415.      * 缩放图片
  416.      *
  417.      * @param src         源图片
  418.      * @param scaleWidth  缩放宽度倍数
  419.      * @param scaleHeight 缩放高度倍数
  420.      * @param recycle     是否回收
  421.      * @return 缩放后的图片
  422.      */
  423.     public static Bitmap scale(Bitmap src, float scaleWidth, float scaleHeight, boolean recycle) {
  424.         if (isEmptyBitmap(src)) return null;
  425.         Matrix matrix = new Matrix();
  426.         matrix.setScale(scaleWidth, scaleHeight);
  427.         Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
  428.         if (recycle && !src.isRecycled()) src.recycle();
  429.         return ret;
  430.     }
  432.     /**
  433.      * 裁剪图片
  434.      *
  435.      * @param src    源图片
  436.      * @param x      开始坐标x
  437.      * @param y      开始坐标y
  438.      * @param width  裁剪宽度
  439.      * @param height 裁剪高度
  440.      * @return 裁剪后的图片
  441.      */
  442.     public static Bitmap clip(Bitmap src, int x, int y, int width, int height) {
  443.         return clip(src, x, y, width, height, false);
  444.     }
  446.     /**
  447.      * 裁剪图片
  448.      *
  449.      * @param src     源图片
  450.      * @param x       开始坐标x
  451.      * @param y       开始坐标y
  452.      * @param width   裁剪宽度
  453.      * @param height  裁剪高度
  454.      * @param recycle 是否回收
  455.      * @return 裁剪后的图片
  456.      */
  457.     public static Bitmap clip(Bitmap src, int x, int y, int width, int height, boolean recycle) {
  458.         if (isEmptyBitmap(src)) return null;
  459.         Bitmap ret = Bitmap.createBitmap(src, x, y, width, height);
  460.         if (recycle && !src.isRecycled()) src.recycle();
  461.         return ret;
  462.     }
  464.     /**
  465.      * 倾斜图片
  466.      *
  467.      * @param src 源图片
  468.      * @param kx  倾斜因子x
  469.      * @param ky  倾斜因子y
  470.      * @return 倾斜后的图片
  471.      */
  472.     public static Bitmap skew(Bitmap src, float kx, float ky) {
  473.         return skew(src, kx, ky, 0, 0, false);
  474.     }
  476.     /**
  477.      * 倾斜图片
  478.      *
  479.      * @param src     源图片
  480.      * @param kx      倾斜因子x
  481.      * @param ky      倾斜因子y
  482.      * @param recycle 是否回收
  483.      * @return 倾斜后的图片
  484.      */
  485.     public static Bitmap skew(Bitmap src, float kx, float ky, boolean recycle) {
  486.         return skew(src, kx, ky, 0, 0, recycle);
  487.     }
  489.     /**
  490.      * 倾斜图片
  491.      *
  492.      * @param src 源图片
  493.      * @param kx  倾斜因子x
  494.      * @param ky  倾斜因子y
  495.      * @param px  平移因子x
  496.      * @param py  平移因子y
  497.      * @return 倾斜后的图片
  498.      */
  499.     public static Bitmap skew(Bitmap src, float kx, float ky, float px, float py) {
  500.         return skew(src, kx, ky, 0, 0, false);
  501.     }
  503.     /**
  504.      * 倾斜图片
  505.      *
  506.      * @param src     源图片
  507.      * @param kx      倾斜因子x
  508.      * @param ky      倾斜因子y
  509.      * @param px      平移因子x
  510.      * @param py      平移因子y
  511.      * @param recycle 是否回收
  512.      * @return 倾斜后的图片
  513.      */
  514.     public static Bitmap skew(Bitmap src, float kx, float ky, float px, float py, boolean recycle) {
  515.         if (isEmptyBitmap(src)) return null;
  516.         Matrix matrix = new Matrix();
  517.         matrix.setSkew(kx, ky, px, py);
  518.         Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
  519.         if (recycle && !src.isRecycled()) src.recycle();
  520.         return ret;
  521.     }
  523.     /**
  524.      * 旋转图片
  525.      *
  526.      * @param src     源图片
  527.      * @param degrees 旋转角度
  528.      * @param px      旋转点横坐标
  529.      * @param py      旋转点纵坐标
  530.      * @return 旋转后的图片
  531.      */
  532.     public static Bitmap rotate(Bitmap src, int degrees, float px, float py) {
  533.         return rotate(src, degrees, px, py, false);
  534.     }
  536.     /**
  537.      * 旋转图片
  538.      *
  539.      * @param src     源图片
  540.      * @param degrees 旋转角度
  541.      * @param px      旋转点横坐标
  542.      * @param py      旋转点纵坐标
  543.      * @param recycle 是否回收
  544.      * @return 旋转后的图片
  545.      */
  546.     public static Bitmap rotate(Bitmap src, int degrees, float px, float py, boolean recycle) {
  547.         if (isEmptyBitmap(src)) return null;
  548.         if (degrees == 0) return src;
  549.         Matrix matrix = new Matrix();
  550.         matrix.setRotate(degrees, px, py);
  551.         Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
  552.         if (recycle && !src.isRecycled()) src.recycle();
  553.         return ret;
  554.     }
  556.     /**
  557.      * 获取图片旋转角度
  558.      *
  559.      * @param filePath 文件路径
  560.      * @return 旋转角度
  561.      */
  562.     public static int getRotateDegree(String filePath) {
  563.         int degree = 0;
  564.         try {
  565.             ExifInterface exifInterface = new ExifInterface(filePath);
  566.             int orientation = exifInterface.getAttributeInt(
  567.                     ExifInterface.TAG_ORIENTATION,
  568.                     ExifInterface.ORIENTATION_NORMAL);
  569.             switch (orientation) {
  570.                 default:
  571.                 case ExifInterface.ORIENTATION_ROTATE_90:
  572.                     degree = 90;
  573.                     break;
  574.                 case ExifInterface.ORIENTATION_ROTATE_180:
  575.                     degree = 180;
  576.                     break;
  577.                 case ExifInterface.ORIENTATION_ROTATE_270:
  578.                     degree = 270;
  579.                     break;
  580.             }
  581.         } catch (IOException e) {
  582.             e.printStackTrace();
  583.         }
  584.         return degree;
  585.     }
  587.     /**
  588.      * 转为圆形图片
  589.      *
  590.      * @param src 源图片
  591.      * @return 圆形图片
  592.      */
  593.     public static Bitmap toRound(Bitmap src) {
  594.         return toRound(src, false);
  595.     }
  597.     /**
  598.      * 转为圆形图片
  599.      *
  600.      * @param src     源图片
  601.      * @param recycle 是否回收
  602.      * @return 圆形图片
  603.      */
  604.     public static Bitmap toRound(Bitmap src, boolean recycle) {
  605.         if (isEmptyBitmap(src)) return null;
  606.         int width = src.getWidth();
  607.         int height = src.getHeight();
  608.         int radius = Math.min(width, height) >> 1;
  609.         Bitmap ret = src.copy(src.getConfig(), true);
  610.         Paint paint = new Paint();
  611.         Canvas canvas = new Canvas(ret);
  612.         Rect rect = new Rect(0, 0, width, height);
  613.         paint.setAntiAlias(true);
  614.         paint.setColor(Color.TRANSPARENT);
  615.         paint.setXfermode(new PorterDuffXfermode(PorterDuff.Mode.SRC_IN));
  616.         canvas.drawARGB(0, 0, 0, 0);
  617.         canvas.drawCircle(width >> 1, height >> 1, radius, paint);
  618.         canvas.drawBitmap(src, rect, rect, paint);
  619.         if (recycle && !src.isRecycled()) src.recycle();
  620.         return ret;
  621.     }
  623.     /**
  624.      * 转为圆角图片
  625.      *
  626.      * @param src    源图片
  627.      * @param radius 圆角的度数
  628.      * @return 圆角图片
  629.      */
  630.     public static Bitmap toRoundCorner(Bitmap src, float radius) {
  631.         return toRoundCorner(src, radius, false);
  632.     }
  634.     /**
  635.      * 转为圆角图片
  636.      *
  637.      * @param src     源图片
  638.      * @param radius  圆角的度数
  639.      * @param recycle 是否回收
  640.      * @return 圆角图片
  641.      */
  642.     public static Bitmap toRoundCorner(Bitmap src, float radius, boolean recycle) {
  643.         if (null == src) return null;
  644.         int width = src.getWidth();
  645.         int height = src.getHeight();
  646.         Bitmap ret = src.copy(src.getConfig(), true);
  647.         BitmapShader bitmapShader = new BitmapShader(src,
  648.                 Shader.TileMode.CLAMP, Shader.TileMode.CLAMP);
  649.         Paint paint = new Paint();
  650.         Canvas canvas = new Canvas(ret);
  651.         RectF rectf = new RectF(0, 0, width, height);
  652.         paint.setAntiAlias(true);
  653.         paint.setShader(bitmapShader);
  654.         canvas.drawRoundRect(rectf, radius, radius, paint);
  655.         if (recycle && !src.isRecycled()) src.recycle();
  656.         return ret;
  657.     }
  659.     /**
  660.      * 快速模糊
  661.      * <p>先缩小原图，对小图进行模糊，再放大回原先尺寸</p>
  662.      *
  663.      * @param context 上下文
  664.      * @param src     源图片
  665.      * @param scale   缩小倍数(0...1)
  666.      * @param radius  模糊半径
  667.      * @return 模糊后的图片
  668.      */
  669.     public static Bitmap fastBlur(Context context, Bitmap src, float scale, float radius) {
  670.         return fastBlur(context, src, scale, radius, false);
  671.     }
  673.     /**
  674.      * 快速模糊
  675.      * <p>先缩小原图，对小图进行模糊，再放大回原先尺寸</p>
  676.      *
  677.      * @param context 上下文
  678.      * @param src     源图片
  679.      * @param scale   缩小倍数(0...1)
  680.      * @param radius  模糊半径
  681.      * @param recycle 是否回收
  682.      * @return 模糊后的图片
  683.      */
  684.     public static Bitmap fastBlur(Context context, Bitmap src, float scale, float radius, boolean recycle) {
  685.         if (isEmptyBitmap(src)) return null;
  686.         int width = src.getWidth();
  687.         int height = src.getHeight();
  688.         int scaleWidth = (int) (width * scale + 0.5f);
  689.         int scaleHeight = (int) (height * scale + 0.5f);
  690.         if (scaleWidth == 0 || scaleHeight == 0) return null;
  691.         Bitmap scaleBitmap = Bitmap.createScaledBitmap(src, scaleWidth, scaleHeight, true);
  692.         Paint paint = new Paint(Paint.FILTER_BITMAP_FLAG | Paint.ANTI_ALIAS_FLAG);
  693.         Canvas canvas = new Canvas();
  694.         PorterDuffColorFilter filter = new PorterDuffColorFilter(
  695.                 Color.TRANSPARENT, PorterDuff.Mode.SRC_ATOP);
  696.         paint.setColorFilter(filter);
  697.         canvas.scale(scale, scale);
  698.         canvas.drawBitmap(scaleBitmap, 0, 0, paint);
  699.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) {
  700.             scaleBitmap = renderScriptBlur(context, scaleBitmap, radius);
  701.         } else {
  702.             scaleBitmap = stackBlur(scaleBitmap, (int) radius, true);
  703.         }
  704.         if (scale == 1) return scaleBitmap;
  705.         Bitmap ret = Bitmap.createScaledBitmap(scaleBitmap, width, height, true);
  706.         if (scaleBitmap != null && !scaleBitmap.isRecycled()) scaleBitmap.recycle();
  707.         if (recycle && !src.isRecycled()) src.recycle();
  708.         return ret;
  709.     }
  711.     /**
  712.      * renderScript模糊图片
  713.      * <p>API大于17</p>
  714.      *
  715.      * @param context 上下文
  716.      * @param src     源图片
  717.      * @param radius  模糊度(0...25)
  718.      * @return 模糊后的图片
  719.      */
  720.     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
  721.     public static Bitmap renderScriptBlur(Context context, Bitmap src, float radius) {
  722.         if (isEmptyBitmap(src)) return null;
  723.         RenderScript rs = null;
  724.         try {
  725.             rs = RenderScript.create(context);
  726.             rs.setMessageHandler(new RenderScript.RSMessageHandler());
  727.             Allocation input = Allocation.createFromBitmap(rs, src, Allocation.MipmapControl.MIPMAP_NONE, Allocation
  728.                     .USAGE_SCRIPT);
  729.             Allocation output = Allocation.createTyped(rs, input.getType());
  730.             ScriptIntrinsicBlur blurScript = ScriptIntrinsicBlur.create(rs, Element.U8_4(rs));
  731.             if (radius > 25) {
  732.                 radius = 25.0f;
  733.             } else if (radius <= 0) {
  734.                 radius = 1.0f;
  735.             }
  736.             blurScript.setInput(input);
  737.             blurScript.setRadius(radius);
  738.             blurScript.forEach(output);
  739.             output.copyTo(src);
  740.         } finally {
  741.             if (rs != null) {
  742.                 rs.destroy();
  743.             }
  744.         }
  745.         return src;
  746.     }
  748.     /**
  749.      * stack模糊图片
  750.      *
  751.      * @param src     源图片
  752.      * @param radius  模糊半径
  753.      * @param recycle 是否回收
  754.      * @return stackBlur模糊图片
  755.      */
  756.     public static Bitmap stackBlur(Bitmap src, int radius, boolean recycle) {
  757.         Bitmap ret;
  758.         if (recycle) {
  759.             ret = src;
  760.         } else {
  761.             ret = src.copy(src.getConfig(), true);
  762.         }
  764.         if (radius < 1) {
  765.             return (null);
  766.         }
  768.         int w = ret.getWidth();
  769.         int h = ret.getHeight();
  771.         int[] pix = new int[w * h];
  772.         ret.getPixels(pix, 0, w, 0, 0, w, h);
  774.         int wm = w - 1;
  775.         int hm = h - 1;
  776.         int wh = w * h;
  777.         int div = radius + radius + 1;
  779.         int r[] = new int[wh];
  780.         int g[] = new int[wh];
  781.         int b[] = new int[wh];
  782.         int rsum, gsum, bsum, x, y, i, p, yp, yi, yw;
  783.         int vmin[] = new int[Math.max(w, h)];
  785.         int divsum = (div + 1) >> 1;
  786.         divsum *= divsum;
  787.         int dv[] = new int[256 * divsum];
  788.         for (i = 0; i < 256 * divsum; i++) {
  789.             dv[i] = (i / divsum);
  790.         }
  792.         yw = yi = 0;
  794.         int[][] stack = new int[div][3];
  795.         int stackpointer;
  796.         int stackstart;
  797.         int[] sir;
  798.         int rbs;
  799.         int r1 = radius + 1;
  800.         int routsum, goutsum, boutsum;
  801.         int rinsum, ginsum, binsum;
  803.         for (y = 0; y < h; y++) {
  804.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
  805.             for (i = -radius; i <= radius; i++) {
  806.                 p = pix[yi + Math.min(wm, Math.max(i, 0))];
  807.                 sir = stack[i + radius];
  808.                 sir[0] = (p & 0xff0000) >> 16;
  809.                 sir[1] = (p & 0x00ff00) >> 8;
  810.                 sir[2] = (p & 0x0000ff);
  811.                 rbs = r1 - Math.abs(i);
  812.                 rsum += sir[0] * rbs;
  813.                 gsum += sir[1] * rbs;
  814.                 bsum += sir[2] * rbs;
  815.                 if (i > 0) {
  816.                     rinsum += sir[0];
  817.                     ginsum += sir[1];
  818.                     binsum += sir[2];
  819.                 } else {
  820.                     routsum += sir[0];
  821.                     goutsum += sir[1];
  822.                     boutsum += sir[2];
  823.                 }
  824.             }
  825.             stackpointer = radius;
  827.             for (x = 0; x < w; x++) {
  829.                 r[yi] = dv[rsum];
  830.                 g[yi] = dv[gsum];
  831.                 b[yi] = dv[bsum];
  833.                 rsum -= routsum;
  834.                 gsum -= goutsum;
  835.                 bsum -= boutsum;
  837.                 stackstart = stackpointer - radius + div;
  838.                 sir = stack[stackstart % div];
  840.                 routsum -= sir[0];
  841.                 goutsum -= sir[1];
  842.                 boutsum -= sir[2];
  844.                 if (y == 0) {
  845.                     vmin[x] = Math.min(x + radius + 1, wm);
  846.                 }
  847.                 p = pix[yw + vmin[x]];
  849.                 sir[0] = (p & 0xff0000) >> 16;
  850.                 sir[1] = (p & 0x00ff00) >> 8;
  851.                 sir[2] = (p & 0x0000ff);
  853.                 rinsum += sir[0];
  854.                 ginsum += sir[1];
  855.                 binsum += sir[2];
  857.                 rsum += rinsum;
  858.                 gsum += ginsum;
  859.                 bsum += binsum;
  861.                 stackpointer = (stackpointer + 1) % div;
  862.                 sir = stack[(stackpointer) % div];
  864.                 routsum += sir[0];
  865.                 goutsum += sir[1];
  866.                 boutsum += sir[2];
  868.                 rinsum -= sir[0];
  869.                 ginsum -= sir[1];
  870.                 binsum -= sir[2];
  872.                 yi++;
  873.             }
  874.             yw += w;
  875.         }
  876.         for (x = 0; x < w; x++) {
  877.             rinsum = ginsum = binsum = routsum = goutsum = boutsum = rsum = gsum = bsum = 0;
  878.             yp = -radius * w;
  879.             for (i = -radius; i <= radius; i++) {
  880.                 yi = Math.max(0, yp) + x;
  882.                 sir = stack[i + radius];
  884.                 sir[0] = r[yi];
  885.                 sir[1] = g[yi];
  886.                 sir[2] = b[yi];
  888.                 rbs = r1 - Math.abs(i);
  890.                 rsum += r[yi] * rbs;
  891.                 gsum += g[yi] * rbs;
  892.                 bsum += b[yi] * rbs;
  894.                 if (i > 0) {
  895.                     rinsum += sir[0];
  896.                     ginsum += sir[1];
  897.                     binsum += sir[2];
  898.                 } else {
  899.                     routsum += sir[0];
  900.                     goutsum += sir[1];
  901.                     boutsum += sir[2];
  902.                 }
  904.                 if (i < hm) {
  905.                     yp += w;
  906.                 }
  907.             }
  908.             yi = x;
  909.             stackpointer = radius;
  910.             for (y = 0; y < h; y++) {
  911.                 // Preserve alpha channel: ( 0xff000000 & pix[yi] )
  912.                 pix[yi] = (0xff000000 & pix[yi]) | (dv[rsum] << 16) | (dv[gsum] << 8) | dv[bsum];
  914.                 rsum -= routsum;
  915.                 gsum -= goutsum;
  916.                 bsum -= boutsum;
  918.                 stackstart = stackpointer - radius + div;
  919.                 sir = stack[stackstart % div];
  921.                 routsum -= sir[0];
  922.                 goutsum -= sir[1];
  923.                 boutsum -= sir[2];
  925.                 if (x == 0) {
  926.                     vmin[y] = Math.min(y + r1, hm) * w;
  927.                 }
  928.                 p = x + vmin[y];
  930.                 sir[0] = r[p];
  931.                 sir[1] = g[p];
  932.                 sir[2] = b[p];
  934.                 rinsum += sir[0];
  935.                 ginsum += sir[1];
  936.                 binsum += sir[2];
  938.                 rsum += rinsum;
  939.                 gsum += ginsum;
  940.                 bsum += binsum;
  942.                 stackpointer = (stackpointer + 1) % div;
  943.                 sir = stack[stackpointer];
  945.                 routsum += sir[0];
  946.                 goutsum += sir[1];
  947.                 boutsum += sir[2];
  949.                 rinsum -= sir[0];
  950.                 ginsum -= sir[1];
  951.                 binsum -= sir[2];
  953.                 yi += w;
  954.             }
  955.         }
  956.         ret.setPixels(pix, 0, w, 0, 0, w, h);
  957.         return (ret);
  958.     }
  960.     /**
  961.      * 添加颜色边框
  962.      *
  963.      * @param src         源图片
  964.      * @param borderWidth 边框宽度
  965.      * @param color       边框的颜色值
  966.      * @return 带颜色边框图
  967.      */
  968.     public static Bitmap addFrame(Bitmap src, int borderWidth, int color) {
  969.         return addFrame(src, borderWidth, color);
  970.     }
  972.     /**
  973.      * 添加颜色边框
  974.      *
  975.      * @param src         源图片
  976.      * @param borderWidth 边框宽度
  977.      * @param color       边框的颜色值
  978.      * @param recycle     是否回收
  979.      * @return 带颜色边框图
  980.      */
  981.     public static Bitmap addFrame(Bitmap src, int borderWidth, int color, boolean recycle) {
  982.         if (isEmptyBitmap(src)) return null;
  983.         int newWidth = src.getWidth() + borderWidth >> 1;
  984.         int newHeight = src.getHeight() + borderWidth >> 1;
  985.         Bitmap ret = Bitmap.createBitmap(newWidth, newHeight, src.getConfig());
  986.         Canvas canvas = new Canvas(ret);
  987.         Rect rec = canvas.getClipBounds();
  988.         Paint paint = new Paint();
  989.         paint.setColor(color);
  990.         paint.setStyle(Paint.Style.STROKE);
  991.         paint.setStrokeWidth(borderWidth);
  992.         canvas.drawRect(rec, paint);
  993.         canvas.drawBitmap(src, borderWidth, borderWidth, null);
  994.         if (recycle && !src.isRecycled()) src.recycle();
  995.         return ret;
  996.     }
  998.     /**
  999.      * 添加倒影
  1000.      *
  1001.      * @param src              源图片的
  1002.      * @param reflectionHeight 倒影高度
  1003.      * @return 带倒影图片
  1004.      */
  1005.     public static Bitmap addReflection(Bitmap src, int reflectionHeight) {
  1006.         return addReflection(src, reflectionHeight, false);
  1007.     }
  1009.     /**
  1010.      * 添加倒影
  1011.      *
  1012.      * @param src              源图片的
  1013.      * @param reflectionHeight 倒影高度
  1014.      * @param recycle          是否回收
  1015.      * @return 带倒影图片
  1016.      */
  1017.     public static Bitmap addReflection(Bitmap src, int reflectionHeight, boolean recycle) {
  1018.         if (isEmptyBitmap(src)) return null;
  1019.         final int REFLECTION_GAP = 0;
  1020.         int srcWidth = src.getWidth();
  1021.         int srcHeight = src.getHeight();
  1022.         if (0 == srcWidth || srcHeight == 0) return null;
  1023.         Matrix matrix = new Matrix();
  1024.         matrix.preScale(1, -1);
  1025.         Bitmap reflectionBitmap = Bitmap.createBitmap(src, 0, srcHeight - reflectionHeight,
  1026.                 srcWidth, reflectionHeight, matrix, false);
  1027.         if (null == reflectionBitmap) return null;
  1028.         Bitmap ret = Bitmap.createBitmap(srcWidth, srcHeight + reflectionHeight, src.getConfig());
  1029.         Canvas canvas = new Canvas(ret);
  1030.         canvas.drawBitmap(src, 0, 0, null);
  1031.         canvas.drawBitmap(reflectionBitmap, 0, srcHeight + REFLECTION_GAP, null);
  1032.         Paint paint = new Paint();
  1033.         paint.setAntiAlias(true);
  1034.         LinearGradient shader = new LinearGradient(0, srcHeight, 0,
  1035.                 ret.getHeight() + REFLECTION_GAP,
  1036.                 0x70FFFFFF, 0x00FFFFFF, Shader.TileMode.MIRROR);
  1037.         paint.setShader(shader);
  1038.         paint.setXfermode(new PorterDuffXfermode(
  1039.                 android.graphics.PorterDuff.Mode.DST_IN));
  1040.         canvas.save();
  1041.         canvas.drawRect(0, srcHeight, srcWidth,
  1042.                 ret.getHeight() + REFLECTION_GAP, paint);
  1043.         canvas.restore();
  1044.         if (!reflectionBitmap.isRecycled()) reflectionBitmap.recycle();
  1045.         if (recycle && !src.isRecycled()) src.recycle();
  1046.         return ret;
  1047.     }
  1049.     /**
  1050.      * 添加文字水印
  1051.      *
  1052.      * @param src      源图片
  1053.      * @param content  水印文本
  1054.      * @param textSize 水印字体大小
  1055.      * @param color    水印字体颜色
  1056.      * @param alpha    水印字体透明度
  1057.      * @param x        起始坐标x
  1058.      * @param y        起始坐标y
  1059.      * @return 带有文字水印的图片
  1060.      */
  1061.     public static Bitmap addTextWatermark(Bitmap src, String content, int textSize, int color, int alpha, float x, float y) {
  1062.         return addTextWatermark(src, content, textSize, color, alpha, x, y, false);
  1063.     }
  1065.     /**
  1066.      * 添加文字水印
  1067.      *
  1068.      * @param src      源图片
  1069.      * @param content  水印文本
  1070.      * @param textSize 水印字体大小
  1071.      * @param color    水印字体颜色
  1072.      * @param alpha    水印字体透明度
  1073.      * @param x        起始坐标x
  1074.      * @param y        起始坐标y
  1075.      * @param recycle  是否回收
  1076.      * @return 带有文字水印的图片
  1077.      */
  1078.     public static Bitmap addTextWatermark(Bitmap src, String content, int textSize, int color, int alpha, float x, float y, boolean recycle) {
  1079.         if (isEmptyBitmap(src) || content == null) return null;
  1080.         Bitmap ret = src.copy(src.getConfig(), true);
  1081.         Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
  1082.         Canvas canvas = new Canvas(ret);
  1083.         paint.setAlpha(alpha);
  1084.         paint.setColor(color);
  1085.         paint.setTextSize(textSize);
  1086.         Rect bounds = new Rect();
  1087.         paint.getTextBounds(content, 0, content.length(), bounds);
  1088.         canvas.drawText(content, x, y, paint);
  1089.         if (recycle && !src.isRecycled()) src.recycle();
  1090.         return ret;
  1091.     }
  1093.     /**
  1094.      * 添加图片水印
  1095.      *
  1096.      * @param src       源图片
  1097.      * @param watermark 图片水印
  1098.      * @param x         起始坐标x
  1099.      * @param y         起始坐标y
  1100.      * @param alpha     透明度
  1101.      * @return 带有图片水印的图片
  1102.      */
  1103.     public static Bitmap addImageWatermark(Bitmap src, Bitmap watermark, int x, int y, int alpha) {
  1104.         return addImageWatermark(src, watermark, x, y, alpha, false);
  1105.     }
  1107.     /**
  1108.      * 添加图片水印
  1109.      *
  1110.      * @param src       源图片
  1111.      * @param watermark 图片水印
  1112.      * @param x         起始坐标x
  1113.      * @param y         起始坐标y
  1114.      * @param alpha     透明度
  1115.      * @param recycle   是否回收
  1116.      * @return 带有图片水印的图片
  1117.      */
  1118.     public static Bitmap addImageWatermark(Bitmap src, Bitmap watermark, int x, int y, int alpha, boolean recycle) {
  1119.         if (isEmptyBitmap(src)) return null;
  1120.         Bitmap ret = src.copy(src.getConfig(), true);
  1121.         if (!isEmptyBitmap(watermark)) {
  1122.             Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
  1123.             Canvas canvas = new Canvas(ret);
  1124.             paint.setAlpha(alpha);
  1125.             canvas.drawBitmap(watermark, x, y, paint);
  1126.         }
  1127.         if (recycle && !src.isRecycled()) src.recycle();
  1128.         return ret;
  1129.     }
  1131.     /**
  1132.      * 转为alpha位图
  1133.      *
  1134.      * @param src 源图片
  1135.      * @return alpha位图
  1136.      */
  1137.     public static Bitmap toAlpha(Bitmap src) {
  1138.         return toAlpha(src);
  1139.     }
  1141.     /**
  1142.      * 转为alpha位图
  1143.      *
  1144.      * @param src     源图片
  1145.      * @param recycle 是否回收
  1146.      * @return alpha位图
  1147.      */
  1148.     public static Bitmap toAlpha(Bitmap src, Boolean recycle) {
  1149.         if (isEmptyBitmap(src)) return null;
  1150.         Bitmap ret = src.extractAlpha();
  1151.         if (recycle && !src.isRecycled()) src.recycle();
  1152.         return ret;
  1153.     }
  1155.     /**
  1156.      * 转为灰度图片
  1157.      *
  1158.      * @param src 源图片
  1159.      * @return 灰度图
  1160.      */
  1161.     public static Bitmap toGray(Bitmap src) {
  1162.         return toGray(src, false);
  1163.     }
  1165.     /**
  1166.      * 转为灰度图片
  1167.      *
  1168.      * @param src     源图片
  1169.      * @param recycle 是否回收
  1170.      * @return 灰度图
  1171.      */
  1172.     public static Bitmap toGray(Bitmap src, boolean recycle) {
  1173.         if (isEmptyBitmap(src)) return null;
  1174.         Bitmap grayBitmap = Bitmap.createBitmap(src.getWidth(),
  1175.                 src.getHeight(), Bitmap.Config.RGB_565);
  1176.         Canvas canvas = new Canvas(grayBitmap);
  1177.         Paint paint = new Paint();
  1178.         ColorMatrix colorMatrix = new ColorMatrix();
  1179.         colorMatrix.setSaturation(0);
  1180.         ColorMatrixColorFilter colorMatrixColorFilter = new ColorMatrixColorFilter(colorMatrix);
  1181.         paint.setColorFilter(colorMatrixColorFilter);
  1182.         canvas.drawBitmap(src, 0, 0, paint);
  1183.         if (recycle && !src.isRecycled()) src.recycle();
  1184.         return grayBitmap;
  1185.     }
  1187.     /**
  1188.      * 保存图片
  1189.      *
  1190.      * @param src      源图片
  1191.      * @param filePath 要保存到的文件路径
  1192.      * @param format   格式
  1193.      * @return {@code true}: 成功<br>{@code false}: 失败
  1194.      */
  1195.     public static boolean save(Bitmap src, String filePath, CompressFormat format) {
  1196.         return save(src, FileUtils.getFileByPath(filePath), format, false);
  1197.     }
  1199.     /**
  1200.      * 保存图片
  1201.      *
  1202.      * @param src    源图片
  1203.      * @param file   要保存到的文件
  1204.      * @param format 格式
  1205.      * @return {@code true}: 成功<br>{@code false}: 失败
  1206.      */
  1207.     public static boolean save(Bitmap src, File file, CompressFormat format) {
  1208.         return save(src, file, format, false);
  1209.     }
  1211.     /**
  1212.      * 保存图片
  1213.      *
  1214.      * @param src      源图片
  1215.      * @param filePath 要保存到的文件路径
  1216.      * @param format   格式
  1217.      * @param recycle  是否回收
  1218.      * @return {@code true}: 成功<br>{@code false}: 失败
  1219.      */
  1220.     public static boolean save(Bitmap src, String filePath, CompressFormat format, boolean recycle) {
  1221.         return save(src, FileUtils.getFileByPath(filePath), format, recycle);
  1222.     }
  1224.     /**
  1225.      * 保存图片
  1226.      *
  1227.      * @param src     源图片
  1228.      * @param file    要保存到的文件
  1229.      * @param format  格式
  1230.      * @param recycle 是否回收
  1231.      * @return {@code true}: 成功<br>{@code false}: 失败
  1232.      */
  1233.     public static boolean save(Bitmap src, File file, CompressFormat format, boolean recycle) {
  1234.         if (isEmptyBitmap(src) || !FileUtils.createOrExistsFile(file)) return false;
  1235.         System.out.println(src.getWidth() + ", " + src.getHeight());
  1236.         OutputStream os = null;
  1237.         boolean ret = false;
  1238.         try {
  1239.             os = new BufferedOutputStream(new FileOutputStream(file));
  1240.             ret = src.compress(format, 100, os);
  1241.             if (recycle && !src.isRecycled()) src.recycle();
  1242.         } catch (IOException e) {
  1243.             e.printStackTrace();
  1244.         } finally {
  1245.             FileUtils.closeIO(os);
  1246.         }
  1247.         return ret;
  1248.     }
  1250.     /**
  1251.      * 根据文件名判断文件是否为图片
  1252.      *
  1253.      * @param file 　文件
  1254.      * @return {@code true}: 是<br>{@code false}: 否
  1255.      */
  1256.     public static boolean isImage(File file) {
  1257.         return file != null && isImage(file.getPath());
  1258.     }
  1260.     /**
  1261.      * 根据文件名判断文件是否为图片
  1262.      *
  1263.      * @param filePath 　文件路径
  1264.      * @return {@code true}: 是<br>{@code false}: 否
  1265.      */
  1266.     public static boolean isImage(String filePath) {
  1267.         String path = filePath.toUpperCase();
  1268.         return path.endsWith(".PNG") || path.endsWith(".JPG")
  1269.                 || path.endsWith(".JPEG") || path.endsWith(".BMP")
  1270.                 || path.endsWith(".GIF");
  1271.     }
  1273.     /**
  1274.      * 获取图片类型
  1275.      *
  1276.      * @param filePath 文件路径
  1277.      * @return 图片类型
  1278.      */
  1279.     public static String getImageType(String filePath) {
  1280.         return getImageType(FileUtils.getFileByPath(filePath));
  1281.     }
  1283.     /**
  1284.      * 获取图片类型
  1285.      *
  1286.      * @param file 文件
  1287.      * @return 图片类型
  1288.      */
  1289.     public static String getImageType(File file) {
  1290.         if (file == null) return null;
  1291.         InputStream is = null;
  1292.         try {
  1293.             is = new FileInputStream(file);
  1294.             return getImageType(is);
  1295.         } catch (IOException e) {
  1296.             e.printStackTrace();
  1297.             return null;
  1298.         } finally {
  1299.             FileUtils.closeIO(is);
  1300.         }
  1301.     }
  1303.     /**
  1304.      * 流获取图片类型
  1305.      *
  1306.      * @param is 图片输入流
  1307.      * @return 图片类型
  1308.      */
  1309.     public static String getImageType(InputStream is) {
  1310.         if (is == null) return null;
  1311.         try {
  1312.             byte[] bytes = new byte[8];
  1313.             return is.read(bytes, 0, 8) != -1 ? getImageType(bytes) : null;
  1314.         } catch (IOException e) {
  1315.             e.printStackTrace();
  1316.             return null;
  1317.         }
  1318.     }
  1320.     /**
  1321.      * 获取图片类型
  1322.      *
  1323.      * @param bytes bitmap的前8字节
  1324.      * @return 图片类型
  1325.      */
  1326.     public static String getImageType(byte[] bytes) {
  1327.         if (isJPEG(bytes)) return "JPEG";
  1328.         if (isGIF(bytes)) return "GIF";
  1329.         if (isPNG(bytes)) return "PNG";
  1330.         if (isBMP(bytes)) return "BMP";
  1331.         return null;
  1332.     }
  1334.     private static boolean isJPEG(byte[] b) {
  1335.         return b.length >= 2
  1336.                 && (b[0] == (byte) 0xFF) && (b[1] == (byte) 0xD8);
  1337.     }
  1339.     private static boolean isGIF(byte[] b) {
  1340.         return b.length >= 6
  1341.                 && b[0] == 'G' && b[1] == 'I'
  1342.                 && b[2] == 'F' && b[3] == '8'
  1343.                 && (b[4] == '7' || b[4] == '9') && b[5] == 'a';
  1344.     }
  1346.     private static boolean isPNG(byte[] b) {
  1347.         return b.length >= 8
  1348.                 && (b[0] == (byte) 137 && b[1] == (byte) 80
  1349.                 && b[2] == (byte) 78 && b[3] == (byte) 71
  1350.                 && b[4] == (byte) 13 && b[5] == (byte) 10
  1351.                 && b[6] == (byte) 26 && b[7] == (byte) 10);
  1352.     }
  1354.     private static boolean isBMP(byte[] b) {
  1355.         return b.length >= 2
  1356.                 && (b[0] == 0x42) && (b[1] == 0x4d);
  1357.     }
  1359.     /**
  1360.      * 判断bitmap对象是否为空
  1361.      *
  1362.      * @param src 源图片
  1363.      * @return {@code true}: 是<br>{@code false}: 否
  1364.      */
  1365.     private static boolean isEmptyBitmap(Bitmap src) {
  1366.         return src == null || src.getWidth() == 0 || src.getHeight() == 0;
  1367.     }
  1369.     /******************************~~~~~~~~~ 下方和压缩有关 ~~~~~~~~~******************************/
  1371.     /**
  1372.      * 按缩放压缩
  1373.      *
  1374.      * @param src       源图片
  1375.      * @param newWidth  新宽度
  1376.      * @param newHeight 新高度
  1377.      * @return 缩放压缩后的图片
  1378.      */
  1379.     public static Bitmap compressByScale(Bitmap src, int newWidth, int newHeight) {
  1380.         return scale(src, newWidth, newHeight, false);
  1381.     }
  1383.     /**
  1384.      * 按缩放压缩
  1385.      *
  1386.      * @param src       源图片
  1387.      * @param newWidth  新宽度
  1388.      * @param newHeight 新高度
  1389.      * @param recycle   是否回收
  1390.      * @return 缩放压缩后的图片
  1391.      */
  1392.     public static Bitmap compressByScale(Bitmap src, int newWidth, int newHeight, boolean recycle) {
  1393.         return scale(src, newWidth, newHeight, recycle);
  1394.     }
  1396.     /**
  1397.      * 按缩放压缩
  1398.      *
  1399.      * @param src         源图片
  1400.      * @param scaleWidth  缩放宽度倍数
  1401.      * @param scaleHeight 缩放高度倍数
  1402.      * @return 缩放压缩后的图片
  1403.      */
  1404.     public static Bitmap compressByScale(Bitmap src, float scaleWidth, float scaleHeight) {
  1405.         return scale(src, scaleWidth, scaleHeight, false);
  1406.     }
  1408.     /**
  1409.      * 按缩放压缩
  1410.      *
  1411.      * @param src         源图片
  1412.      * @param scaleWidth  缩放宽度倍数
  1413.      * @param scaleHeight 缩放高度倍数
  1414.      * @param recycle     是否回收
  1415.      * @return 缩放压缩后的图片
  1416.      */
  1417.     public static Bitmap compressByScale(Bitmap src, float scaleWidth, float scaleHeight, boolean recycle) {
  1418.         return scale(src, scaleWidth, scaleHeight, recycle);
  1419.     }
  1421.     /**
  1422.      * 按质量压缩
  1423.      *
  1424.      * @param src     源图片
  1425.      * @param quality 质量
  1426.      * @return 质量压缩后的图片
  1427.      */
  1428.     public static Bitmap compressByQuality(Bitmap src, int quality) {
  1429.         return compressByQuality(src, quality, false);
  1430.     }
  1432.     /**
  1433.      * 按质量压缩
  1434.      *
  1435.      * @param src     源图片
  1436.      * @param quality 质量
  1437.      * @param recycle 是否回收
  1438.      * @return 质量压缩后的图片
  1439.      */
  1440.     public static Bitmap compressByQuality(Bitmap src, int quality, boolean recycle) {
  1441.         if (isEmptyBitmap(src) || quality < 0 || quality > 100) return null;
  1442.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  1443.         src.compress(Bitmap.CompressFormat.JPEG, quality, baos);
  1444.         byte[] bytes = baos.toByteArray();
  1445.         if (recycle && !src.isRecycled()) src.recycle();
  1446.         return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
  1447.     }
  1449.     /**
  1450.      * 按质量压缩
  1451.      *
  1452.      * @param src         源图片
  1453.      * @param maxByteSize 允许最大值字节数
  1454.      * @return 质量压缩压缩过的图片
  1455.      */
  1456.     public static Bitmap compressByQuality(Bitmap src, long maxByteSize) {
  1457.         return compressByQuality(src, maxByteSize, false);
  1458.     }
  1460.     /**
  1461.      * 按质量压缩
  1462.      *
  1463.      * @param src         源图片
  1464.      * @param maxByteSize 允许最大值字节数
  1465.      * @param recycle     是否回收
  1466.      * @return 质量压缩压缩过的图片
  1467.      */
  1468.     public static Bitmap compressByQuality(Bitmap src, long maxByteSize, boolean recycle) {
  1469.         if (isEmptyBitmap(src) || maxByteSize <= 0) return null;
  1470.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  1471.         int quality = 100;
  1472.         src.compress(CompressFormat.JPEG, quality, baos);
  1473.         while (baos.toByteArray().length > maxByteSize && quality >= 0) {
  1474.             baos.reset();
  1475.             src.compress(CompressFormat.JPEG, quality -= 5, baos);
  1476.         }
  1477.         if (quality < 0) return null;
  1478.         byte[] bytes = baos.toByteArray();
  1479.         if (recycle && !src.isRecycled()) src.recycle();
  1480.         return BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
  1481.     }
  1483.     /**
  1484.      * 按采样大小压缩
  1485.      *
  1486.      * @param src        源图片
  1487.      * @param sampleSize 采样率大小
  1488.      * @return 按采样率压缩后的图片
  1489.      */
  1490.     public static Bitmap compressBySampleSize(Bitmap src, int sampleSize) {
  1491.         return compressBySampleSize(src, sampleSize, false);
  1492.     }
  1494.     /**
  1495.      * 按采样大小压缩
  1496.      *
  1497.      * @param src        源图片
  1498.      * @param sampleSize 采样率大小
  1499.      * @param recycle    是否回收
  1500.      * @return 按采样率压缩后的图片
  1501.      */
  1502.     public static Bitmap compressBySampleSize(Bitmap src, int sampleSize, boolean recycle) {
  1503.         if (isEmptyBitmap(src)) return null;
  1504.         BitmapFactory.Options options = new BitmapFactory.Options();
  1505.         options.inSampleSize = sampleSize;
  1506.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  1507.         src.compress(Bitmap.CompressFormat.JPEG, 100, baos);
  1508.         byte[] bytes = baos.toByteArray();
  1509.         if (recycle && !src.isRecycled()) src.recycle();
  1510.         return BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
  1511.     }
  1512. }

IntentUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.ComponentName;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.net.Uri;
  7. import android.os.Build;
  8. import android.os.Bundle;
  9. import android.webkit.MimeTypeMap;
  11. import java.io.File;
  13. /**
  14.  * <pre>
  15.  *     author: Blankj
  16.  *     blog  : http://blankj.com
  17.  *     time  : 2016/9/23
  18.  *     desc  : Intent相关工具类
  19.  * </pre>
  20.  */
  21. public class IntentUtils {
  23.     private IntentUtils() {
  24.         throw new UnsupportedOperationException("u can't fuck me...");
  25.     }
  27.     /**
  28.      * 获取安装App(支持6.0)的意图
  29.      *
  30.      * @param filePath 文件路径
  31.      * @return 意图
  32.      */
  33.     public static Intent getInstallAppIntent(String filePath) {
  34.         return getInstallAppIntent(FileUtils.getFileByPath(filePath));
  35.     }
  37.     /**
  38.      * 获取安装App(支持6.0)的意图
  39.      *
  40.      * @param file 文件
  41.      * @return 意图
  42.      */
  43.     public static Intent getInstallAppIntent(File file) {
  44.         if (file == null) return null;
  45.         Intent intent = new Intent(Intent.ACTION_VIEW);
  46.         intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  47.         String type;
  48.         if (Build.VERSION.SDK_INT < 23) {
  49.             type = "application/vnd.android.package-archive";
  50.         } else {
  51.             type = MimeTypeMap.getSingleton().getMimeTypeFromExtension(FileUtils.getFileExtension(file));
  52.         }
  53.         return intent.setDataAndType(Uri.fromFile(file), type);
  54.     }
  56.     /**
  57.      * 获取卸载App的意图
  58.      *
  59.      * @param packageName 包名
  60.      * @return 意图
  61.      */
  62.     public Intent getUninstallAppIntent(String packageName) {
  63.         Intent intent = new Intent(Intent.ACTION_DELETE);
  64.         intent.setData(Uri.parse("package:" + packageName));
  65.         return intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  66.     }
  68.     /**
  69.      * 获取打开App的意图
  70.      *
  71.      * @param context     上下文
  72.      * @param packageName 包名
  73.      * @return 意图
  74.      */
  75.     public static Intent getLaunchAppItent(Context context, String packageName) {
  76.         return getIntentByPackageName(context, packageName);
  77.     }
  79.     /**
  80.      * 获取App信息的意图
  81.      *
  82.      * @param packageName 包名
  83.      * @return 意图
  84.      */
  85.     public static Intent getAppInfoIntent(String packageName) {
  86.         Intent intent = new Intent("android.settings.APPLICATION_DETAILS_SETTINGS");
  87.         return intent.setData(Uri.parse("package:" + packageName));
  88.     }
  90.     /**
  91.      * 获取App信息分享的意图
  92.      *
  93.      * @param info 分享信息
  94.      * @return 意图
  95.      */
  96.     public static Intent getShareInfoIntent(String info) {
  97.         Intent intent = new Intent(Intent.ACTION_SEND);
  98.         intent.setType("text/plain");
  99.         return intent.putExtra(Intent.EXTRA_TEXT, info);
  100.     }
  102.     /**
  103.      * 根据包名获取意图
  104.      *
  105.      * @param context     上下文
  106.      * @param packageName 包名
  107.      * @return 意图
  108.      */
  109.     private static Intent getIntentByPackageName(Context context, String packageName) {
  110.         return context.getPackageManager().getLaunchIntentForPackage(packageName);
  111.     }
  113.     /**
  114.      * 获取其他应用的Intent
  115.      *
  116.      * @param packageName 包名
  117.      * @param className   全类名
  118.      * @return 意图
  119.      */
  120.     public static Intent getComponentNameIntent(String packageName, String className) {
  121.         return getComponentNameIntent(packageName, className, null);
  122.     }
  124.     /**
  125.      * 获取其他应用的Intent
  126.      *
  127.      * @param packageName 包名
  128.      * @param className   全类名
  129.      * @return 意图
  130.      */
  131.     public static Intent getComponentNameIntent(String packageName, String className, Bundle bundle) {
  132.         Intent intent = new Intent(Intent.ACTION_VIEW);
  133.         if (bundle != null) intent.putExtras(bundle);
  134.         ComponentName cn = new ComponentName(packageName, className);
  135.         intent.setComponent(cn);
  136.         return intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
  137.     }
  138. }

KeyboardUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.Activity;
  4. import android.content.Context;
  5. import android.util.Log;
  6. import android.view.View;
  7. import android.view.inputmethod.InputMethodManager;
  8. import android.widget.EditText;
  10. /**
  11.  * <pre>
  12.  *     author: Blankj
  13.  *     blog  : http://blankj.com
  14.  *     time  : 2016/8/2
  15.  *     desc  : 键盘相关工具类
  16.  * </pre>
  17.  */
  18. public class KeyboardUtils {
  20.     private KeyboardUtils() {
  21.         throw new UnsupportedOperationException("u can't fuck me...");
  22.     }
  24.     /**
  25.      * 避免输入法面板遮挡
  26.      * <p>在manifest.xml中activity中设置</p>
  27.      * <p>android:windowSoftInputMode="stateVisible|adjustResize"</p>
  28.      */
  30.     /**
  31.      * 动态隐藏软键盘
  32.      *
  33.      * @param activity activity
  34.      */
  35.     public static void hideSoftInput(Activity activity) {
  36.         View view = activity.getWindow().peekDecorView();
  37.         if (view != null) {
  38.             InputMethodManager inputmanger = (InputMethodManager) activity
  39.                     .getSystemService(Context.INPUT_METHOD_SERVICE);
  40.             inputmanger.hideSoftInputFromWindow(view.getWindowToken(), 0);
  41.         }
  42.     }
  44.     /**
  45.      * 动态隐藏软键盘
  46.      *
  47.      * @param context 上下文
  48.      * @param edit    输入框
  49.      */
  50.     public static void hideSoftInput(Context context, EditText edit) {
  51.         edit.clearFocus();
  52.         InputMethodManager inputmanger = (InputMethodManager) context
  53.                 .getSystemService(Context.INPUT_METHOD_SERVICE);
  54.         inputmanger.hideSoftInputFromWindow(edit.getWindowToken(), 0);
  55.     }
  57.     /**
  58.      * 点击屏幕空白区域隐藏软键盘（方法1）
  59.      * <p>在onTouch中处理，未获焦点则隐藏</p>
  60.      * <p>参照以下注释代码</p>
  61.      */
  62.     public static void clickBlankArea2HideSoftInput0() {
  63.         Log.i("tips", "U should copy the following code.");
  64.         /*
  65.         @Override
  66.         public boolean onTouchEvent (MotionEvent event){
  67.             if (null != this.getCurrentFocus()) {
  68.                 InputMethodManager mInputMethodManager = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
  69.                 return mInputMethodManager.hideSoftInputFromWindow(this.getCurrentFocus().getWindowToken(), 0);
  70.             }
  71.             return super.onTouchEvent(event);
  72.         }
  73.         */
  74.     }
  76.     /**
  77.      * 点击屏幕空白区域隐藏软键盘（方法2）
  78.      * <p>根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘</p>
  79.      * <p>需重写dispatchTouchEvent</p>
  80.      * <p>参照以下注释代码</p>
  81.      */
  82.     public static void clickBlankArea2HideSoftInput1() {
  83.         Log.i("tips", "U should copy the following code.");
  84.         /*
  85.         @Override
  86.         public boolean dispatchTouchEvent(MotionEvent ev) {
  87.             if (ev.getAction() == MotionEvent.ACTION_DOWN) {
  88.                 View v = getCurrentFocus();
  89.                 if (isShouldHideKeyboard(v, ev)) {
  90.                     hideKeyboard(v.getWindowToken());
  91.                 }
  92.             }
  93.             return super.dispatchTouchEvent(ev);
  94.         }
  96.         // 根据EditText所在坐标和用户点击的坐标相对比，来判断是否隐藏键盘
  97.         private boolean isShouldHideKeyboard(View v, MotionEvent event) {
  98.             if (v != null && (v instanceof EditText)) {
  99.                 int[] l = {0, 0};
  100.                 v.getLocationInWindow(l);
  101.                 int left = l[0],
  102.                         top = l[1],
  103.                         bottom = top + v.getHeight(),
  104.                         right = left + v.getWidth();
  105.                 return !(event.getX() > left && event.getX() < right
  106.                         && event.getY() > top && event.getY() < bottom);
  107.             }
  108.             return false;
  109.         }
  111.         // 获取InputMethodManager，隐藏软键盘
  112.         private void hideKeyboard(IBinder token) {
  113.             if (token != null) {
  114.                 InputMethodManager im = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
  115.                 im.hideSoftInputFromWindow(token, InputMethodManager.HIDE_NOT_ALWAYS);
  116.             }
  117.         }
  118.         */
  119.     }
  121.     /**
  122.      * 动态显示软键盘
  123.      *
  124.      * @param context 上下文
  125.      * @param edit    输入框
  126.      */
  127.     public static void showSoftInput(Context context, EditText edit) {
  128.         edit.setFocusable(true);
  129.         edit.setFocusableInTouchMode(true);
  130.         edit.requestFocus();
  131.         InputMethodManager inputManager = (InputMethodManager) context
  132.                 .getSystemService(Context.INPUT_METHOD_SERVICE);
  133.         inputManager.showSoftInput(edit, 0);
  134.     }
  136.     /**
  137.      * 切换键盘显示与否状态
  138.      *
  139.      * @param context 上下文
  140.      * @param edit    输入框
  141.      */
  142.     public static void toggleSoftInput(Context context, EditText edit) {
  143.         edit.setFocusable(true);
  144.         edit.setFocusableInTouchMode(true);
  145.         edit.requestFocus();
  146.         InputMethodManager inputManager = (InputMethodManager) context
  147.                 .getSystemService(Context.INPUT_METHOD_SERVICE);
  148.         inputManager.toggleSoftInput(InputMethodManager.SHOW_FORCED, 0);
  149.     }
  150. }

LogUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.os.Environment;
  5. import android.util.Log;
  7. import java.io.BufferedWriter;
  8. import java.io.File;
  9. import java.io.FileWriter;
  10. import java.io.IOException;
  11. import java.text.SimpleDateFormat;
  12. import java.util.Calendar;
  13. import java.util.Date;
  15. /**
  16.  * <pre>
  17.  *     author: Blankj
  18.  *     blog  : http://blankj.com
  19.  *     time  : 2016/9/21
  20.  *     desc  :
  21.  * </pre>
  22.  */
  23. public class LogUtils {
  25.     private static Boolean LOG_SWITCH = true; // 日志文件总开关
  26.     private static Boolean LOG_TO_FILE = false; // 日志写入文件开关
  27.     private static String LOG_TAG = "TAG"; // 默认的tag
  28.     private static char LOG_TYPE = 'v';// 输入日志类型，v代表输出所有信息,w则只输出警告...
  29.     private static int LOG_SAVE_DAYS = 7;// sd卡中日志文件的最多保存天数
  31.     private final static SimpleDateFormat LOG_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");// 日志的输出格式
  32.     private final static SimpleDateFormat FILE_SUFFIX = new SimpleDateFormat("yyyy-MM-dd");// 日志文件格式
  33.     private static String LOG_FILE_PATH; // 日志文件保存路径
  34.     private static String LOG_FILE_NAME;// 日志文件保存名称
  36.     public static void init(Context context) { // 在Application中初始化
  37.         LOG_FILE_PATH = Environment.getExternalStorageDirectory().getPath() + File.separator + context.getPackageName();
  38.         LOG_FILE_NAME = "Log";
  39.     }
  41.     /****************************
  42.      * Warn
  43.      *********************************/
  44.     public static void w(Object msg) {
  45.         w(LOG_TAG, msg);
  46.     }
  48.     public static void w(String tag, Object msg) {
  49.         w(tag, msg, null);
  50.     }
  52.     public static void w(String tag, Object msg, Throwable tr) {
  53.         log(tag, msg.toString(), tr, 'w');
  54.     }
  56.     /***************************
  57.      * Error
  58.      ********************************/
  59.     public static void e(Object msg) {
  60.         e(LOG_TAG, msg);
  61.     }
  63.     public static void e(String tag, Object msg) {
  64.         e(tag, msg, null);
  65.     }
  67.     public static void e(String tag, Object msg, Throwable tr) {
  68.         log(tag, msg.toString(), tr, 'e');
  69.     }
  71.     /***************************
  72.      * Debug
  73.      ********************************/
  74.     public static void d(Object msg) {
  75.         d(LOG_TAG, msg);
  76.     }
  78.     public static void d(String tag, Object msg) {// 调试信息
  79.         d(tag, msg, null);
  80.     }
  82.     public static void d(String tag, Object msg, Throwable tr) {
  83.         log(tag, msg.toString(), tr, 'd');
  84.     }
  86.     /****************************
  87.      * Info
  88.      *********************************/
  89.     public static void i(Object msg) {
  90.         i(LOG_TAG, msg);
  91.     }
  93.     public static void i(String tag, Object msg) {
  94.         i(tag, msg, null);
  95.     }
  97.     public static void i(String tag, Object msg, Throwable tr) {
  98.         log(tag, msg.toString(), tr, 'i');
  99.     }
  101.     /**************************
  102.      * Verbose
  103.      ********************************/
  104.     public static void v(Object msg) {
  105.         v(LOG_TAG, msg);
  106.     }
  108.     public static void v(String tag, Object msg) {
  109.         v(tag, msg, null);
  110.     }
  112.     public static void v(String tag, Object msg, Throwable tr) {
  113.         log(tag, msg.toString(), tr, 'v');
  114.     }
  116.     /**
  117.      * 根据tag, msg和等级，输出日志
  118.      *
  119.      * @param tag
  120.      * @param msg
  121.      * @param level
  122.      */
  123.     private static void log(String tag, String msg, Throwable tr, char level) {
  124.         if (LOG_SWITCH) {
  125.             if ('e' == level && ('e' == LOG_TYPE || 'v' == LOG_TYPE)) { // 输出错误信息
  126.                 Log.e(tag, msg, tr);
  127.             } else if ('w' == level && ('w' == LOG_TYPE || 'v' == LOG_TYPE)) {
  128.                 Log.w(tag, msg, tr);
  129.             } else if ('d' == level && ('d' == LOG_TYPE || 'v' == LOG_TYPE)) {
  130.                 Log.d(tag, msg, tr);
  131.             } else if ('i' == level && ('d' == LOG_TYPE || 'v' == LOG_TYPE)) {
  132.                 Log.i(tag, msg, tr);
  133.             } else {
  134.                 Log.v(tag, msg, tr);
  135.             }
  136.             if (LOG_TO_FILE)
  137.                 log2File(String.valueOf(level), tag, msg + tr == null ? "" : "\n" + Log.getStackTraceString(tr));
  138.         }
  139.     }
  141.     /**
  142.      * 打开日志文件并写入日志
  143.      *
  144.      * @return
  145.      **/
  146.     private synchronized static void log2File(String mylogtype, String tag, String text) {
  147.         Date nowtime = new Date();
  148.         String date = FILE_SUFFIX.format(nowtime);
  149.         String dateLogContent = LOG_FORMAT.format(nowtime) + ":" + mylogtype + ":" + tag + ":" + text; // 日志输出格式
  150.         File destDir = new File(LOG_FILE_PATH);
  151.         if (!destDir.exists()) {
  152.             destDir.mkdirs();
  153.         }
  154.         File file = new File(LOG_FILE_PATH, LOG_FILE_NAME + date);
  155.         try {
  156.             FileWriter filerWriter = new FileWriter(file, true);
  157.             BufferedWriter bufWriter = new BufferedWriter(filerWriter);
  158.             bufWriter.write(dateLogContent);
  159.             bufWriter.newLine();
  160.             bufWriter.close();
  161.             filerWriter.close();
  162.         } catch (IOException e) {
  163.             e.printStackTrace();
  164.         }
  165.     }
  167.     /**
  168.      * 删除指定的日志文件
  169.      */
  170.     public static void delFile() {// 删除日志文件
  171.         String needDelFiel = FILE_SUFFIX.format(getDateBefore());
  172.         File file = new File(LOG_FILE_PATH, needDelFiel + LOG_FILE_NAME);
  173.         if (file.exists()) {
  174.             file.delete();
  175.         }
  176.     }
  178.     /**
  179.      * 得到LOG_SAVE_DAYS天前的日期
  180.      *
  181.      * @return
  182.      */
  183.     private static Date getDateBefore() {
  184.         Date nowtime = new Date();
  185.         Calendar now = Calendar.getInstance();
  186.         now.setTime(nowtime);
  187.         now.set(Calendar.DATE, now.get(Calendar.DATE) - LOG_SAVE_DAYS);
  188.         return now.getTime();
  189.     }
  190. }

NetworkUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.content.Intent;
  5. import android.net.ConnectivityManager;
  6. import android.net.NetworkInfo;
  7. import android.telephony.TelephonyManager;
  9. /**
  10.  * <pre>
  11.  *     author: Blankj
  12.  *     blog  : http://blankj.com
  13.  *     time  : 2016/8/2
  14.  *     desc  : 网络相关工具类
  15.  * </pre>
  16.  */
  17. public class NetworkUtils {
  19.     private NetworkUtils() {
  20.         throw new UnsupportedOperationException("u can't fuck me...");
  21.     }
  23.     public static final int NETWORK_WIFI = 1;    // wifi network
  24.     public static final int NETWORK_4G = 4;    // "4G" networks
  25.     public static final int NETWORK_3G = 3;    // "3G" networks
  26.     public static final int NETWORK_2G = 2;    // "2G" networks
  27.     public static final int NETWORK_UNKNOWN = 5;    // unknown network
  28.     public static final int NETWORK_NO = -1;   // no network
  30.     private static final int NETWORK_TYPE_GSM = 16;
  31.     private static final int NETWORK_TYPE_TD_SCDMA = 17;
  32.     private static final int NETWORK_TYPE_IWLAN = 18;
  34.     /**
  35.      * 打开网络设置界面
  36.      * <p>3.0以下打开设置界面</p>
  37.      *
  38.      * @param context 上下文
  39.      */
  40.     public static void openWirelessSettings(Context context) {
  41.         if (android.os.Build.VERSION.SDK_INT > 10) {
  42.             context.startActivity(new Intent(android.provider.Settings.ACTION_SETTINGS));
  43.         } else {
  44.             context.startActivity(new Intent(android.provider.Settings.ACTION_WIRELESS_SETTINGS));
  45.         }
  46.     }
  48.     /**
  49.      * 获取活动网络信息
  50.      *
  51.      * @param context 上下文
  52.      * @return NetworkInfo
  53.      */
  54.     private static NetworkInfo getActiveNetworkInfo(Context context) {
  55.         ConnectivityManager cm = (ConnectivityManager) context
  56.                 .getSystemService(Context.CONNECTIVITY_SERVICE);
  57.         return cm.getActiveNetworkInfo();
  58.     }
  60.     /**
  61.      * 判断网络是否可用
  62.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
  63.      *
  64.      * @param context 上下文
  65.      * @return {@code true}: 可用<br>{@code false}: 不可用
  66.      */
  67.     public static boolean isAvailable(Context context) {
  68.         NetworkInfo info = getActiveNetworkInfo(context);
  69.         return info != null && info.isAvailable();
  70.     }
  72.     /**
  73.      * 判断网络是否连接
  74.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
  75.      *
  76.      * @param context 上下文
  77.      * @return {@code true}: 是<br>{@code false}: 否
  78.      */
  79.     public static boolean isConnected(Context context) {
  80.         NetworkInfo info = getActiveNetworkInfo(context);
  81.         return info != null && info.isConnected();
  82.     }
  84.     /**
  85.      * 判断网络是否是4G
  86.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
  87.      *
  88.      * @param context 上下文
  89.      * @return {@code true}: 是<br>{@code false}: 不是
  90.      */
  91.     public static boolean is4G(Context context) {
  92.         NetworkInfo info = getActiveNetworkInfo(context);
  93.         return info != null && info.isAvailable() && info.getSubtype() == TelephonyManager.NETWORK_TYPE_LTE;
  94.     }
  96.     /**
  97.      * 判断wifi是否连接状态
  98.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
  99.      *
  100.      * @param context 上下文
  101.      * @return {@code true}: 连接<br>{@code false}: 未连接
  102.      */
  103.     public static boolean isWifiConnected(Context context) {
  104.         ConnectivityManager cm = (ConnectivityManager) context
  105.                 .getSystemService(Context.CONNECTIVITY_SERVICE);
  106.         return cm != null && cm.getActiveNetworkInfo() != null
  107.                 && cm.getActiveNetworkInfo().getType() == ConnectivityManager.TYPE_WIFI;
  108.     }
  110.     /**
  111.      * 获取移动网络运营商名称
  112.      * <p>如中国联通、中国移动、中国电信</p>
  113.      *
  114.      * @param context 上下文
  115.      * @return 移动网络运营商名称
  116.      */
  117.     public static String getNetworkOperatorName(Context context) {
  118.         TelephonyManager tm = (TelephonyManager) context
  119.                 .getSystemService(Context.TELEPHONY_SERVICE);
  120.         return tm != null ? tm.getNetworkOperatorName() : null;
  121.     }
  123.     /**
  124.      * 获取移动终端类型
  125.      *
  126.      * @param context 上下文
  127.      * @return 手机制式
  128.      * <ul>
  129.      * <li>{@link TelephonyManager#PHONE_TYPE_NONE } : 0 手机制式未知</li>
  130.      * <li>{@link TelephonyManager#PHONE_TYPE_GSM  } : 1 手机制式为GSM，移动和联通</li>
  131.      * <li>{@link TelephonyManager#PHONE_TYPE_CDMA } : 2 手机制式为CDMA，电信</li>
  132.      * <li>{@link TelephonyManager#PHONE_TYPE_SIP  } : 3</li>
  133.      * </ul>
  134.      */
  135.     public static int getPhoneType(Context context) {
  136.         TelephonyManager tm = (TelephonyManager) context
  137.                 .getSystemService(Context.TELEPHONY_SERVICE);
  138.         return tm != null ? tm.getPhoneType() : -1;
  139.     }
  142.     /**
  143.      * 获取当前的网络类型(WIFI,2G,3G,4G)
  144.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>}</p>
  145.      *
  146.      * @param context 上下文
  147.      * @return 网络类型
  148.      * <ul>
  149.      * <li>{@link #NETWORK_WIFI   } = 1;</li>
  150.      * <li>{@link #NETWORK_4G     } = 4;</li>
  151.      * <li>{@link #NETWORK_3G     } = 3;</li>
  152.      * <li>{@link #NETWORK_2G     } = 2;</li>
  153.      * <li>{@link #NETWORK_UNKNOWN} = 5;</li>
  154.      * <li>{@link #NETWORK_NO     } = -1;</li>
  155.      * </ul>
  156.      */
  157.     public static int getNetWorkType(Context context) {
  158.         int netType = NETWORK_NO;
  159.         NetworkInfo info = getActiveNetworkInfo(context);
  160.         if (info != null && info.isAvailable()) {
  162.             if (info.getType() == ConnectivityManager.TYPE_WIFI) {
  163.                 netType = NETWORK_WIFI;
  164.             } else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
  165.                 switch (info.getSubtype()) {
  167.                     case NETWORK_TYPE_GSM:
  168.                     case TelephonyManager.NETWORK_TYPE_GPRS:
  169.                     case TelephonyManager.NETWORK_TYPE_CDMA:
  170.                     case TelephonyManager.NETWORK_TYPE_EDGE:
  171.                     case TelephonyManager.NETWORK_TYPE_1xRTT:
  172.                     case TelephonyManager.NETWORK_TYPE_IDEN:
  173.                         netType = NETWORK_2G;
  174.                         break;
  176.                     case NETWORK_TYPE_TD_SCDMA:
  177.                     case TelephonyManager.NETWORK_TYPE_EVDO_A:
  178.                     case TelephonyManager.NETWORK_TYPE_UMTS:
  179.                     case TelephonyManager.NETWORK_TYPE_EVDO_0:
  180.                     case TelephonyManager.NETWORK_TYPE_HSDPA:
  181.                     case TelephonyManager.NETWORK_TYPE_HSUPA:
  182.                     case TelephonyManager.NETWORK_TYPE_HSPA:
  183.                     case TelephonyManager.NETWORK_TYPE_EVDO_B:
  184.                     case TelephonyManager.NETWORK_TYPE_EHRPD:
  185.                     case TelephonyManager.NETWORK_TYPE_HSPAP:
  186.                         netType = NETWORK_3G;
  187.                         break;
  189.                     case NETWORK_TYPE_IWLAN:
  190.                     case TelephonyManager.NETWORK_TYPE_LTE:
  191.                         netType = NETWORK_4G;
  192.                         break;
  193.                     default:
  195.                         String subtypeName = info.getSubtypeName();
  196.                         if (subtypeName.equalsIgnoreCase("TD-SCDMA")
  197.                                 || subtypeName.equalsIgnoreCase("WCDMA")
  198.                                 || subtypeName.equalsIgnoreCase("CDMA2000")) {
  199.                             netType = NETWORK_3G;
  200.                         } else {
  201.                             netType = NETWORK_UNKNOWN;
  202.                         }
  203.                         break;
  204.                 }
  205.             } else {
  206.                 netType = NETWORK_UNKNOWN;
  207.             }
  208.         }
  209.         return netType;
  210.     }
  212.     /**
  213.      * 获取当前的网络类型(WIFI,2G,3G,4G)
  214.      * <p>依赖上面的方法</p>
  215.      *
  216.      * @param context 上下文
  217.      * @return 网络类型名称
  218.      * <ul>
  219.      * <li>NETWORK_WIFI   </li>
  220.      * <li>NETWORK_4G     </li>
  221.      * <li>NETWORK_3G     </li>
  222.      * <li>NETWORK_2G     </li>
  223.      * <li>NETWORK_UNKNOWN</li>
  224.      * <li>NETWORK_NO     </li>
  225.      * </ul>
  226.      */
  227.     public static String getNetWorkTypeName(Context context) {
  228.         switch (getNetWorkType(context)) {
  229.             case NETWORK_WIFI:
  230.                 return "NETWORK_WIFI";
  231.             case NETWORK_4G:
  232.                 return "NETWORK_4G";
  233.             case NETWORK_3G:
  234.                 return "NETWORK_3G";
  235.             case NETWORK_2G:
  236.                 return "NETWORK_2G";
  237.             case NETWORK_NO:
  238.                 return "NETWORK_NO";
  239.             default:
  240.                 return "NETWORK_UNKNOWN";
  241.         }
  242.     }
  243. }

PhoneUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.ContentResolver;
  4. import android.content.Context;
  5. import android.content.Intent;
  6. import android.database.Cursor;
  7. import android.net.Uri;
  8. import android.os.SystemClock;
  9. import android.provider.Settings;
  10. import android.telephony.TelephonyManager;
  11. import android.util.Log;
  12. import android.util.Xml;
  14. import org.xmlpull.v1.XmlSerializer;
  16. import java.io.File;
  17. import java.io.FileOutputStream;
  18. import java.util.ArrayList;
  19. import java.util.HashMap;
  20. import java.util.List;
  22. /**
  23.  * <pre>
  24.  *     author: Blankj
  25.  *     blog  : http://blankj.com
  26.  *     time  : 2016/8/2
  27.  *     desc  : 手机相关工具类
  28.  * </pre>
  29.  */
  30. public class PhoneUtils {
  32.     private PhoneUtils() {
  33.         throw new UnsupportedOperationException("u can't fuck me...");
  34.     }
  36.     /**
  37.      * 判断设备是否是手机
  38.      *
  39.      * @param context 上下文
  40.      * @return {@code true}: 是<br>{@code false}: 否
  41.      */
  42.     public static boolean isPhone(Context context) {
  43.         TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
  44.         return tm.getPhoneType() != TelephonyManager.PHONE_TYPE_NONE;
  45.     }
  47.     /**
  48.      * 获取手机的IMIE
  49.      * <p>需与{@link #isPhone(Context)}一起使用</p>
  50.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.READ_PHONE_STATE"/>}</p>
  51.      *
  52.      * @param context 上下文
  53.      * @return IMIE码
  54.      */
  55.     public static String getPhoneIMEI(Context context) {
  56.         String deviceId;
  57.         if (isPhone(context)) {
  58.             TelephonyManager tm = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
  59.             deviceId = tm.getDeviceId();
  60.         } else {
  61.             deviceId = Settings.Secure.getString(context.getContentResolver(), Settings.Secure.ANDROID_ID);
  62.         }
  63.         return deviceId;
  64.     }
  66.     /**
  67.      * 获取手机状态信息
  68.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.READ_PHONE_STATE"/>}</p>
  69.      *
  70.      * @param context 上下文
  71.      * @return DeviceId(IMEI) = 99000311726612<br>
  72.      * DeviceSoftwareVersion = 00<br>
  73.      * Line1Number =<br>
  74.      * NetworkCountryIso = cn<br>
  75.      * NetworkOperator = 46003<br>
  76.      * NetworkOperatorName = 中国电信<br>
  77.      * NetworkType = 6<br>
  78.      * honeType = 2<br>
  79.      * SimCountryIso = cn<br>
  80.      * SimOperator = 46003<br>
  81.      * SimOperatorName = 中国电信<br>
  82.      * SimSerialNumber = 89860315045710604022<br>
  83.      * SimState = 5<br>
  84.      * SubscriberId(IMSI) = 460030419724900<br>
  85.      * VoiceMailNumber = *86<br>
  86.      */
  87.     public static String getPhoneStatus(Context context) {
  88.         TelephonyManager tm = (TelephonyManager) context
  89.                 .getSystemService(Context.TELEPHONY_SERVICE);
  90.         String str = "";
  91.         str += "DeviceId(IMEI) = " + tm.getDeviceId() + "\n";
  92.         str += "DeviceSoftwareVersion = " + tm.getDeviceSoftwareVersion() + "\n";
  93.         str += "Line1Number = " + tm.getLine1Number() + "\n";
  94.         str += "NetworkCountryIso = " + tm.getNetworkCountryIso() + "\n";
  95.         str += "NetworkOperator = " + tm.getNetworkOperator() + "\n";
  96.         str += "NetworkOperatorName = " + tm.getNetworkOperatorName() + "\n";
  97.         str += "NetworkType = " + tm.getNetworkType() + "\n";
  98.         str += "honeType = " + tm.getPhoneType() + "\n";
  99.         str += "SimCountryIso = " + tm.getSimCountryIso() + "\n";
  100.         str += "SimOperator = " + tm.getSimOperator() + "\n";
  101.         str += "SimOperatorName = " + tm.getSimOperatorName() + "\n";
  102.         str += "SimSerialNumber = " + tm.getSimSerialNumber() + "\n";
  103.         str += "SimState = " + tm.getSimState() + "\n";
  104.         str += "SubscriberId(IMSI) = " + tm.getSubscriberId() + "\n";
  105.         str += "VoiceMailNumber = " + tm.getVoiceMailNumber() + "\n";
  106.         return str;
  107.     }
  109.     /**
  110.      * 跳至填充好phoneNumber的拨号界面
  111.      *
  112.      * @param context     上下文
  113.      * @param phoneNumber 电话号码
  114.      */
  115.     public static void dial(Context context, String phoneNumber) {
  116.         context.startActivity(new Intent(Intent.ACTION_DIAL, Uri.parse("tel:" + phoneNumber)));
  117.     }
  119.     /**
  120.      * 拨打phoneNumber
  121.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.CALL_PHONE"/>}</p>
  122.      *
  123.      * @param context     上下文
  124.      * @param phoneNumber 电话号码
  125.      */
  126.     public static void call(Context context, String phoneNumber) {
  127.         context.startActivity(new Intent("android.intent.action.CALL", Uri.parse("tel:" + phoneNumber)));
  128.     }
  130.     /**
  131.      * 发送短信
  132.      *
  133.      * @param context     上下文
  134.      * @param phoneNumber 电话号码
  135.      * @param content     内容
  136.      */
  137.     public static void sendSms(Context context, String phoneNumber, String content) {
  138.         Uri uri = Uri.parse("smsto:" + (StringUtils.isEmpty(phoneNumber) ? "" : phoneNumber));
  139.         Intent intent = new Intent(Intent.ACTION_SENDTO, uri);
  140.         intent.putExtra("sms_body", StringUtils.isEmpty(content) ? "" : content);
  141.         context.startActivity(intent);
  142.     }
  144.     /**
  145.      * 获取手机联系人
  146.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>}</p>
  147.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.READ_CONTACTS"/>}</p>
  148.      *
  149.      * @param context 上下文;
  150.      * @return 联系人链表
  151.      */
  152.     public static List<HashMap<String, String>> getAllContactInfo(Context context) {
  153.         SystemClock.sleep(3000);
  154.         ArrayList<HashMap<String, String>> list = new ArrayList<HashMap<String, String>>();
  155.         // 1.获取内容解析者
  156.         ContentResolver resolver = context.getContentResolver();
  157.         // 2.获取内容提供者的地址:com.android.contacts
  158.         // raw_contacts表的地址 :raw_contacts
  159.         // view_data表的地址 : data
  160.         // 3.生成查询地址
  161.         Uri raw_uri = Uri.parse("content://com.android.contacts/raw_contacts");
  162.         Uri date_uri = Uri.parse("content://com.android.contacts/data");
  163.         // 4.查询操作,先查询raw_contacts,查询contact_id
  164.         // projection : 查询的字段
  165.         Cursor cursor = resolver.query(raw_uri, new String[]{"contact_id"},
  166.                 null, null, null);
  167.         // 5.解析cursor
  168.         while (cursor.moveToNext()) {
  169.             // 6.获取查询的数据
  170.             String contact_id = cursor.getString(0);
  171.             // cursor.getString(cursor.getColumnIndex("contact_id"));//getColumnIndex
  172.             // : 查询字段在cursor中索引值,一般都是用在查询字段比较多的时候
  173.             // 判断contact_id是否为空
  174.             if (!StringUtils.isEmpty(contact_id)) {//null   ""
  175.                 // 7.根据contact_id查询view_data表中的数据
  176.                 // selection : 查询条件
  177.                 // selectionArgs :查询条件的参数
  178.                 // sortOrder : 排序
  179.                 // 空指针: 1.null.方法 2.参数为null
  180.                 Cursor c = resolver.query(date_uri, new String[]{"data1",
  181.                                 "mimetype"}, "raw_contact_id=?",
  182.                         new String[]{contact_id}, null);
  183.                 HashMap<String, String> map = new HashMap<String, String>();
  184.                 // 8.解析c
  185.                 while (c.moveToNext()) {
  186.                     // 9.获取数据
  187.                     String data1 = c.getString(0);
  188.                     String mimetype = c.getString(1);
  189.                     // 10.根据类型去判断获取的data1数据并保存
  190.                     if (mimetype.equals("vnd.android.cursor.item/phone_v2")) {
  191.                         // 电话
  192.                         map.put("phone", data1);
  193.                     } else if (mimetype.equals("vnd.android.cursor.item/name")) {
  194.                         // 姓名
  195.                         map.put("name", data1);
  196.                     }
  197.                 }
  198.                 // 11.添加到集合中数据
  199.                 list.add(map);
  200.                 // 12.关闭cursor
  201.                 c.close();
  202.             }
  203.         }
  204.         // 12.关闭cursor
  205.         cursor.close();
  206.         return list;
  207.     }
  209.     /**
  210.      * 打开手机联系人界面点击联系人后便获取该号码
  211.      * <p>参照以下注释代码</p>
  212.      */
  213.     public static void getContantNum() {
  214.         Log.i("tips", "U should copy the following code.");
  215.         /*
  216.         Intent intent = new Intent();
  217.         intent.setAction("android.intent.action.PICK");
  218.         intent.setType("vnd.android.cursor.dir/phone_v2");
  219.         startActivityForResult(intent, 0);
  221.         @Override
  222.         protected void onActivityResult ( int requestCode, int resultCode, Intent data){
  223.             super.onActivityResult(requestCode, resultCode, data);
  224.             if (data != null) {
  225.                 Uri uri = data.getData();
  226.                 String num = null;
  227.                 // 创建内容解析者
  228.                 ContentResolver contentResolver = getContentResolver();
  229.                 Cursor cursor = contentResolver.query(uri,
  230.                         null, null, null, null);
  231.                 while (cursor.moveToNext()) {
  232.                     num = cursor.getString(cursor.getColumnIndex("data1"));
  233.                 }
  234.                 cursor.close();
  235.                 num = num.replaceAll("-", "");//替换的操作,555-6 -> 5556
  236.             }
  237.         }
  238.         */
  239.     }
  241.     /**
  242.      * 获取手机短信并保存到xml中
  243.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.READ_SMS"/>}</p>
  244.      * <p>需添加权限 {@code <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>}</p>
  245.      *
  246.      * @param context 上下文
  247.      */
  248.     public static void getAllSMS(Context context) {
  249.         // 1.获取短信
  250.         // 1.1获取内容解析者
  251.         ContentResolver resolver = context.getContentResolver();
  252.         // 1.2获取内容提供者地址   sms,sms表的地址:null  不写
  253.         // 1.3获取查询路径
  254.         Uri uri = Uri.parse("content://sms");
  255.         // 1.4.查询操作
  256.         // projection : 查询的字段
  257.         // selection : 查询的条件
  258.         // selectionArgs : 查询条件的参数
  259.         // sortOrder : 排序
  260.         Cursor cursor = resolver.query(uri, new String[]{"address", "date", "type", "body"}, null, null, null);
  261.         // 设置最大进度
  262.         int count = cursor.getCount();//获取短信的个数
  263.         // 2.备份短信
  264.         // 2.1获取xml序列器
  265.         XmlSerializer xmlSerializer = Xml.newSerializer();
  266.         try {
  267.             // 2.2设置xml文件保存的路径
  268.             // os : 保存的位置
  269.             // encoding : 编码格式
  270.             xmlSerializer.setOutput(new FileOutputStream(new File("/mnt/sdcard/backupsms.xml")), "utf-8");
  271.             // 2.3设置头信息
  272.             // standalone : 是否独立保存
  273.             xmlSerializer.startDocument("utf-8", true);
  274.             // 2.4设置根标签
  275.             xmlSerializer.startTag(null, "smss");
  276.             // 1.5.解析cursor
  277.             while (cursor.moveToNext()) {
  278.                 SystemClock.sleep(1000);
  279.                 // 2.5设置短信的标签
  280.                 xmlSerializer.startTag(null, "sms");
  281.                 // 2.6设置文本内容的标签
  282.                 xmlSerializer.startTag(null, "address");
  283.                 String address = cursor.getString(0);
  284.                 // 2.7设置文本内容
  285.                 xmlSerializer.text(address);
  286.                 xmlSerializer.endTag(null, "address");
  287.                 xmlSerializer.startTag(null, "date");
  288.                 String date = cursor.getString(1);
  289.                 xmlSerializer.text(date);
  290.                 xmlSerializer.endTag(null, "date");
  291.                 xmlSerializer.startTag(null, "type");
  292.                 String type = cursor.getString(2);
  293.                 xmlSerializer.text(type);
  294.                 xmlSerializer.endTag(null, "type");
  295.                 xmlSerializer.startTag(null, "body");
  296.                 String body = cursor.getString(3);
  297.                 xmlSerializer.text(body);
  298.                 xmlSerializer.endTag(null, "body");
  299.                 xmlSerializer.endTag(null, "sms");
  300.                 System.out.println("address:" + address + "   date:" + date + "  type:" + type + "  body:" + body);
  301.             }
  302.             xmlSerializer.endTag(null, "smss");
  303.             xmlSerializer.endDocument();
  304.             // 2.8将数据刷新到文件中
  305.             xmlSerializer.flush();
  306.         } catch (Exception e) {
  307.             e.printStackTrace();
  308.         }
  309.     }
  310. }

RegexUtils

  1. package com.blankj.utilcode.utils;
  3. import java.util.regex.Pattern;
  5. import static com.blankj.utilcode.utils.ConstUtils.*;
  7. /**
  8.  * <pre>
  9.  *     author: Blankj
  10.  *     blog  : http://blankj.com
  11.  *     time  : 2016/8/2
  12.  *     desc  : 正则相关工具类
  13.  * </pre>
  14.  */
  15. public class RegexUtils {
  17.     private RegexUtils() {
  18.         throw new UnsupportedOperationException("u can't fuck me...");
  19.     }
  21.     /**
  22.      * If u want more please visit http://toutiao.com/i6231678548520731137/
  23.      */
  25.     /**
  26.      * 验证手机号（简单）
  27.      *
  28.      * @param string 待验证文本
  29.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  30.      */
  31.     public static boolean isMobileSimple(String string) {
  32.         return isMatch(REGEX_MOBILE_SIMPLE, string);
  33.     }
  35.     /**
  36.      * 验证手机号（精确）
  37.      *
  38.      * @param string 待验证文本
  39.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  40.      */
  41.     public static boolean isMobileExact(String string) {
  42.         return isMatch(REGEX_MOBILE_EXACT, string);
  43.     }
  45.     /**
  46.      * 验证电话号码
  47.      *
  48.      * @param string 待验证文本
  49.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  50.      */
  51.     public static boolean isTel(String string) {
  52.         return isMatch(REGEX_TEL, string);
  53.     }
  55.     /**
  56.      * 验证身份证号码15位
  57.      *
  58.      * @param string 待验证文本
  59.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  60.      */
  61.     public static boolean isIDCard15(String string) {
  62.         return isMatch(REGEX_IDCARD15, string);
  63.     }
  65.     /**
  66.      * 验证身份证号码18位
  67.      *
  68.      * @param string 待验证文本
  69.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  70.      */
  71.     public static boolean isIDCard18(String string) {
  72.         return isMatch(REGEX_IDCARD18, string);
  73.     }
  75.     /**
  76.      * 验证邮箱
  77.      *
  78.      * @param string 待验证文本
  79.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  80.      */
  81.     public static boolean isEmail(String string) {
  82.         return isMatch(REGEX_EMAIL, string);
  83.     }
  85.     /**
  86.      * 验证URL
  87.      *
  88.      * @param string 待验证文本
  89.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  90.      */
  91.     public static boolean isURL(String string) {
  92.         return isMatch(REGEX_URL, string);
  93.     }
  95.     /**
  96.      * 验证汉字
  97.      *
  98.      * @param string 待验证文本
  99.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  100.      */
  101.     public static boolean isChz(String string) {
  102.         return isMatch(REGEX_CHZ, string);
  103.     }
  105.     /**
  106.      * 验证用户名
  107.      * <p>取值范围为a-z,A-Z,0-9,"_",汉字，不能以"_"结尾,用户名必须是6-20位</p>
  108.      *
  109.      * @param string 待验证文本
  110.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  111.      */
  112.     public static boolean isUsername(String string) {
  113.         return isMatch(REGEX_USERNAME, string);
  114.     }
  116.     /**
  117.      * 验证yyyy-MM-dd格式的日期校验，已考虑平闰年
  118.      *
  119.      * @param string 待验证文本
  120.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  121.      */
  122.     public static boolean isDate(String string) {
  123.         return isMatch(REGEX_DATE, string);
  124.     }
  126.     /**
  127.      * 验证IP地址
  128.      *
  129.      * @param string 待验证文本
  130.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  131.      */
  132.     public static boolean isIP(String string) {
  133.         return isMatch(REGEX_IP, string);
  134.     }
  136.     /**
  137.      * string是否匹配regex
  138.      *
  139.      * @param regex  正则表达式字符串
  140.      * @param string 要匹配的字符串
  141.      * @return {@code true}: 匹配<br>{@code false}: 不匹配
  142.      */
  143.     public static boolean isMatch(String regex, String string) {
  144.         return !StringUtils.isEmpty(string) && Pattern.matches(regex, string);
  145.     }
  146. }

ScreenUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.Activity;
  4. import android.app.KeyguardManager;
  5. import android.content.Context;
  6. import android.content.pm.ActivityInfo;
  7. import android.content.res.Configuration;
  8. import android.graphics.Bitmap;
  9. import android.util.DisplayMetrics;
  10. import android.view.Surface;
  11. import android.view.View;
  12. import android.view.WindowManager;
  14. /**
  15.  * <pre>
  16.  *     author: Blankj
  17.  *     blog  : http://blankj.com
  18.  *     time  : 2016/8/2
  19.  *     desc  : 屏幕相关工具类
  20.  * </pre>
  21.  */
  22. public class ScreenUtils {
  24.     private ScreenUtils() {
  25.         throw new UnsupportedOperationException("u can't fuck me...");
  26.     }
  28.     /**
  29.      * 获取屏幕的宽度px
  30.      *
  31.      * @param context 上下文
  32.      * @return 屏幕宽px
  33.      */
  34.     public static int getScreenWidth(Context context) {
  35.         WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  36.         DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
  37.         windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
  38.         return outMetrics.widthPixels;
  39.     }
  41.     /**
  42.      * 获取屏幕的高度px
  43.      *
  44.      * @param context 上下文
  45.      * @return 屏幕高px
  46.      */
  47.     public static int getScreenHeight(Context context) {
  48.         WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
  49.         DisplayMetrics outMetrics = new DisplayMetrics();// 创建了一张白纸
  50.         windowManager.getDefaultDisplay().getMetrics(outMetrics);// 给白纸设置宽高
  51.         return outMetrics.heightPixels;
  52.     }
  54.     /**
  55.      * 设置屏幕为横屏
  56.      * <p>还有一种就是在Activity中加属性android:screenOrientation="landscape"</p>
  57.      * <p>不设置Activity的android:configChanges时，切屏会重新调用各个生命周期，切横屏时会执行一次，切竖屏时会执行两次</p>
  58.      * <p>设置Activity的android:configChanges="orientation"时，切屏还是会重新调用各个生命周期，切横、竖屏时只会执行一次</p>
  59.      * <p>设置Activity的android:configChanges="orientation|keyboardHidden|screenSize"（4.0以上必须带最后一个参数）时
  60.      * 切屏不会重新调用各个生命周期，只会执行onConfigurationChanged方法</p>
  61.      *
  62.      * @param activity activity
  63.      */
  64.     public static void setLandscape(Activity activity) {
  65.         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  66.     }
  68.     /**
  69.      * 设置屏幕为竖屏
  70.      *
  71.      * @param activity activity
  72.      */
  73.     public static void setPortrait(Activity activity) {
  74.         activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
  75.     }
  77.     /**
  78.      * 判断是否横屏
  79.      *
  80.      * @param context 上下文
  81.      * @return {@code true}: 是<br>{@code false}: 否
  82.      */
  83.     public static boolean isLandscape(Context context) {
  84.         return context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE;
  85.     }
  87.     /**
  88.      * 判断是否竖屏
  89.      *
  90.      * @param context 上下文
  91.      * @return {@code true}: 是<br>{@code false}: 否
  92.      */
  93.     public static boolean isPortrait(Context context) {
  94.         return context.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT;
  95.     }
  97.     /**
  98.      * 获取屏幕旋转角度
  99.      *
  100.      * @param activity activity
  101.      * @return 屏幕旋转角度
  102.      */
  103.     public static int getScreenRotation(Activity activity) {
  104.         switch (activity.getWindowManager().getDefaultDisplay().getRotation()) {
  105.             default:
  106.             case Surface.ROTATION_0:
  107.                 return 0;
  108.             case Surface.ROTATION_90:
  109.                 return 90;
  110.             case Surface.ROTATION_180:
  111.                 return 180;
  112.             case Surface.ROTATION_270:
  113.                 return 270;
  114.         }
  115.     }
  117.     /**
  118.      * 获取当前屏幕截图，包含状态栏
  119.      *
  120.      * @param activity activity
  121.      * @return Bitmap
  122.      */
  123.     public static Bitmap captureWithStatusBar(Activity activity) {
  124.         View view = activity.getWindow().getDecorView();
  125.         view.setDrawingCacheEnabled(true);
  126.         view.buildDrawingCache();
  127.         Bitmap bmp = view.getDrawingCache();
  128.         int width = getScreenWidth(activity);
  129.         int height = getScreenHeight(activity);
  130.         Bitmap ret = Bitmap.createBitmap(bmp, 0, 0, width, height);
  131.         view.destroyDrawingCache();
  132.         return ret;
  133.     }
  135.     /**
  136.      * 获取当前屏幕截图，不包含状态栏
  137.      * <p>需要用到上面获取状态栏高度getStatusBarHeight的方法</p>
  138.      *
  139.      * @param activity activity
  140.      * @return Bitmap
  141.      */
  142.     public static Bitmap captureWithoutStatusBar(Activity activity) {
  143.         View view = activity.getWindow().getDecorView();
  144.         view.setDrawingCacheEnabled(true);
  145.         view.buildDrawingCache();
  146.         Bitmap bmp = view.getDrawingCache();
  147.         int statusBarHeight = BarUtils.getStatusBarHeight(activity);
  148.         int width = getScreenWidth(activity);
  149.         int height = getScreenHeight(activity);
  150.         Bitmap ret = Bitmap.createBitmap(bmp, 0, statusBarHeight, width, height - statusBarHeight);
  151.         view.destroyDrawingCache();
  152.         return ret;
  153.     }
  155.     /**
  156.      * 判断是否锁屏
  157.      *
  158.      * @param context 上下文
  159.      * @return {@code true}: 是<br>{@code false}: 否
  160.      */
  161.     public static boolean isScreenLock(Context context) {
  162.         KeyguardManager km = (KeyguardManager) context
  163.                 .getSystemService(Context.KEYGUARD_SERVICE);
  164.         return km.inKeyguardRestrictedInputMode();
  165.     }
  166. }

SDCardUtils

  1. package com.blankj.utilcode.utils;
  3. import android.annotation.TargetApi;
  4. import android.os.Build;
  5. import android.os.Environment;
  6. import android.os.StatFs;
  8. import java.io.File;
  10. import static com.blankj.utilcode.utils.ConstUtils.*;
  12. /**
  13.  * <pre>
  14.  *     author: Blankj
  15.  *     blog  : http://blankj.com
  16.  *     time  : 2016/8/11
  17.  *     desc  : SD卡相关工具类
  18.  * </pre>
  19.  */
  20. public class SDCardUtils {
  22.     private SDCardUtils() {
  23.         throw new UnsupportedOperationException("u can't fuck me...");
  24.     }
  26.     /**
  27.      * 判断SD卡是否可用
  28.      *
  29.      * @return true : 可用<br>false : 不可用
  30.      */
  31.     public static boolean isSDCardEnable() {
  32.         return Environment.MEDIA_MOUNTED.equals(Environment.getExternalStorageState());
  33.     }
  35.     /**
  36.      * 获取SD卡路径
  37.      * <p>一般是/storage/emulated/0/</p>
  38.      *
  39.      * @return SD卡路径
  40.      */
  41.     public static String getSDCardPath() {
  42.         if (!isSDCardEnable()) return "sdcard unable!";
  43.         return Environment.getExternalStorageDirectory().getPath() + File.separator;
  44.     }
  46.     /**
  47.      * 获取SD卡Data路径
  48.      *
  49.      * @return SD卡Data路径
  50.      */
  51.     public static String getDataPath() {
  52.         if (!isSDCardEnable()) return "sdcard unable!";
  53.         return Environment.getDataDirectory().getPath();
  54.     }
  56.     /**
  57.      * 获取SD卡剩余空间
  58.      *
  59.      * @return SD卡剩余空间
  60.      */
  61.     @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
  62.     public static String getFreeSpace() {
  63.         if (!isSDCardEnable()) return "sdcard unable!";
  64.         StatFs stat = new StatFs(getSDCardPath());
  65.         long blockSize, availableBlocks;
  66.         availableBlocks = stat.getAvailableBlocksLong();
  67.         blockSize = stat.getBlockSizeLong();
  68.         return ConvertUtils.byte2FitSize(availableBlocks * blockSize);
  69.     }
  70. }

ServiceUtils

  1. package com.blankj.utilcode.utils;
  3. import android.app.ActivityManager;
  4. import android.app.ActivityManager.RunningServiceInfo;
  5. import android.content.ComponentName;
  6. import android.content.Context;
  7. import android.content.Intent;
  8. import android.content.pm.ResolveInfo;
  9. import android.os.Bundle;
  11. import java.util.List;
  13. /**
  14.  * <pre>
  15.  *     author: Blankj
  16.  *     blog  : http://blankj.com
  17.  *     time  : 2016/8/2
  18.  *     desc  : 服务工具类
  19.  * </pre>
  20.  */
  21. public class ServiceUtils {
  23.     private ServiceUtils() {
  24.         throw new UnsupportedOperationException("u can't fuck me...");
  25.     }
  27.     /**
  28.      * 获取服务是否开启
  29.      *
  30.      * @param context   上下文
  31.      * @param className 完整包名的服务类名
  32.      * @return {@code true}: 是<br>{@code false}: 否
  33.      */
  34.     public static boolean isRunningService(Context context, String className) {
  35.         // 进程的管理者,活动的管理者
  36.         ActivityManager activityManager = (ActivityManager)
  37.                 context.getSystemService(Context.ACTIVITY_SERVICE);
  38.         // 获取正在运行的服务，最多获取1000个
  39.         List<RunningServiceInfo> runningServices = activityManager.getRunningServices(1000);
  40.         // 遍历集合
  41.         for (RunningServiceInfo runningServiceInfo : runningServices) {
  42.             ComponentName service = runningServiceInfo.service;
  43.             if (className.equals(service.getClassName())) {
  44.                 return true;
  45.             }
  46.         }
  47.         return false;
  48.     }
  49. }

ShellUtils

  1. package com.blankj.utilcode.utils;
  3. import java.io.BufferedReader;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.io.InputStreamReader;
  7. import java.util.List;
  9. /**
  10.  * <pre>
  11.  *     author: Blankj
  12.  *     blog  : http://blankj.com
  13.  *     time  : 2016/8/7
  14.  *     desc  : Shell相关工具类
  15.  * </pre>
  16.  */
  17. public class ShellUtils {
  19.     private ShellUtils() {
  20.         throw new UnsupportedOperationException("u can't fuck me...");
  21.     }
  23.     public static final String COMMAND_SU = "su";
  24.     public static final String COMMAND_SH = "sh";
  25.     public static final String COMMAND_EXIT = "exit\n";
  26.     public static final String COMMAND_LINE_END = "\n";
  28.     /**
  29.      * 判断设备是否root
  30.      * @return {@code true}: root<br>{@code false}: 没root
  31.      */
  32.     public static boolean isRoot() {
  33.         return execCmd("echo root", true, false).result == 0;
  34.     }
  36.     /**
  37.      * 是否是在root下执行命令
  38.      *
  39.      * @param command 命令
  40.      * @param isRoot  是否root
  41.      * @return CommandResult
  42.      */
  43.     public static CommandResult execCmd(String command, boolean isRoot) {
  44.         return execCmd(new String[]{command}, isRoot, true);
  45.     }
  47.     /**
  48.      * 是否是在root下执行命令
  49.      *
  50.      * @param commands 多条命令链表
  51.      * @param isRoot   是否root
  52.      * @return CommandResult
  53.      */
  54.     public static CommandResult execCmd(List<String> commands, boolean isRoot) {
  55.         return execCmd(commands == null ? null : commands.toArray(new String[]{}), isRoot, true);
  56.     }
  58.     /**
  59.      * 是否是在root下执行命令
  60.      *
  61.      * @param commands 多条命令数组
  62.      * @param isRoot   是否root
  63.      * @return CommandResult
  64.      */
  65.     public static CommandResult execCmd(String[] commands, boolean isRoot) {
  66.         return execCmd(commands, isRoot, true);
  67.     }
  69.     /**
  70.      * 是否是在root下执行命令
  71.      *
  72.      * @param command         命令
  73.      * @param isRoot          是否root
  74.      * @param isNeedResultMsg 是否需要结果消息
  75.      * @return CommandResult
  76.      */
  77.     public static CommandResult execCmd(String command, boolean isRoot, boolean isNeedResultMsg) {
  78.         return execCmd(new String[]{command}, isRoot, isNeedResultMsg);
  79.     }
  81.     /**
  82.      * 是否是在root下执行命令
  83.      *
  84.      * @param commands        命令链表
  85.      * @param isRoot          是否root
  86.      * @param isNeedResultMsg 是否需要结果消息
  87.      * @return CommandResult
  88.      */
  89.     public static CommandResult execCmd(List<String> commands, boolean isRoot, boolean isNeedResultMsg) {
  90.         return execCmd(commands == null ? null : commands.toArray(new String[]{}), isRoot, isNeedResultMsg);
  91.     }
  93.     /**
  94.      * 是否是在root下执行命令
  95.      *
  96.      * @param commands        命令数组
  97.      * @param isRoot          是否root
  98.      * @param isNeedResultMsg 是否需要结果消息
  99.      * @return CommandResult
  100.      */
  101.     public static CommandResult execCmd(String[] commands, boolean isRoot, boolean isNeedResultMsg) {
  102.         int result = -1;
  103.         if (commands == null || commands.length == 0) {
  104.             return new CommandResult(result, null, null);
  105.         }
  106.         Process process = null;
  107.         BufferedReader successResult = null;
  108.         BufferedReader errorResult = null;
  109.         StringBuilder successMsg = null;
  110.         StringBuilder errorMsg = null;
  111.         DataOutputStream os = null;
  112.         try {
  113.             process = Runtime.getRuntime().exec(isRoot ? COMMAND_SU : COMMAND_SH);
  114.             os = new DataOutputStream(process.getOutputStream());
  115.             for (String command : commands) {
  116.                 if (command == null) {
  117.                     continue;
  118.                 }
  119.                 os.write(command.getBytes());
  120.                 os.writeBytes(COMMAND_LINE_END);
  121.                 os.flush();
  122.             }
  123.             os.writeBytes(COMMAND_EXIT);
  124.             os.flush();
  126.             result = process.waitFor();
  127.             if (isNeedResultMsg) {
  128.                 successMsg = new StringBuilder();
  129.                 errorMsg = new StringBuilder();
  130.                 successResult = new BufferedReader(new InputStreamReader(process.getInputStream()));
  131.                 errorResult = new BufferedReader(new InputStreamReader(process.getErrorStream()));
  132.                 String s;
  133.                 while ((s = successResult.readLine()) != null) {
  134.                     successMsg.append(s);
  135.                 }
  136.                 while ((s = errorResult.readLine()) != null) {
  137.                     errorMsg.append(s);
  138.                 }
  139.             }
  140.         } catch (Exception e) {
  141.             e.printStackTrace();
  142.         } finally {
  143.             try {
  144.                 if (os != null) {
  145.                     os.close();
  146.                 }
  147.                 if (successResult != null) {
  148.                     successResult.close();
  149.                 }
  150.                 if (errorResult != null) {
  151.                     errorResult.close();
  152.                 }
  153.             } catch (IOException e) {
  154.                 e.printStackTrace();
  155.             }
  157.             if (process != null) {
  158.                 process.destroy();
  159.             }
  160.         }
  161.         return new CommandResult(result, successMsg == null ? null : successMsg.toString(), errorMsg == null ? null
  162.                 : errorMsg.toString());
  163.     }
  165.     /**
  166.      * 返回的命令结果
  167.      */
  168.     public static class CommandResult {
  170.         /**
  171.          * 结果码
  172.          **/
  173.         public int result;
  174.         /**
  175.          * 成功的信息
  176.          **/
  177.         public String successMsg;
  178.         /**
  179.          * 错误信息
  180.          **/
  181.         public String errorMsg;
  183.         public CommandResult(int result) {
  184.             this.result = result;
  185.         }
  187.         public CommandResult(int result, String successMsg, String errorMsg) {
  188.             this.result = result;
  189.             this.successMsg = successMsg;
  190.             this.errorMsg = errorMsg;
  191.         }
  192.     }
  193. }

SizeUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.util.DisplayMetrics;
  5. import android.util.Log;
  6. import android.util.TypedValue;
  7. import android.view.View;
  9. /**
  10.  * <pre>
  11.  *     author: Blankj
  12.  *     blog  : http://blankj.com
  13.  *     time  : 2016/8/2
  14.  *     desc  : 尺寸相关工具类
  15.  * </pre>
  16.  */
  17. public class SizeUtils {
  19.     private SizeUtils() {
  20.         throw new UnsupportedOperationException("u can't fuck me...");
  21.     }
  23.     /**
  24.      * dp转px
  25.      *
  26.      * @param context 上下文
  27.      * @param dpValue dp值
  28.      * @return px值
  29.      */
  30.     public static int dp2px(Context context, float dpValue) {
  31.         final float scale = context.getResources().getDisplayMetrics().density;
  32.         return (int) (dpValue * scale + 0.5f);
  33.     }
  35.     /**
  36.      * px转dp
  37.      *
  38.      * @param context 上下文
  39.      * @param pxValue px值
  40.      * @return dp值
  41.      */
  42.     public static int px2dp(Context context, float pxValue) {
  43.         final float scale = context.getResources().getDisplayMetrics().density;
  44.         return (int) (pxValue / scale + 0.5f);
  45.     }
  47.     /**
  48.      * sp转px
  49.      *
  50.      * @param context 上下文
  51.      * @param spValue sp值
  52.      * @return px值
  53.      */
  54.     public static int sp2px(Context context, float spValue) {
  55.         final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
  56.         return (int) (spValue * fontScale + 0.5f);
  57.     }
  59.     /**
  60.      * px转sp
  61.      *
  62.      * @param context 上下文
  63.      * @param pxValue px值
  64.      * @return sp值
  65.      */
  66.     public static int px2sp(Context context, float pxValue) {
  67.         final float fontScale = context.getResources().getDisplayMetrics().scaledDensity;
  68.         return (int) (pxValue / fontScale + 0.5f);
  69.     }
  71.     /**
  72.      * 各种单位转换
  73.      * <p>该方法存在于TypedValue</p>
  74.      *
  75.      * @param unit    单位
  76.      * @param value   值
  77.      * @param metrics DisplayMetrics
  78.      * @return 转换结果
  79.      */
  80.     public static float applyDimension(int unit, float value, DisplayMetrics metrics) {
  81.         switch (unit) {
  82.             case TypedValue.COMPLEX_UNIT_PX:
  83.                 return value;
  84.             case TypedValue.COMPLEX_UNIT_DIP:
  85.                 return value * metrics.density;
  86.             case TypedValue.COMPLEX_UNIT_SP:
  87.                 return value * metrics.scaledDensity;
  88.             case TypedValue.COMPLEX_UNIT_PT:
  89.                 return value * metrics.xdpi * (1.0f / 72);
  90.             case TypedValue.COMPLEX_UNIT_IN:
  91.                 return value * metrics.xdpi;
  92.             case TypedValue.COMPLEX_UNIT_MM:
  93.                 return value * metrics.xdpi * (1.0f / 25.4f);
  94.         }
  95.         return 0;
  96.     }
  98.     /**
  99.      * 在onCreate()即可强行获取View的尺寸
  100.      * <p>需回调onGetSizeListener接口，在onGetSize中获取view宽高</p>
  101.      * <p>用法示例如下所示</p>
  102.      * <pre>{@code
  103.      * SizeUtils.forceGetViewSize(view);
  104.      * SizeUtils.setListener(new SizeUtils.onGetSizeListener() {
  105.      *     public void onGetSize(View view) {
  106.      *         Log.d("tag", view.getWidth() + " " + view.getHeight());
  107.      *     }
  108.      * });}
  109.      * </pre>
  110.      *
  111.      * @param view 视图
  112.      */
  113.     public static void forceGetViewSize(final View view) {
  114.         view.post(new Runnable() {
  115.             @Override
  116.             public void run() {
  117.                 if (mListener != null) {
  118.                     mListener.onGetSize(view);
  119.                 }
  120.             }
  121.         });
  122.     }
  124.     /**
  125.      * 获取到View尺寸的监听
  126.      */
  127.     public interface onGetSizeListener {
  128.         void onGetSize(View view);
  129.     }
  131.     public static void setListener(onGetSizeListener listener) {
  132.         mListener = listener;
  133.     }
  135.     private static onGetSizeListener mListener;
  137.     /**
  138.      * ListView中提前测量View尺寸，如headerView
  139.      * <p>用的时候去掉注释拷贝到ListView中即可</p>
  140.      * <p>参照以下注释代码</p>
  141.      *
  142.      * @param view 视图
  143.      */
  144.     public static void measureViewInLV(View view) {
  145.         Log.i("tips", "U should copy the following code.");
  146.         /*
  147.         ViewGroup.LayoutParams p = view.getLayoutParams();
  148.         if (p == null) {
  149.             p = new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT,
  150.                     ViewGroup.LayoutParams.WRAP_CONTENT);
  151.         }
  152.         int width = ViewGroup.getChildMeasureSpec(0, 0, p.width);
  153.         int height;
  154.         int tempHeight = p.height;
  155.         if (tempHeight > 0) {
  156.             height = MeasureSpec.makeMeasureSpec(tempHeight,
  157.                     MeasureSpec.EXACTLY);
  158.         } else {
  159.             height = MeasureSpec.makeMeasureSpec(0, MeasureSpec.UNSPECIFIED);
  160.         }
  161.         view.measure(width, height);
  162.         */
  163.     }
  164. }

SPUtils

  1. package com.blankj.utilcode.utils;
  3. import android.content.Context;
  4. import android.content.SharedPreferences;
  6. import java.util.Map;
  8. /**
  9.  * <pre>
  10.  *     author: Blankj
  11.  *     blog  : http://blankj.com
  12.  *     time  : 2016/8/2
  13.  *     desc  : SP相关工具类
  14.  * </pre>
  15.  */
  16. public class SPUtils {
  18.     private SharedPreferences sp;
  19.     private SharedPreferences.Editor editor;
  21.     /**
  22.      * SPUtils构造函数
  23.      *
  24.      * @param context 上下文
  25.      * @param spName  spName
  26.      */
  27.     public SPUtils(Context context, String spName) {
  28.         sp = context.getSharedPreferences(spName, Context.MODE_PRIVATE);
  29.         editor = sp.edit();
  30.         editor.apply();
  31.     }
  33.     /**
  34.      * SP中写入String类型value
  35.      *
  36.      * @param key   键
  37.      * @param value 值
  38.      */
  39.     public void putString(String key, String value) {
  40.         editor.putString(key, value).apply();
  41.     }
  43.     /**
  44.      * SP中读取String
  45.      *
  46.      * @param key 键
  47.      * @return 存在返回对应值，不存在返回默认值{@code null}
  48.      */
  49.     public String getString(String key) {
  50.         return getString(key, null);
  51.     }
  53.     /**
  54.      * SP中读取String
  55.      *
  56.      * @param key          键
  57.      * @param defaultValue 默认值
  58.      * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
  59.      */
  60.     public String getString(String key, String defaultValue) {
  61.         return sp.getString(key, defaultValue);
  62.     }
  64.     /**
  65.      * SP中写入int类型value
  66.      *
  67.      * @param key   键
  68.      * @param value 值
  69.      */
  70.     public void putInt(String key, int value) {
  71.         editor.putInt(key, value).apply();
  72.     }
  74.     /**
  75.      * SP中读取int
  76.      *
  77.      * @param key 键
  78.      * @return 存在返回对应值，不存在返回默认值-1
  79.      */
  80.     public int getInt(String key) {
  81.         return getInt(key, -1);
  82.     }
  84.     /**
  85.      * SP中读取int
  86.      *
  87.      * @param key          键
  88.      * @param defaultValue 默认值
  89.      * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
  90.      */
  91.     public int getInt(String key, int defaultValue) {
  92.         return sp.getInt(key, defaultValue);
  93.     }
  95.     /**
  96.      * SP中写入long类型value
  97.      *
  98.      * @param key   键
  99.      * @param value 值
  100.      */
  101.     public void putLong(String key, long value) {
  102.         editor.putLong(key, value).apply();
  103.     }
  105.     /**
  106.      * SP中读取long
  107.      *
  108.      * @param key 键
  109.      * @return 存在返回对应值，不存在返回默认值-1
  110.      */
  111.     public long getLong(String key) {
  112.         return getLong(key, -1L);
  113.     }
  115.     /**
  116.      * SP中读取long
  117.      *
  118.      * @param key          键
  119.      * @param defaultValue 默认值
  120.      * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
  121.      */
  122.     public long getLong(String key, long defaultValue) {
  123.         return sp.getLong(key, defaultValue);
  124.     }
  126.     /**
  127.      * SP中写入float类型value
  128.      *
  129.      * @param key   键
  130.      * @param value 值
  131.      */
  132.     public void putFloat(String key, float value) {
  133.         editor.putFloat(key, value).apply();
  134.     }
  136.     /**
  137.      * SP中读取float
  138.      *
  139.      * @param key 键
  140.      * @return 存在返回对应值，不存在返回默认值-1
  141.      */
  142.     public float getFloat(String key) {
  143.         return getFloat(key, -1f);
  144.     }
  146.     /**
  147.      * SP中读取float
  148.      *
  149.      * @param key          键
  150.      * @param defaultValue 默认值
  151.      * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
  152.      */
  153.     public float getFloat(String key, float defaultValue) {
  154.         return sp.getFloat(key, defaultValue);
  155.     }
  157.     /**
  158.      * SP中写入boolean类型value
  159.      *
  160.      * @param key   键
  161.      * @param value 值
  162.      */
  163.     public void putBoolean(String key, boolean value) {
  164.         editor.putBoolean(key, value).apply();
  165.     }
  167.     /**
  168.      * SP中读取boolean
  169.      *
  170.      * @param key 键
  171.      * @return 存在返回对应值，不存在返回默认值{@code false}
  172.      */
  173.     public boolean getBoolean(String key) {
  174.         return getBoolean(key, false);
  175.     }
  177.     /**
  178.      * SP中读取boolean
  179.      *
  180.      * @param key          键
  181.      * @param defaultValue 默认值
  182.      * @return 存在返回对应值，不存在返回默认值{@code defaultValue}
  183.      */
  184.     public boolean getBoolean(String key, boolean defaultValue) {
  185.         return sp.getBoolean(key, defaultValue);
  186.     }
  188.     /**
  189.      * SP中获取所有键值对
  190.      *
  191.      * @return Map对象
  192.      */
  193.     public Map<String, ?> getAll() {
  194.         return sp.getAll();
  195.     }
  197.     /**
  198.      * SP中移除该key
  199.      *
  200.      * @param key 键
  201.      */
  202.     public void remove(String key) {
  203.         editor.remove(key).apply();
  204.     }
  206.     /**
  207.      * SP中是否存在该key
  208.      *
  209.      * @param key 键
  210.      * @return {@code true}: 存在<br>{@code false}: 不存在
  211.      */
  212.     public boolean contains(String key) {
  213.         return sp.contains(key);
  214.     }
  216.     /**
  217.      * SP中清除所有数据
  218.      */
  219.     public void clear() {
  220.         editor.clear().apply();
  221.     }
  222. }

StringUtils

  1. package com.blankj.utilcode.utils;
  3. import java.io.UnsupportedEncodingException;
  5. /**
  6.  * <pre>
  7.  *     author: Blankj
  8.  *     blog  : http://blankj.com
  9.  *     time  : 2016/8/16
  10.  *     desc  : 字符串相关工具类
  11.  * </pre>
  12.  */
  13. public class StringUtils {
  15.     private StringUtils() {
  16.         throw new UnsupportedOperationException("u can't fuck me...");
  17.     }
  19.     /**
  20.      * 判断字符串是否为null或长度为0
  21.      *
  22.      * @param s 待校验字符串
  23.      * @return {@code true}: 空<br> {@code false}: 不为空
  24.      */
  25.     public static boolean isEmpty(CharSequence s) {
  26.         return s == null || s.length() == 0;
  27.     }
  29.     /**
  30.      * 判断字符串是否为null或全为空格
  31.      *
  32.      * @param s 待校验字符串
  33.      * @return {@code true}: null或全空格<br> {@code false}: 不为null且不全空格
  34.      */
  35.     public static boolean isSpace(String s) {
  36.         return (s == null || s.trim().length() == 0);
  37.     }
  39.     /**
  40.      * null转为长度为0的字符串
  41.      *
  42.      * @param s 待转字符串
  43.      * @return s为null转为长度为0字符串，否则不改变
  44.      */
  45.     public static String null2Length0(String s) {
  46.         return s == null ? "" : s;
  47.     }
  49.     /**
  50.      * 返回字符串长度
  51.      *
  52.      * @param s 字符串
  53.      * @return null返回0，其他返回自身长度
  54.      */
  55.     public static int length(CharSequence s) {
  56.         return s == null ? 0 : s.length();
  57.     }
  59.     /**
  60.      * 首字母大写
  61.      *
  62.      * @param s 待转字符串
  63.      * @return 首字母大写字符串
  64.      */
  65.     public static String upperFirstLetter(String s) {
  66.         if (isEmpty(s) || !Character.isLowerCase(s.charAt(0))) {
  67.             return s;
  68.         }
  69.         return String.valueOf((char) (s.charAt(0) - 32)) + s.substring(1);
  70.     }
  72.     /**
  73.      * 首字母小写
  74.      *
  75.      * @param s 待转字符串
  76.      * @return 首字母小写字符串
  77.      */
  78.     public static String lowerFirstLetter(String s) {
  79.         if (isEmpty(s) || !Character.isUpperCase(s.charAt(0))) {
  80.             return s;
  81.         }
  82.         return String.valueOf((char) (s.charAt(0) + 32)) + s.substring(1);
  83.     }
  85.     /**
  86.      * 反转字符串
  87.      *
  88.      * @param s 待反转字符串
  89.      * @return 反转字符串
  90.      */
  91.     public static String reverse(String s) {
  92.         int len = length(s);
  93.         if (len <= 1) return s;
  94.         int mid = len >> 1;
  95.         char[] chars = s.toCharArray();
  96.         char c;
  97.         for (int i = 0; i < mid; ++i) {
  98.             c = chars[i];
  99.             chars[i] = chars[len - i - 1];
  100.             chars[len - i - 1] = c;
  101.         }
  102.         return new String(chars);
  103.     }
  105.     /**
  106.      * 转化为半角字符
  107.      *
  108.      * @param s 待转字符串
  109.      * @return 半角字符串
  110.      */
  111.     public static String toDBC(String s) {
  112.         if (isEmpty(s)) {
  113.             return s;
  114.         }
  115.         char[] chars = s.toCharArray();
  116.         for (int i = 0, len = chars.length; i < len; i++) {
  117.             if (chars[i] == 12288) {
  118.                 chars[i] = ' ';
  119.             } else if (65281 <= chars[i] && chars[i] <= 65374) {
  120.                 chars[i] = (char) (chars[i] - 65248);
  121.             } else {
  122.                 chars[i] = chars[i];
  123.             }
  124.         }
  125.         return new String(chars);
  126.     }
  128.     /**
  129.      * 转化为全角字符
  130.      *
  131.      * @param s 待转字符串
  132.      * @return 全角字符串
  133.      */
  134.     public static String toSBC(String s) {
  135.         if (isEmpty(s)) {
  136.             return s;
  137.         }
  138.         char[] chars = s.toCharArray();
  139.         for (int i = 0, len = chars.length; i < len; i++) {
  140.             if (chars[i] == ' ') {
  141.                 chars[i] = (char) 12288;
  142.             } else if (33 <= chars[i] && chars[i] <= 126) {
  143.                 chars[i] = (char) (chars[i] + 65248);
  144.             } else {
  145.                 chars[i] = chars[i];
  146.             }
  147.         }
  148.         return new String(chars);
  149.     }
  151.     private static int[] pyValue = new int[]{-20319, -20317, -20304, -20295, -20292, -20283, -20265, -20257, -20242,
  152.             -20230, -20051, -20036, -20032,
  153.             -20026, -20002, -19990, -19986, -19982, -19976, -19805, -19784, -19775, -19774, -19763, -19756, -19751,
  154.             -19746, -19741, -19739, -19728,
  155.             -19725, -19715, -19540, -19531, -19525, -19515, -19500, -19484, -19479, -19467, -19289, -19288, -19281,
  156.             -19275, -19270, -19263, -19261,
  157.             -19249, -19243, -19242, -19238, -19235, -19227, -19224, -19218, -19212, -19038, -19023, -19018, -19006,
  158.             -19003, -18996, -18977, -18961,
  159.             -18952, -18783, -18774, -18773, -18763, -18756, -18741, -18735, -18731, -18722, -18710, -18697, -18696,
  160.             -18526, -18518, -18501, -18490,
  161.             -18478, -18463, -18448, -18447, -18446, -18239, -18237, -18231, -18220, -18211, -18201, -18184, -18183,
  162.             -18181, -18012, -17997, -17988,
  163.             -17970, -17964, -17961, -17950, -17947, -17931, -17928, -17922, -17759, -17752, -17733, -17730, -17721,
  164.             -17703, -17701, -17697, -17692,
  165.             -17683, -17676, -17496, -17487, -17482, -17468, -17454, -17433, -17427, -17417, -17202, -17185, -16983,
  166.             -16970, -16942, -16915, -16733,
  167.             -16708, -16706, -16689, -16664, -16657, -16647, -16474, -16470, -16465, -16459, -16452, -16448, -16433,
  168.             -16429, -16427, -16423, -16419,
  169.             -16412, -16407, -16403, -16401, -16393, -16220, -16216, -16212, -16205, -16202, -16187, -16180, -16171,
  170.             -16169, -16158, -16155, -15959,
  171.             -15958, -15944, -15933, -15920, -15915, -15903, -15889, -15878, -15707, -15701, -15681, -15667, -15661,
  172.             -15659, -15652, -15640, -15631,
  173.             -15625, -15454, -15448, -15436, -15435, -15419, -15416, -15408, -15394, -15385, -15377, -15375, -15369,
  174.             -15363, -15362, -15183, -15180,
  175.             -15165, -15158, -15153, -15150, -15149, -15144, -15143, -15141, -15140, -15139, -15128, -15121, -15119,
  176.             -15117, -15110, -15109, -14941,
  177.             -14937, -14933, -14930, -14929, -14928, -14926, -14922, -14921, -14914, -14908, -14902, -14894, -14889,
  178.             -14882, -14873, -14871, -14857,
  179.             -14678, -14674, -14670, -14668, -14663, -14654, -14645, -14630, -14594, -14429, -14407, -14399, -14384,
  180.             -14379, -14368, -14355, -14353,
  181.             -14345, -14170, -14159, -14151, -14149, -14145, -14140, -14137, -14135, -14125, -14123, -14122, -14112,
  182.             -14109, -14099, -14097, -14094,
  183.             -14092, -14090, -14087, -14083, -13917, -13914, -13910, -13907, -13906, -13905, -13896, -13894, -13878,
  184.             -13870, -13859, -13847, -13831,
  185.             -13658, -13611, -13601, -13406, -13404, -13400, -13398, -13395, -13391, -13387, -13383, -13367, -13359,
  186.             -13356, -13343, -13340, -13329,
  187.             -13326, -13318, -13147, -13138, -13120, -13107, -13096, -13095, -13091, -13076, -13068, -13063, -13060,
  188.             -12888, -12875, -12871, -12860,
  189.             -12858, -12852, -12849, -12838, -12831, -12829, -12812, -12802, -12607, -12597, -12594, -12585, -12556,
  190.             -12359, -12346, -12320, -12300,
  191.             -12120, -12099, -12089, -12074, -12067, -12058, -12039, -11867, -11861, -11847, -11831, -11798, -11781,
  192.             -11604, -11589, -11536, -11358,
  193.             -11340, -11339, -11324, -11303, -11097, -11077, -11067, -11055, -11052, -11045, -11041, -11038, -11024,
  194.             -11020, -11019, -11018, -11014,
  195.             -10838, -10832, -10815, -10800, -10790, -10780, -10764, -10587, -10544, -10533, -10519, -10331, -10329,
  196.             -10328, -10322, -10315, -10309,
  197.             -10307, -10296, -10281, -10274, -10270, -10262, -10260, -10256, -10254};
  199.     private static String[] pyStr = new String[]{"a", "ai", "an", "ang", "ao", "ba", "bai", "ban", "bang", "bao",
  200.             "bei", "ben", "beng", "bi", "bian",
  201.             "biao", "bie", "bin", "bing", "bo", "bu", "ca", "cai", "can", "cang", "cao", "ce", "ceng", "cha", "chai",
  202.             "chan", "chang", "chao", "che",
  203.             "chen", "cheng", "chi", "chong", "chou", "chu", "chuai", "chuan", "chuang", "chui", "chun", "chuo", "ci",
  204.             "cong", "cou", "cu", "cuan",
  205.             "cui", "cun", "cuo", "da", "dai", "dan", "dang", "dao", "de", "deng", "di", "dian", "diao", "die",
  206.             "ding", "diu", "dong", "dou", "du",
  207.             "duan", "dui", "dun", "duo", "e", "en", "er", "fa", "fan", "fang", "fei", "fen", "feng", "fo", "fou",
  208.             "fu", "ga", "gai", "gan", "gang",
  209.             "gao", "ge", "gei", "gen", "geng", "gong", "gou", "gu", "gua", "guai", "guan", "guang", "gui", "gun",
  210.             "guo", "ha", "hai", "han", "hang",
  211.             "hao", "he", "hei", "hen", "heng", "hong", "hou", "hu", "hua", "huai", "huan", "huang", "hui", "hun",
  212.             "huo", "ji", "jia", "jian",
  213.             "jiang", "jiao", "jie", "jin", "jing", "jiong", "jiu", "ju", "juan", "jue", "jun", "ka", "kai", "kan",
  214.             "kang", "kao", "ke", "ken",
  215.             "keng", "kong", "kou", "ku", "kua", "kuai", "kuan", "kuang", "kui", "kun", "kuo", "la", "lai", "lan",
  216.             "lang", "lao", "le", "lei", "leng",
  217.             "li", "lia", "lian", "liang", "liao", "lie", "lin", "ling", "liu", "long", "lou", "lu", "lv", "luan",
  218.             "lue", "lun", "luo", "ma", "mai",
  219.             "man", "mang", "mao", "me", "mei", "men", "meng", "mi", "mian", "miao", "mie", "min", "ming", "miu",
  220.             "mo", "mou", "mu", "na", "nai",
  221.             "nan", "nang", "nao", "ne", "nei", "nen", "neng", "ni", "nian", "niang", "niao", "nie", "nin", "ning",
  222.             "niu", "nong", "nu", "nv", "nuan",
  223.             "nue", "nuo", "o", "ou", "pa", "pai", "pan", "pang", "pao", "pei", "pen", "peng", "pi", "pian", "piao",
  224.             "pie", "pin", "ping", "po", "pu",
  225.             "qi", "qia", "qian", "qiang", "qiao", "qie", "qin", "qing", "qiong", "qiu", "qu", "quan", "que", "qun",
  226.             "ran", "rang", "rao", "re",
  227.             "ren", "reng", "ri", "rong", "rou", "ru", "ruan", "rui", "run", "ruo", "sa", "sai", "san", "sang", "sao",
  228.             "se", "sen", "seng", "sha",
  229.             "shai", "shan", "shang", "shao", "she", "shen", "sheng", "shi", "shou", "shu", "shua", "shuai", "shuan",
  230.             "shuang", "shui", "shun",
  231.             "shuo", "si", "song", "sou", "su", "suan", "sui", "sun", "suo", "ta", "tai", "tan", "tang", "tao", "te",
  232.             "teng", "ti", "tian", "tiao",
  233.             "tie", "ting", "tong", "tou", "tu", "tuan", "tui", "tun", "tuo", "wa", "wai", "wan", "wang", "wei",
  234.             "wen", "weng", "wo", "wu", "xi",
  235.             "xia", "xian", "xiang", "xiao", "xie", "xin", "xing", "xiong", "xiu", "xu", "xuan", "xue", "xun", "ya",
  236.             "yan", "yang", "yao", "ye", "yi",
  237.             "yin", "ying", "yo", "yong", "you", "yu", "yuan", "yue", "yun", "za", "zai", "zan", "zang", "zao", "ze",
  238.             "zei", "zen", "zeng", "zha",
  239.             "zhai", "zhan", "zhang", "zhao", "zhe", "zhen", "zheng", "zhi", "zhong", "zhou", "zhu", "zhua", "zhuai",
  240.             "zhuan", "zhuang", "zhui",
  241.             "zhun", "zhuo", "zi", "zong", "zou", "zu", "zuan", "zui", "zun", "zuo"};
  243.     /**
  244.      * 单个汉字转成ASCII码
  245.      *
  246.      * @param s 单个汉字字符串
  247.      * @return 如果字符串长度是1返回的是对应的ascii码，否则返回-1
  248.      */
  249.     private static int oneCn2ASCII(String s) {
  250.         if (s.length() != 1) return -1;
  251.         int ascii = 0;
  252.         try {
  253.             byte[] bytes = s.getBytes("GB2312");
  254.             if (bytes.length == 1) {
  255.                 ascii = bytes[0];
  256.             } else if (bytes.length == 2) {
  257.                 int highByte = 256 + bytes[0];
  258.                 int lowByte = 256 + bytes[1];
  259.                 ascii = (256 * highByte + lowByte) - 256 * 256;
  260.             } else {
  261.                 throw new IllegalArgumentException("Illegal resource string");
  262.             }
  263.         } catch (UnsupportedEncodingException e) {
  264.             e.printStackTrace();
  265.         }
  266.         return ascii;
  267.     }
  269.     /**
  270.      * 单个汉字转成拼音
  271.      *
  272.      * @param s 单个汉字字符串
  273.      * @return 如果字符串长度是1返回的是对应的拼音，否则返回{@code null}
  274.      */
  275.     private static String oneCn2PY(String s) {
  276.         int ascii = oneCn2ASCII(s);
  277.         if (ascii == -1) return null;
  278.         String ret = null;
  279.         if (0 <= ascii && ascii <= 127) {
  280.             ret = String.valueOf((char) ascii);
  281.         } else {
  282.             for (int i = pyValue.length - 1; i >= 0; i--) {
  283.                 if (pyValue[i] <= ascii) {
  284.                     ret = pyStr[i];
  285.                     break;
  286.                 }
  287.             }
  288.         }
  289.         return ret;
  290.     }
  292.     /**
  293.      * 获得第一个汉字首字母
  294.      *
  295.      * @param s 单个汉字字符串
  296.      * @return 拼音
  297.      */
  298.     public static String getPYFirstLetter(String s) {
  299.         if (isSpace(s)) return "";
  300.         String first, py;
  301.         first = s.substring(0, 1);
  302.         py = oneCn2PY(first);
  303.         if (py == null) return null;
  304.         return py.substring(0, 1);
  305.     }
  307.     /**
  308.      * 中文转拼音
  309.      *
  310.      * @param s 汉字字符串
  311.      * @return 拼音
  312.      */
  313.     public static String cn2PY(String s) {
  314.         String hz, py;
  315.         StringBuilder sb = new StringBuilder();
  316.         for (int i = 0; i < s.length(); i++) {
  317.             hz = s.substring(i, i + 1);
  318.             py = oneCn2PY(hz);
  319.             if (py == null) {
  320.                 py = "?";
  321.             }
  322.             sb.append(py);
  323.         }
  324.         return sb.toString();
  325.     }
  326. }

ThreadPoolUtils

  1. package com.blankj.utilcode.utils;
  3. import java.util.Collection;
  4. import java.util.List;
  5. import java.util.concurrent.Callable;
  6. import java.util.concurrent.ExecutionException;
  7. import java.util.concurrent.ExecutorService;
  8. import java.util.concurrent.Executors;
  9. import java.util.concurrent.Future;
  10. import java.util.concurrent.ScheduledExecutorService;
  11. import java.util.concurrent.ScheduledFuture;
  12. import java.util.concurrent.TimeUnit;
  13. import java.util.concurrent.TimeoutException;
  15. /**
  16.  * <pre>
  17.  *     author: Blankj
  18.  *     blog  : http://blankj.com
  19.  *     time  : 2016/8/25
  20.  *     desc  : 线程池相关工具类
  21.  * </pre>
  22.  */
  23. public class ThreadPoolUtils {
  25.     public enum Type {
  26.         FixedThread,
  27.         CachedThread,
  28.         SingleThread,
  29.     }
  31.     private ExecutorService exec;
  32.     private ScheduledExecutorService scheduleExec;
  34.     /**
  35.      * ThreadPoolUtils构造函数
  36.      *
  37.      * @param type         线程池类型
  38.      * @param corePoolSize 只对Fixed和Scheduled线程池起效
  39.      */
  40.     public ThreadPoolUtils(Type type, int corePoolSize) {
  41.         // 构造有定时功能的线程池
  42.         // ThreadPoolExecutor(corePoolSize, Integer.MAX_VALUE, 10L, TimeUnit.MILLISECONDS, new BlockingQueue<Runnable>)
  43.         scheduleExec = Executors.newScheduledThreadPool(corePoolSize);
  44.         switch (type) {
  45.             case FixedThread:
  46.                 // 构造一个固定线程数目的线程池
  47.                 // ThreadPoolExecutor(corePoolSize, corePoolSize, 0L, TimeUnit.MILLISECONDS, new
  48.                 // LinkedBlockingQueue<Runnable>());
  49.                 exec = Executors.newFixedThreadPool(corePoolSize);
  50.                 break;
  51.             case SingleThread:
  52.                 // 构造一个只支持一个线程的线程池,相当于newFixedThreadPool(1)
  53.                 // ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>())
  54.                 exec = Executors.newSingleThreadExecutor();
  55.                 break;
  56.             case CachedThread:
  57.                 // 构造一个缓冲功能的线程池
  58.                 // ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue<Runnable>());
  59.                 exec = Executors.newCachedThreadPool();
  60.                 break;
  61.             default:
  62.                 exec = scheduleExec;
  63.                 break;
  64.         }
  65.     }
  67.     /**
  68.      * 在未来某个时间执行给定的命令
  69.      * <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
  70.      *
  71.      * @param command 命令
  72.      */
  73.     public void execute(Runnable command) {
  74.         exec.execute(command);
  75.     }
  77.     /**
  78.      * 在未来某个时间执行给定的命令链表
  79.      * <p>该命令可能在新的线程、已入池的线程或者正调用的线程中执行，这由 Executor 实现决定。</p>
  80.      *
  81.      * @param commands 命令链表
  82.      */
  83.     public void execute(List<Runnable> commands) {
  84.         for (Runnable command : commands) {
  85.             exec.execute(command);
  86.         }
  87.     }
  89.     /**
  90.      * 待以前提交的任务执行完毕后关闭线程池
  91.      * <p>启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
  92.      * 如果已经关闭，则调用没有作用。</p>
  93.      */
  94.     public void shutDown() {
  95.         exec.shutdown();
  96.     }
  98.     /**
  99.      * 试图停止所有正在执行的活动任务
  100.      * <p>试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。</p>
  101.      * <p>无法保证能够停止正在处理的活动执行任务，但是会尽力尝试。</p>
  102.      *
  103.      * @return 等待执行的任务的列表
  104.      */
  105.     public List<Runnable> shutDownNow() {
  106.         return exec.shutdownNow();
  107.     }
  109.     /**
  110.      * 判断线程池是否已关闭
  111.      *
  112.      * @return {@code true}: 是<br>{@code false}: 否
  113.      */
  114.     public boolean isShutDown() {
  115.         return exec.isShutdown();
  116.     }
  118.     /**
  119.      * 关闭线程池后判断所有任务是否都已完成
  120.      * <p>注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。</p>
  121.      *
  122.      * @return {@code true}: 是<br>{@code false}: 否
  123.      */
  124.     public boolean isTerminated() {
  125.         return exec.isTerminated();
  126.     }
  129.     /**
  130.      * 请求关闭、发生超时或者当前线程中断
  131.      * <p>无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。</p>
  132.      *
  133.      * @param timeout 最长等待时间
  134.      * @param unit    时间单位
  135.      * @return {@code true}: 请求成功<br>{@code false}: 请求超时
  136.      * @throws InterruptedException 终端异常
  137.      */
  138.     public boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException {
  139.         return exec.awaitTermination(timeout, unit);
  140.     }
  142.     /**
  143.      * 提交一个Callable任务用于执行
  144.      * <p>如果想立即阻塞任务的等待，则可以使用{@code result = exec.submit(aCallable).get();}形式的构造。</p>
  145.      *
  146.      * @param task 任务
  147.      * @param <T>  泛型
  148.      * @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
  149.      */
  150.     public <T> Future<T> submit(Callable<T> task) {
  151.         return exec.submit(task);
  152.     }
  154.     /**
  155.      * 提交一个Runnable任务用于执行
  156.      *
  157.      * @param task   任务
  158.      * @param result 返回的结果
  159.      * @param <T>    泛型
  160.      * @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回该任务的结果。
  161.      */
  162.     public <T> Future<T> submit(Runnable task, T result) {
  163.         return exec.submit(task, result);
  164.     }
  166.     /**
  167.      * 提交一个Runnable任务用于执行
  168.      *
  169.      * @param task 任务
  170.      * @return 表示任务等待完成的Future, 该Future的{@code get}方法在成功完成时将会返回null结果。
  171.      */
  172.     public Future<?> submit(Runnable task) {
  173.         return exec.submit(task);
  174.     }
  176.     /**
  177.      * 执行给定的任务
  178.      * <p>当所有任务完成时，返回保持任务状态和结果的Future列表。
  179.      * 返回列表的所有元素的{@link Future#isDone}为{@code true}。
  180.      * 注意，可以正常地或通过抛出异常来终止已完成任务。
  181.      * 如果正在进行此操作时修改了给定的 collection，则此方法的结果是不确定的。</p>
  182.      *
  183.      * @param tasks 任务集合
  184.      * @param <T>   泛型
  185.      * @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同，每个任务都已完成。
  186.      * @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务。
  187.      */
  188.     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) throws InterruptedException {
  189.         return exec.invokeAll(tasks);
  190.     }
  192.     /**
  193.      * 执行给定的任务
  194.      * <p>当所有任务完成或超时期满时(无论哪个首先发生)，返回保持任务状态和结果的Future列表。
  195.      * 返回列表的所有元素的{@link Future#isDone}为{@code true}。
  196.      * 一旦返回后，即取消尚未完成的任务。
  197.      * 注意，可以正常地或通过抛出异常来终止已完成任务。
  198.      * 如果此操作正在进行时修改了给定的 collection，则此方法的结果是不确定的。</p>
  199.      *
  200.      * @param tasks   任务集合
  201.      * @param timeout 最长等待时间
  202.      * @param unit    时间单位
  203.      * @param <T>     泛型
  204.      * @return 表示任务的 Future 列表，列表顺序与给定任务列表的迭代器所生成的顺序相同。如果操作未超时，则已完成所有任务。如果确实超时了，则某些任务尚未完成。
  205.      * @throws InterruptedException 如果等待时发生中断，在这种情况下取消尚未完成的任务
  206.      */
  207.     public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
  208.             InterruptedException {
  209.         return exec.invokeAll(tasks, timeout, unit);
  210.     }
  212.     /**
  213.      * 执行给定的任务
  214.      * <p>如果某个任务已成功完成（也就是未抛出异常），则返回其结果。
  215.      * 一旦正常或异常返回后，则取消尚未完成的任务。
  216.      * 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
  217.      *
  218.      * @param tasks 任务集合
  219.      * @param <T>   泛型
  220.      * @return 某个任务返回的结果
  221.      * @throws InterruptedException 如果等待时发生中断
  222.      * @throws ExecutionException   如果没有任务成功完成
  223.      */
  224.     public <T> T invokeAny(Collection<? extends Callable<T>> tasks) throws InterruptedException, ExecutionException {
  225.         return exec.invokeAny(tasks);
  226.     }
  228.     /**
  229.      * 执行给定的任务
  230.      * <p>如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
  231.      * 一旦正常或异常返回后，则取消尚未完成的任务。
  232.      * 如果此操作正在进行时修改了给定的collection，则此方法的结果是不确定的。</p>
  233.      *
  234.      * @param tasks   任务集合
  235.      * @param timeout 最长等待时间
  236.      * @param unit    时间单位
  237.      * @param <T>     泛型
  238.      * @return 某个任务返回的结果
  239.      * @throws InterruptedException 如果等待时发生中断
  240.      * @throws ExecutionException   如果没有任务成功完成
  241.      * @throws TimeoutException     如果在所有任务成功完成之前给定的超时期满
  242.      */
  243.     public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) throws
  244.             InterruptedException, ExecutionException, TimeoutException {
  245.         return exec.invokeAny(tasks, timeout, unit);
  246.     }
  248.     /**
  249.      * 延迟执行Runnable命令
  250.      *
  251.      * @param command 命令
  252.      * @param delay   延迟时间
  253.      * @param unit    单位
  254.      * @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在完成后将返回{@code null}
  255.      */
  256.     public ScheduledFuture<?> schedule(Runnable command, long delay, TimeUnit unit) {
  257.         return scheduleExec.schedule(command, delay, unit);
  258.     }
  260.     /**
  261.      * 延迟执行Callable命令
  262.      *
  263.      * @param callable 命令
  264.      * @param delay    延迟时间
  265.      * @param unit     时间单位
  266.      * @param <V>      泛型
  267.      * @return 可用于提取结果或取消的ScheduledFuture
  268.      */
  269.     public <V> ScheduledFuture<V> schedule(Callable<V> callable, long delay, TimeUnit unit) {
  270.         return scheduleExec.schedule(callable, delay, unit);
  271.     }
  273.     /**
  274.      * 延迟并循环执行命令
  275.      *
  276.      * @param command      命令
  277.      * @param initialDelay 首次执行的延迟时间
  278.      * @param period       连续执行之间的周期
  279.      * @param unit         时间单位
  280.      * @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
  281.      */
  282.     public ScheduledFuture<?> scheduleWithFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit) {
  283.         return scheduleExec.scheduleAtFixedRate(command, initialDelay, period, unit);
  284.     }
  286.     /**
  287.      * 延迟并以固定休息时间循环执行命令
  288.      *
  289.      * @param command      命令
  290.      * @param initialDelay 首次执行的延迟时间
  291.      * @param delay        每一次执行终止和下一次执行开始之间的延迟
  292.      * @param unit         时间单位
  293.      * @return 表示挂起任务完成的ScheduledFuture，并且其{@code get()}方法在取消后将抛出异常
  294.      */
  295.     public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command, long initialDelay, long delay, TimeUnit unit) {
  296.         return scheduleExec.scheduleWithFixedDelay(command, initialDelay, delay, unit);
  297.     }
  298. }

TimeUtils

  1. package com.blankj.utilcode.utils;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Locale;
  8. import static com.blankj.utilcode.utils.ConstUtils.*;
  11. /**
  12.  * <pre>
  13.  *     author: Blankj
  14.  *     blog  : http://blankj.com
  15.  *     time  : 2016/8/2
  16.  *     desc  : 时间相关工具类
  17.  * </pre>
  18.  */
  19. public class TimeUtils {
  21.     private TimeUtils() {
  22.         throw new UnsupportedOperationException("u can't fuck me...");
  23.     }
  25.     /**
  26.      * <p>在工具类中经常使用到工具类的格式化描述，这个主要是一个日期的操作类，所以日志格式主要使用 SimpleDateFormat的定义格式.</p>
  27.      * 格式的意义如下： 日期和时间模式 <br>
  28.      * <p>日期和时间格式由日期和时间模式字符串指定。在日期和时间模式字符串中，未加引号的字母 'A' 到 'Z' 和 'a' 到 'z'
  29.      * 被解释为模式字母，用来表示日期或时间字符串元素。文本可以使用单引号 (') 引起来，以免进行解释。"''"
  30.      * 表示单引号。所有其他字符均不解释；只是在格式化时将它们简单复制到输出字符串，或者在分析时与输入字符串进行匹配。
  31.      * </p>
  32.      * 定义了以下模式字母（所有其他字符 'A' 到 'Z' 和 'a' 到 'z' 都被保留）： <br>
  33.      * <table border="1" cellspacing="1" cellpadding="1" summary="Chart shows pattern letters, date/time component,
  34.      * presentation, and examples.">
  35.      * <tr>
  36.      * <th align="left">字母</th>
  37.      * <th align="left">日期或时间元素</th>
  38.      * <th align="left">表示</th>
  39.      * <th align="left">示例</th>
  40.      * </tr>
  41.      * <tr>
  42.      * <td><code>G</code></td>
  43.      * <td>Era 标志符</td>
  44.      * <td>Text</td>
  45.      * <td><code>AD</code></td>
  46.      * </tr>
  47.      * <tr>
  48.      * <td><code>y</code> </td>
  49.      * <td>年 </td>
  50.      * <td>Year </td>
  51.      * <td><code>1996</code>; <code>96</code> </td>
  52.      * </tr>
  53.      * <tr>
  54.      * <td><code>M</code> </td>
  55.      * <td>年中的月份 </td>
  56.      * <td>Month </td>
  57.      * <td><code>July</code>; <code>Jul</code>; <code>07</code> </td>
  58.      * </tr>
  59.      * <tr>
  60.      * <td><code>w</code> </td>
  61.      * <td>年中的周数 </td>
  62.      * <td>Number </td>
  63.      * <td><code>27</code> </td>
  64.      * </tr>
  65.      * <tr>
  66.      * <td><code>W</code> </td>
  67.      * <td>月份中的周数 </td>
  68.      * <td>Number </td>
  69.      * <td><code>2</code> </td>
  70.      * </tr>
  71.      * <tr>
  72.      * <td><code>D</code> </td>
  73.      * <td>年中的天数 </td>
  74.      * <td>Number </td>
  75.      * <td><code>189</code> </td>
  76.      * </tr>
  77.      * <tr>
  78.      * <td><code>d</code> </td>
  79.      * <td>月份中的天数 </td>
  80.      * <td>Number </td>
  81.      * <td><code>10</code> </td>
  82.      * </tr>
  83.      * <tr>
  84.      * <td><code>F</code> </td>
  85.      * <td>月份中的星期 </td>
  86.      * <td>Number </td>
  87.      * <td><code>2</code> </td>
  88.      * </tr>
  89.      * <tr>
  90.      * <td><code>E</code> </td>
  91.      * <td>星期中的天数 </td>
  92.      * <td>Text </td>
  93.      * <td><code>Tuesday</code>; <code>Tue</code> </td>
  94.      * </tr>
  95.      * <tr>
  96.      * <td><code>a</code> </td>
  97.      * <td>Am/pm 标记 </td>
  98.      * <td>Text </td>
  99.      * <td><code>PM</code> </td>
  100.      * </tr>
  101.      * <tr>
  102.      * <td><code>H</code> </td>
  103.      * <td>一天中的小时数（0-23） </td>
  104.      * <td>Number </td>
  105.      * <td><code>0</code> </td>
  106.      * </tr>
  107.      * <tr>
  108.      * <td><code>k</code> </td>
  109.      * <td>一天中的小时数（1-24） </td>
  110.      * <td>Number </td>
  111.      * <td><code>24</code> </td>
  112.      * </tr>
  113.      * <tr>
  114.      * <td><code>K</code> </td>
  115.      * <td>am/pm 中的小时数（0-11） </td>
  116.      * <td>Number </td>
  117.      * <td><code>0</code> </td>
  118.      * </tr>
  119.      * <tr>
  120.      * <td><code>h</code> </td>
  121.      * <td>am/pm 中的小时数（1-12） </td>
  122.      * <td>Number </td>
  123.      * <td><code>12</code> </td>
  124.      * </tr>
  125.      * <tr>
  126.      * <td><code>m</code> </td>
  127.      * <td>小时中的分钟数 </td>
  128.      * <td>Number </td>
  129.      * <td><code>30</code> </td>
  130.      * </tr>
  131.      * <tr>
  132.      * <td><code>s</code> </td>
  133.      * <td>分钟中的秒数 </td>
  134.      * <td>Number </td>
  135.      * <td><code>55</code> </td>
  136.      * </tr>
  137.      * <tr>
  138.      * <td><code>S</code> </td>
  139.      * <td>毫秒数 </td>
  140.      * <td>Number </td>
  141.      * <td><code>978</code> </td>
  142.      * </tr>
  143.      * <tr>
  144.      * <td><code>z</code> </td>
  145.      * <td>时区 </td>
  146.      * <td>General time zone </td>
  147.      * <td><code>Pacific Standard Time</code>; <code>PST</code>; <code>GMT-08:00</code> </td>
  148.      * </tr>
  149.      * <tr>
  150.      * <td><code>Z</code> </td>
  151.      * <td>时区 </td>
  152.      * <td>RFC 822 time zone </td>
  153.      * <td><code>-0800</code> </td>
  154.      * </tr>
  155.      * </table>
  156.      * <pre>
  157.      *                          HH:mm    15:44
  158.      *                         h:mm a    3:44 下午
  159.      *                        HH:mm z    15:44 CST
  160.      *                        HH:mm Z    15:44 +0800
  161.      *                     HH:mm zzzz    15:44 中国标准时间
  162.      *                       HH:mm:ss    15:44:40
  163.      *                     yyyy-MM-dd    2016-08-12
  164.      *               yyyy-MM-dd HH:mm    2016-08-12 15:44
  165.      *            yyyy-MM-dd HH:mm:ss    2016-08-12 15:44:40
  166.      *       yyyy-MM-dd HH:mm:ss zzzz    2016-08-12 15:44:40 中国标准时间
  167.      *  EEEE yyyy-MM-dd HH:mm:ss zzzz    星期五 2016-08-12 15:44:40 中国标准时间
  168.      *       yyyy-MM-dd HH:mm:ss.SSSZ    2016-08-12 15:44:40.461+0800
  169.      *     yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
  170.      *   yyyy.MM.dd G 'at' HH:mm:ss z    2016.08.12 公元 at 15:44:40 CST
  171.      *                         K:mm a    3:44 下午
  172.      *               EEE, MMM d, ''yy    星期五, 八月 12, '16
  173.      *          hh 'o''clock' a, zzzz    03 o'clock 下午, 中国标准时间
  174.      *   yyyyy.MMMMM.dd GGG hh:mm aaa    02016.八月.12 公元 03:44 下午
  175.      *     EEE, d MMM yyyy HH:mm:ss Z    星期五, 12 八月 2016 15:44:40 +0800
  176.      *                  yyMMddHHmmssZ    160812154440+0800
  177.      *     yyyy-MM-dd'T'HH:mm:ss.SSSZ    2016-08-12T15:44:40.461+0800
  178.      * EEEE 'DATE('yyyy-MM-dd')' 'TIME('HH:mm:ss')' zzzz    星期五 DATE(2016-08-12) TIME(15:44:40) 中国标准时间
  179.      * </pre>
  180.      */
  181.     public static final SimpleDateFormat DEFAULT_SDF = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", Locale.getDefault());
  184.     /**
  185.      * 将时间戳转为时间字符串
  186.      * <p>格式为yyyy-MM-dd HH:mm:ss</p>
  187.      *
  188.      * @param milliseconds 毫秒时间戳
  189.      * @return 时间字符串
  190.      */
  191.     public static String milliseconds2String(long milliseconds) {
  192.         return milliseconds2String(milliseconds, DEFAULT_SDF);
  193.     }
  195.     /**
  196.      * 将时间戳转为时间字符串
  197.      * <p>格式为用户自定义</p>
  198.      *
  199.      * @param milliseconds 毫秒时间戳
  200.      * @param format       时间格式
  201.      * @return 时间字符串
  202.      */
  203.     public static String milliseconds2String(long milliseconds, SimpleDateFormat format) {
  204.         return format.format(new Date(milliseconds));
  205.     }
  207.     /**
  208.      * 将时间字符串转为时间戳
  209.      * <p>格式为yyyy-MM-dd HH:mm:ss</p>
  210.      *
  211.      * @param time 时间字符串
  212.      * @return 毫秒时间戳
  213.      */
  214.     public static long string2Milliseconds(String time) {
  215.         return string2Milliseconds(time, DEFAULT_SDF);
  216.     }
  218.     /**
  219.      * 将时间字符串转为时间戳
  220.      * <p>格式为用户自定义</p>
  221.      *
  222.      * @param time   时间字符串
  223.      * @param format 时间格式
  224.      * @return 毫秒时间戳
  225.      */
  226.     public static long string2Milliseconds(String time, SimpleDateFormat format) {
  227.         try {
  228.             return format.parse(time).getTime();
  229.         } catch (ParseException e) {
  230.             e.printStackTrace();
  231.         }
  232.         return -1;
  233.     }
  235.     /**
  236.      * 将时间字符串转为Date类型
  237.      * <p>格式为yyyy-MM-dd HH:mm:ss</p>
  238.      *
  239.      * @param time 时间字符串
  240.      * @return Date类型
  241.      */
  242.     public static Date string2Date(String time) {
  243.         return string2Date(time, DEFAULT_SDF);
  244.     }
  246.     /**
  247.      * 将时间字符串转为Date类型
  248.      * <p>格式为用户自定义</p>
  249.      *
  250.      * @param time   时间字符串
  251.      * @param format 时间格式
  252.      * @return Date类型
  253.      */
  254.     public static Date string2Date(String time, SimpleDateFormat format) {
  255.         return new Date(string2Milliseconds(time, format));
  256.     }
  258.     /**
  259.      * 将Date类型转为时间字符串
  260.      * <p>格式为yyyy-MM-dd HH:mm:ss</p>
  261.      *
  262.      * @param time Date类型时间
  263.      * @return 时间字符串
  264.      */
  265.     public static String date2String(Date time) {
  266.         return date2String(time, DEFAULT_SDF);
  267.     }
  269.     /**
  270.      * 将Date类型转为时间字符串
  271.      * <p>格式为用户自定义</p>
  272.      *
  273.      * @param time   Date类型时间
  274.      * @param format 时间格式
  275.      * @return 时间字符串
  276.      */
  277.     public static String date2String(Date time, SimpleDateFormat format) {
  278.         return format.format(time);
  279.     }
  281.     /**
  282.      * 将Date类型转为时间戳
  283.      *
  284.      * @param time Date类型时间
  285.      * @return 毫秒时间戳
  286.      */
  287.     public static long date2Milliseconds(Date time) {
  288.         return time.getTime();
  289.     }
  291.     /**
  292.      * 将时间戳转为Date类型
  293.      *
  294.      * @param milliseconds 毫秒时间戳
  295.      * @return Date类型时间
  296.      */
  297.     public static Date milliseconds2Date(long milliseconds) {
  298.         return new Date(milliseconds);
  299.     }
  301.     /**
  302.      * 毫秒时间戳单位转换（单位：unit）
  303.      *
  304.      * @param milliseconds 毫秒时间戳
  305.      * @param unit         <ul>
  306.      *                     <li>{@link TimeUnit#MSEC}: 毫秒</li>
  307.      *                     <li>{@link TimeUnit#SEC }: 秒</li>
  308.      *                     <li>{@link TimeUnit#MIN }: 分</li>
  309.      *                     <li>{@link TimeUnit#HOUR}: 小时</li>
  310.      *                     <li>{@link TimeUnit#DAY }: 天</li>
  311.      *                     </ul>
  312.      * @return unit时间戳
  313.      */
  314.     private static long milliseconds2Unit(long milliseconds, TimeUnit unit) {
  315.         switch (unit) {
  316.             case MSEC:
  317.                 return milliseconds / MSEC;
  318.             case SEC:
  319.                 return milliseconds / SEC;
  320.             case MIN:
  321.                 return milliseconds / MIN;
  322.             case HOUR:
  323.                 return milliseconds / HOUR;
  324.             case DAY:
  325.                 return milliseconds / DAY;
  326.         }
  327.         return -1;
  328.     }
  330.     /**
  331.      * 获取两个时间差（单位：unit）
  332.      * <p>time1和time2格式都为yyyy-MM-dd HH:mm:ss</p>
  333.      *
  334.      * @param time0 时间字符串1
  335.      * @param time1 时间字符串2
  336.      * @param unit  <ul>
  337.      *              <li>{@link TimeUnit#MSEC}: 毫秒</li>
  338.      *              <li>{@link TimeUnit#SEC }: 秒</li>
  339.      *              <li>{@link TimeUnit#MIN }: 分</li>
  340.      *              <li>{@link TimeUnit#HOUR}: 小时</li>
  341.      *              <li>{@link TimeUnit#DAY }: 天</li>
  342.      *              </ul>
  343.      * @return unit时间戳
  344.      */
  345.     public static long getIntervalTime(String time0, String time1, TimeUnit unit) {
  346.         return getIntervalTime(time0, time1, unit, DEFAULT_SDF);
  347.     }
  349.     /**
  350.      * 获取两个时间差（单位：unit）
  351.      * <p>time1和time2格式都为format</p>
  352.      *
  353.      * @param time0  时间字符串1
  354.      * @param time1  时间字符串2
  355.      * @param unit   <ul>
  356.      *               <li>{@link TimeUnit#MSEC}: 毫秒</li>
  357.      *               <li>{@link TimeUnit#SEC }: 秒</li>
  358.      *               <li>{@link TimeUnit#MIN }: 分</li>
  359.      *               <li>{@link TimeUnit#HOUR}: 小时</li>
  360.      *               <li>{@link TimeUnit#DAY }: 天</li>
  361.      *               </ul>
  362.      * @param format 时间格式
  363.      * @return unit时间戳
  364.      */
  365.     public static long getIntervalTime(String time0, String time1, TimeUnit unit, SimpleDateFormat format) {
  366.         return Math.abs(milliseconds2Unit(string2Milliseconds(time0, format)
  367.                 - string2Milliseconds(time1, format), unit));
  368.     }
  370.     /**
  371.      * 获取两个时间差（单位：unit）
  372.      * <p>time1和time2都为Date类型</p>
  373.      *
  374.      * @param time0 Date类型时间1
  375.      * @param time1 Date类型时间2
  376.      * @param unit  <ul>
  377.      *              <li>{@link TimeUnit#MSEC}: 毫秒</li>
  378.      *              <li>{@link TimeUnit#SEC }: 秒</li>
  379.      *              <li>{@link TimeUnit#MIN }: 分</li>
  380.      *              <li>{@link TimeUnit#HOUR}: 小时</li>
  381.      *              <li>{@link TimeUnit#DAY }: 天</li>
  382.      *              </ul>
  383.      * @return unit时间戳
  384.      */
  385.     public static long getIntervalTime(Date time0, Date time1, TimeUnit unit) {
  386.         return Math.abs(milliseconds2Unit(date2Milliseconds(time1)
  387.                 - date2Milliseconds(time0), unit));
  388.     }
  390.     /**
  391.      * 获取当前时间
  392.      *
  393.      * @return 毫秒时间戳
  394.      */
  395.     public static long getCurTimeMills() {
  396.         return System.currentTimeMillis();
  397.     }
  399.     /**
  400.      * 获取当前时间
  401.      * <p>格式为yyyy-MM-dd HH:mm:ss</p>
  402.      *
  403.      * @return 时间字符串
  404.      */
  405.     public static String getCurTimeString() {
  406.         return date2String(new Date());
  407.     }
  409.     /**
  410.      * 获取当前时间
  411.      * <p>格式为用户自定义</p>
  412.      *
  413.      * @param format 时间格式
  414.      * @return 时间字符串
  415.      */
  416.     public static String getCurTimeString(SimpleDateFormat format) {
  417.         return date2String(new Date(), format);
  418.     }
  420.     /**
  421.      * 获取当前时间
  422.      * <p>Date类型</p>
  423.      *
  424.      * @return Date类型时间
  425.      */
  426.     public static Date getCurTimeDate() {
  427.         return new Date();
  428.     }
  430.     /**
  431.      * 获取与当前时间的差（单位：unit）
  432.      * <p>time格式为yyyy-MM-dd HH:mm:ss</p>
  433.      *
  434.      * @param time 时间字符串
  435.      * @param unit <ul>
  436.      *             <li>{@link TimeUnit#MSEC}:毫秒</li>
  437.      *             <li>{@link TimeUnit#SEC }:秒</li>
  438.      *             <li>{@link TimeUnit#MIN }:分</li>
  439.      *             <li>{@link TimeUnit#HOUR}:小时</li>
  440.      *             <li>{@link TimeUnit#DAY }:天</li>
  441.      *             </ul>
  442.      * @return unit时间戳
  443.      */
  444.     public static long getIntervalByNow(String time, TimeUnit unit) {
  445.         return getIntervalByNow(time, unit, DEFAULT_SDF);
  446.     }
  448.     /**
  449.      * 获取与当前时间的差（单位：unit）
  450.      * <p>time格式为format</p>
  451.      *
  452.      * @param time   时间字符串
  453.      * @param unit   <ul>
  454.      *               <li>{@link TimeUnit#MSEC}: 毫秒</li>
  455.      *               <li>{@link TimeUnit#SEC }: 秒</li>
  456.      *               <li>{@link TimeUnit#MIN }: 分</li>
  457.      *               <li>{@link TimeUnit#HOUR}: 小时</li>
  458.      *               <li>{@link TimeUnit#DAY }: 天</li>
  459.      *               </ul>
  460.      * @param format 时间格式
  461.      * @return unit时间戳
  462.      */
  463.     public static long getIntervalByNow(String time, TimeUnit unit, SimpleDateFormat format) {
  464.         return getIntervalTime(getCurTimeString(), time, unit, format);
  465.     }
  467.     /**
  468.      * 获取与当前时间的差（单位：unit）
  469.      * <p>time为Date类型</p>
  470.      *
  471.      * @param time Date类型时间
  472.      * @param unit <ul>
  473.      *             <li>{@link TimeUnit#MSEC}: 毫秒</li>
  474.      *             <li>{@link TimeUnit#SEC }: 秒</li>
  475.      *             <li>{@link TimeUnit#MIN }: 分</li>
  476.      *             <li>{@link TimeUnit#HOUR}: 小时</li>
  477.      *             <li>{@link TimeUnit#DAY }: 天</li>
  478.      *             </ul>
  479.      * @return unit时间戳
  480.      */
  481.     public static long getIntervalByNow(Date time, TimeUnit unit) {
  482.         return getIntervalTime(getCurTimeDate(), time, unit);
  483.     }
  485.     /**
  486.      * 判断闰年
  487.      *
  488.      * @param year 年份
  489.      * @return {@code true}: 闰年<br>{@code false}: 平年
  490.      */
  491.     public static boolean isLeapYear(int year) {
  492.         return year % 4 == 0 && year % 100 != 0 || year % 400 == 0;
  493.     }
  494. }

ZipUtils

  1. package com.blankj.utilcode.utils;
  3. import java.io.BufferedInputStream;
  4. import java.io.BufferedOutputStream;
  5. import java.io.File;
  6. import java.io.FileInputStream;
  7. import java.io.FileOutputStream;
  8. import java.io.IOException;
  9. import java.io.InputStream;
  10. import java.io.OutputStream;
  11. import java.util.ArrayList;
  12. import java.util.Collection;
  13. import java.util.Enumeration;
  14. import java.util.List;
  15. import java.util.zip.ZipEntry;
  16. import java.util.zip.ZipFile;
  17. import java.util.zip.ZipOutputStream;
  19. import static com.blankj.utilcode.utils.ConstUtils.KB;
  21. /**
  22.  * <pre>
  23.  *     author: Blankj
  24.  *     blog  : http://blankj.com
  25.  *     time  : 2016/8/27
  26.  *     desc  : 压缩相关工具类
  27.  * </pre>
  28.  */
  29. public class ZipUtils {
  31.     private ZipUtils() {
  32.         throw new UnsupportedOperationException("u can't fuck me...");
  33.     }
  35.     /**
  36.      * 批量压缩文件
  37.      *
  38.      * @param resFiles    待压缩文件集合
  39.      * @param zipFilePath 压缩文件路径
  40.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  41.      * @throws IOException IO错误时抛出
  42.      */
  43.     public static boolean zipFiles(Collection<File> resFiles, String zipFilePath)
  44.             throws IOException {
  45.         return zipFiles(resFiles, zipFilePath, null);
  46.     }
  48.     /**
  49.      * 批量压缩文件
  50.      *
  51.      * @param resFiles    待压缩文件集合
  52.      * @param zipFilePath 压缩文件路径
  53.      * @param comment     压缩文件的注释
  54.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  55.      * @throws IOException IO错误时抛出
  56.      */
  57.     public static boolean zipFiles(Collection<File> resFiles, String zipFilePath, String comment)
  58.             throws IOException {
  59.         return zipFiles(resFiles, FileUtils.getFileByPath(zipFilePath), comment);
  60.     }
  62.     /**
  63.      * 批量压缩文件
  64.      *
  65.      * @param resFiles 待压缩文件集合
  66.      * @param zipFile  压缩文件
  67.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  68.      * @throws IOException IO错误时抛出
  69.      */
  70.     public static boolean zipFiles(Collection<File> resFiles, File zipFile)
  71.             throws IOException {
  72.         return zipFiles(resFiles, zipFile, null);
  73.     }
  75.     /**
  76.      * 批量压缩文件
  77.      *
  78.      * @param resFiles 待压缩文件集合
  79.      * @param zipFile  压缩文件
  80.      * @param comment  压缩文件的注释
  81.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  82.      * @throws IOException IO错误时抛出
  83.      */
  84.     public static boolean zipFiles(Collection<File> resFiles, File zipFile, String comment)
  85.             throws IOException {
  86.         if (resFiles == null || zipFile == null) return false;
  87.         ZipOutputStream zos = null;
  88.         try {
  89.             zos = new ZipOutputStream(new FileOutputStream(zipFile));
  90.             for (File resFile : resFiles) {
  91.                 if (!zipFile(resFile, "", zos, comment)) return false;
  92.             }
  93.             return true;
  94.         } finally {
  95.             if (zos != null) {
  96.                 zos.finish();
  97.                 FileUtils.closeIO(zos);
  98.             }
  99.         }
  100.     }
  102.     /**
  103.      * 压缩文件
  104.      *
  105.      * @param resFilePath 待压缩文件路径
  106.      * @param zipFilePath 压缩文件路径
  107.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  108.      * @throws IOException IO错误时抛出
  109.      */
  110.     public static boolean zipFile(String resFilePath, String zipFilePath)
  111.             throws IOException {
  112.         return zipFile(resFilePath, zipFilePath, null);
  113.     }
  115.     /**
  116.      * 压缩文件
  117.      *
  118.      * @param resFilePath 待压缩文件路径
  119.      * @param zipFilePath 压缩文件路径
  120.      * @param comment     压缩文件的注释
  121.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  122.      * @throws IOException IO错误时抛出
  123.      */
  124.     public static boolean zipFile(String resFilePath, String zipFilePath, String comment)
  125.             throws IOException {
  126.         return zipFile(FileUtils.getFileByPath(resFilePath), FileUtils.getFileByPath(zipFilePath), comment);
  127.     }
  129.     /**
  130.      * 压缩文件
  131.      *
  132.      * @param resFile 待压缩文件
  133.      * @param zipFile 压缩文件
  134.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  135.      * @throws IOException IO错误时抛出
  136.      */
  137.     public static boolean zipFile(File resFile, File zipFile)
  138.             throws IOException {
  139.         return zipFile(resFile, zipFile, null);
  140.     }
  142.     /**
  143.      * 压缩文件
  144.      *
  145.      * @param resFile 待压缩文件
  146.      * @param zipFile 压缩文件
  147.      * @param comment 压缩文件的注释
  148.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  149.      * @throws IOException IO错误时抛出
  150.      */
  151.     public static boolean zipFile(File resFile, File zipFile, String comment)
  152.             throws IOException {
  153.         if (resFile == null || zipFile == null) return false;
  154.         ZipOutputStream zos = null;
  155.         try {
  156.             zos = new ZipOutputStream(new FileOutputStream(zipFile));
  157.             return zipFile(resFile, "", zos, comment);
  158.         } finally {
  159.             if (zos != null) {
  160.                 zos.finish();
  161.                 FileUtils.closeIO(zos);
  162.             }
  163.         }
  164.     }
  166.     /**
  167.      * 压缩文件
  168.      *
  169.      * @param resFile  待压缩文件
  170.      * @param rootPath 相对于压缩文件的路径
  171.      * @param zos      压缩文件输出流
  172.      * @param comment  压缩文件的注释
  173.      * @return {@code true}: 压缩成功<br>{@code false}: 压缩失败
  174.      * @throws IOException IO错误时抛出
  175.      */
  176.     private static boolean zipFile(File resFile, String rootPath, ZipOutputStream zos, String comment)
  177.             throws IOException {
  178.         rootPath = rootPath + (StringUtils.isSpace(rootPath) ? "" : File.separator) + resFile.getName();
  179.         if (resFile.isDirectory()) {
  180.             File[] fileList = resFile.listFiles();
  181.             // 如果是空文件夹那么创建它，我把'/'换为File.separator测试就不成功，eggPain
  182.             if (fileList.length <= 0) {
  183.                 ZipEntry entry = new ZipEntry(rootPath + '/');
  184.                 if (!StringUtils.isEmpty(comment)) entry.setComment(comment);
  185.                 zos.putNextEntry(entry);
  186.                 zos.closeEntry();
  187.             } else {
  188.                 for (File file : fileList) {
  189.                     // 如果递归返回false则返回false
  190.                     if (!zipFile(file, rootPath, zos, comment)) return false;
  191.                 }
  192.             }
  193.         } else {
  194.             InputStream is = null;
  195.             try {
  196.                 is = new BufferedInputStream(new FileInputStream(resFile));
  197.                 ZipEntry entry = new ZipEntry(rootPath);
  198.                 if (!StringUtils.isEmpty(comment)) entry.setComment(comment);
  199.                 zos.putNextEntry(entry);
  200.                 byte buffer[] = new byte[KB];
  201.                 int len;
  202.                 while ((len = is.read(buffer, 0, KB)) != -1) {
  203.                     zos.write(buffer, 0, len);
  204.                 }
  205.                 zos.closeEntry();
  206.             } finally {
  207.                 FileUtils.closeIO(is);
  208.             }
  209.         }
  210.         return true;
  211.     }
  213.     /**
  214.      * 批量解压文件
  215.      *
  216.      * @param zipFiles    压缩文件集合
  217.      * @param destDirPath 目标目录路径
  218.      * @return {@code true}: 解压成功<br>{@code false}: 解压失败
  219.      * @throws IOException IO错误时抛出
  220.      */
  221.     public static boolean unzipFiles(Collection<File> zipFiles, String destDirPath)
  222.             throws IOException {
  223.         return unzipFiles(zipFiles, FileUtils.getFileByPath(destDirPath));
  224.     }
  226.     /**
  227.      * 批量解压文件
  228.      *
  229.      * @param zipFiles 压缩文件集合
  230.      * @param destDir  目标目录
  231.      * @return {@code true}: 解压成功<br>{@code false}: 解压失败
  232.      * @throws IOException IO错误时抛出
  233.      */
  234.     public static boolean unzipFiles(Collection<File> zipFiles, File destDir)
  235.             throws IOException {
  236.         if (zipFiles == null || destDir == null) return false;
  237.         for (File zipFile : zipFiles) {
  238.             if (!unzipFile(zipFile, destDir)) return false;
  239.         }
  240.         return true;
  241.     }
  243.     /**
  244.      * 解压文件
  245.      *
  246.      * @param zipFilePath 待解压文件路径
  247.      * @param destDirPath 目标目录路径
  248.      * @return {@code true}: 解压成功<br>{@code false}: 解压失败
  249.      * @throws IOException IO错误时抛出
  250.      */
  251.     public static boolean unzipFile(String zipFilePath, String destDirPath)
  252.             throws IOException {
  253.         return unzipFile(FileUtils.getFileByPath(zipFilePath), FileUtils.getFileByPath(destDirPath));
  254.     }
  256.     /**
  257.      * 解压文件
  258.      *
  259.      * @param zipFile 待解压文件
  260.      * @param destDir 目标目录
  261.      * @return {@code true}: 解压成功<br>{@code false}: 解压失败
  262.      * @throws IOException IO错误时抛出
  263.      */
  264.     public static boolean unzipFile(File zipFile, File destDir)
  265.             throws IOException {
  266.         return unzipFileByKeyword(zipFile, destDir, null) != null;
  267.     }
  269.     /**
  270.      * 解压带有关键字的文件
  271.      *
  272.      * @param zipFilePath 待解压文件路径
  273.      * @param destDirPath 目标目录路径
  274.      * @param keyword     关键字
  275.      * @return 返回带有关键字的文件链表
  276.      * @throws IOException IO错误时抛出
  277.      */
  278.     public static List<File> unzipFileByKeyword(String zipFilePath, String destDirPath, String keyword)
  279.             throws IOException {
  280.         return unzipFileByKeyword(FileUtils.getFileByPath(zipFilePath),
  281.                 FileUtils.getFileByPath(destDirPath), keyword);
  282.     }
  284.     /**
  285.      * 解压带有关键字的文件
  286.      *
  287.      * @param zipFile 待解压文件
  288.      * @param destDir 目标目录
  289.      * @param keyword 关键字
  290.      * @return 返回带有关键字的文件链表
  291.      * @throws IOException IO错误时抛出
  292.      */
  293.     public static List<File> unzipFileByKeyword(File zipFile, File destDir, String keyword)
  294.             throws IOException {
  295.         if (zipFile == null || destDir == null) return null;
  296.         List<File> files = new ArrayList<>();
  297.         ZipFile zf = new ZipFile(zipFile);
  298.         Enumeration<?> entries = zf.entries();
  299.         while (entries.hasMoreElements()) {
  300.             ZipEntry entry = ((ZipEntry) entries.nextElement());
  301.             String entryName = entry.getName();
  302.             if (StringUtils.isEmpty(keyword) || FileUtils.getFileName(entryName).toLowerCase().contains(keyword.toLowerCase())) {
  303.                 String filePath = destDir + File.separator + entryName;
  304.                 File file = new File(filePath);
  305.                 files.add(file);
  306.                 if (entry.isDirectory()) {
  307.                     if (!FileUtils.createOrExistsDir(file)) return null;
  308.                 } else {
  309.                     if (!FileUtils.createOrExistsFile(file)) return null;
  310.                     InputStream in = null;
  311.                     OutputStream out = null;
  312.                     try {
  313.                         in = new BufferedInputStream(zf.getInputStream(entry));
  314.                         out = new BufferedOutputStream(new FileOutputStream(file));
  315.                         byte buffer[] = new byte[KB];
  316.                         int len;
  317.                         while ((len = in.read(buffer)) != -1) {
  318.                             out.write(buffer, 0, len);
  319.                         }
  320.                     } finally {
  321.                         FileUtils.closeIO(in, out);
  322.                     }
  323.                 }
  324.             }
  325.         }
  326.         return files;
  327.     }
  329.     /**
  330.      * 获取压缩文件中的文件路径链表
  331.      *
  332.      * @param zipFilePath 压缩文件路径
  333.      * @return 压缩文件中的文件路径链表
  334.      * @throws IOException IO错误时抛出
  335.      */
  336.     public static List<String> getFilesPath(String zipFilePath)
  337.             throws IOException {
  338.         return getFilesPath(FileUtils.getFileByPath(zipFilePath));
  339.     }
  341.     /**
  342.      * 获取压缩文件中的文件路径链表
  343.      *
  344.      * @param zipFile 压缩文件
  345.      * @return 压缩文件中的文件路径链表
  346.      * @throws IOException IO错误时抛出
  347.      */
  348.     public static List<String> getFilesPath(File zipFile)
  349.             throws IOException {
  350.         if (zipFile == null) return null;
  351.         List<String> paths = new ArrayList<>();
  352.         Enumeration<?> entries = getEntries(zipFile);
  353.         while (entries.hasMoreElements()) {
  354.             paths.add(((ZipEntry) entries.nextElement()).getName());
  355.         }
  356.         return paths;
  357.     }
  359.     /**
  360.      * 获取压缩文件中的注释链表
  361.      *
  362.      * @param zipFilePath 压缩文件路径
  363.      * @return 压缩文件中的注释链表
  364.      * @throws IOException IO错误时抛出
  365.      */
  366.     public static List<String> getComments(String zipFilePath)
  367.             throws IOException {
  368.         return getComments(FileUtils.getFileByPath(zipFilePath));
  369.     }
  372.     /**
  373.      * 获取压缩文件中的注释链表
  374.      *
  375.      * @param zipFile 压缩文件
  376.      * @return 压缩文件中的注释链表
  377.      * @throws IOException IO错误时抛出
  378.      */
  379.     public static List<String> getComments(File zipFile)
  380.             throws IOException {
  381.         if (zipFile == null) return null;
  382.         List<String> comments = new ArrayList<>();
  383.         Enumeration<?> entries = getEntries(zipFile);
  384.         while (entries.hasMoreElements()) {
  385.             ZipEntry entry = ((ZipEntry) entries.nextElement());
  386.             comments.add(entry.getComment());
  387.         }
  388.         return comments;
  389.     }
  391.     /**
  392.      * 获取压缩文件中的文件对象
  393.      *
  394.      * @param zipFilePath 压缩文件路径
  395.      * @return 压缩文件中的文件对象
  396.      * @throws IOException IO错误时抛出
  397.      */
  398.     public static Enumeration<?> getEntries(String zipFilePath)
  399.             throws IOException {
  400.         return getEntries(FileUtils.getFileByPath(zipFilePath));
  401.     }
  403.     /**
  404.      * 获取压缩文件中的文件对象
  405.      *
  406.      * @param zipFile 压缩文件
  407.      * @return 压缩文件中的文件对象
  408.      * @throws IOException IO错误时抛出
  409.      */
  410.     public static Enumeration<?> getEntries(File zipFile)
  411.             throws IOException {
  412.         if (zipFile == null) return null;
  413.         return new ZipFile(zipFile).entries();
  414.     }
  415. }

Android Studio 相关

keymap

常用：    Ctrl+Shift+A    搜索菜单命令    Alt+F12     切换TerminalF1 帮助     Alt(Option)+F1 查找文件所在目录位置     Alt(Option)+1 快速打开或隐藏工程面板     Ctrl(Command)+Alt(Option)+ 打开设置对话框     Alt(Option)+Home 跳转到导航栏     Esc 光标返回编辑框     Shift+Esc 光标返回编辑框,关闭无用的窗口     Shift+Click 关闭标签页     F12 把焦点从编辑器移到最近使用的工具窗口     Ctrl(Command)+Alt(Option)+Y 同步     Ctrl(Command)+Alt(Option)+S 打开设置对话框     Alt(Option)+Shift+Inert 开启/关闭列选择模式     Ctrl(Command)+Alt(Option)+Shift+S 打开当前项目/模块属性     Alt(Option)+Shift+C 查看文件的变更历史     Ctrl(Command)+Shift+F10 运行     Ctrl(Command)+Shift+F9 debug运行     Ctrl(Command)+Alt(Option)+F12 资源管理器打开文件夹 编辑     Ctrl(Command)+C 复制当前行或选中的内容     Ctrl(Command)+D 粘贴当前行或选中的内容     Ctrl(Command)+X 剪切当前行或选中的内容     Ctrl(Command)+Y 删除行     Ctrl(Command)+Z 倒退     Ctrl(Command)+Shift+Z 向前     Alt(Option)+Enter 自动修正     Ctrl(Command)+Alt(Option)+L 格式化代码     Ctrl(Command)+Alt(Option)+I 将选中的代码进行自动缩进编排     Ctrl(Command)+Alt(Option)+O 优化导入的类和包     Alt(Option)+Insert 得到一些Intention Action，可以生成构造器、Getter、Setter、将 == 改为equals() 等 Ctrl(Command)+Shift+V 选最近使用的剪贴板内容并插入     Ctrl(Command)+Alt(Option)+Shift+V 简单粘贴     Ctrl(Command)+Shift+Insert 选最近使用的剪贴板内容并插入(同Ctrl(Command)+Shift+V)     Ctrl(Command)+Enter 在当前行的上面插入新行，并移动光标到新行(此功能光标在行首时有效)     Shift+Enter 在当前行的下面插入新行，并移动光标到新行     Ctrl(Command)+J 自动代码     Ctrl(Command)+Alt(Option)+T     把选中的代码放在 try{} 、if{} 、 else{} 里     Shift+Alt(Option)+Insert 竖编辑模式     Ctrl(Command)+ / 注释 //     Ctrl(Command)+Shift+ / 注释 /…/     Ctrl(Command)+Shift+J 合并成一行     F2/Shift+F2 跳转到下/上一个错误语句处     Ctrl(Command)+Shift+Back 跳转到上次编辑的地方     Ctrl(Command)+Alt(Option)+Space 类名自动完成     Shift+Alt(Option)+Up/Down 内容向上/下移动     Ctrl(Command)+Shift+Up/Down 语句向上/下移动     Ctrl(Command)+Shift+U 大小写切换     Tab 代码标签输入完成后，按 Tab，生成代码     Ctrl(Command)+Backspace 按单词删除     Ctrl(Command)+Shift+Enter 语句完成     Ctrl(Command)+Alt(Option)+J 用动态模板环绕 文件     Ctrl(Command)+F12 显示当前文件的结构     Ctrl(Command)+H 显示类继承结构图     Ctrl(Command)+Q 显示注释文档     Ctrl(Command)+P 方法参数提示     Ctrl(Command)+U 打开当前类的父类或者实现的接口     Alt(Option)+Left/Right 切换代码视图     Ctrl(Command)+Alt(Option)+Left/Right 返回上次编辑的位置     Alt(Option)+Up/Down 在方法间快速移动定位     Ctrl(Command)+B 快速打开光标处的类或方法     Ctrl(Command)+W 选中代码，连续按会有其他效果     Ctrl(Command)+Shift+W 取消选择光标所在词     Ctrl(Command)+ - / + 折叠/展开代码     Ctrl(Command)+Shift+ - / + 折叠/展开全部代码     Ctrl(Command)+Shift+. 折叠/展开当前花括号中的代码     Ctrl(Command)+ ] / [ 跳转到代码块结束/开始处     F2 或 Shift+F2 高亮错误或警告快速定位     Ctrl(Command)+Shift+C 复制路径     Ctrl(Command)+Alt(Option)+Shift+C 复制引用，必须选择类名     Alt(Option)+Up/Down 在方法间快速移动定位     Shift+F1 要打开编辑器光标字符处使用的类或者方法 Java 文档的浏览器     Ctrl(Command)+G 定位行 查找     Ctrl(Command)+F 在当前窗口查找文本     Ctrl(Command)+Shift+F 在指定环境下查找文本     F3 向下查找关键字出现位置     Shift+F3 向上一个关键字出现位置     Ctrl(Command)+R 在当前窗口替换文本     Ctrl(Command)+Shift+R 在指定窗口替换文本     Ctrl(Command)+N 查找类     Ctrl(Command)+Shift+N 查找文件     Ctrl(Command)+Shift+Alt(Option)+N 查找项目中的方法或变量     Ctrl(Command)+B 查找变量的来源     Ctrl(Command)+Alt(Option)+B 快速打开光标处的类或方法     Ctrl(Command)+Shift+B 跳转到类或方法实现处     Ctrl(Command)+E 最近打开的文件     Alt(Option)+F3 快速查找，效果和Ctrl(Command)+F相同     F4 跳转至定义变量的位置     Alt(Option)+F7 查询当前元素在工程中的引用     Ctrl(Command)+F7 查询当前元素在当前文件中的引用，然后按 F3 可以选择     Ctrl(Command)+Alt(Option)+F7 选中查询当前元素在工程中的引用     Ctrl(Command)+Shift+F7 高亮显示匹配的字符，按 Esc 高亮消失     Ctrl(Command)+Alt(Option)+F7 查找某个方法的所有调用地方     Ctrl(Command)+Shift+Alt(Option)+N 查找类中的方法或变量     Ctrl(Command)+Shift+O 弹出显示查找内容     Ctrl(Command)+Alt(Option)+Up/Down 快速跳转搜索结果     Ctrl(Command)+Shift+S 高级搜索、搜索结构 重构     F5 复制     F6 移动     Alt(Option)+Delete 安全删除     Ctrl(Command)+U 转到父类     Ctrl(Command)+O 重写父类的方法     Ctrl(Command)+I 实现方法     Ctrl(Command)+Alt(Option)+N 内联     Ctrl(Command)+Alt(Option)+Shift+T 弹出重构菜单     Shift+F6 重构-重命名     Ctrl(Command)+Alt(Option)+M 提取代码组成方法     Ctrl(Command)+Alt(Option)+C 将变量更改为常量     Ctrl(Command)+Alt(Option)+V 定义变量引用当前对象或者方法的返回值     Ctrl(Command)+Alt(Option)+F 将局部变量更改为类的成员变量     Ctrl(Command)+Alt(Option)+P 将变量更改为方法的参数 调试     F8 跳到下一步     Shift+F8 跳出函数、跳到下一个断点     Alt(Option)+Shift+F8 强制跳出函数     F7 进入代码     Shift+F7 智能进入代码     Alt(Option)+Shift+F7 强制进入代码     Alt(Option)+F9 运行至光标处     Ctrl(Command)+Alt(Option)+F9 强制运行至光标处     Ctrl(Command)+F2 停止运行     Alt(Option)+F8 计算变量值 VCS     Ctrl(Command)+K 提交更改     Ctrl(Command)+T 更新项目     Ctrl(Command)+Alt(Option)+Shift+D   显示变化

gradle问题总结：

  • App第一次安装启动的时候很慢，不要升级gradle版本，虽然提示升级了之后可以使用强大的Install Run功能！

    1. dependencies {
    2.     classpath 'com.android.tools.build:gradle:2.1.0+'
    3. }


Android系统架构图


Android相关

常用第三方jar、aar包
名称下载地址fastjsonhttp://7j1w9c.com1.z0.glb.clouddn.com/fastjson-1.2.9.jarxpp3-minhttp://7j1w9c.com1.z0.glb.clouddn.com/xpp3_min-1.1.4c.jarxstreamhttp://7j1w9c.com1.z0.glb.clouddn.com/xstream-1.4.6.jaruniversal-image-loaderhttp://7j1w9c.com1.z0.glb.clouddn.com/universal-image-loader-1.9.4.jarcorehttp://7j1w9c.com1.z0.glb.clouddn.com/core-3.0.0.jarcommons-httpclienthttp://7j1w9c.com1.z0.glb.clouddn.com/commons-httpclient-3.1.jarxUtils3http://7j1w9c.com1.z0.glb.clouddn.com/xutils-3.3.36.aar

|org.apache.http.legacy|http://7j1w9c.com1.z0.glb.clouddn.com/org.apache.http.legacy.jar|

aar包引入方式

java相关

VIM Keymap

sublime 支持 VIM 80% 左右的快捷键，以实际为准。

一. 移动：    h,j,k,l: 左，下，上，右。    w: 下一个词的词首。W:下一个单词(不含标点)。    e:下一个词的词尾。E:不含标点。    b:上一个词的词首。B:不含标点。    <>: v 模式选中后进行缩进。    >><<:向前向后缩进。 二. 跳转：    %: 可以匹配{},"",(),[]之间跳转。    H、M、L：直接跳转到当前屏幕的顶部、中部、底部。    #H：跳转到当前屏的第#行。    #L：跳转到当前屏的倒数第#行。    zt: 当前编辑行置为屏顶。    zz: 当前编辑行置为屏中。    zb: 当前编辑行置为屏底。    G：直接跳转到文件的底部。    gg: 跳转到文件首。    gd: 跳转到光标所在函数和变量的定义。    ():跳转到当前的行首、行尾。    {}：向上、向下跳转到最近的空行。    [{：跳转到目前区块开头。    ]}：跳转到目前区块结尾。    0: 跳转到行首。    $: 跳转到行尾。        2$: 跳转到下一行的行尾。    #：跳转到该行的第#个位置。    #G: 15G,跳转到15行。    :#：跳转到#行。    f'n'：跳转到下一个"n"字母后。    ctrl+b: 向后翻一页。    ctrl+f：向前翻一页。    ctrl+u: 向后翻半页。    ctrl+d: 向前翻半页。    ctry+e: 下滚一行。三. 选择：    1.v: 开启可视模式。 V: 开启逐行可视模式。    2.^V: 矩形选择。    3.v3w: 选择三个字符。      4.ab：包括括号和()内的区域。    5.aB：包括括号和{}内的区域。    6.ib：括号()内的区域。    7.iB：括号{}内的区域。    8.aw：标记一个单词。四. 编辑：    1. 新增：        i: 光标前插入。        I: 在当前行首插入。        a: 光标后插入。        A: 当前行尾插入。        O: 在当前行之前插入新行。        o: 在当前行之后插入新行。    2. 修改 c(change) 为主：        r: 替换光标所在处的字符。        R：替换光标所到之处的字符。        cw: 更改光标所在处的字到字尾处。        c#w: c3w 修改3个字符。        C：修改到行尾。        ci'：修改配对标点符号中的文本内容。        di'：删除配对标点符号中的文本内容。        yi'：复制配对标点符号中的文本内容。        vi'：选中配对标点符号中的文本内容。        s：替换当前一个光标所处字符。        #S：删除 # 行，并以新文本代替。    3. 删除 d(delete) 为主：        D：删除到行尾。        X: 每按一次，删除光标所在位置的前面一个字符。        x: 每按一次，删除光标所在位置的后面一个字符。        #x: 删除光标所在位置后面6个字符。        d^: 删至行首。        d$: 删至行尾。        dd:(剪切)删除光标所在行。                dw: 删除一个单词/光标之后的单词剩余部分。        d4w: 删除4个word。        #dd: 从光标所在行开始删除#行。        daB: 删除{}及其内的内容。        diB: 删除{}中的内容。        n1,n2 d：将n1,n2行之间的内容删除。    4. 查找：        /： 输入关键字，发现不是要找的，直接在按n，向后查找直到找到为止。        ?： 输入关键字，发现不是要找的，直接在按n，向前查找直到找到为止。        *: 在当前页向后查找同一字。        #: 在当前页向前查找同一字。    5. 复制 y(yank)为主：        yw: 将光标所在之处到字尾的字符复制到缓冲区中。        #yw: 复制#个字到缓冲区。        Y：相当于yy, 复制整行。        #yy:表示复制从光标所在的该行往下数#行文字。        p: 粘贴。所有与y相关的操作必用p来结合粘贴。        ]p：粘贴到合适的缩进处。        n1,n2 co n3：复制第n1行到第n2行之间的内容到第n3行后面。    6. 大小写转换：        gUU: 将当前行的字母改为大写。        guu: 将当前行的字母改为小写。        gUw: 将当前光标下的单词改为大写。        guw: 将当前光标下的单词改为小写。        a. 整篇大写:        ggguG        gg: 光标到文件第一个字符。        gu: 把选择范围全部小写。        G: 到文件结束。        b. 整篇小写：gggUG    7.  其它：        J：当前行和下一行合并成一行。    8.  移动：        n1,n2 m n3：将n1行到n2行之间的内容移至n3行下。五.退出：     1. w filename: 保存正在编辑的文件filename     2. wq filename: 保存后退出正在编辑的文件filename     3. q：退出不保存。六.窗口操作：     1. ctrl+w p: 在两个分割窗口之间来回切换。     2. ctrl+w j: 跳到下面的分割窗     3. ctrl+w h: 跳到左边的分割窗。     4. ctrl+w k: 跳到上面的分割窗。     5. ctrl+w l: 跳到右边的分割窗。七.折叠：    zo 將游標所在處的折疊打開。open。    zc 將游標所在處已打開的內容再度折疊起來。close。    zr 將全文的所有折疊依層次通通打開。reduce。    zm 將全文已打開的折疊依層次通通再折疊起來。more。    zR 作用和 zr 同，但會打開含巢狀折疊（折疊中又還有折疊）的所有折疊。    zM 作用和 zm 同，但對於巢狀折疊亦有作用。    zi 這是個切換，是折疊與不折疊指令間的切換。    zn 打開全文的所有折疊。fold none。    zN 這是 zn 的相對指令，回復所有的折疊。








    • 0 0
    最小的windows平板 最小的windows平板
    原创粉丝点击
    热门IT博客
    布雷特 布朗知乎布雷特 布朗知乎
    普通扑克分析软件普通扑克分析软件
    德阳广电网络
    软件投标设计方案模板
    范德堡大学知乎
    广西广电网络投诉电话
    Linux断电文件丢失
    面向接口编程 mp3 u盘
    银行卡开户行数据库
    数据库系统概念精编版
    网络交友的利与弊100字
    小语网络加速器账号
    三维动画分镜 软件
    阿里云的开源项目软件
    遥感影像数据特点
    如何优化公司人力成本
    matlab画二维数组
    左旋肉碱茶多酚片 知乎
    淘宝关注有礼怎么设置
    python运行
    热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 强哥9527 实力主播强哥 呆哥强推兰兰在线播放 呆哥强推178 呆哥强上新婚兰兰 男主播强哥 呆哥强上兰兰 强啊霸哥什么梗 强哥抓娃娃 强哥小静餐厅 实力男主播强哥 学习强哥 呆哥强推新品 准夫妻小静强哥续出差 主播强哥 从强哥开始的万界称雄路 强哥 雅思 小静圣诞节强哥王导 王牌战士强哥怎么连砍 英雄无敌3强哥虐圣龙原理 强哥烧烤 呆哥新婚兰兰 小静番外篇为强哥生孩子 女朋友在工地给人玩强哥下 我爷爷是迪拜首富 强哥9527 强壮英文 强壮的英文 强壮英语 强壮 强壮的英语 强壮拼音 强壮反义词 强壮的三叔 强壮的拼音 强壮近义词 强壮造句 强壮功 身体强壮 强壮的 强壮的狗老公 男主很强壮肉很多种田

    程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里