Android关闭指定的Activity或多个Activity

接触过Android的应该都知道关闭一个Activity直接调用finish()就好啦！但项目中偶尔会遇到在某个Activity中关闭另一个Activity的需求。举个栗子，比如开发某个APP，用户从“登录界面A”跳转到“主界面B”，然后在“主界面B”跳转到"个人中心C"，此时用户在"个人中心C"点击了“注销”按钮，那么这个时候应该是要跳转到“登录界面A”，并且“主界面B”和“个人中心界面C”都应该关闭，只保留登录界面A，否则用户点击返回的时候还可以返回主界面那就不是我们想要的了。那么问题来了从"个人中心C"跳转的时候关闭当前"个人中心C界面"直接finish就好了，但如何在"个人中心C"界面finish"主界面B"呢?

方式一：

在Activity中声明一个Activity类型的静态变量，onCreate的时候赋上当前的Activity对象，在需要关闭这个Activity的时候直接调用这个Activity类型的静态变量finish掉

需要关闭的Activity代码：

public class TestActivity extends Activity{

  public static TestActivity testActivity;

  protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        testActivity=this;
    }
  
}

在其他地方关闭TestActivity时调用：

if(TestActivity.testActivity!=null){
    TestActivity.testActivity.finish();
}

这种方式针对只关闭一两个特定Activity倒还算简单方便，假如APP界面多了之后，要求用户点击注销后跳转到登录界面，并且关闭除登录界面外其他所有Activity的话，或者类似这种要求同时关闭多个Activity的需求，这种方式就比较麻烦了，总不能在每个Activity都加上这么一段，然后调用的时候一个一个关？显然太繁琐。

方式二：

这也是网上比较常用的方式，创建一个Activity的集合，对所有的Activity进行统一的管理。

大致思路：创建一个存放Activity对象的集合，当某个Activity创建时就在集合里面添加当前的Activity，当某个Activity销毁时就在集合里面清除掉当前Activity，这样集合里面存在的都是未销毁的Activity对象，我们需要的时候就可以针对这些对象进行操作。

第一步:

创建一个ActivityCollector的工具类，声明一个存放Activity对象的集合，当然这个集合肯定得是单例的。然后在ActivityCollector中添加从集合删除、添加Activity对象的方法

kotlin代码：

/**
 * 一个专门对所有的活动（ Activity）进行管理的
 */
object ActivityCollector {

    var activities  = mutableListOf<Activity>()

    /**
     * 添加Activity
     * @param activity 添加的Activity对象
     */
    fun addActivity(activity: Activity) {
        activities.add(activity)
    }

    /**
     * 删除Activity
     * @param activity 删除的Activity对象
     */
    fun removeActivity(activity: Activity) {
        activities.remove(activity)
    }

}

java代码：

/**
 *一个专门的集合类对所有的活动（ Activity）进行管理
 *
 * */
public class ActivityCollector {

    public static List<Activity> activities = new ArrayList<Activity>();

    /**
     * 添加Activity
     * @param activity 添加的Activity对象
     * */
    public static void addActivity(Activity activity) {
        activities.add(activity);
    }

    /**
     * 删除Activity
     * @param activity 删除的Activity对象
     * */
    public static void removeActivity(Activity activity) {
        activities.remove(activity);
    }

}

第二步：

创建一个自定义的Activity类MyActivity，其他所有界面的Activity都继承MyActivity，并且在MyActivity的onCreate()生命周期中调用ActivityCollector的addActivity()方法，在MyActivity的onDestroy()生命周期中调用ActivityCollector的removeActivity()方法。这样每创建一个Activity都会在Activity的集合activities中添加一个当前Activity对象，每销毁一个Activity都会从activities中清除掉当前Activity。

kotlin代码：

open class MyActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        //添加activity到活动管理器
        ActivityCollector.addActivity(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        //从activity的活动管理器清除
        ActivityCollector.removeActivity(this)
    }
}

java代码：

public class MyActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //在活动管理器添加当前Activity
        ActivityCollector.addActivity(this);
    }

  
    @Override
    protected void onDestroy() {
        super.onDestroy();
        //从活动管理器删除当前Activity
        ActivityCollector.removeActivity(this);
    }
}

不要忘了要将其他Activity都继承MyActivity，这个活动管理器才会有意义。

第三步：

在活动管理器ActivityCollector中添加各种方法用于管理Activity。

比如：关闭某个指定的Activity，那我们就在ActivityCollector中添加一个关闭指定Activity的方法

kotlin代码：

    /**
     * 关闭指定的Activity
     * @param activityName 需要关闭的Activity类名
     */
    fun finishOneActivity(activityName: String) {
        //在activities集合中找到类名与指定类名相同的Activity就关闭
        for (activity in activities) {
            val name = activity.javaClass.name//activity的类名
            if (name == activityName) {
                if(activity.isFinishing){
                    activities.remove(activity)
                }else{
                    activity.finish()
                }
            }
        }
    }

java代码：

    /**
     * 关闭指定的Activity
     * @param activityName 需要关闭的Activity包名类名
     * */
    public static void finishOneActivity(String activityName){
        //在activities集合中找到类名与指定类名相同的Activity就关闭
        for (Activity activity : activities){
            String name= activity.getClass().getName();//activity的包名+类名
            if(name.equals(activityName)){
                if(activity.isFinishing()){
                    //当前activity如果已经Finish，则只从activities清除就好了
                    activities.remove(activity);
                } else {
                    //没有Finish则Finish
                    activity.finish();
                }
            }
        }
    }

调用：

kotlin：

//关闭Test2Acticity
ActivityCollector.finishOneActivity(Test2Acticity::class.java.name)

java:

//关闭Test2Acticity
ActivityCollector.finishOneActivity(Test2Acticity.class.getName())

再比如：只保留某个Activity，关闭其他所有Activity

kotlin代码：

    /**
     * 只保留某个Activity，关闭其他所有Activity
     * @param activityName 要保留的Activity类名
     */
    fun finishOtherActivity(activityName: String) {

        for (activity in activities) {
            val name = activity.javaClass.name //activity的类名
            if (name != activityName) {
                if(activity.isFinishing){
                    activities.remove(activity)
                }else{
                    activity.finish()
                }
            }
        }
    }

java代码：

    /**
     * 只保留某个Activity，关闭其他所有Activity
     * @param activityName 要保留的Activity类名
     * */
    public static void finishOtherActivity(String activityName){
        for (Activity activity : activities){
           String name= activity.getClass().getName();//activity的类名
            if(!name.equals(activityName)){
                if(activity.isFinishing()){
                    //当前activity如果已经Finish，则只从activities清除就好了
                    activities.remove(activity);
                } else {
                    //没有Finish则Finish
                    activity.finish();
                }
            }
        }
    }

调用和上面那个方法类似，我就不写了，大家如此聪明我就懒一点。写到这里我想如果再需要延伸一些什么需求大家应该也能举一反三了。

贴上ActivityCollector类的完整代码

kotlin代码：

/**
 * 一个专门对所有的活动（ Activity）进行管理的
 */
object ActivityCollector {

    var activities  = mutableListOf<Activity>()

    /**
     * 添加Activity
     * @param activity 添加的Activity对象
     */
    fun addActivity(activity: Activity) {
        activities.add(activity)
    }

    /**
     * 删除Activity
     * @param activity 删除的Activity对象
     */
    fun removeActivity(activity: Activity) {
        activities.remove(activity)
    }

    /**
     * 关闭指定的Activity
     * @param activityName 需要关闭的Activity类名
     */
    fun finishOneActivity(activityName: String) {
        //在activities集合中找到类名与指定类名相同的Activity就关闭
        for (activity in activities) {
            val name = activity.javaClass.name//activity的类名
            if (name == activityName) {
                if(activity.isFinishing){
                    activities.remove(activity)
                }else{
                    activity.finish()
                }
            }
        }
    }

    /**
     * 只保留某个Activity，关闭其他所有Activity
     * @param activityName 要保留的Activity类名
     */
    fun finishOtherActivity(activityName: String) {

        for (activity in activities) {
            val name = activity.javaClass.name //activity的类名
            if (name != activityName) {
                if(activity.isFinishing){
                    activities.remove(activity)
                }else{
                    activity.finish()
                }
            }
        }
    }

    /**
     * 关闭所有Activity
     */
    fun finishAll() {
        for (activity in activities) {
            if (!activity.isFinishing) {
                activity.finish()
            }
        }
        activities.clear()
    }


}

java代码：

/**
 *一个专门的集合类对所有的活动（ Activity）进行管理
 *
 * */
public class ActivityCollector {

    public static List<Activity> activities = new ArrayList<Activity>();

    /**
     * 添加Activity
     * @param activity 添加的Activity对象
     * */
    public static void addActivity(Activity activity) {
        activities.add(activity);
    }

    /**
     * 删除Activity
     * @param activity 删除的Activity对象
     * */
    public static void removeActivity(Activity activity) {
        activities.remove(activity);
    }

    /**
     * 关闭指定的Activity
     * @param activityName 需要关闭的Activity包名类名
     * */
    public static void finishOneActivity(String activityName){
        //在activities集合中找到类名与指定类名相同的Activity就关闭
        for (Activity activity : activities){
            String name= activity.getClass().getName();//activity的包名+类名
            if(name.equals(activityName)){
                if(activity.isFinishing()){
                    //当前activity如果已经Finish，则只从activities清除就好了
                    activities.remove(activity);
                } else {
                    //没有Finish则Finish
                    activity.finish();
                }
            }
        }
    }

    /**
     * 只保留某个Activity，关闭其他所有Activity
     * @param activityName 要保留的Activity类名
     * */
    public static void finishOtherActivity(String activityName){
        for (Activity activity : activities){
           String name= activity.getClass().getName();//activity的类名
            if(!name.equals(activityName)){
                if(activity.isFinishing()){
                    //当前activity如果已经Finish，则只从activities清除就好了
                    activities.remove(activity);
                } else {
                    //没有Finish则Finish
                    activity.finish();
                }
            }
        }
    }


    /**
     * 关闭所有Activity
     * */
    public static void finishAll() {
        for (Activity activity : activities) {
            if (!activity.isFinishing()) {
                activity.finish();
            }
        }
        activities.clear();
    }



}