1 更新glide特效库

2 基类新增常用工具类

1 更新glide特效库
2 基类新增常用工具类
YangShuai
1 parent 3aef610f
Showing 17 changed files with 3938 additions and 119 deletions
app/strike/build.gradle
app/strike/src/main/AndroidManifest.xml
app/strike/src/main/java/com/cnlive/strike/MyActivity.java
app/strike/src/main/res/layout/activity_my.xml
build.gradle
cloud/user/src/main/java/com/cnlive/strike/user/auth/UserAccountAuthenticator.java
cloud/user/src/main/java/com/cnlive/strike/user/frame/presenter/QuickLoginPresenter.java
cloud/user/src/main/java/com/cnlive/strike/user/ui/activity/FirstLoginActivity.java
cloud/user/src/main/java/com/cnlive/strike/user/ui/activity/LoginActivity.java
config.gradle
core/base/src/main/java/com/cnlive/core/libs/base/frame/activity/BaseActivity.java
core/base/src/main/java/com/cnlive/core/libs/base/frame/fragment/BaseFragment.java
core/base/src/main/java/com/cnlive/core/libs/base/network/manager/SubscriptionManager.java
core/base/src/main/java/com/cnlive/core/libs/base/util/ArrayUtils.java
core/base/src/main/java/com/cnlive/core/libs/base/util/CollectionUtils.java
core/base/src/main/java/com/cnlive/core/libs/base/util/ColorUtils.java
core/base/src/main/java/com/cnlive/core/libs/base/util/EncodeUtils.java
@@ -107,7 +107,7 @@ android {
             zipAlignEnabled true  // 是否支持zip
 //            shrinkResources true  // 移除无用的resource文件
             minifyEnabled false // 是否对代码进行混淆，true表示混淆
-            debuggable false  //是否支持调试
+            debuggable true  //是否支持调试
 //            proguardFiles getDefaultProguardFile('proguard-android.txt'),
 //                    'proguard-rules.pro'
  
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
     package="com.cnlive.strike">
  
     <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
-
     <application
         android:name=".MyApp"
         android:allowBackup="true"
@@ -16,6 +16,7 @@
         android:roundIcon="@mipmap/ic_launcher_round"
         android:supportsRtl="true"
         android:theme="@style/AppTheme">
+
         <activity android:name=".demo.activity.DemoActivity" />
         <activity android:name=".MyActivity"></activity>
         <activity android:name=".imgutil.ImgActivity" />
 package com.cnlive.strike;
  
  
-import android.content.Intent;
 import android.text.TextUtils;
 import android.view.View;
  
 import com.alibaba.android.arouter.facade.annotation.Route;
 import com.cnlive.core.libs.base.frame.activity.BaseActivity;
-import com.cnlive.core.network.HttpConn;
-import com.cnlive.core.network.NetCallBack;
-import com.cnlive.core.network.model.BaseResult;
-import com.cnlive.libs.wjjpay.model.GroupBalanceInfo;
-import com.cnlive.libs.wjjpay.pay.WjjPay;
+import com.cnlive.core.libs.base.util.NetworkUtil;
 import com.cnlive.moudle.pedometer.commonInfo.CommonInfo;
-import com.cnlive.moudle.pedometer.ui.activity.RunLineActivity;
 import com.cnlive.strike.databinding.ActivityMyBinding;
 import com.cnlive.strike.user.auth.UserService;
 import com.cnlive.strike.xiaojiaspeaker.commonInfo.XiaoJIaCommInfo;
-import com.cnlive.strike.xiaojiaspeaker.ui.activity.AllDeviceActivity;
-import com.cnlive.strike.xiaojiaspeaker.util.QMUITipDialogUtil;
  
 @Route(path = "/strick/MyActivity")
 public class MyActivity extends BaseActivity {
@@ -44,7 +36,10 @@ public class MyActivity extends BaseActivity {
         binding.btnChange.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
-                startActivity(new Intent(MyActivity.this, RunLineActivity.class));
+//                Bitmap bitmap=ImageUtils.drawable2Bitmap(getResources().getDrawable(R.mipmap.timg));
+                binding.btnChange.setText(NetworkUtil.getNetWorkType(me) + "");
+                binding.ivImg.setImageBitmap(screenShot());
+//                startActivity(new Intent(MyActivity.this, RunLineActivity.class));
  
 //                WjjPay.passwordIsExisting(UserService.getUid(me), new NetCallBack<BaseResult<GroupBalanceInfo>>() {
 //                    @Override
 <?xml version="1.0" encoding="utf-8"?>
 <layout>
  
-    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
         xmlns:app="http://schemas.android.com/apk/res-auto"
         xmlns:tools="http://schemas.android.com/tools"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
         tools:context="com.cnlive.strike.MyActivity">
  
-        <RelativeLayout
+        <LinearLayout
             android:id="@+id/fragment_container"
             android:layout_width="match_parent"
-            android:layout_height="match_parent">
+            android:layout_height="match_parent"
+            android:orientation="vertical">
  
             <TextView
                 android:layout_width="wrap_content"
@@ -23,6 +24,11 @@
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
                 android:text="修改支付密码" />
-        </RelativeLayout>
-    </RelativeLayout>
+
+            <ImageView
+                android:id="@+id/iv_img"
+                android:layout_width="100dp"
+                android:layout_height="100dp" />
+        </LinearLayout>
+    </LinearLayout>
 </layout>
 \ No newline at end of file
@@ -29,22 +29,10 @@ allprojects {
     }
 }
  
-////配置全局变量
-//ext {
-//    def versionMajor = 1
-//    def versionMinor = 5
-//    def versionPatch = 6
-//    def versionBuild = 0
-//    // module依赖库公共版本号
-//    versionCode = versionMajor * 1000 + versionMinor * 100 + versionPatch * 10 + versionBuild
-//    versionName = "${versionMajor}.${versionMinor}.${versionPatch}.${versionBuild}"
-//
-//    compileSdkVersion = 29
-//    buildToolsVersion = "29.0.2"
-//    minSdkVersion = 19
-//    targetSdkVersion = 29
-//}
 allprojects {
+//    configurations.all {
+//////    resolutionStrategy.force 'androidx.appcompat:appcompat:1.1.0'
+//    }
     afterEvaluate {
         if (project.parent == null || project.parent == rootProject) return
  
@@ -69,7 +57,21 @@ allprojects {
                         ]
                     }
                 }
-
+                //解决引用glide-transformations冲突问题
+                packagingOptions {
+                    exclude "lib/armeabi-v7a/libRSSupport.so"
+                    exclude "lib/arm64-v8a/librsjni.so"
+                    exclude "lib/arm64-v8a/libRSSupport.so"
+                    exclude "lib/x86_64/libRSSupport.so"
+                    exclude "lib/x86/librsjni.so"
+                    exclude "lib/x86_64/librsjni.so"
+                    exclude "lib/armeabi-v7a/librsjni.so"
+                    exclude "lib/x86/libRSSupport.so"
+                    exclude "lib/x86_64/librsjni_androidx.so"
+                    exclude "lib/x86/librsjni_androidx.so"
+                    exclude "lib/arm64-v8a/librsjni_androidx.so"
+                    exclude "lib/armeabi-v7a/librsjni_androidx.so"
+                }
                 ndk {
                     abiFilters(
                             "armeabi-v7a"
@@ -8,8 +8,7 @@ import android.accounts.NetworkErrorException;
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
-
-import com.cnlive.core.libs.base.util.LogUtil;
+import android.util.Log;
  
  
 public class UserAccountAuthenticator extends AbstractAccountAuthenticator {
@@ -22,7 +21,7 @@ public class UserAccountAuthenticator extends AbstractAccountAuthenticator {
     }
  
     public Bundle addAccount(AccountAuthenticatorResponse response, String accountType, String authTokenType, String[] requiredFeatures, Bundle options) {
-        LogUtil.d(_tag, accountType + " - " + authTokenType);
+        Log.d(_tag, accountType + " - " + authTokenType);
         Bundle ret = new Bundle();
         try {
             Class<?> clazz = Class.forName("com.cnlive.strike.moudle.user.ui.activity.LoginActivity");
@@ -38,42 +37,42 @@ public class UserAccountAuthenticator extends AbstractAccountAuthenticator {
  
     @Override
     public Bundle confirmCredentials(AccountAuthenticatorResponse response, Account account, Bundle options) {
-        LogUtil.d(_tag, ".confirmCredentials");
+        Log.d(_tag, ".confirmCredentials");
         return null;
     }
  
  
     @Override
     public Bundle editProperties(AccountAuthenticatorResponse response, String accountType) {
-        LogUtil.d(_tag, ".editProperties");
+        Log.d(_tag, ".editProperties");
         return null;
     }
  
  
     @Override
     public Bundle getAuthToken(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle loginOptions) throws NetworkErrorException {
-        LogUtil.d(_tag, ".getAuthToken");
+        Log.d(_tag, ".getAuthToken");
         return null;
     }
  
  
     @Override
     public String getAuthTokenLabel(String authTokenType) {
-        LogUtil.d(_tag, ".getAuthTokenLabel");
+        Log.d(_tag, ".getAuthTokenLabel");
         return null;
     }
  
  
     @Override
     public Bundle hasFeatures(AccountAuthenticatorResponse response, Account account, String[] features) throws NetworkErrorException {
-        LogUtil.d(_tag, ".hasFeatures");
+        Log.d(_tag, ".hasFeatures");
         return null;
     }
  
  
     @Override
     public Bundle updateCredentials(AccountAuthenticatorResponse response, Account account, String authTokenType, Bundle loginOptions) {
-        LogUtil.d(_tag, ".updateCredentials");
+        Log.d(_tag, ".updateCredentials");
         return null;
     }
  
@@ -9,7 +9,7 @@ import com.cnlive.core.libs.base.frame.presenter.BasePresenter;
 import com.cnlive.core.network.model.BaseResult;
 import com.cnlive.core.network.HttpConn;
 import com.cnlive.core.network.NetCallBack;
-import com.cnlive.core.libs.base.util.TimerUtil;
+import com.cnlive.core.libs.base.util.TimerWaitUtil;
 import com.cnlive.strike.user.R;
 import com.cnlive.strike.user.UserUtilAction;
 import com.cnlive.strike.user.auth.UserService;
@@ -34,7 +34,7 @@ import io.reactivex.disposables.Disposable;
  */
  
 public class QuickLoginPresenter extends BasePresenter<QuickLoginView> {
-    private TimerUtil timerUtil; //计时工具类
+    private TimerWaitUtil timerUtil; //计时工具类
  
     private Disposable event;
     private Disposable sendMsgBefQuickLogin;
@@ -69,11 +69,11 @@ public class QuickLoginPresenter extends BasePresenter&lt;QuickLoginView&gt; {
     private void startTimer() {
         if (timerUtil != null) timerUtil.cancel();
  
-        timerUtil = new TimerUtil();
+        timerUtil = new TimerWaitUtil();
         timerUtil.setTotalTime(60_000);//设置毫秒数
         timerUtil.setIntervalTime(500);//设置间隔数
         timerUtil.start();
-        timerUtil.setTimerLiener(new TimerUtil.TimeListener() {
+        timerUtil.setTimerLiener(new TimerWaitUtil.TimeListener() {
             @Override
             public void onFinish() {
                 ifViewAttached(view -> view.onTimerFinish());
 package com.cnlive.strike.user.ui.activity;
  
-import android.content.Intent;
 import android.os.Bundle;
 import android.text.TextUtils;
  
-import androidx.annotation.NonNull;
-import androidx.fragment.app.FragmentManager;
-
 import com.cnlive.core.libs.base.frame.activity.BaseActivity;
 import com.cnlive.core.libs.base.util.AlertUtil;
 import com.cnlive.core.libs.base.util.DoublePressed;
-import com.cnlive.core.libs.base.util.FragmentUtil;
 import com.cnlive.strike.user.R;
 import com.cnlive.strike.user.ui.fragment.FirstLoginFragment;
  
@@ -6,17 +6,11 @@ import android.content.Intent;
 import android.net.Uri;
  
 import androidx.annotation.NonNull;
-import androidx.fragment.app.Fragment;
-import androidx.fragment.app.FragmentManager;
  
 import com.alibaba.android.arouter.facade.annotation.Route;
 import com.cnlive.core.libs.base.frame.activity.BaseActivity;
 import com.cnlive.core.libs.base.frame.fragment.BaseFragment;
-import com.cnlive.core.libs.base.util.FragmentUtil;
-import com.cnlive.strike.user.R;
 import com.cnlive.strike.user.ui.fragment.QuickLoginFragment;
-import com.me.yokeyword.fragmentation.anim.DefaultHorizontalAnimator;
-import com.me.yokeyword.fragmentation.anim.FragmentAnimator;
  
 /**
  * @author Lynn
@@ -20,7 +20,7 @@ ext {
             //用户
             core_network: project(':core:network'),
             //基础库
-            core_base: project(':core:base')
+            core_base   : project(':core:base')
  
     ]
  
@@ -34,11 +34,15 @@ ext {
             api     : 'com.alibaba:arouter-api:1.5.0',
             compiler: 'com.alibaba:arouter-compiler:1.2.2'
     ]
+
     //图片加载库Glide
     glide = [
-            api            : 'com.github.bumptech.glide:glide:4.10.0',
-            transformations: 'jp.wasabeef:glide-transformations:3.0.1',
-            compiler       : 'com.github.bumptech.glide:compiler:4.10.0'
+            api                     : 'com.github.bumptech.glide:glide:4.10.0',
+            compiler                : 'com.github.bumptech.glide:compiler:4.10.0',
+            //图片加载特效
+            transformations         : 'jp.wasabeef:glide-transformations:4.1.0',
+            //图片滤镜
+            transformations_gpuimage: 'jp.co.cyberagent.android:gpuimage:2.0.4'
     ]
     test = [
             junit   : 'junit:junit:4.12',
@@ -46,7 +50,7 @@ ext {
             espresso: 'androidx.test.espresso:espresso-core:3.2.0'
     ]
  
-    //Maven Base库配置
+//Maven Base库配置
     moudle_cnlive_base = [
             //编译方式
             debug  : false,
@@ -113,7 +117,9 @@ ext {
             cardviewV7              : 'com.android.support:cardview-v7:28.0.0',
             dataBinding             : 'com.android.databinding.library:3.5.1'
     ]
-    //基础三方库
+
+
+//基础三方库
     base_librarys = [
             library.logger,
             //视讯云加密库
@@ -137,6 +143,7 @@ ext {
             //图片加载Glide
             glide.api,
             glide.transformations,
+            glide.transformations_gpuimage,
             //使用androidx
             androidx.appcompat,
             androidx.constraintlayout,
@@ -164,7 +171,8 @@ ext {
             router.compiler
     ]
  
-    //正式签名配置
+
+//正式签名配置
     Properties properties = new Properties()
     properties.load(project.rootProject.file('local.properties').newDataInputStream())
  
@@ -7,6 +7,9 @@ import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.graphics.Bitmap;
 import android.graphics.Point;
 import android.net.Uri;
 import android.os.Build;
@@ -24,6 +27,7 @@ import android.view.inputmethod.InputMethodManager;
 import androidx.annotation.ColorInt;
 import androidx.annotation.ColorRes;
 import androidx.annotation.DrawableRes;
+import androidx.annotation.IntDef;
 import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -59,6 +63,10 @@ import com.me.yokeyword.fragmentation_swipeback.core.ISwipeBackActivity;
 import com.me.yokeyword.fragmentation_swipeback.core.SwipeBackActivityDelegate;
 import com.orhanobut.logger.Logger;
  
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;
@@ -214,6 +222,94 @@ public abstract class BaseActivity&lt;V extends BaseView, P extends BasePresenter&lt;V
         isAllowScreenRoate = allowScreenRoate;
     }
  
+
+    /**
+     * 设置屏幕为横屏
+     * Set the screen to landscape.
+     */
+    public void setLandscape() {
+        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
+    }
+
+    /**
+     * 设置屏幕为竖屏
+     * Set the screen to portrait.
+     */
+    public void setPortrait() {
+        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
+    }
+
+
+    /**
+     * 是否横屏
+     * Return whether screen is landscape.
+     *
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public boolean isLandscape() {
+        return getResources().getConfiguration().orientation
+                == Configuration.ORIENTATION_LANDSCAPE;
+    }
+
+    /**
+     * 是否竖屏
+     * Return whether screen is portrait.
+     *
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public boolean isPortrait() {
+        return getResources().getConfiguration().orientation
+                == Configuration.ORIENTATION_PORTRAIT;
+    }
+
+    /**
+     * 截屏
+     * Return the bitmap of screen.
+     *
+     * @return the bitmap of screen
+     */
+    public Bitmap screenShot() {
+        return screenShot(this, false);
+    }
+
+    public Bitmap screenShot(boolean isDeleteStatusBar) {
+        return screenShot(this, isDeleteStatusBar);
+    }
+
+    /**
+     * Return the bitmap of screen.
+     *
+     * @param activity          The activity.
+     * @param isDeleteStatusBar True to delete status bar, false otherwise.
+     * @return the bitmap of screen
+     */
+    private Bitmap screenShot(@NonNull final Activity activity, boolean isDeleteStatusBar) {
+        View decorView = activity.getWindow().getDecorView();
+        decorView.setDrawingCacheEnabled(true);
+        decorView.setWillNotCacheDrawing(false);
+        Bitmap bmp = decorView.getDrawingCache();
+        if (bmp == null) return null;
+        DisplayMetrics dm = new DisplayMetrics();
+        activity.getWindowManager().getDefaultDisplay().getMetrics(dm);
+        Bitmap ret;
+        if (isDeleteStatusBar) {
+            Resources resources = activity.getResources();
+            int resourceId = resources.getIdentifier("status_bar_height", "dimen", "android");
+            int statusBarHeight = resources.getDimensionPixelSize(resourceId);
+            ret = Bitmap.createBitmap(
+                    bmp,
+                    0,
+                    statusBarHeight,
+                    dm.widthPixels,
+                    dm.heightPixels - statusBarHeight
+            );
+        } else {
+            ret = Bitmap.createBitmap(bmp, 0, 0, dm.widthPixels, dm.heightPixels);
+        }
+        decorView.destroyDrawingCache();
+        return ret;
+    }
+
     /**
      * 保证同一按钮在1秒内只会响应一次点击事件
      */
@@ -235,18 +331,6 @@ public abstract class BaseActivity&lt;V extends BaseView, P extends BasePresenter&lt;V
     }
  
     /**
-     * 同一按钮在短时间内可重复响应点击事件
-     */
-    public abstract class OnMultiClickListener implements View.OnClickListener {
-        public abstract void onMultiClick(View view);
-
-        @Override
-        public void onClick(View v) {
-            onMultiClick(v);
-        }
-    }
-
-    /**
      * 隐藏软键盘
      */
     public void hideSoftInput() {
@@ -270,7 +354,6 @@ public abstract class BaseActivity&lt;V extends BaseView, P extends BasePresenter&lt;V
      * 显示软键盘
      */
     public void showSoftInput(View view) {
-        // InputMethodManager.SHOW_FORCED);
         InputMethodManager imm = (InputMethodManager) getSystemService(INPUT_METHOD_SERVICE);
         imm.showSoftInput(view, InputMethodManager.SHOW_FORCED);
     }
@@ -339,7 +422,8 @@ public abstract class BaseActivity&lt;V extends BaseView, P extends BasePresenter&lt;V
     /**
      * 设置状态栏字体颜色
      */
-    public void setStatusBarTextColor(int type) {
+    // 定义适用于参数的注解，限定取值范围为{STATUS_OPEN, STATUS_CLOSE}
+    public void setStatusBarTextColor(@StatusBarConfig.Unit final int type) {
         if (type == StatusBarConfig.BLACK) {
             StatusBarUtil.setStatusBarWrite(this);
         } else if (type == StatusBarConfig.WHITE) {
@@ -366,7 +450,6 @@ public abstract class BaseActivity&lt;V extends BaseView, P extends BasePresenter&lt;V
         return view;
     }
  
-    //    protected abstract int getLayoutId();
     protected int getBindLayoutId() {
         return 0;
     }
@@ -2,13 +2,12 @@ package com.cnlive.core.libs.base.frame.fragment;
  
 import android.app.Activity;
 import android.content.Intent;
-import android.content.pm.ActivityInfo;
+import android.graphics.Bitmap;
 import android.os.Bundle;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.animation.Animation;
-import android.view.inputmethod.InputMethodManager;
  
 import androidx.annotation.ColorInt;
 import androidx.annotation.ColorRes;
@@ -17,7 +16,6 @@ import androidx.annotation.IntRange;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.StringRes;
-import androidx.core.content.ContextCompat;
 import androidx.databinding.DataBindingUtil;
 import androidx.databinding.ViewDataBinding;
  
@@ -26,11 +24,9 @@ import com.cnlive.core.libs.base.frame.activity.BaseActivity;
 import com.cnlive.core.libs.base.frame.presenter.BasePresenter;
 import com.cnlive.core.libs.base.interfaces.OnPermissionResponseListener;
 import com.cnlive.core.libs.base.network.manager.SubscriptionManager;
-import com.cnlive.core.libs.base.util.ParameterCache;
 import com.cnlive.core.libs.base.util.ReflectUtil;
 import com.cnlive.core.libs.base.frame.view.BaseView;
 import com.cnlive.core.libs.base.util.StatusBarConfig;
-import com.cnlive.core.libs.base.util.StatusBarUtil;
 import com.me.yokeyword.fragmentation.ExtraTransaction;
 import com.me.yokeyword.fragmentation.ISupportFragment;
 import com.me.yokeyword.fragmentation.SupportFragmentDelegate;
@@ -41,9 +37,6 @@ import com.me.yokeyword.fragmentation_swipeback.core.ISwipeBackFragment;
 import com.me.yokeyword.fragmentation_swipeback.core.SwipeBackFragmentDelegate;
 import com.orhanobut.logger.Logger;
  
-
-import static android.content.Context.INPUT_METHOD_SERVICE;
-
 /**
  * 基类fragment
  *
@@ -232,7 +225,7 @@ public abstract class BaseFragment&lt;V extends BaseView, P extends BasePresenter&lt;V
     /**
      * 设置状态栏字体颜色
      */
-    public void setStatusBarTextColor(int type) {
+    public void setStatusBarTextColor(@StatusBarConfig.Unit int type) {
         me.setStatusBarTextColor(type);
     }
  
@@ -244,13 +237,56 @@ public abstract class BaseFragment&lt;V extends BaseView, P extends BasePresenter&lt;V
         me.showSoftInput();
     }
  
-//    /**
-//     * 显示软键盘
-//     */
-//    public void showSoftInput(View view) {
-//        me.showSoftInput(view);
-//    }
+    /**
+     * 设置屏幕为横屏
+     * Set the screen to landscape.
+     */
+    public void setLandscape() {
+        me.setLandscape();
+    }
+
+    /**
+     * 设置屏幕为竖屏
+     * Set the screen to portrait.
+     */
+    public void setPortrait() {
+        me.setPortrait();
+    }
+
+
+    /**
+     * 是否横屏
+     * Return whether screen is landscape.
+     *
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public boolean isLandscape() {
+        return me.isLandscape();
+    }
+
+    /**
+     * 是否竖屏
+     * Return whether screen is portrait.
+     *
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public boolean isPortrait() {
+        return me.isPortrait();
+    }
  
+    /**
+     * 截屏
+     * Return the bitmap of screen.
+     *
+     * @return the bitmap of screen
+     */
+    public Bitmap screenShot() {
+        return me.screenShot();
+    }
+
+    public Bitmap screenShot(boolean isDeleteStatusBar) {
+        return me.screenShot(isDeleteStatusBar);
+    }
  
     /*********************************************************/
     //用于进行dip和px转换
@@ -15,16 +15,16 @@ import io.reactivex.disposables.Disposable;
  * @author ys
  */
 public class SubscriptionManager {
-    public static SubscriptionManager instance;
-    public HashMap<String, CompositeDisposable> hashDisposable;//所有订阅关系
-    public HashMap<Integer, String> hashTag;//当前activity
-    public HashMap<String, Integer> hashTagIndex;//当前activity
+    private static SubscriptionManager instance;
+    private HashMap<String, CompositeDisposable> hashDisposable;//所有订阅关系
+    private HashMap<Integer, String> hashTag;//当前activity
+    private HashMap<String, Integer> hashTagIndex;//当前activity
     private String currentClassName;
  
     /**
      * 构造函数 new CompositeDisposable对象
      */
-    public  SubscriptionManager() {
+    public SubscriptionManager() {
         if (null == hashDisposable) {
             hashDisposable = new HashMap<>();
         }
@@ -59,7 +59,7 @@ public class SubscriptionManager {
             //存放当前class映射
             hashTag.put(hashDisposable.size() - 1, TAG);
             hashTagIndex.put(TAG, hashTag.size() - 1);
-            Log.e(TAG, "初始化: ");
+            Log.d(TAG, "初始化: ");
         }
     }
  
@@ -89,7 +89,7 @@ public class SubscriptionManager {
                 hashTagIndex.remove(TAG);
             }
         } catch (Exception e) {
-            Log.e(TAG, "cancel: " + e.getMessage());
+            Log.d(TAG, "cancel: " + e.getMessage());
         }
     }
  
@@ -99,16 +99,20 @@ public class SubscriptionManager {
      * @param disposable 订阅事件
      */
     public synchronized void add(Disposable disposable) {
-        if (disposable == null) return;
-        //每次去除最新的activity进行存放
-        if (null != hashDisposable && hashDisposable.size() > 0) {
-            if (!TextUtils.isEmpty(currentClassName)) {
-                if (null != hashDisposable.get(currentClassName)) {
-                    //存放当前activity对应的订阅
-                    hashDisposable.get(currentClassName).add(disposable);
-                    Log.e(currentClassName, "add: 添加订阅关系" + hashDisposable.size());
+        try {
+            if (disposable == null) return;
+            //每次去除最新的activity进行存放
+            if (null != hashDisposable && hashDisposable.size() > 0) {
+                if (!TextUtils.isEmpty(currentClassName)) {
+                    if (null != hashDisposable.get(currentClassName)) {
+                        //存放当前activity对应的订阅
+                        hashDisposable.get(currentClassName).add(disposable);
+                        Log.d(currentClassName, "add: 添加订阅关系" + hashDisposable.size());
+                    }
                 }
             }
+        } catch (Exception e) {
+            Log.e("SubscriptionManager", "cancel: " + e.getMessage());
         }
     }
  
@@ -127,20 +131,24 @@ public class SubscriptionManager {
      * 清除容器所有
      */
     public synchronized void cancelAll() {
-        //解除所有订阅
-        if (null != hashDisposable && hashDisposable.size() > 0) {
-            if (null != hashTag && hashTag.size() > 0) {
-                for (int i = 0; i < hashTag.size(); i++) {
-                    if (null != hashTag.get(i)) {
-                        if (null != hashDisposable.get(hashTag.get(i))) {
-                            hashDisposable.get(hashTag.get(i)).clear();
+        try {
+            //解除所有订阅
+            if (null != hashDisposable && hashDisposable.size() > 0) {
+                if (null != hashTag && hashTag.size() > 0) {
+                    for (int i = 0; i < hashTag.size(); i++) {
+                        if (null != hashTag.get(i)) {
+                            if (null != hashDisposable.get(hashTag.get(i))) {
+                                hashDisposable.get(hashTag.get(i)).clear();
+                            }
                         }
                     }
                 }
             }
+            hashDisposable.clear();
+            hashTag.clear();
+            hashTagIndex.clear();
+        } catch (Exception e) {
+            Log.e("SubscriptionManager", "cancelAll: " + e.getMessage());
         }
-        hashDisposable.clear();
-        hashTag.clear();
-        hashTagIndex.clear();
     }
 }
+package com.cnlive.core.libs.base.util;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+/**
+ * <pre>
+ *     author: blankj
+ *     blog  : http://blankj.com
+ *     time  : 2019/08/10
+ *     desc  : utils about array
+ * </pre>
+ * newArray          : 新建数组
+ * newLongArray      : 新建长整型数组
+ * newIntArray       : 新建整型数组
+ * newShortArray     : 新建 short 数组
+ * newCharArray      : 新建字符数组
+ * newByteArray      : 新建字节数组
+ * newDoubleArray    : 新建双精度数组
+ * newFloatArray     : 新建浮点数数组
+ * newBooleanArray   : 新建 boolean 数组
+ * isEmpty           : 判断数组是否为空
+ * getLength         : 获取数组长度
+ * isSameLength      : 判断两数组长度是否相等
+ * get               : 获取数组的索引值
+ * set               : 设置数组的索引值
+ * equals            : 判断数组是否相等
+ * reverse           : 逆序数组
+ * copy              : 拷贝数组
+ * subArray          : 截取数组
+ * add               : 增加数组
+ * remove            : 移除指定的索引
+ * removeElement     : 移除指定的元素
+ * indexOf           : 查找第一个元素的索引
+ * lastIndexOf       : 查找最后一个元素的索引
+ * contains          : 判断是否包含该元素
+ * toPrimitive       : 装箱数组转基本类型数组
+ * toObject          : 基本类型数组转装箱数组
+ * asList            : 转为链表
+ * asUnmodifiableList: 转为不可变链表
+ * asArrayList       : 转为数组链表
+ * asLinkedList      : 转为双向链表
+ * sort              : 排序
+ * forAllDo          : 对所有元素做操作
+ * toString          : 数组转为字符串
+ */
+public class ArrayUtils {
+
+    public static final int INDEX_NOT_FOUND = -1;
+
+    private ArrayUtils() {
+        throw new UnsupportedOperationException("u can't instantiate me...");
+    }
+
+    /**
+     * 新建数组
+     * Returns a new array only of those given elements.
+     *
+     * @param array The array.
+     * @return a new array only of those given elements.
+     */
+    @SafeVarargs
+    public static <T> T[] newArray(T... array) {
+        return array;
+    }
+
+    /**
+     * 新建长整型数组
+     *
+     * @param array
+     * @return
+     */
+    public static long[] newLongArray(long... array) {
+        return array;
+    }
+
+    /**
+     * 新建整型数组
+     *
+     * @param array
+     * @return
+     */
+    public static int[] newIntArray(int... array) {
+        return array;
+    }
+
+    /**
+     * 新建 short 数组
+     *
+     * @param array
+     * @return
+     */
+    public static short[] newShortArray(short... array) {
+        return array;
+    }
+
+    /**
+     * 新建字符数组
+     *
+     * @param array
+     * @return
+     */
+    public static char[] newCharArray(char... array) {
+        return array;
+    }
+
+    /**
+     * 新建字节数组
+     *
+     * @param array
+     * @return
+     */
+    public static byte[] newByteArray(byte... array) {
+        return array;
+    }
+
+    /**
+     * 新建双精度数组
+     *
+     * @param array
+     * @return
+     */
+    public static double[] newDoubleArray(double... array) {
+        return array;
+    }
+
+    /**
+     * 新建浮点数数组
+     *
+     * @param array
+     * @return
+     */
+    public static float[] newFloatArray(float... array) {
+        return array;
+    }
+
+    /**
+     * 新建 boolean 数组
+     *
+     * @param array
+     * @return
+     */
+    public static boolean[] newBooleanArray(boolean... array) {
+        return array;
+    }
+
+    /**
+     * 判断数组是否为空
+     * Return the array is empty.
+     *
+     * @param array The array.
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public static boolean isEmpty(Object array) {
+        return getLength(array) == 0;
+    }
+
+    /**
+     * 获取数组长度
+     * Return the size of array.
+     *
+     * @param array The array.
+     * @return the size of array
+     */
+    public static int getLength(Object array) {
+        if (array == null) return 0;
+        return Array.getLength(array);
+    }
+
+    /**
+     * 判断两数组长度是否相等
+     *
+     * @param array1
+     * @param array2
+     * @return
+     */
+    public static boolean isSameLength(Object array1, Object array2) {
+        return getLength(array1) == getLength(array2);
+    }
+
+    /**
+     * 获取数组的索引值
+     * Get the value of the specified index of the array.
+     *
+     * @param array The array.
+     * @param index The index into the array.
+     * @return the value of the specified index of the array
+     */
+    public static Object get(Object array, int index) {
+        return get(array, index, null);
+    }
+
+    /**
+     * 取数组的索引值,带有默认值
+     * Get the value of the specified index of the array.
+     *
+     * @param array        The array.
+     * @param index        The index into the array.
+     * @param defaultValue The default value.
+     * @return the value of the specified index of the array
+     */
+    public static Object get(Object array, int index, Object defaultValue) {
+        if (array == null) return defaultValue;
+        try {
+            return Array.get(array, index);
+        } catch (Exception ignore) {
+            return defaultValue;
+        }
+    }
+
+    /**
+     * 设置数组的索引值
+     * Set the value of the specified index of the array.
+     *
+     * @param array The array.
+     * @param index The index into the array.
+     * @param value The new value of the indexed component.
+     */
+    public static void set(Object array, int index, Object value) {
+        if (array == null) return;
+        Array.set(array, index, value);
+    }
+
+    /**
+     * 判断数组是否相等
+     * Return whether the two arrays are equals.
+     *
+     * @param a  One array.
+     * @param a2 The other array.
+     * @return {@code true}: yes<br>{@code false}: no
+     */
+    public static boolean equals(Object[] a, Object[] a2) {
+        return Arrays.deepEquals(a, a2);
+    }
+
+    public static boolean equals(boolean[] a, boolean[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(byte[] a, byte[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(char[] a, char[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(double[] a, double[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(float[] a, float[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(int[] a, int[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    public static boolean equals(short[] a, short[] a2) {
+        return Arrays.equals(a, a2);
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // reverse
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 逆序数组
+     * <p>Reverses the order of the given array.</p>
+     *
+     * <p>There is no special handling for multi-dimensional arrays.</p>
+     *
+     * <p>This method does nothing for a <code>null</code> input array.</p>
+     *
+     * @param array the array to reverse, may be <code>null</code>
+     */
+    public static <T> void reverse(T[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        T tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(long[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        long tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(int[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        int tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(short[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        short tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(char[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        char tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(byte[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        byte tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(double[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        double tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(float[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        float tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    public static void reverse(boolean[] array) {
+        if (array == null) {
+            return;
+        }
+        int i = 0;
+        int j = array.length - 1;
+        boolean tmp;
+        while (j > i) {
+            tmp = array[j];
+            array[j] = array[i];
+            array[i] = tmp;
+            j--;
+            i++;
+        }
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // copy
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 拷贝数组
+     * <p>Copies the specified array and handling
+     * <code>null</code>.</p>
+     *
+     * <p>The objects in the array are not cloned, thus there is no special
+     * handling for multi-dimensional arrays.</p>
+     *
+     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     *
+     * @param array the array to shallow clone, may be <code>null</code>
+     * @return the cloned array, <code>null</code> if <code>null</code> input
+     */
+    public static <T> T[] copy(T[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static long[] copy(long[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static int[] copy(int[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static short[] copy(short[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static char[] copy(char[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static byte[] copy(byte[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static double[] copy(double[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static float[] copy(float[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    public static boolean[] copy(boolean[] array) {
+        if (array == null) return null;
+        return subArray(array, 0, array.length);
+    }
+
+    private static Object realCopy(Object array) {
+        if (array == null) return null;
+        return realSubArray(array, 0, getLength(array));
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // subArray
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 截取数组
+     *
+     * @param array
+     * @param startIndexInclusive
+     * @param endIndexExclusive
+     * @param <T>
+     * @return
+     */
+    public static <T> T[] subArray(T[] array, int startIndexInclusive, int endIndexExclusive) {
+        //noinspection unchecked
+        return (T[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static long[] subArray(long[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (long[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static int[] subArray(int[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (int[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static short[] subArray(short[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (short[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static char[] subArray(char[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (char[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static byte[] subArray(byte[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (byte[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static double[] subArray(double[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (double[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static float[] subArray(float[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (float[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    public static boolean[] subArray(boolean[] array, int startIndexInclusive, int endIndexExclusive) {
+        return (boolean[]) realSubArray(array, startIndexInclusive, endIndexExclusive);
+    }
+
+    private static Object realSubArray(Object array, int startIndexInclusive, int endIndexExclusive) {
+        if (array == null) {
+            return null;
+        }
+        if (startIndexInclusive < 0) {
+            startIndexInclusive = 0;
+        }
+        int length = getLength(array);
+        if (endIndexExclusive > length) {
+            endIndexExclusive = length;
+        }
+        int newSize = endIndexExclusive - startIndexInclusive;
+        Class type = array.getClass().getComponentType();
+        if (newSize <= 0) {
+            return Array.newInstance(type, 0);
+        }
+        Object subArray = Array.newInstance(type, newSize);
+        System.arraycopy(array, startIndexInclusive, subArray, 0, newSize);
+        return subArray;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // add
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 增加数组
+     * <p>Copies the given array and adds the given element at the end of the new array.</p>
+     *
+     * <p>The new array contains the same elements of the input
+     * array plus the given element in the last position. The component type of
+     * the new array is the same as that of the input array.</p>
+     *
+     * <p>If the input array is <code>null</code>, a new one element array is returned
+     * whose component type is the same as the element.</p>
+     *
+     * <pre>
+     * ArrayUtils.realAdd(null, null)      = [null]
+     * ArrayUtils.realAdd(null, "a")       = ["a"]
+     * ArrayUtils.realAdd(["a"], null)     = ["a", null]
+     * ArrayUtils.realAdd(["a"], "b")      = ["a", "b"]
+     * ArrayUtils.realAdd(["a", "b"], "c") = ["a", "b", "c"]
+     * </pre>
+     *
+     * @param array   the array to "realAdd" the element to, may be <code>null</code>
+     * @param element the object to realAdd
+     * @return A new array containing the existing elements plus the new element
+     */
+    public static <T> T[] add(T[] array, T element) {
+        Class type = array != null ? array.getClass() : (element != null ? element.getClass() : Object.class);
+        return (T[]) realAddOne(array, element, type);
+    }
+
+    public static boolean[] add(boolean[] array, boolean element) {
+        return (boolean[]) realAddOne(array, element, Boolean.TYPE);
+    }
+
+    public static byte[] add(byte[] array, byte element) {
+        return (byte[]) realAddOne(array, element, Byte.TYPE);
+    }
+
+    public static char[] add(char[] array, char element) {
+        return (char[]) realAddOne(array, element, Character.TYPE);
+    }
+
+    public static double[] add(double[] array, double element) {
+        return (double[]) realAddOne(array, element, Double.TYPE);
+    }
+
+    public static float[] add(float[] array, float element) {
+        return (float[]) realAddOne(array, element, Float.TYPE);
+    }
+
+    public static int[] add(int[] array, int element) {
+        return (int[]) realAddOne(array, element, Integer.TYPE);
+    }
+
+    public static long[] add(long[] array, long element) {
+        return (long[]) realAddOne(array, element, Long.TYPE);
+    }
+
+    public static short[] add(short[] array, short element) {
+        return (short[]) realAddOne(array, element, Short.TYPE);
+    }
+
+    private static Object realAddOne(Object array, Object element, Class newArrayComponentType) {
+        Object newArray;
+        int arrayLength = 0;
+        if (array != null) {
+            arrayLength = getLength(array);
+            newArray = Array.newInstance(array.getClass().getComponentType(), arrayLength + 1);
+            System.arraycopy(array, 0, newArray, 0, arrayLength);
+        } else {
+            newArray = Array.newInstance(newArrayComponentType, 1);
+        }
+        Array.set(newArray, arrayLength, element);
+        return newArray;
+    }
+
+    /**
+     * <p>Adds all the elements of the given arrays into a new array.</p>
+     * <p>The new array contains all of the element of <code>array1</code> followed
+     * by all of the elements <code>array2</code>. When an array is returned, it is always
+     * a new array.</p>
+     *
+     * <pre>
+     * ArrayUtils.add(null, null)     = null
+     * ArrayUtils.add(array1, null)   = copy of array1
+     * ArrayUtils.add(null, array2)   = copy of array2
+     * ArrayUtils.add([], [])         = []
+     * ArrayUtils.add([null], [null]) = [null, null]
+     * ArrayUtils.add(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
+     * </pre>
+     *
+     * @param array1 the first array whose elements are added to the new array, may be <code>null</code>
+     * @param array2 the second array whose elements are added to the new array, may be <code>null</code>
+     * @return The new array, <code>null</code> if <code>null</code> array inputs.
+     * The type of the new array is the type of the first array.
+     */
+    public static <T> T[] add(T[] array1, T[] array2) {
+        return (T[]) realAddArr(array1, array2);
+    }
+
+    public static boolean[] add(boolean[] array1, boolean[] array2) {
+        return (boolean[]) realAddArr(array1, array2);
+    }
+
+    public static char[] add(char[] array1, char[] array2) {
+        return (char[]) realAddArr(array1, array2);
+    }
+
+    public static byte[] add(byte[] array1, byte[] array2) {
+        return (byte[]) realAddArr(array1, array2);
+    }
+
+    public static short[] add(short[] array1, short[] array2) {
+        return (short[]) realAddArr(array1, array2);
+    }
+
+    public static int[] add(int[] array1, int[] array2) {
+        return (int[]) realAddArr(array1, array2);
+    }
+
+    public static long[] add(long[] array1, long[] array2) {
+        return (long[]) realAddArr(array1, array2);
+    }
+
+    public static float[] add(float[] array1, float[] array2) {
+        return (float[]) realAddArr(array1, array2);
+    }
+
+    public static double[] add(double[] array1, double[] array2) {
+        return (double[]) realAddArr(array1, array2);
+    }
+
+    private static Object realAddArr(Object array1, Object array2) {
+        if (array1 == null && array2 == null) return null;
+        if (array1 == null) {
+            return realCopy(array2);
+        }
+        if (array2 == null) {
+            return realCopy(array1);
+        }
+        int len1 = getLength(array1);
+        int len2 = getLength(array2);
+        Object joinedArray = Array.newInstance(array1.getClass().getComponentType(), len1 + len2);
+        System.arraycopy(array1, 0, joinedArray, 0, len1);
+        System.arraycopy(array2, 0, joinedArray, len1, len2);
+        return joinedArray;
+    }
+
+    /**
+     * <p>Inserts the specified element at the specified position in the array.
+     * Shifts the element currently at that position (if any) and any subsequent
+     * elements to the right (adds one to their indices).</p>
+     *
+     * <p>This method returns a new array with the same elements of the input
+     * array plus the given element on the specified position. The component
+     * type of the returned array is always the same as that of the input
+     * array.</p>
+     *
+     * <p>If the input array is <code>null</code>, a new one element array is returned
+     * whose component type is the same as the element.</p>
+     *
+     * <pre>
+     * ArrayUtils.add(null, 0, null)      = [null]
+     * ArrayUtils.add(null, 0, "a")       = ["a"]
+     * ArrayUtils.add(["a"], 1, null)     = ["a", null]
+     * ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
+     * ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
+     * </pre>
+     *
+     * @param array1 the array to realAdd the element to, may be <code>null</code>
+     * @param index  the position of the new object
+     * @param array2 the array to realAdd
+     * @return A new array containing the existing elements and the new element
+     * @throws IndexOutOfBoundsException if the index is out of range
+     *                                   (index < 0 || index > array.length).
+     */
+    public static <T> T[] add(T[] array1, int index, T[] array2) {
+        Class clss;
+        if (array1 != null) {
+            clss = array1.getClass().getComponentType();
+        } else if (array2 != null) {
+            clss = array2.getClass().getComponentType();
+        } else {
+            return (T[]) new Object[]{null};
+        }
+        return (T[]) realAddArr(array1, index, array2, clss);
+    }
+
+    public static boolean[] add(boolean[] array1, int index, boolean[] array2) {
+        return (boolean[]) realAddArr(array1, index, array2, Boolean.TYPE);
+    }
+
+    public static char[] add(char[] array1, int index, char[] array2) {
+        return (char[]) realAddArr(array1, index, array2, Character.TYPE);
+    }
+
+    public static byte[] add(byte[] array1, int index, byte[] array2) {
+        return (byte[]) realAddArr(array1, index, array2, Byte.TYPE);
+    }
+
+    public static short[] add(short[] array1, int index, short[] array2) {
+        return (short[]) realAddArr(array1, index, array2, Short.TYPE);
+    }
+
+    public static int[] add(int[] array1, int index, int[] array2) {
+        return (int[]) realAddArr(array1, index, array2, Integer.TYPE);
+    }
+
+    public static long[] add(long[] array1, int index, long[] array2) {
+        return (long[]) realAddArr(array1, index, array2, Long.TYPE);
+    }
+
+    public static float[] add(float[] array1, int index, float[] array2) {
+        return (float[]) realAddArr(array1, index, array2, Float.TYPE);
+    }
+
+    public static double[] add(double[] array1, int index, double[] array2) {
+        return (double[]) realAddArr(array1, index, array2, Double.TYPE);
+    }
+
+    private static Object realAddArr(Object array1, int index, Object array2, Class clss) {
+        if (array1 == null && array2 == null) return null;
+        int len1 = getLength(array1);
+        int len2 = getLength(array2);
+        if (len1 == 0) {
+            if (index != 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", array1 Length: 0");
+            }
+            return realCopy(array2);
+        }
+        if (len2 == 0) {
+            return realCopy(array1);
+        }
+        if (index > len1 || index < 0) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", array1 Length: " + len1);
+        }
+        Object joinedArray = Array.newInstance(array1.getClass().getComponentType(), len1 + len2);
+        if (index == len1) {
+            System.arraycopy(array1, 0, joinedArray, 0, len1);
+            System.arraycopy(array2, 0, joinedArray, len1, len2);
+        } else if (index == 0) {
+            System.arraycopy(array2, 0, joinedArray, 0, len2);
+            System.arraycopy(array1, 0, joinedArray, len2, len1);
+        } else {
+            System.arraycopy(array1, 0, joinedArray, 0, index);
+            System.arraycopy(array2, 0, joinedArray, index, len2);
+            System.arraycopy(array1, index, joinedArray, index + len2, len1 - index);
+        }
+        return joinedArray;
+    }
+
+    /**
+     * <p>Inserts the specified element at the specified position in the array.
+     * Shifts the element currently at that position (if any) and any subsequent
+     * elements to the right (adds one to their indices).</p>
+     *
+     * <p>This method returns a new array with the same elements of the input
+     * array plus the given element on the specified position. The component
+     * type of the returned array is always the same as that of the input
+     * array.</p>
+     *
+     * <p>If the input array is <code>null</code>, a new one element array is returned
+     * whose component type is the same as the element.</p>
+     *
+     * <pre>
+     * ArrayUtils.add(null, 0, null)      = [null]
+     * ArrayUtils.add(null, 0, "a")       = ["a"]
+     * ArrayUtils.add(["a"], 1, null)     = ["a", null]
+     * ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
+     * ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
+     * </pre>
+     *
+     * @param array   the array to realAdd the element to, may be <code>null</code>
+     * @param index   the position of the new object
+     * @param element the object to realAdd
+     * @return A new array containing the existing elements and the new element
+     * @throws IndexOutOfBoundsException if the index is out of range
+     *                                   (index < 0 || index > array.length).
+     */
+    public static <T> T[] add(T[] array, int index, T element) {
+        Class clss;
+        if (array != null) {
+            clss = array.getClass().getComponentType();
+        } else if (element != null) {
+            clss = element.getClass();
+        } else {
+            return (T[]) new Object[]{null};
+        }
+        return (T[]) realAdd(array, index, element, clss);
+    }
+
+    public static boolean[] add(boolean[] array, int index, boolean element) {
+        return (boolean[]) realAdd(array, index, element, Boolean.TYPE);
+    }
+
+    public static char[] add(char[] array, int index, char element) {
+        return (char[]) realAdd(array, index, element, Character.TYPE);
+    }
+
+    public static byte[] add(byte[] array, int index, byte element) {
+        return (byte[]) realAdd(array, index, element, Byte.TYPE);
+    }
+
+    public static short[] add(short[] array, int index, short element) {
+        return (short[]) realAdd(array, index, element, Short.TYPE);
+    }
+
+    public static int[] add(int[] array, int index, int element) {
+        return (int[]) realAdd(array, index, element, Integer.TYPE);
+    }
+
+    public static long[] add(long[] array, int index, long element) {
+        return (long[]) realAdd(array, index, element, Long.TYPE);
+    }
+
+    public static float[] add(float[] array, int index, float element) {
+        return (float[]) realAdd(array, index, element, Float.TYPE);
+    }
+
+    public static double[] add(double[] array, int index, double element) {
+        return (double[]) realAdd(array, index, element, Double.TYPE);
+    }
+
+    private static Object realAdd(Object array, int index, Object element, Class clss) {
+        if (array == null) {
+            if (index != 0) {
+                throw new IndexOutOfBoundsException("Index: " + index + ", Length: 0");
+            }
+            Object joinedArray = Array.newInstance(clss, 1);
+            Array.set(joinedArray, 0, element);
+            return joinedArray;
+        }
+        int length = Array.getLength(array);
+        if (index > length || index < 0) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
+        }
+        Object result = Array.newInstance(clss, length + 1);
+        System.arraycopy(array, 0, result, 0, index);
+        Array.set(result, index, element);
+        if (index < length) {
+            System.arraycopy(array, index, result, index + 1, length - index);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // remove
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 移除指定的索引
+     * <p>Removes the element at the specified position from the specified array.
+     * All subsequent elements are shifted to the left (substracts one from
+     * their indices).</p>
+     *
+     * <p>This method returns a new array with the same elements of the input
+     * array except the element on the specified position. The component
+     * type of the returned array is always the same as that of the input
+     * array.</p>
+     *
+     * <p>If the input array is <code>null</code>, an IndexOutOfBoundsException
+     * will be thrown, because in that case no valid index can be specified.</p>
+     *
+     * <pre>
+     * ArrayUtils.remove(["a"], 0)           = []
+     * ArrayUtils.remove(["a", "b"], 0)      = ["b"]
+     * ArrayUtils.remove(["a", "b"], 1)      = ["a"]
+     * ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]
+     * </pre>
+     *
+     * @param array the array to remove the element from, may not be <code>null</code>
+     * @param index the position of the element to be removed
+     * @return A new array containing the existing elements except the element
+     * at the specified position.
+     * @throws IndexOutOfBoundsException if the index is out of range
+     *                                   (index < 0 || index >= array.length), or if the array is <code>null</code>.
+     * @since 2.1
+     */
+    public static Object[] remove(Object[] array, int index) {
+        return (Object[]) remove((Object) array, index);
+    }
+
+    /**
+     * 移除指定的元素
+     * <p>Removes the first occurrence of the specified element from the
+     * specified array. All subsequent elements are shifted to the left
+     * (substracts one from their indices). If the array doesn't contains
+     * such an element, no elements are removed from the array.</p>
+     *
+     * <p>This method returns a new array with the same elements of the input
+     * array except the first occurrence of the specified element. The component
+     * type of the returned array is always the same as that of the input
+     * array.</p>
+     *
+     * <pre>
+     * ArrayUtils.removeElement(null, "a")            = null
+     * ArrayUtils.removeElement([], "a")              = []
+     * ArrayUtils.removeElement(["a"], "b")           = ["a"]
+     * ArrayUtils.removeElement(["a", "b"], "a")      = ["b"]
+     * ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]
+     * </pre>
+     *
+     * @param array   the array to remove the element from, may be <code>null</code>
+     * @param element the element to be removed
+     * @return A new array containing the existing elements except the first
+     * occurrence of the specified element.
+     * @since 2.1
+     */
+    public static Object[] removeElement(Object[] array, Object element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static boolean[] remove(boolean[] array, int index) {
+        return (boolean[]) remove((Object) array, index);
+    }
+
+    public static boolean[] removeElement(boolean[] array, boolean element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static byte[] remove(byte[] array, int index) {
+        return (byte[]) remove((Object) array, index);
+    }
+
+    public static byte[] removeElement(byte[] array, byte element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static char[] remove(char[] array, int index) {
+        return (char[]) remove((Object) array, index);
+    }
+
+    public static char[] removeElement(char[] array, char element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static double[] remove(double[] array, int index) {
+        return (double[]) remove((Object) array, index);
+    }
+
+    public static double[] removeElement(double[] array, double element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static float[] remove(float[] array, int index) {
+        return (float[]) remove((Object) array, index);
+    }
+
+    public static float[] removeElement(float[] array, float element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static int[] remove(int[] array, int index) {
+        return (int[]) remove((Object) array, index);
+    }
+
+    public static int[] removeElement(int[] array, int element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static long[] remove(long[] array, int index) {
+        return (long[]) remove((Object) array, index);
+    }
+
+    public static long[] removeElement(long[] array, long element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    public static short[] remove(short[] array, int index) {
+        return (short[]) remove((Object) array, index);
+    }
+
+    public static short[] removeElement(short[] array, short element) {
+        int index = indexOf(array, element);
+        if (index == INDEX_NOT_FOUND) {
+            return copy(array);
+        }
+        return remove(array, index);
+    }
+
+    private static Object remove(Object array, int index) {
+        int length = getLength(array);
+        if (index < 0 || index >= length) {
+            throw new IndexOutOfBoundsException("Index: " + index + ", Length: " + length);
+        }
+
+        Object result = Array.newInstance(array.getClass().getComponentType(), length - 1);
+        System.arraycopy(array, 0, result, 0, index);
+        if (index < length - 1) {
+            System.arraycopy(array, index + 1, result, index, length - index - 1);
+        }
+
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // object indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 查找第一个元素的索引
+     *
+     * @param array
+     * @param objectToFind
+     * @return
+     */
+    public static int indexOf(Object[] array, Object objectToFind) {
+        return indexOf(array, objectToFind, 0);
+    }
+
+    public static int indexOf(Object[] array, final Object objectToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        if (objectToFind == null) {
+            for (int i = startIndex; i < array.length; i++) {
+                if (array[i] == null) {
+                    return i;
+                }
+            }
+        } else {
+            for (int i = startIndex; i < array.length; i++) {
+                if (objectToFind.equals(array[i])) {
+                    return i;
+                }
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    /**
+     * 查找最后一个元素的索引
+     *
+     * @param array
+     * @param objectToFind
+     * @return
+     */
+    public static int lastIndexOf(Object[] array, Object objectToFind) {
+        return lastIndexOf(array, objectToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        if (objectToFind == null) {
+            for (int i = startIndex; i >= 0; i--) {
+                if (array[i] == null) {
+                    return i;
+                }
+            }
+        } else {
+            for (int i = startIndex; i >= 0; i--) {
+                if (objectToFind.equals(array[i])) {
+                    return i;
+                }
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    /**
+     * 判断是否包含该元素
+     *
+     * @param array
+     * @param objectToFind
+     * @return
+     */
+    public static boolean contains(Object[] array, Object objectToFind) {
+        return indexOf(array, objectToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // long indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(long[] array, long valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(long[] array, long valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(long[] array, long valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(long[] array, long valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(long[] array, long valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // int indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(int[] array, int valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(int[] array, int valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(int[] array, int valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(int[] array, int valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(int[] array, int valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // short indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(short[] array, short valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(short[] array, short valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(short[] array, short valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(short[] array, short valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(short[] array, short valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // char indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(char[] array, char valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(char[] array, char valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(char[] array, char valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(char[] array, char valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(char[] array, char valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // byte indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(byte[] array, byte valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(byte[] array, byte valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(byte[] array, byte valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
+        if (array == null) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(byte[] array, byte valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // double indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(double[] array, double valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(double[] array, double valueToFind, double tolerance) {
+        return indexOf(array, valueToFind, 0, tolerance);
+    }
+
+    public static int indexOf(double[] array, double valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int indexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        double min = valueToFind - tolerance;
+        double max = valueToFind + tolerance;
+        for (int i = startIndex; i < array.length; i++) {
+            if (array[i] >= min && array[i] <= max) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(double[] array, double valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(double[] array, double valueToFind, double tolerance) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE, tolerance);
+    }
+
+    public static int lastIndexOf(double[] array, double valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        double min = valueToFind - tolerance;
+        double max = valueToFind + tolerance;
+        for (int i = startIndex; i >= 0; i--) {
+            if (array[i] >= min && array[i] <= max) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(double[] array, double valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(double[] array, double valueToFind, double tolerance) {
+        return indexOf(array, valueToFind, 0, tolerance) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // float indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(float[] array, float valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(float[] array, float valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(float[] array, float valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(float[] array, float valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(float[] array, float valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // bool indexOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int indexOf(boolean[] array, boolean valueToFind) {
+        return indexOf(array, valueToFind, 0);
+    }
+
+    public static int indexOf(boolean[] array, boolean valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            startIndex = 0;
+        }
+        for (int i = startIndex; i < array.length; i++) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static int lastIndexOf(boolean[] array, boolean valueToFind) {
+        return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
+    }
+
+    public static int lastIndexOf(boolean[] array, boolean valueToFind, int startIndex) {
+        if (ArrayUtils.isEmpty(array)) {
+            return INDEX_NOT_FOUND;
+        }
+        if (startIndex < 0) {
+            return INDEX_NOT_FOUND;
+        } else if (startIndex >= array.length) {
+            startIndex = array.length - 1;
+        }
+        for (int i = startIndex; i >= 0; i--) {
+            if (valueToFind == array[i]) {
+                return i;
+            }
+        }
+        return INDEX_NOT_FOUND;
+    }
+
+    public static boolean contains(boolean[] array, boolean valueToFind) {
+        return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // char converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 装箱数组转基本类型数组
+     *
+     * @param array
+     * @return
+     */
+    public static char[] toPrimitive(Character[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new char[0];
+        }
+        final char[] result = new char[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].charValue();
+        }
+        return result;
+    }
+
+    public static char[] toPrimitive(Character[] array, char valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new char[0];
+        }
+        final char[] result = new char[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Character b = array[i];
+            result[i] = (b == null ? valueForNull : b.charValue());
+        }
+        return result;
+    }
+
+    /**
+     * 基本类型数组转装箱数组
+     *
+     * @param array
+     * @return
+     */
+    public static Character[] toObject(char[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Character[0];
+        }
+        final Character[] result = new Character[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Character(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // long converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static long[] toPrimitive(Long[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new long[0];
+        }
+        final long[] result = new long[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].longValue();
+        }
+        return result;
+    }
+
+    public static long[] toPrimitive(Long[] array, long valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new long[0];
+        }
+        final long[] result = new long[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Long b = array[i];
+            result[i] = (b == null ? valueForNull : b.longValue());
+        }
+        return result;
+    }
+
+    public static Long[] toObject(long[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Long[0];
+        }
+        final Long[] result = new Long[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Long(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // int converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static int[] toPrimitive(Integer[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new int[0];
+        }
+        final int[] result = new int[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].intValue();
+        }
+        return result;
+    }
+
+    public static int[] toPrimitive(Integer[] array, int valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new int[0];
+        }
+        final int[] result = new int[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Integer b = array[i];
+            result[i] = (b == null ? valueForNull : b.intValue());
+        }
+        return result;
+    }
+
+    public static Integer[] toObject(int[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Integer[0];
+        }
+        final Integer[] result = new Integer[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Integer(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // short converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static short[] toPrimitive(Short[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new short[0];
+        }
+        final short[] result = new short[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].shortValue();
+        }
+        return result;
+    }
+
+    public static short[] toPrimitive(Short[] array, short valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new short[0];
+        }
+        final short[] result = new short[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Short b = array[i];
+            result[i] = (b == null ? valueForNull : b.shortValue());
+        }
+        return result;
+    }
+
+    public static Short[] toObject(short[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Short[0];
+        }
+        final Short[] result = new Short[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Short(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // byte converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static byte[] toPrimitive(Byte[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new byte[0];
+        }
+        final byte[] result = new byte[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].byteValue();
+        }
+        return result;
+    }
+
+    public static byte[] toPrimitive(Byte[] array, byte valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new byte[0];
+        }
+        final byte[] result = new byte[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Byte b = array[i];
+            result[i] = (b == null ? valueForNull : b.byteValue());
+        }
+        return result;
+    }
+
+    public static Byte[] toObject(byte[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Byte[0];
+        }
+        final Byte[] result = new Byte[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Byte(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // double converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static double[] toPrimitive(Double[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new double[0];
+        }
+        final double[] result = new double[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].doubleValue();
+        }
+        return result;
+    }
+
+    public static double[] toPrimitive(Double[] array, double valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new double[0];
+        }
+        final double[] result = new double[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Double b = array[i];
+            result[i] = (b == null ? valueForNull : b.doubleValue());
+        }
+        return result;
+    }
+
+    public static Double[] toObject(double[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Double[0];
+        }
+        final Double[] result = new Double[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Double(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // float converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static float[] toPrimitive(Float[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new float[0];
+        }
+        final float[] result = new float[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].floatValue();
+        }
+        return result;
+    }
+
+    public static float[] toPrimitive(Float[] array, float valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new float[0];
+        }
+        final float[] result = new float[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Float b = array[i];
+            result[i] = (b == null ? valueForNull : b.floatValue());
+        }
+        return result;
+    }
+
+    public static Float[] toObject(float[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Float[0];
+        }
+        final Float[] result = new Float[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = new Float(array[i]);
+        }
+        return result;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // boolean converters
+    ///////////////////////////////////////////////////////////////////////////
+
+    public static boolean[] toPrimitive(Boolean[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new boolean[0];
+        }
+        final boolean[] result = new boolean[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = array[i].booleanValue();
+        }
+        return result;
+    }
+
+    public static boolean[] toPrimitive(Boolean[] array, boolean valueForNull) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new boolean[0];
+        }
+        final boolean[] result = new boolean[array.length];
+        for (int i = 0; i < array.length; i++) {
+            Boolean b = array[i];
+            result[i] = (b == null ? valueForNull : b.booleanValue());
+        }
+        return result;
+    }
+
+    public static Boolean[] toObject(boolean[] array) {
+        if (array == null) {
+            return null;
+        } else if (array.length == 0) {
+            return new Boolean[0];
+        }
+        final Boolean[] result = new Boolean[array.length];
+        for (int i = 0; i < array.length; i++) {
+            result[i] = (array[i] ? Boolean.TRUE : Boolean.FALSE);
+        }
+        return result;
+    }
+
+    /**
+     * 转为链表
+     *
+     * @param array
+     * @param <T>
+     * @return
+     */
+    public static <T> List<T> asList(T... array) {
+        if (array == null || array.length == 0) {
+            return Collections.emptyList();
+        }
+        return Arrays.asList(array);
+    }
+
+    /**
+     * 转为不可变链表
+     *
+     * @param array
+     * @param <T>
+     * @return
+     */
+    public static <T> List<T> asUnmodifiableList(T... array) {
+        return Collections.unmodifiableList(asList(array));
+    }
+
+    /**
+     * 转为数组链表
+     *
+     * @param array
+     * @param <T>
+     * @return
+     */
+    public static <T> List<T> asArrayList(T... array) {
+        List<T> list = new ArrayList<>();
+        if (array == null || array.length == 0) return list;
+        list.addAll(Arrays.asList(array));
+        return list;
+    }
+
+    /**
+     * 转为双向链表
+     *
+     * @param array
+     * @param <T>
+     * @return
+     */
+    public static <T> List<T> asLinkedList(T... array) {
+        List<T> list = new LinkedList<>();
+        if (array == null || array.length == 0) return list;
+        list.addAll(Arrays.asList(array));
+        return list;
+    }
+
+    /**
+     * 排序
+     *
+     * @param array
+     * @param c
+     * @param <T>
+     */
+    public static <T> void sort(T[] array, Comparator<? super T> c) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array, c);
+    }
+
+    public static void sort(byte[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(char[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(double[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(float[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(int[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(long[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    public static void sort(short[] array) {
+        if (array == null || array.length < 2) return;
+        Arrays.sort(array);
+    }
+
+    /**
+     * 对所有元素做操作
+     * Executes the given closure on each element in the array.
+     * <p>
+     * If the input array or closure is null, there is no change made.
+     *
+     * @param array   The array.
+     * @param closure the closure to perform, may be null
+     */
+    public static <E> void forAllDo(Object array, Closure<E> closure) {
+        if (array == null || closure == null) return;
+        if (array instanceof Object[]) {
+            Object[] objects = (Object[]) array;
+            for (int i = 0, length = objects.length; i < length; i++) {
+                Object ele = objects[i];
+                closure.execute(i, (E) ele);
+            }
+        } else if (array instanceof boolean[]) {
+            boolean[] booleans = (boolean[]) array;
+            for (int i = 0, length = booleans.length; i < length; i++) {
+                boolean ele = booleans[i];
+                closure.execute(i, (E) (ele ? Boolean.TRUE : Boolean.FALSE));
+            }
+        } else if (array instanceof byte[]) {
+            byte[] bytes = (byte[]) array;
+            for (int i = 0, length = bytes.length; i < length; i++) {
+                byte ele = bytes[i];
+                closure.execute(i, (E) Byte.valueOf(ele));
+            }
+        } else if (array instanceof char[]) {
+            char[] chars = (char[]) array;
+            for (int i = 0, length = chars.length; i < length; i++) {
+                char ele = chars[i];
+                closure.execute(i, (E) Character.valueOf(ele));
+            }
+        } else if (array instanceof short[]) {
+            short[] shorts = (short[]) array;
+            for (int i = 0, length = shorts.length; i < length; i++) {
+                short ele = shorts[i];
+                closure.execute(i, (E) Short.valueOf(ele));
+            }
+        } else if (array instanceof int[]) {
+            int[] ints = (int[]) array;
+            for (int i = 0, length = ints.length; i < length; i++) {
+                int ele = ints[i];
+                closure.execute(i, (E) Integer.valueOf(ele));
+            }
+        } else if (array instanceof long[]) {
+            long[] longs = (long[]) array;
+            for (int i = 0, length = longs.length; i < length; i++) {
+                long ele = longs[i];
+                closure.execute(i, (E) Long.valueOf(ele));
+            }
+        } else if (array instanceof float[]) {
+            float[] floats = (float[]) array;
+            for (int i = 0, length = floats.length; i < length; i++) {
+                float ele = floats[i];
+                closure.execute(i, (E) Float.valueOf(ele));
+            }
+        } else if (array instanceof double[]) {
+            double[] doubles = (double[]) array;
+            for (int i = 0, length = doubles.length; i < length; i++) {
+                double ele = doubles[i];
+                closure.execute(i, (E) Double.valueOf(ele));
+            }
+        } else {
+            throw new IllegalArgumentException("Not an array: " + array.getClass());
+        }
+    }
+
+    /**
+     * 数组转为字符串
+     * Return the string of array.
+     *
+     * @param array The array.
+     * @return the string of array
+     */
+    public static String toString(Object array) {
+        if (array == null) return "null";
+        if (array instanceof Object[]) {
+            return Arrays.deepToString((Object[]) array);
+        } else if (array instanceof boolean[]) {
+            return Arrays.toString((boolean[]) array);
+        } else if (array instanceof byte[]) {
+            return Arrays.toString((byte[]) array);
+        } else if (array instanceof char[]) {
+            return Arrays.toString((char[]) array);
+        } else if (array instanceof double[]) {
+            return Arrays.toString((double[]) array);
+        } else if (array instanceof float[]) {
+            return Arrays.toString((float[]) array);
+        } else if (array instanceof int[]) {
+            return Arrays.toString((int[]) array);
+        } else if (array instanceof long[]) {
+            return Arrays.toString((long[]) array);
+        } else if (array instanceof short[]) {
+            return Arrays.toString((short[]) array);
+        }
+        throw new IllegalArgumentException("Array has incompatible type: " + array.getClass());
+    }
+
+    public interface Closure<E> {
+        void execute(int index, E item);
+    }
+}
+package com.cnlive.core.libs.base.util;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Enumeration;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * <pre>
+ *     author: blankj
+ *     blog  : http://blankj.com
+ *     time  : 2019/07/26
+ *     desc  : utils about collection
+ * </pre>
+ * newUnmodifiableList[NotNull]: 新建只读[非空]链表
+ * newArrayList[NotNull]       : 新建数组型[非空]链表
+ * newLinkedList[NotNull]      : 新建指针型[非空]链表
+ * newHashSet[NotNull]         : 新建哈希[非空]集合
+ * newTreeSet[NotNull]         : 新建有序[非空]集合
+ * newSynchronizedCollection   : 新建同步集合
+ * newUnmodifiableCollection   : 新建只读集合
+ * union                       : 获取并集
+ * intersection                : 获取交集
+ * disjunction                 : 获取并集减交集
+ * subtract                    : 获取差集
+ * containsAny                 : 判断是否有交集
+ * getCardinalityMap           : 获取集合中所有元素的基数
+ * isSubCollection             : 是否子集
+ * isProperSubCollection       : 是否真子集
+ * isEqualCollection           : 判断集合是否相等
+ * cardinality                 : 获取集合中元素的基数
+ * find                        : 查找第一个符合条件的元素
+ * forAllDo                    : 对所有元素做操作
+ * filter                      : 删除原集合中不符合条件的元素
+ * select                      : 查找出所有符合条件的元素并返回新集合
+ * selectRejected              : 查找出所有不符合条件的元素并返回新集合
+ * transform                   : 对原集合进行转变
+ * collect                     : 转变为新的集合
+ * countMatches                : 查找到匹配的元素个数
+ * exists                      : 判断集合是否存在符合条件的元素
+ * addIgnoreNull               : 新增元素如果不为空
+ * addAll                      : 新增多个元素
+ * get                         : 获取集合元素
+ * size                        : 获取集合个数
+ * sizeIsEmpty                 : 判断个数是否为零
+ * isEmpty                     : 判断是否为空
+ * isNotEmpty                  : 判断是否非空
+ * retainAll                   : 保留元素
+ * removeAll                   : 删除下来
+ * toString                    : 集合转为字符串
+ */
+public final class CollectionUtils {
+
+    private CollectionUtils() {
+        throw new UnsupportedOperationException("u can't instantiate me...");
+    }
+
+    ///////////////////////////////////////////////////////////////////////////
+    // listOf
+    ///////////////////////////////////////////////////////////////////////////
+
+    /**
+     * 新建只读[非空]链表
+     * Returns a new read-only list of given elements.
+     *
+     * @param array The array.
+     * @return a new read-only list of given elements
+     */
+    @SafeVarargs
+    public static <E> List<E> newUnmodifiableList(E... array) {
+        return Collections.unmodifiableList(newArrayList(array));
+    }
+
+    /**
+     * Returns a new read-only list only of those given elements, that are not null.
+     *
+     * @param array The array.
+     * @return a new read-only list only of those given elements, that are not null
+     */
+    @SafeVarargs
+    public static <E> List<E> newUnmodifiableListNotNull(E... array) {
+        return Collections.unmodifiableList(newArrayListNotNull(array));
+    }
+
+    /**
+     * 新建数组型[非空]链表
+     *
+     * @param array
+     * @param <E>
+     * @return
+     */
+    @SafeVarargs
+    public static <E> ArrayList<E> newArrayList(E... array) {
+        ArrayList<E> list = new ArrayList<>();
+        if (array == null || array.length == 0) return list;
+        for (E e : array) {
+            list.add(e);
+        }
+        return list;
+    }
+
+    @SafeVarargs
+    public static <E> ArrayList<E> newArrayListNotNull(E... array) {
+        ArrayList<E> list = new ArrayList<>();
+        if (array == null || array.length == 0) return list;
+        for (E e : array) {
+            if (e == null) continue;
+            list.add(e);
+        }
+        return list;
+    }
+
+    /**
+     * 新建指针型[非空]链表
+     *
+     * @param array
+     * @param <E>
+     * @return
+     */
+    @SafeVarargs
+    public static <E> List<E> newLinkedList(E... array) {
+        LinkedList<E> list = new LinkedList<>();
+        if (array == null || array.length == 0) return list;
+        for (E e : array) {
+            list.add(e);
+        }
+        return list;
+    }
+
+    @SafeVarargs
+    public static <E> List<E> newLinkedListNotNull(E... array) {
+        LinkedList<E> list = new LinkedList<>();
+        if (array == null || array.length == 0) return list;
+        for (E e : array) {
+            if (e == null) continue;
+            list.add(e);
+        }
+        return list;
+    }
+
+    /**
+     * 新建哈希[非空]集合
+     *
+     * @param array
+     * @param <E>
+     * @return
+     */
+    @SafeVarargs
+    public static <E> HashSet<E> newHashSet(E... array) {
+        HashSet<E> set = new HashSet<>();
+        if (array == null || array.length == 0) return set;
+        for (E e : array) {
+            set.add(e);
+        }
+        return set;
+    }
+
+    @SafeVarargs
+    public static <E> HashSet<E> newHashSetNotNull(E... array) {
+        HashSet<E> set = new HashSet<>();
+        if (array == null || array.length == 0) return set;
+        for (E e : array) {
+            if (e == null) continue;
+            set.add(e);
+        }
+        return set;
+    }
+
+    /**
+     * 新建有序[非空]集合
+     *
+     * @param comparator
+     * @param array
+     * @param <E>
+     * @return
+     */
+    @SafeVarargs
+    public static <E> TreeSet<E> newTreeSet(Comparator<E> comparator, E... array) {
+        TreeSet<E> set = new TreeSet<>(comparator);
+        if (array == null || array.length == 0) return set;
+        for (E e : array) {
+            set.add(e);
+        }
+        return set;
+    }
+
+    @SafeVarargs
+    public static <E> TreeSet<E> newTreeSetNotNull(Comparator<E> comparator, E... array) {
+        TreeSet<E> set = new TreeSet<>(comparator);
+        if (array == null || array.length == 0) return set;
+        for (E e : array) {
+            if (e == null) continue;
+            set.add(e);
+        }
+        return set;
+    }
+
+    /**
+     * 新建同步集合
+     *
+     * @param collection
+     * @return
+     */
+    public static Collection newSynchronizedCollection(Collection collection) {
+        return Collections.synchronizedCollection(collection);
+    }
+
+    /**
+     * 新建只读集合
+     *
+     * @param collection
+     * @return
+     */
+    public static Collection newUnmodifiableCollection(Collection collection) {
+        return Collections.unmodifiableCollection(collection);
+    }
+
+    /**
+     * 获取并集
+     * Returns a {@link Collection} containing the union
+     * of the given {@link Collection}s.
+     * <p>
+     * The cardinality of each element in the returned {@link Collection}
+     * will be equal to the maximum of the cardinality of that element
+     * in the two given {@link Collection}s.
+     *
+     * @param a the first collection
+     * @param b the second collection
+     * @return the union of the two collections
+     * @see Collection#addAll
+     */
+    public static Collection union(final Collection a, final Collection b) {
+        if (a == null && b == null) return new ArrayList();
+        if (a == null) return new ArrayList<Object>(b);
+        if (b == null) return new ArrayList<Object>(a);
+        ArrayList<Object> list = new ArrayList<>();
+        Map<Object, Integer> mapA = getCardinalityMap(a);
+        Map<Object, Integer> mapB = getCardinalityMap(b);
+        Set<Object> elts = new HashSet<Object>(a);
+        elts.addAll(b);
+        for (Object obj : elts) {
+            for (int i = 0, m = Math.max(getFreq(obj, mapA), getFreq(obj, mapB)); i < m; i++) {
+                list.add(obj);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 获取交集
+     * Returns a {@link Collection} containing the intersection
+     * of the given {@link Collection}s.
+     * <p>
+     * The cardinality of each element in the returned {@link Collection}
+     * will be equal to the minimum of the cardinality of that element
+     * in the two given {@link Collection}s.
+     *
+     * @param a the first collection
+     * @param b the second collection
+     * @return the intersection of the two collections
+     * @see Collection#retainAll
+     */
+    public static Collection intersection(final Collection a, final Collection b) {
+        if (a == null || b == null) return new ArrayList();
+        ArrayList<Object> list = new ArrayList<>();
+        Map mapA = getCardinalityMap(a);
+        Map mapB = getCardinalityMap(b);
+        Set<Object> elts = new HashSet<Object>(a);
+        elts.addAll(b);
+        for (Object obj : elts) {
+            for (int i = 0, m = Math.min(getFreq(obj, mapA), getFreq(obj, mapB)); i < m; i++) {
+                list.add(obj);
+            }
+        }
+        return list;
+    }
+
+    private static int getFreq(final Object obj, final Map freqMap) {
+        Integer count = (Integer) freqMap.get(obj);
+        if (count != null) {
+            return count;
+        }
+        return 0;
+    }
+
+    /**
+     * 获取并集减交集
+     * Returns a {@link Collection} containing the exclusive disjunction
+     * (symmetric difference) of the given {@link Collection}s.
+     * <p>
+     * The cardinality of each element <i>e</i> in the returned {@link Collection}
+     * will be equal to
+     * <tt>max(cardinality(<i>e</i>,<i>a</i>),cardinality(<i>e</i>,<i>b</i>)) - min(cardinality(<i>e</i>,<i>a</i>),cardinality(<i>e</i>,<i>b</i>))</tt>.
+     * <p>
+     * This is equivalent to
+     * <tt>{@link #subtract subtract}({@link #union union(a,b)},{@link #intersection intersection(a,b)})</tt>
+     * or
+     * <tt>{@link #union union}({@link #subtract subtract(a,b)},{@link #subtract subtract(b,a)})</tt>.
+     *
+     * @param a the first collection
+     * @param b the second collection
+     * @return the symmetric difference of the two collections
+     */
+    public static Collection disjunction(final Collection a, final Collection b) {
+        if (a == null && b == null) return new ArrayList();
+        if (a == null) return new ArrayList<Object>(b);
+        if (b == null) return new ArrayList<Object>(a);
+        ArrayList<Object> list = new ArrayList<>();
+        Map mapA = getCardinalityMap(a);
+        Map mapB = getCardinalityMap(b);
+        Set<Object> elts = new HashSet<Object>(a);
+        elts.addAll(b);
+        for (Object obj : elts) {
+            for (int i = 0, m = ((Math.max(getFreq(obj, mapA), getFreq(obj, mapB)))
+                    - (Math.min(getFreq(obj, mapA), getFreq(obj, mapB)))); i < m; i++) {
+                list.add(obj);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 获取差集
+     * Returns a new {@link Collection} containing <tt><i>a</i> - <i>b</i></tt>.
+     * The cardinality of each element <i>e</i> in the returned {@link Collection}
+     * will be the cardinality of <i>e</i> in <i>a</i> minus the cardinality
+     * of <i>e</i> in <i>b</i>, or zero, whichever is greater.
+     *
+     * @param a the collection to subtract from
+     * @param b the collection to subtract
+     * @return a new collection with the results
+     * @see Collection#removeAll
+     */
+    public static Collection subtract(final Collection a, final Collection b) {
+        if (a == null) return new ArrayList();
+        if (b == null) return new ArrayList<Object>(a);
+        ArrayList<Object> list = new ArrayList<Object>(a);
+        for (Object o : b) {
+            list.remove(o);
+        }
+        return list;
+    }
+
+    /**
+     * 判断是否有交集
+     * Returns <code>true</code> iff at least one element is in both collections.
+     * <p>
+     * In other words, this method returns <code>true</code> iff the
+     * {@link #intersection} of <i>coll1</i> and <i>coll2</i> is not empty.
+     *
+     * @param coll1 the first collection
+     * @param coll2 the first collection
+     * @return <code>true</code> iff the intersection of the collections is non-empty
+     * @see #intersection
+     */
+    public static boolean containsAny(final Collection coll1, final Collection coll2) {
+        if (coll1 == null || coll2 == null) return false;
+        if (coll1.size() < coll2.size()) {
+            for (Object o : coll1) {
+                if (coll2.contains(o)) {
+                    return true;
+                }
+            }
+        } else {
+            for (Object o : coll2) {
+                if (coll1.contains(o)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * 获取集合中所有元素的基数
+     * Returns a {@link Map} mapping each unique element in the given
+     * {@link Collection} to an {@link Integer} representing the number
+     * of occurrences of that element in the {@link Collection}.
+     * <p>
+     * Only those elements present in the collection will appear as
+     * keys in the map.
+     *
+     * @param coll the collection to get the cardinality map for, must not be null
+     * @return the populated cardinality map
+     */
+    public static Map<Object, Integer> getCardinalityMap(final Collection coll) {
+        Map<Object, Integer> count = new HashMap<>();
+        if (coll == null) return count;
+        for (Object obj : coll) {
+            Integer c = count.get(obj);
+            if (c == null) {
+                count.put(obj, 1);
+            } else {
+                count.put(obj, c + 1);
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 是否子集
+     * Returns <tt>true</tt> iff <i>a</i> is a sub-collection of <i>b</i>,
+     * that is, iff the cardinality of <i>e</i> in <i>a</i> is less
+     * than or equal to the cardinality of <i>e</i> in <i>b</i>,
+     * for each element <i>e</i> in <i>a</i>.
+     *
+     * @param a the first (sub?) collection
+     * @param b the second (super?) collection
+     * @return <code>true</code> iff <i>a</i> is a sub-collection of <i>b</i>
+     * @see #isProperSubCollection
+     * @see Collection#containsAll
+     */
+    public static boolean isSubCollection(final Collection a, final Collection b) {
+        if (a == null || b == null) return false;
+        Map mapA = getCardinalityMap(a);
+        Map mapB = getCardinalityMap(b);
+        for (Object obj : a) {
+            if (getFreq(obj, mapA) > getFreq(obj, mapB)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /**
+     * 是否真子集
+     * Returns <tt>true</tt> iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>,
+     * that is, iff the cardinality of <i>e</i> in <i>a</i> is less
+     * than or equal to the cardinality of <i>e</i> in <i>b</i>,
+     * for each element <i>e</i> in <i>a</i>, and there is at least one
+     * element <i>f</i> such that the cardinality of <i>f</i> in <i>b</i>
+     * is strictly greater than the cardinality of <i>f</i> in <i>a</i>.
+     * <p>
+     * The implementation assumes
+     * <ul>
+     * <li><code>a.size()</code> and <code>b.size()</code> represent the
+     * total cardinality of <i>a</i> and <i>b</i>, resp. </li>
+     * <li><code>a.size() < Integer.MAXVALUE</code></li>
+     * </ul>
+     *
+     * @param a the first (sub?) collection
+     * @param b the second (super?) collection
+     * @return <code>true</code> iff <i>a</i> is a <i>proper</i> sub-collection of <i>b</i>
+     * @see #isSubCollection
+     * @see Collection#containsAll
+     */
+    public static boolean isProperSubCollection(final Collection a, final Collection b) {
+        if (a == null || b == null) return false;
+        return a.size() < b.size() && CollectionUtils.isSubCollection(a, b);
+    }
+
+    /**
+     * 判断集合是否相等
+     * Returns <tt>true</tt> iff the given {@link Collection}s contain
+     * exactly the same elements with exactly the same cardinalities.
+     * <p>
+     * That is, iff the cardinality of <i>e</i> in <i>a</i> is
+     * equal to the cardinality of <i>e</i> in <i>b</i>,
+     * for each element <i>e</i> in <i>a</i> or <i>b</i>.
+     *
+     * @param a the first collection
+     * @param b the second collection
+     * @return <code>true</code> iff the collections contain the same elements with the same cardinalities.
+     */
+    public static boolean isEqualCollection(final Collection a, final Collection b) {
+        if (a == null || b == null) return false;
+        if (a.size() != b.size()) {
+            return false;
+        } else {
+            Map mapA = getCardinalityMap(a);
+            Map mapB = getCardinalityMap(b);
+            if (mapA.size() != mapB.size()) {
+                return false;
+            } else {
+                for (Object obj : mapA.keySet()) {
+                    if (getFreq(obj, mapA) != getFreq(obj, mapB)) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+        }
+    }
+
+    /**
+     * 获取集合中元素的基数
+     * Returns the number of occurrences of <i>obj</i> in <i>coll</i>.
+     *
+     * @param obj  the object to find the cardinality of
+     * @param coll the collection to search
+     * @return the the number of occurrences of obj in coll
+     */
+    public static <E> int cardinality(E obj, final Collection<E> coll) {
+        if (coll == null) return 0;
+        if (coll instanceof Set) {
+            return (coll.contains(obj) ? 1 : 0);
+        }
+        int count = 0;
+        if (obj == null) {
+            for (E e : coll) {
+                if (e == null) {
+                    count++;
+                }
+            }
+        } else {
+            for (E e : coll) {
+                if (obj.equals(e)) {
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 查找第一个符合条件的元素
+     * Finds the first element in the given collection which matches the given predicate.
+     * <p>
+     * If the input collection or predicate is null, or no element of the collection
+     * matches the predicate, null is returned.
+     *
+     * @param collection the collection to search, may be null
+     * @param predicate  the predicate to use, may be null
+     * @return the first element of the collection which matches the predicate or null if none could be found
+     */
+    public static <E> E find(Collection<E> collection, Predicate<E> predicate) {
+        if (collection == null || predicate == null) return null;
+        for (E item : collection) {
+            if (predicate.evaluate(item)) {
+                return item;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * 对所有元素做操作
+     * Executes the given closure on each element in the collection.
+     * <p>
+     * If the input collection or closure is null, there is no change made.
+     *
+     * @param collection the collection to get the input from, may be null
+     * @param closure    the closure to perform, may be null
+     */
+    public static <E> void forAllDo(Collection<E> collection, Closure<E> closure) {
+        if (collection == null || closure == null) return;
+        int index = 0;
+        for (E e : collection) {
+            closure.execute(index++, e);
+        }
+    }
+
+    /**
+     * 删除原集合中不符合条件的元素
+     * Filter the collection by applying a Predicate to each element. If the
+     * predicate returns false, remove the element.
+     * <p>
+     * If the input collection or predicate is null, there is no change made.
+     *
+     * @param collection the collection to get the input from, may be null
+     * @param predicate  the predicate to use as a filter, may be null
+     */
+    public static <E> void filter(Collection<E> collection, Predicate<E> predicate) {
+        if (collection == null || predicate == null) return;
+        for (Iterator it = collection.iterator(); it.hasNext(); ) {
+            if (!predicate.evaluate((E) it.next())) {
+                it.remove();
+            }
+        }
+    }
+
+    /**
+     * 查找出所有符合条件的元素并返回新集合
+     * Selects all elements from input collection which match the given predicate
+     * into an output collection.
+     * <p>
+     * A <code>null</code> predicate matches no elements.
+     *
+     * @param inputCollection the collection to get the input from, may not be null
+     * @param predicate       the predicate to use, may be null
+     * @return the elements matching the predicate (new list)
+     * @throws NullPointerException if the input collection is null
+     */
+    public static <E> Collection<E> select(Collection<E> inputCollection, Predicate<E> predicate) {
+        if (inputCollection == null || predicate == null) return new ArrayList<>();
+        ArrayList<E> answer = new ArrayList<>(inputCollection.size());
+        for (E o : inputCollection) {
+            if (predicate.evaluate(o)) {
+                answer.add(o);
+            }
+        }
+        return answer;
+    }
+
+    /**
+     * 查找出所有不符合条件的元素并返回新集合
+     * Selects all elements from inputCollection which don't match the given predicate
+     * into an output collection.
+     * <p>
+     * If the input predicate is <code>null</code>, the result is an empty list.
+     *
+     * @param inputCollection the collection to get the input from, may not be null
+     * @param predicate       the predicate to use, may be null
+     * @return the elements <b>not</b> matching the predicate (new list)
+     * @throws NullPointerException if the input collection is null
+     */
+    public static <E> Collection<E> selectRejected(Collection<E> inputCollection, Predicate<E> predicate) {
+        if (inputCollection == null || predicate == null) return new ArrayList<>();
+        ArrayList<E> answer = new ArrayList<>(inputCollection.size());
+        for (E o : inputCollection) {
+            if (!predicate.evaluate(o)) {
+                answer.add(o);
+            }
+        }
+        return answer;
+    }
+
+    /**
+     * 对原集合进行转变
+     * Transform the collection by applying a Transformer to each element.
+     * <p>
+     * If the input collection or transformer is null, there is no change made.
+     * <p>
+     * This routine is best for Lists, for which set() is used to do the
+     * transformations "in place."  For other Collections, clear() and addAll()
+     * are used to replace elements.
+     * <p>
+     * If the input collection controls its input, such as a Set, and the
+     * Transformer creates duplicates (or are otherwise invalid), the
+     * collection may reduce in size due to calling this method.
+     *
+     * @param collection  the collection to get the input from, may be null
+     * @param transformer the transformer to perform, may be null
+     */
+    public static <E1, E2> void transform(Collection<E1> collection, Transformer<E1, E2> transformer) {
+        if (collection == null || transformer == null) return;
+        if (collection instanceof List) {
+            List list = (List) collection;
+            for (ListIterator it = list.listIterator(); it.hasNext(); ) {
+                it.set(transformer.transform((E1) it.next()));
+            }
+        } else {
+            Collection resultCollection = collect(collection, transformer);
+            collection.clear();
+            collection.addAll(resultCollection);
+        }
+    }
+
+
+    /**
+     * 转变为新的集合
+     * Returns a new Collection consisting of the elements of inputCollection transformed
+     * by the given transformer.
+     * <p>
+     * If the input transformer is null, the result is an empty list.
+     *
+     * @param inputCollection the collection to get the input from, may be null
+     * @param transformer     the transformer to use, may be null
+     * @return the transformed result (new list)
+     */
+    public static <E1, E2> Collection<E2> collect(final Collection<E1> inputCollection,
+                                                  final Transformer<E1, E2> transformer) {
+        List<E2> answer = new ArrayList<>();
+        if (inputCollection == null || transformer == null) return answer;
+        for (E1 e1 : inputCollection) {
+            answer.add(transformer.transform(e1));
+        }
+        return answer;
+    }
+
+    /**
+     * 查找到匹配的元素个数
+     * Counts the number of elements in the input collection that match the predicate.
+     * <p>
+     * A <code>null</code> collection or predicate matches no elements.
+     *
+     * @param collection the collection to get the input from, may be null
+     * @param predicate  the predicate to use, may be null
+     * @return the number of matches for the predicate in the collection
+     */
+    public static <E> int countMatches(Collection<E> collection, Predicate<E> predicate) {
+        if (collection == null || predicate == null) return 0;
+        int count = 0;
+        for (E o : collection) {
+            if (predicate.evaluate(o)) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /**
+     * 判断集合是否存在符合条件的元素
+     * Answers true if a predicate is true for at least one element of a collection.
+     * <p>
+     * A <code>null</code> collection or predicate returns false.
+     *
+     * @param collection the collection to get the input from, may be null
+     * @param predicate  the predicate to use, may be null
+     * @return true if at least one element of the collection matches the predicate
+     */
+    public static <E> boolean exists(Collection<E> collection, Predicate<E> predicate) {
+        if (collection == null || predicate == null) return false;
+        for (E o : collection) {
+            if (predicate.evaluate(o)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * 新增元素如果不为空
+     * Adds an element to the collection unless the element is null.
+     *
+     * @param collection the collection to add to, may be null
+     * @param object     the object to add, if null it will not be added
+     * @return true if the collection changed
+     */
+    public static <E> boolean addIgnoreNull(Collection<E> collection, E object) {
+        if (collection == null) return false;
+        return (object != null && collection.add(object));
+    }
+
+    /**
+     * 新增多个元素
+     * Adds all elements in the iteration to the given collection.
+     *
+     * @param collection the collection to add to, may be null
+     * @param iterator   the iterator of elements to add, may be null
+     */
+    public static <E> void addAll(Collection<E> collection, Iterator<E> iterator) {
+        if (collection == null || iterator == null) return;
+        while (iterator.hasNext()) {
+            collection.add(iterator.next());
+        }
+    }
+
+    /**
+     * Adds all elements in the enumeration to the given collection.
+     *
+     * @param collection  the collection to add to, may be null
+     * @param enumeration the enumeration of elements to add, may be null
+     */
+    public static <E> void addAll(Collection<E> collection, Enumeration<E> enumeration) {
+        if (collection == null || enumeration == null) return;
+        while (enumeration.hasMoreElements()) {
+            collection.add(enumeration.nextElement());
+        }
+    }
+
+    /**
+     * Adds all elements in the array to the given collection.
+     *
+     * @param collection the collection to add to, may be null
+     * @param elements   the array of elements to add, may be null
+     */
+    public static <E> void addAll(Collection<E> collection, E[] elements) {
+        if (collection == null || elements == null || elements.length == 0) return;
+        collection.addAll(Arrays.asList(elements));
+    }
+
+    /**
+     * 获取集合元素
+     * Returns the <code>index</code>-th value in <code>object</code>, throwing
+     * <code>IndexOutOfBoundsException</code> if there is no such element or
+     * <code>IllegalArgumentException</code> if <code>object</code> is not an
+     * instance of one of the supported types.
+     * <p>
+     * The supported types, and associated semantics are:
+     * <ul>
+     * <li> Map -- the value returned is the <code>Map.Entry</code> in position
+     * <code>index</code> in the map's <code>entrySet</code> iterator,
+     * if there is such an entry.</li>
+     * <li> List -- this method is equivalent to the list's get method.</li>
+     * <li> Array -- the <code>index</code>-th array entry is returned,
+     * if there is such an entry; otherwise an <code>IndexOutOfBoundsException</code>
+     * is thrown.</li>
+     * <li> Collection -- the value returned is the <code>index</code>-th object
+     * returned by the collection's default iterator, if there is such an element.</li>
+     * <li> Iterator or Enumeration -- the value returned is the
+     * <code>index</code>-th object in the Iterator/Enumeration, if there
+     * is such an element.  The Iterator/Enumeration is advanced to
+     * <code>index</code> (or to the end, if <code>index</code> exceeds the
+     * number of entries) as a side effect of this method.</li>
+     * </ul>
+     *
+     * @param object the object to get a value from
+     * @param index  the index to get
+     * @return the object at the specified index
+     * @throws IndexOutOfBoundsException if the index is invalid
+     * @throws IllegalArgumentException  if the object type is invalid
+     */
+    public static Object get(Object object, int index) {
+        if (object == null) return null;
+        if (index < 0) {
+            throw new IndexOutOfBoundsException("Index cannot be negative: " + index);
+        }
+        if (object instanceof Map) {
+            Map map = (Map) object;
+            Iterator iterator = map.entrySet().iterator();
+            return get(iterator, index);
+        } else if (object instanceof List) {
+            return ((List) object).get(index);
+        } else if (object instanceof Object[]) {
+            return ((Object[]) object)[index];
+        } else if (object instanceof Iterator) {
+            Iterator it = (Iterator) object;
+            while (it.hasNext()) {
+                index--;
+                if (index == -1) {
+                    return it.next();
+                } else {
+                    it.next();
+                }
+            }
+            throw new IndexOutOfBoundsException("Entry does not exist: " + index);
+        } else if (object instanceof Collection) {
+            Iterator iterator = ((Collection) object).iterator();
+            return get(iterator, index);
+        } else if (object instanceof Enumeration) {
+            Enumeration it = (Enumeration) object;
+            while (it.hasMoreElements()) {
+                index--;
+                if (index == -1) {
+                    return it.nextElement();
+                } else {
+                    it.nextElement();
+                }
+            }
+            throw new IndexOutOfBoundsException("Entry does not exist: " + index);
+        } else {
+            try {
+                return Array.get(object, index);
+            } catch (IllegalArgumentException ex) {
+                throw new IllegalArgumentException("Unsupported object type: " + object.getClass().getName());
+            }
+        }
+    }
+
+    /**
+     * 获取集合个数
+     * Gets the size of the collection/iterator specified.
+     * <p>
+     * This method can handles objects as follows
+     * <ul>
+     * <li>Collection - the collection size
+     * <li>Map - the map size
+     * <li>Array - the array size
+     * <li>Iterator - the number of elements remaining in the iterator
+     * <li>Enumeration - the number of elements remaining in the enumeration
+     * </ul>
+     *
+     * @param object the object to get the size of
+     * @return the size of the specified collection
+     * @throws IllegalArgumentException thrown if object is not recognised or null
+     */
+    public static int size(Object object) {
+        if (object == null) return 0;
+        int total = 0;
+        if (object instanceof Map) {
+            total = ((Map) object).size();
+        } else if (object instanceof Collection) {
+            total = ((Collection) object).size();
+        } else if (object instanceof Object[]) {
+            total = ((Object[]) object).length;
+        } else if (object instanceof Iterator) {
+            Iterator it = (Iterator) object;
+            while (it.hasNext()) {
+                total++;
+                it.next();
+            }
+        } else if (object instanceof Enumeration) {
+            Enumeration it = (Enumeration) object;
+            while (it.hasMoreElements()) {
+                total++;
+                it.nextElement();
+            }
+        } else {
+            try {
+                total = Array.getLength(object);
+            } catch (IllegalArgumentException ex) {
+                throw new IllegalArgumentException("Unsupported object type: " + object.getClass().getName());
+            }
+        }
+        return total;
+    }
+
+    /**
+     * 判断个数是否为零
+     * Checks if the specified collection/array/iterator is empty.
+     * <p>
+     * This method can handles objects as follows
+     * <ul>
+     * <li>Collection - via collection isEmpty
+     * <li>Map - via map isEmpty
+     * <li>Array - using array size
+     * <li>Iterator - via hasNext
+     * <li>Enumeration - via hasMoreElements
+     * </ul>
+     * <p>
+     * Note: This method is named to avoid clashing with
+     * {@link #isEmpty(Collection)}.
+     *
+     * @param object the object to get the size of, not null
+     * @return true if empty
+     * @throws IllegalArgumentException thrown if object is not recognised or null
+     */
+    public static boolean sizeIsEmpty(Object object) {
+        if (object == null) return true;
+        if (object instanceof Collection) {
+            return ((Collection) object).isEmpty();
+        } else if (object instanceof Map) {
+            return ((Map) object).isEmpty();
+        } else if (object instanceof Object[]) {
+            return ((Object[]) object).length == 0;
+        } else if (object instanceof Iterator) {
+            return !((Iterator) object).hasNext();
+        } else if (object instanceof Enumeration) {
+            return !((Enumeration) object).hasMoreElements();
+        } else {
+            try {
+                return Array.getLength(object) == 0;
+            } catch (IllegalArgumentException ex) {
+                throw new IllegalArgumentException("Unsupported object type: " + object.getClass().getName());
+            }
+        }
+    }
+
+    /**
+     * 判断是否为空
+     * Null-safe check if the specified collection is empty.
+     * <p>
+     * Null returns true.
+     *
+     * @param coll the collection to check, may be null
+     * @return true if empty or null
+     */
+    public static boolean isEmpty(Collection coll) {
+        return coll == null || coll.size() == 0;
+    }
+
+    /**
+     * 判断是否非空
+     * Null-safe check if the specified collection is not empty.
+     * <p>
+     * Null returns false.
+     *
+     * @param coll the collection to check, may be null
+     * @return true if non-null and non-empty
+     */
+    public static boolean isNotEmpty(Collection coll) {
+        return !isEmpty(coll);
+    }
+
+
+    /**
+     * 保留元素
+     * Returns a collection containing all the elements in <code>collection</code>
+     * that are also in <code>retain</code>. The cardinality of an element <code>e</code>
+     * in the returned collection is the same as the cardinality of <code>e</code>
+     * in <code>collection</code> unless <code>retain</code> does not contain <code>e</code>, in which
+     * case the cardinality is zero. This method is useful if you do not wish to modify
+     * the collection <code>c</code> and thus cannot call <code>c.retainAll(retain);</code>.
+     *
+     * @param collection the collection whose contents are the target of the #retailAll operation
+     * @param retain     the collection containing the elements to be retained in the returned collection
+     * @return a <code>Collection</code> containing all the elements of <code>collection</code>
+     * that occur at least once in <code>retain</code>.
+     */
+    public static <E> Collection<E> retainAll(Collection<E> collection, Collection<E> retain) {
+        if (collection == null || retain == null) return new ArrayList<>();
+        List<E> list = new ArrayList<>();
+        for (E item : collection) {
+            if (retain.contains(item)) {
+                list.add(item);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * 删除下来
+     * Removes the elements in <code>remove</code> from <code>collection</code>. That is, this
+     * method returns a collection containing all the elements in <code>c</code>
+     * that are not in <code>remove</code>. The cardinality of an element <code>e</code>
+     * in the returned collection is the same as the cardinality of <code>e</code>
+     * in <code>collection</code> unless <code>remove</code> contains <code>e</code>, in which
+     * case the cardinality is zero. This method is useful if you do not wish to modify
+     * the collection <code>c</code> and thus cannot call <code>collection.removeAll(remove);</code>.
+     *
+     * @param collection the collection from which items are removed (in the returned collection)
+     * @param remove     the items to be removed from the returned <code>collection</code>
+     * @return a <code>Collection</code> containing all the elements of <code>collection</code> except
+     * any elements that also occur in <code>remove</code>.
+     */
+    public static <E> Collection<E> removeAll(Collection<E> collection, Collection<E> remove) {
+        if (collection == null) return new ArrayList<>();
+        if (remove == null) return new ArrayList<>(collection);
+        List<E> list = new ArrayList<>();
+        for (E obj : collection) {
+            if (!remove.contains(obj)) {
+                list.add(obj);
+            }
+        }
+        return list;
+    }
+
+    /**
+     * Randomly permutes the specified list using a default source of randomness.
+     *
+     * @param list the list to be shuffled.
+     * @throws UnsupportedOperationException if the specified list or
+     *                                       its list-iterator does not support the <tt>set</tt> operation.
+     */
+    public static <T> void shuffle(List<T> list) {
+        Collections.shuffle(list);
+    }
+
+    /**
+     * 集合转为字符串
+     * Return the string of collection.
+     *
+     * @param collection The collection.
+     * @return the string of collection
+     */
+    public static String toString(Collection collection) {
+        if (collection == null) return "null";
+        return collection.toString();
+    }
+
+    public interface Closure<E> {
+        void execute(int index, E item);
+    }
+
+    public interface Transformer<E1, E2> {
+        E2 transform(E1 input);
+    }
+
+    public interface Predicate<E> {
+        boolean evaluate(E item);
+    }
+}
+package com.cnlive.core.libs.base.util;
+
+import android.content.Context;
+import android.graphics.Color;
+
+import androidx.annotation.ColorInt;
+import androidx.annotation.ColorRes;
+import androidx.annotation.FloatRange;
+import androidx.annotation.IntRange;
+import androidx.annotation.NonNull;
+import androidx.core.content.ContextCompat;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2019/01/15
+ *     desc  : utils about color
+ * </pre>
+ * getColor         : 获取颜色
+ * setAlphaComponent: 设置颜色透明度值
+ * setRedComponent  : 设置颜色红色值
+ * setGreenComponent: 设置颜色绿色值
+ * setBlueComponent : 设置颜色蓝色值
+ * string2Int       : 颜色串转颜色值
+ * int2RgbString    : 颜色值转 RGB 串
+ * int2ArgbString   : 颜色值转 ARGB 串
+ * getRandomColor   : 获取随机色
+ */
+public final class ColorUtils {
+
+    private ColorUtils() {
+        throw new UnsupportedOperationException("u can't instantiate me...");
+    }
+
+    /**
+     * 获取颜色
+     * Returns a color associated with a particular resource ID.
+     *
+     * @param id The desired resource identifier.
+     * @return a color associated with a particular resource ID
+     */
+    public static int getColor(Context context, @ColorRes int id) {
+        return ContextCompat.getColor(context, id);
+    }
+
+    /**
+     * 设置颜色透明度值
+     * Set the alpha component of {@code color} to be {@code alpha}.
+     *
+     * @param color The color.
+     * @param alpha Alpha component \([0..255]\) of the color.
+     * @return the {@code color} with {@code alpha} component
+     */
+    public static int setAlphaComponent(@ColorInt final int color,
+                                        @IntRange(from = 0x0, to = 0xFF) int alpha) {
+        return (color & 0x00ffffff) | (alpha << 24);
+    }
+
+    /**
+     * Set the alpha component of {@code color} to be {@code alpha}.
+     *
+     * @param color The color.
+     * @param alpha Alpha component \([0..1]\) of the color.
+     * @return the {@code color} with {@code alpha} component
+     */
+    public static int setAlphaComponent(@ColorInt int color,
+                                        @FloatRange(from = 0, to = 1) float alpha) {
+        return (color & 0x00ffffff) | ((int) (alpha * 255.0f + 0.5f) << 24);
+    }
+
+    /**
+     * 设置颜色红色值
+     * Set the red component of {@code color} to be {@code red}.
+     *
+     * @param color The color.
+     * @param red   Red component \([0..255]\) of the color.
+     * @return the {@code color} with {@code red} component
+     */
+    public static int setRedComponent(@ColorInt int color,
+                                      @IntRange(from = 0x0, to = 0xFF) int red) {
+        return (color & 0xff00ffff) | (red << 16);
+    }
+
+    /**
+     * Set the red component of {@code color} to be {@code red}.
+     *
+     * @param color The color.
+     * @param red   Red component \([0..1]\) of the color.
+     * @return the {@code color} with {@code red} component
+     */
+    public static int setRedComponent(@ColorInt int color,
+                                      @FloatRange(from = 0, to = 1) float red) {
+        return (color & 0xff00ffff) | ((int) (red * 255.0f + 0.5f) << 16);
+    }
+
+    /**
+     * 设置颜色绿色值
+     * Set the green component of {@code color} to be {@code green}.
+     *
+     * @param color The color.
+     * @param green Green component \([0..255]\) of the color.
+     * @return the {@code color} with {@code green} component
+     */
+    public static int setGreenComponent(@ColorInt int color,
+                                        @IntRange(from = 0x0, to = 0xFF) int green) {
+        return (color & 0xffff00ff) | (green << 8);
+    }
+
+    /**
+     * Set the green component of {@code color} to be {@code green}.
+     *
+     * @param color The color.
+     * @param green Green component \([0..1]\) of the color.
+     * @return the {@code color} with {@code green} component
+     */
+    public static int setGreenComponent(@ColorInt int color,
+                                        @FloatRange(from = 0, to = 1) float green) {
+        return (color & 0xffff00ff) | ((int) (green * 255.0f + 0.5f) << 8);
+    }
+
+    /**
+     * 设置颜色蓝色值
+     * Set the blue component of {@code color} to be {@code blue}.
+     *
+     * @param color The color.
+     * @param blue  Blue component \([0..255]\) of the color.
+     * @return the {@code color} with {@code blue} component
+     */
+    public static int setBlueComponent(@ColorInt int color,
+                                       @IntRange(from = 0x0, to = 0xFF) int blue) {
+        return (color & 0xffffff00) | blue;
+    }
+
+    /**
+     * Set the blue component of {@code color} to be {@code blue}.
+     *
+     * @param color The color.
+     * @param blue  Blue component \([0..1]\) of the color.
+     * @return the {@code color} with {@code blue} component
+     */
+    public static int setBlueComponent(@ColorInt int color,
+                                       @FloatRange(from = 0, to = 1) float blue) {
+        return (color & 0xffffff00) | (int) (blue * 255.0f + 0.5f);
+    }
+
+    /**
+     * 颜色串转颜色值
+     * Color-string to color-int.
+     * <p>Supported formats are:</p>
+     *
+     * <ul>
+     * <li><code>#RRGGBB</code></li>
+     * <li><code>#AARRGGBB</code></li>
+     * </ul>
+     *
+     * <p>The following names are also accepted: <code>red</code>, <code>blue</code>,
+     * <code>green</code>, <code>black</code>, <code>white</code>, <code>gray</code>,
+     * <code>cyan</code>, <code>magenta</code>, <code>yellow</code>, <code>lightgray</code>,
+     * <code>darkgray</code>, <code>grey</code>, <code>lightgrey</code>, <code>darkgrey</code>,
+     * <code>aqua</code>, <code>fuchsia</code>, <code>lime</code>, <code>maroon</code>,
+     * <code>navy</code>, <code>olive</code>, <code>purple</code>, <code>silver</code>,
+     * and <code>teal</code>.</p>
+     *
+     * @param colorString The color-string.
+     * @return color-int
+     * @throws IllegalArgumentException The string cannot be parsed.
+     */
+    public static int string2Int(@NonNull String colorString) {
+        return Color.parseColor(colorString);
+    }
+
+    /**
+     * 颜色值转 RGB 串
+     * Color-int to color-string.
+     *
+     * @param colorInt The color-int.
+     * @return color-string
+     */
+    public static String int2RgbString(@ColorInt int colorInt) {
+        colorInt = colorInt & 0x00ffffff;
+        String color = Integer.toHexString(colorInt);
+        while (color.length() < 6) {
+            color = "0" + color;
+        }
+        return "#" + color;
+    }
+
+    /**
+     * 颜色值转 ARGB 串
+     * Color-int to color-string.
+     *
+     * @param colorInt The color-int.
+     * @return color-string
+     */
+    public static String int2ArgbString(@ColorInt final int colorInt) {
+        String color = Integer.toHexString(colorInt);
+        while (color.length() < 6) {
+            color = "0" + color;
+        }
+        while (color.length() < 8) {
+            color = "f" + color;
+        }
+        return "#" + color;
+    }
+
+    /**
+     * 获取随机色
+     * Return the random color.
+     *
+     * @return the random color
+     */
+    public static int getRandomColor() {
+        return getRandomColor(true);
+    }
+
+    /**
+     * Return the random color.
+     *
+     * @param supportAlpha True to support alpha, false otherwise.
+     * @return the random color
+     */
+    public static int getRandomColor(final boolean supportAlpha) {
+        int high = supportAlpha ? (int) (Math.random() * 0x100) << 24 : 0xFF000000;
+        return high | (int) (Math.random() * 0x1000000);
+    }
+}
+package com.cnlive.core.libs.base.util;
+
+import android.os.Build;
+import android.text.Html;
+import android.util.Base64;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLDecoder;
+import java.net.URLEncoder;
+
+/**
+ * <pre>
+ *     author: Blankj
+ *     blog  : http://blankj.com
+ *     time  : 2016/08/07
+ *     desc  : utils about encode
+ * </pre>
+ */
+public final class EncodeUtils {
+
+    private EncodeUtils() {
+        throw new UnsupportedOperationException("u can't instantiate me...");
+    }
+
+    /**
+     * URL 编码
+     * Return the urlencoded string.
+     *
+     * @param input The input.
+     * @return the urlencoded string
+     */
+    public static String urlEncode(final String input) {
+        return urlEncode(input, "UTF-8");
+    }
+
+    /**
+     * URL 解码
+     * Return the urlencoded string.
+     *
+     * @param input       The input.
+     * @param charsetName The name of charset.
+     * @return the urlencoded string
+     */
+    public static String urlEncode(final String input, final String charsetName) {
+        if (input == null || input.length() == 0) return "";
+        try {
+            return URLEncoder.encode(input, charsetName);
+        } catch (UnsupportedEncodingException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * Return the string of decode urlencoded string.
+     *
+     * @param input The input.
+     * @return the string of decode urlencoded string
+     */
+    public static String urlDecode(final String input) {
+        return urlDecode(input, "UTF-8");
+    }
+
+    /**
+     * Return the string of decode urlencoded string.
+     *
+     * @param input       The input.
+     * @param charsetName The name of charset.
+     * @return the string of decode urlencoded string
+     */
+    public static String urlDecode(final String input, final String charsetName) {
+        if (input == null || input.length() == 0) return "";
+        try {
+            return URLDecoder.decode(input, charsetName);
+        } catch (UnsupportedEncodingException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    /**
+     * Base64 编码
+     * Return Base64-encode bytes.
+     *
+     * @param input The input.
+     * @return Base64-encode bytes
+     */
+    public static byte[] base64Encode(final String input) {
+        return base64Encode(input.getBytes());
+    }
+
+    /**
+     * Return Base64-encode bytes.
+     *
+     * @param input The input.
+     * @return Base64-encode bytes
+     */
+    public static byte[] base64Encode(final byte[] input) {
+        if (input == null || input.length == 0) return new byte[0];
+        return Base64.encode(input, Base64.NO_WRAP);
+    }
+
+    /**
+     * Return Base64-encode string.
+     *
+     * @param input The input.
+     * @return Base64-encode string
+     */
+    public static String base64Encode2String(final byte[] input) {
+        if (input == null || input.length == 0) return "";
+        return Base64.encodeToString(input, Base64.NO_WRAP);
+    }
+
+    /**
+     * Base64 解码
+     * Return the bytes of decode Base64-encode string.
+     *
+     * @param input The input.
+     * @return the string of decode Base64-encode string
+     */
+    public static byte[] base64Decode(final String input) {
+        if (input == null || input.length() == 0) return new byte[0];
+        return Base64.decode(input, Base64.NO_WRAP);
+    }
+
+    /**
+     * Return the bytes of decode Base64-encode bytes.
+     *
+     * @param input The input.
+     * @return the bytes of decode Base64-encode bytes
+     */
+    public static byte[] base64Decode(final byte[] input) {
+        if (input == null || input.length == 0) return new byte[0];
+        return Base64.decode(input, Base64.NO_WRAP);
+    }
+
+    /**
+     * Html 编码
+     * Return html-encode string.
+     *
+     * @param input The input.
+     * @return html-encode string
+     */
+    public static String htmlEncode(final CharSequence input) {
+        if (input == null || input.length() == 0) return "";
+        StringBuilder sb = new StringBuilder();
+        char c;
+        for (int i = 0, len = input.length(); i < len; i++) {
+            c = input.charAt(i);
+            switch (c) {
+                case '<':
+                    sb.append("&lt;"); //$NON-NLS-1$
+                    break;
+                case '>':
+                    sb.append("&gt;"); //$NON-NLS-1$
+                    break;
+                case '&':
+                    sb.append("&amp;"); //$NON-NLS-1$
+                    break;
+                case '\'':
+                    //http://www.w3.org/TR/xhtml1
+                    // The named character reference &apos; (the apostrophe, U+0027) was
+                    // introduced in XML 1.0 but does not appear in HTML. Authors should
+                    // therefore use &#39; instead of &apos; to work as expected in HTML 4
+                    // user agents.
+                    sb.append("&#39;"); //$NON-NLS-1$
+                    break;
+                case '"':
+                    sb.append("&quot;"); //$NON-NLS-1$
+                    break;
+                default:
+                    sb.append(c);
+            }
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Html 解码
+     * Return the string of decode html-encode string.
+     *
+     * @param input The input.
+     * @return the string of decode html-encode string
+     */
+    @SuppressWarnings("deprecation")
+    public static CharSequence htmlDecode(final String input) {
+        if (input == null || input.length() == 0) return "";
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            return Html.fromHtml(input, Html.FROM_HTML_MODE_LEGACY);
+        } else {
+            return Html.fromHtml(input);
+        }
+    }
+
+    /**
+     * Return the binary encoded string padded with one space
+     *
+     * @param input
+     * @return binary string
+     */
+    public static String binEncode(final String input) {
+        StringBuilder stringBuilder = new StringBuilder();
+        for (char i : input.toCharArray()) {
+            stringBuilder.append(Integer.toBinaryString(i));
+            stringBuilder.append(' ');
+        }
+        return stringBuilder.toString();
+    }
+
+    /**
+     * 编码解码相关
+     * Return UTF-8 String from binary
+     *
+     * @param input binary string
+     * @return UTF-8 String
+     * urlEncode          : URL 编码
+     * urlDecode          : URL 解码
+     * base64Encode       : Base64 编码
+     * base64Encode2String: Base64 编码
+     * base64Decode       : Base64 解码
+     * htmlEncode         : Html 编码
+     * htmlDecode         : Html 解码
+     */
+    public static String binDecode(final String input) {
+        String[] splitted = input.split(" ");
+        StringBuilder sb = new StringBuilder();
+        for (String i : splitted) {
+            sb.append(((char) Integer.parseInt(i.replace(" ", ""), 2)));
+        }
+        return sb.toString();
+    }
+}