管理Activity和Fragment（通过Stack<？>来进行管理）

    今天无意间看了一个开源代码，第一次用到，也是第一次看见Stack<?>这个玩意，以前都是自己通过List<?>自定义管理Activity 和Fragment，用起来确实也好用，但是感觉没有Stack<?>好用。毕竟它（Statc<?> ）是java所提供的工具类 

 看看代码：

1、管理Actvity（添加Actvity、移除当前Activity、移除指定Activity、移除所有Activity、获取当前Actvity、退出程序）

import java.util.Stack;
import android.app.Activity;

/**
 * @name 管理activity 工具类 （添加Activity ， 移除当前Activity ， 移除指定的Activity ，
 *       移除所有的Activity ，获得当前的Activity 。）
 * 
 *       fragment 也可以这么做
 * 
 * 
 * @author xuyifei
 * 
 */

public class AppManager {

	private Stack<Activity> activities = null;

	private static AppManager instance;

	public static AppManager getAppManager() {
		if (instance == null) {
			instance = new AppManager();
		}
		return instance;

	}

	/**
	 * @name 添加activity 到堆栈中去
	 */

	public void addActivity(Activity activity) {
		if (activities == null) {
			activities = new Stack<Activity>();
		}
		activities.add(activity);
	}

	/**
	 * 获取当前activity（堆栈中最后一个 压入的）
	 */
	public Activity currentActivity() {

		Activity lastElement = activities.lastElement();
		return lastElement;
	}

	/**
	 * 结束当前Activity（堆栈中最后一个 压入的）
	 */
	public void finishActivity() {
		Activity lastElement = activities.lastElement();
		finishActivity(lastElement);
	}

	/**
	 * 结束指定类名的Activity（getClass）
	 */

	public void finishActivity(Class<?> cls) {
		for (Activity activity : activities) {
			if (activity.getClass().equals(cls)) {
				finishActivity(activity);

			}
		}
	}

	/**
	 * 结束指定的activtiy
	 */
	public void finishActivity(Activity activity) {
		if (activity != null) {
			activities.remove(activity);
			activity.finish();
			activity = null;
		}
	}

	/**
	 * 结束所有Actvity
	 */

	public void finishAllActivity() {
		for (int i = 0, size = activities.size(); i < size; i++) {
			if (activities.get(i) != null) {
				activities.get(i).finish();
			}
		}
		activities.clear();
	}
}

管理fragment（这个是拷贝别人，步骤和管理Activity一样）

/**
 * @author lee0000
 */

public class FraManager {
    private static Stack<Fragment> fragmentStack;
    private static FraManager instance;
    private static final Object obj = new Object();

    private FraManager() {
    }

    /**
     * 单一实例
     */
    public static FraManager getFraManager() {
        if (instance == null) {
            synchronized (obj) {
                if (instance == null) {
                    instance = new FraManager();
                }
            }
        }
        return instance;
    }
    
    /**
     * 添加Fragment到堆栈
     */
    public static void pushFragment(FragmentActivity fact, Fragment fragment, int layoutID, String... title){
        if(fragmentStack==null){
            fragmentStack=new Stack<Fragment>();
        }
        fragmentStack.push(fragment);
        FragmentTransaction ft = fact.getSupportFragmentManager().beginTransaction();
        
        ft.replace(layoutID, fragment);
        if (fragmentStack.size() > 1) {
            ft.addToBackStack(null);
        }
        ft.commit();
    }
    
    /**
     * 弹出Fragment
     */
    public static Fragment popFragment(FragmentActivity fact) {
        Fragment fragment = fragmentStack.pop();
        FragmentTransaction ft = fact.getSupportFragmentManager().beginTransaction();
        ft.remove(fragment);
        ft.commit();
        return fragment;
    }
    
    /***
     * 弹出指定Activity中所有的fragment
     * */
    public static void finishFragment(FragmentActivity fact){
        for (int i = 0, size = fragmentStack.size(); i < size; i++){
            Fragment stackFragment = fragmentStack.get(i);
            if (null != stackFragment){
                Fragment fragment = stackFragment;
                if (fact == fragment.getActivity()) {
                    FragmentTransaction ft = fragment.getFragmentManager().beginTransaction();
                    ft.remove(fragment);
                    fragmentStack.remove(i);
                    ft.commit();
                }
            }
        }
    }
    
    /**
     * 清除栈中所有的项
     * */
    public static void clearStack(){
        if (fragmentStack != null && fragmentStack.isEmpty()) {
            fragmentStack.clear();
        }
    }
}