开发的时候，有时候Fragment的切换，是不需要对原先的Fragment进行重新加载的。而Fragment的界面是既可以进行重新加载，也可以不进行重新加载。
每次重新加载的话，我们是使用的replace来进行fragment的替换的。
如果，不对fragment的数据进行重新加载的话，那么就用add来添加fragment，显示的时候用show，切换的时候用hide掉当前的，show切换的目标。
具体的实现代码如下：

private FragmentManager fm;
private FragmentTransaction ft;
//之前显示的fragment
public Fragment mContent, fragment_in, fragment_qm, fragment_se;
//三个fragment
fragment_in = new MakePlanFragment();
fragment_qm = new CourseFragment();
fragment_se = new MakePlanFragment();
setDefaultFragment(fragment_in);
设置默认的fragment的显示。没有切换的时候显示的fragment。


public void setDefaultFragment(Fragment fragment) {
    fm = getFragmentManager();
    ft = fm.beginTransaction();
    ft.add(R.id.fragment_content, fragment).commit();
    mContent = fragment;
}
//切换fragment的显示隐藏
public void switchContent(Fragment to) {
    if (mContent != to) {
        fm = getFragmentManager();
        ft = fm.beginTransaction();
        if (!to.isAdded()) {    // 先判断是否被add过
            ft.hide(mContent).add(R.id.fragment_content, to).commit(); // 隐藏当前的fragment，add下一个到Activity中
        } else {
            ft.hide(mContent).show(to).commit(); // 隐藏当前的fragment，显示下一个
        }
        mContent = to;
    }
}
上面的这个switchContent的方法就是切换fragment的方法封装。在使用的地方，直接传入我们需要的目标fragment即可。如下：


switchContent(fragment_in);
传参为我们要切换的目标fragment。这样就实现了我们的切换fragment，但是不重新进行加载。



如果要进行重新加载，关键代码如下：

fm = getFragmentManager();
ft = fm.beginTransaction();
ft.replace(R.id.fragment_content, fragment_in);
ft.commit();
这就是重载与不重新加载的区别。理解了本质就简单多了。

在项目中需要进行Fragment的切换，一直都是用replace()方法来替换Fragment
但是，这样会有一个问题 ，应该很多朋友都遇到过：
每次切换的时候，Fragment都会重新实例化，也就是运行OnCreatVIew()方法
那么如何让多个Fragment彼此切换时不重新实例化？
正确的切换方式是add()，切换时hide()，add()另一个Fragment，再次切换时，只需hide()当前，show()另一个。
//之前显示的fragment
        private Fragment mContent;
        /** 修改显示的内容 不会重新加载 **/
        public void switchContent(Fragment to) {
                if (mContent != to) {
                        FragmentTransaction transaction = getSupportFragmentManager()
                                        .beginTransaction();
                        if (!to.isAdded()) { // 先判断是否被add过
                                transaction.hide(mContent).add(R.id.content, to).commit(); // 隐藏当前的fragment，add下一个到Activity中
                        } else {
                                transaction.hide(mContent).show(to).commit(); // 隐藏当前的fragment，显示下一个
                        }
                        mContent = to;
                }
                showContent();
        }
转载于:https://www.cnblogs.com/changkai244/p/4110164.html

前言：如果不做fragment的懒加载则每次进入activity就会初始化没必要的数据，消耗内存和网络流量，再每次自动销毁后也需要重新初始化fragment的数据，为此优化，我们要做fragment的懒加载，网络上关于懒加载的文章数不胜数，可是详细、全面，又有实际源码和例子的很少，下面是我摘抄的技术代码，原文地址见文章下面. 

         PagerFragment里面适配的fragment只需要继承自LazyFragment处理懒加载关系，而LazyFragment继承自BaseFragment，BaseFragment处理fragment初始化控件和fragment销毁时和activity分离的事情 

下面献上LazyFragment的源码:

public class LazyFragment extends BaseFragment
{
    private boolean isInit=false;//真正要显示的view是否已经被初始化(正常加载)
    private Bundle savedInstancseState;
    public static final String INTENT_BOOLEAN_LAZYLOAD="intent_boolean_lazyLoad";
    private boolean isLazyLoad=true;//默认状态需要懒加载
    private FrameLayout layout;
    private boolean isStart=false;// 是否处于可见状态，in the screen
    @override 
    protected final void onCreateView(Bundle savedInstancseState)
    {
        super.onCreateView(savedInstancseState);
        Bundle bundle=getArguments();
        if(bundle!=null)
        {
            isLazyLoad=bundle.getBoolean(INTENT_BOOLEAN_LAZYLOAD,isLazyLoad);
        }
        //判断是否懒加载 
        if(isLazyLoad)
        { 
            //一旦isVisibleToUser==true即可对真正需要的显示内容进行加载
            if(getUserVisibleHint()&&!isInint)
            {
                this.savedInstancseState=savedInstancseState;
                onCreateViewLazy(savedInstancseState);
                isInint=true;
            }else{
                 //进行懒加载
                 layout=new FrameLayout(getApplicationContext);
                 layout.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT,LayoutParams.MATCH_PARENT));
                 View view=LayoutInflater.from(getApplicationContext()).inflate(R.layout.fragment_lazy_loading,null);
                 layout.addView(view);
                 super.setContentView(layout);
            }
        }else
        {
             //不需要懒加载，开门见山，调用onCreateViewLazy正常加载显示内容即可
             onCreateViewLazy(savedInstancseState);
             isInint=true;
        }
    }
    @override
    public void setUserVisibleHint(boolean isVisibleToUser)
    {
       super.setUserVisibleHint(isVisibleToUser);
       Log.d("TAG", "setUserVisibleHint() called with: " + "isVisibleToUser = [" + isVisibleToUser + "]");
       //一旦isVisibleToUser==true即可进行对真正需要的显示内容的加载
       //可见，但还没被初始化
       if(isVisibleToUser&&!isInint&&getContentView()!=null)
       {
           onCreateViewLazy(savedInstancseState);
           isInint=true;
           onResumeLazy();//TODO 
       }
       //已经被初始化(正常加载)过了
       if(isInint&&getContentView!=null)
       {
          if(isVisibleToUser)
          {
             isStart=true;
             onFragmentStartLazy();//TODO
          }else{
              isStart=false;
              onFragmentStopLazy();
          }
       }
       @override
       public void setContentView(int layoutResID)
       {
           //判断若isLazyLoad=true,移除所有lazy view，加载真正要显示的view
           if(isLazyLoad&&getContentView()!=null&&getContentView().getParent()!=null)
           {
                layout.removeAllViews();
                View view=inflater.inflate(layoutResID,layout,false);
                layout.addView(view);
           }else
           {
               super.setContentView(layoutResID);
           }
       }
       @override
       public void setContentView(View view)
       {
           //判断若isLazyLoad=true,移除所有lazy view，加载真正要显示的view
           if(isLazyLoad&&getContentView()!=null&&getContentView().getParent!=null)
           {
              layout.removeAllViews();
              layout.addView(view);
           }else
           {
               //否则开门见山，直接加载
               super.setContentView(view);
           }
       }
       @override
       public final void onStart()
       {
             Log.d("TAG", "onStart() : " + "getUserVisibleHint():" + getUserVisibleHint());
             super.onStart();
             if(isInit&&!isStart&&getUserVisibleHint())
             {
                isStart=true;
                onFragmentStartLazy();
             }
       }
    //当Fragment被滑到可见的位置时，调用
    protected void onFragmentStartLazy() {
        Log.d("TAG", "onFragmentStartLazy() called with: " + "");
    }

        @override
        public final void onStop()
        {
           super.onStop();
           if(isInit&&isStart&&getUserVisibleHint())
           {
              isStart=false;
              onFragmentStopLazy();
           }
        }
         @Override
    @Deprecated
    public final void onResume() {
        Log.d("TAG", "onResume() : " + "getUserVisibleHint():" + getUserVisibleHint());
        super.onResume();
        if (isInit) {
            onResumeLazy();
        }
    }
     @Override
    @Deprecated
    public final void onResume() {
        Log.d("TAG", "onResume() : " + "getUserVisibleHint():" + getUserVisibleHint());
        super.onResume();
        if (isInit) {
            onResumeLazy();
        }
    }

    @Override
    @Deprecated
    public final void onPause() {
        Log.d("TAG", "onPause() : " + "getUserVisibleHint():" + getUserVisibleHint());
        super.onPause();
        if (isInit) {
            onPauseLazy();
        }
    }
     @Override
    @Deprecated
    public final void onDestroyView() {
        Log.d("TAG", "onDestroyView() : " + "getUserVisibleHint():" + getUserVisibleHint());
        super.onDestroyView();
        if (isInit) {
            onDestroyViewLazy();
        }
        isInit = false;
    }

     //当Fragment被滑到不可见的位置，offScreen时，调用
    protected void onFragmentStopLazy() {
        Log.d("TAG", "onFragmentStopLazy() called with: " + "");
    }

    protected void onCreateViewLazy(Bundle savedInstanceState) {
        Log.d("TAG", "onCreateViewLazy() called with: " + "savedInstanceState = [" + savedInstanceState + "]");
    }

    protected void onResumeLazy() {
        Log.d("TAG", "onResumeLazy() called with: " + "");
    }

    protected void onPauseLazy() {
        Log.d("TAG", "onPauseLazy() called with: " + "");
    }

    protected void onDestroyViewLazy() {

    }



}

Basefragment的源码如下:



public class BaseFragment extends Fragment
{
    protected LayoutInflater inflater;
    private View contentView;
    private Context context;
    private ViewGroup container;
    @override 
    public void onCreate(Bundle savedInstanceState)
    {
       super.onCreate(savedInstanceState);
       context=getActivity().getApplicationContext();
    }
    //子类通过重写onCreateView，调用setContentView进行布局设置，否者contentView==null,返回Null
    @override
    public final View onCreateView(LayoutInflater inflater,ViewGroup container,Bundle savedInstanceState)
    {
       this.inflater=inflater;
       this.container=container;
       onCreateView(savedInstanceState);
       if(contentView==null)
          return super.onCreateView(inflater,container,savedInstanceState);
    return contentView;
    }
    protected void onCreateView(Bundle savedInstanceState)
    {

    }
    @override
    public void onDestroyView()
    {
       super.onDestroyView();
       contentView=null;
       container=null;
       inflater=null;
    }
    public Context getApplicationContex()
    {
       return context;
    }
    public void setContentView(int layoutResID)
    {
       setContetnView((ViewGroup)inflater.inflate(layoutResID,container,false));
    }
    public void setContentView(View view)
    {
       contentView=view;
    }
    public void getContentView()
    {
      return contentView;
    }
    public View findViewById(int id)
    {
       if(contentView!=null)
       {
          return contentView.findViewById(id);
       }
       return null;
    }
     // http://stackoverflow.com/questions/15207305/getting-the-error-java-lang-illegalstateexception-activity-has-been-destroyed
    @Override
    public void onDetach() {
        Log.d("TAG", "onDetach() : ");
        super.onDetach();
        try {
            Field childFragmentManager = Fragment.class.getDeclaredField("mChildFragmentManager");
            childFragmentManager.setAccessible(true);
            childFragmentManager.set(this, null);

        } catch (NoSuchFieldException e) {
            throw new RuntimeException(e);
        } catch (IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public void onDestroy() {
        Log.d("TAG", "onDestroy() : ");
        super.onDestroy();
    }

}

亲测有效 

                                                备注:转载地址                         (http://www.jianshu.com/p/8a772b9df6d5)

最近在项目中使用ViewPager＋Fragment实现左右两个滑动切换界面。但是遇到一个问题：在不退出当前Activity的情况下，重新加载Fragment，却得到了空白界面，并没有生成新的Fragment添加进去。

这个问题可能是由于旧的Fragment没有被清除导致的。

查看了 FragmentPagerAdapter 类的创建实例的函数 instantiateItem ：

@NonNull
    public Object instantiateItem(@NonNull ViewGroup container, int position) {
        if (this.mCurTransaction == null) {
            this.mCurTransaction = this.mFragmentManager.beginTransaction();
        }

        long itemId = this.getItemId(position);
        String name = makeFragmentName(container.getId(), itemId);
        Fragment fragment = this.mFragmentManager.findFragmentByTag(name);
        if (fragment != null) {
            this.mCurTransaction.attach(fragment);
        } else {
            fragment = this.getItem(position);
            this.mCurTransaction.add(container.getId(), fragment, makeFragmentName(container.getId(), itemId));
        }

        if (fragment != this.mCurrentPrimaryItem) {
            fragment.setMenuVisibility(false);
            fragment.setUserVisibleHint(false);
        }

        return fragment;
    }

我们看到这个函数会先检查是否已经存在了这样一个Fragment，如果不存在才会去调用 getItem 方法产生一个新的Fragment。所以我们可以利用类似的方法先去FragmentManager中清除对应的Fragment，然后再让适配器重新加载新Fragment。如下我们重写 FragmentPagerAdapter 类：

public class ViewMaterialFragmentPagerAdapter extends FragmentPagerAdapter {

    private FragmentManager mFragmentManager;
    private FragmentTransaction mCurTransaction;
    private Context mContext;
    private List<Fragment> mFragmentArrayList;
    private int[] pagerTitles = new int[]{R.string.text_material_qr_code, R.string.text_material_list};


    public ViewMaterialFragmentPagerAdapter(FragmentManager fm, Context ctx, List<Fragment> fragments) {
        super(fm);
        mFragmentManager = fm;
        mContext = ctx;
        mFragmentArrayList = fragments;
    }


    @Override
    public Fragment getItem(int i) {
        return mFragmentArrayList.get(i);
    }

    @Override
    public int getCount() {
        return mFragmentArrayList.size();
    }

    @Override
    public CharSequence getPageTitle(int position) {
        return mContext.getString(pagerTitles[position]);
    }

    @NonNull
    @Override
    public Object instantiateItem(@NonNull ViewGroup container, int position) {
        return super.instantiateItem(container, position);
    }

    /**
     * 清除缓存fragment
     * @param container ViewPager
     */
    public void clear(ViewGroup container){
        if (this.mCurTransaction == null) {
            this.mCurTransaction = this.mFragmentManager.beginTransaction();
        }

        for(int i=0;i<mFragmentArrayList.size();i++){
            long itemId = this.getItemId(i);
            String name = makeFragmentName(container.getId(), itemId);
            Fragment fragment = this.mFragmentManager.findFragmentByTag(name);
            if(fragment != null){//根据对应的ID，找到fragment，删除
                mCurTransaction.remove(fragment);
            }
        }
        mCurTransaction.commitNowAllowingStateLoss();
    }

    /**
     * 等同于FragmentPagerAdapter的makeFragmentName方法，
     * 由于父类的该方法是私有的，所以在此重新定义
     * @param viewId
     * @param id
     * @return
     */
    private static String makeFragmentName(int viewId, long id) {
        return "android:switcher:" + viewId + ":" + id;
    }
}

代码重点是 clear 方法，只要在需要销毁已经加载过得Fragment的地方，调用这个clear方法，再让ViewPager重新设置适配器即可。

pagerAdapter.clear(mViewPager);

mViewPager.setAdapter(pagerAdapter);

clear 方法中的 makeFragmentName 方法，可以在 FragmentPagerAdapter 类源码中找到，此处的makeFragmentName与源码中一模一样，只是由于这个方法在源码中私有的，我就暂且复制过来使用吧，当然也可以使用反射调用。

 

############ 好了，调大音量，听首歌吧 ~ ###############