本人最新公眾號《Android百科全書》，彙集了各個公眾號的優秀文章，進行分類整理，讓大家能夠更方便的查閱，希望大家多多支援，來個關注奧。

在開發過程中，我們常常會用到一個常用的東西，就是activity棧，這個東西得作用就是處理邏輯，在某些情況下直接可以將所有的activity關閉，或者只保留1個指定的activity。

但是很多的棧管理器都是使用強引用寫的，這樣就容易引起app崩潰，因為activity在某些時候回被系統回收，然後返回後重新建立，這時弱引用的優勢就來了，就是他不會直接使用該物件（強引用會），你可以判斷他要使用的物件是否為空，這時，很多的崩潰情況就可以被避免了，下面上程式碼：

/**
 * Author: 姚智勝
 * Version: V1.0版本
 * Description: activity棧管理器
 * Date: 2017/04/22.
 */

public class ActivityStackManager {
    private static final String TAG = "ActivityStackManager";
    /**
     * Activity棧
     */
    private Stack<WeakReference<Activity>> mActivityStack;

    private
 
 static ActivityStackManager activityStackManager = new ActivityStackManager();


    private ActivityStackManager() {
    }

    /***
     * 獲得AppManager的例項
     *
     * @return AppManager例項
     */
    public static ActivityStackManager getInstance() {
        if (activityStackManager == null) {
            activityStackManager
 
 = new ActivityStackManager();
        }
        return activityStackManager;
    }


    /***
     * 棧中Activity的數
     *
     * @return Activity的數
     */
    public int stackSize() {
        return mActivityStack.size();
    }

    /***
     * 獲得Activity棧
     *
     * @return Activity棧
     */
    public Stack<WeakReference<Activity>> getStack() {
        return mActivityStack;
    }


    /**
     * 新增Activity到堆疊
     */
    public void addActivity(WeakReference<Activity> activity) {
        if (mActivityStack == null) {
            mActivityStack = new Stack<>();
        }
        mActivityStack.add(activity);
    }

    /**
     * 刪除ac
     *
     * @param activity 弱引用的ac
     */
    public void removeActivity(WeakReference<Activity> activity) {
        if (mActivityStack != null) {
            mActivityStack.remove(activity);
        }
    }

    /***
     * 獲取棧頂Activity（堆疊中最後一個壓入的）
     *
     * @return Activity
     */
    public Activity getTopActivity() {
        Activity activity = mActivityStack.lastElement().get();
        if (null == activity) {
            return null;
        } else {
            return mActivityStack.lastElement().get();
        }
    }

    /***
     * 通過class 獲取棧頂Activity
     *
     * @param cls
     * @return Activity
     */
    public Activity getActivityByClass(Class<?> cls) {
        Activity return_activity = null;
        for (WeakReference<Activity> activity : mActivityStack) {
            if (activity.get().getClass().equals(cls)) {
                return_activity = activity.get();
                break;
            }
        }
        return return_activity;
    }

    /**
     * 結束棧頂Activity（堆疊中最後一個壓入的）
     */
    public void killTopActivity() {
        try {
            WeakReference<Activity> activity = mActivityStack.lastElement();
            killActivity(activity);
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }

    /***
     * 結束指定的Activity
     *
     * @param activity
     */
    public void killActivity(WeakReference<Activity> activity) {
        try {
            Iterator<WeakReference<Activity>> iterator = mActivityStack.iterator();
            while (iterator.hasNext()) {
                WeakReference<Activity> stackActivity = iterator.next();
                if (stackActivity.get() == null) {
                    iterator.remove();
                    continue;
                }
                if (stackActivity.get().getClass().getName().equals(activity.get().getClass().getName())) {
                    iterator.remove();
                    stackActivity.get().finish();
                    break;
                }
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }


    /***
     * 結束指定類名的Activity
     *
     * @param cls
     */
    public void killActivity(Class<?> cls) {
        try {

            ListIterator<WeakReference<Activity>> listIterator = mActivityStack.listIterator();
            while (listIterator.hasNext()) {
                Activity activity = listIterator.next().get();
                if (activity == null) {
                    listIterator.remove();
                    continue;
                }
                if (activity.getClass() == cls) {
                    listIterator.remove();
                    if (activity != null) {
                        activity.finish();
                    }
                    break;
                }
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }

    /**
     * 結束所有Activity
     */
    public void killAllActivity() {
        try {
            ListIterator<WeakReference<Activity>> listIterator = mActivityStack.listIterator();
            while (listIterator.hasNext()) {
                Activity activity = listIterator.next().get();
                if (activity != null) {
                    activity.finish();
                }
                listIterator.remove();
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }


    /**
     * 移除除了某個activity的其他所有activity
     *
     * @param cls 介面
     */
    public void killAllActivityExceptOne(Class cls) {
        try {
            for (int i = 0; i < mActivityStack.size(); i++) {
                WeakReference<Activity> activity = mActivityStack.get(i);
                if (activity.getClass().equals(cls)) {
                    break;
                }
                if (mActivityStack.get(i) != null) {
                    killActivity(activity);
                }
            }
        } catch (Exception e) {
            Log.e(TAG, e.getMessage());
        }
    }

    /**
     * 退出應用程式
     */
    public void AppExit(Context context) {
        killAllActivity();
        Process.killProcess(Process.myPid());
    }

}

趕快試試吧，如果你感興趣，可以看看我在github的開源專案：

直通車

裡面有很多實用的東西去看看吧，喜歡的話給個star呀

本部落格不定期更新╮(╯▽╰)╭╮(╯▽╰)╭