BasePagerAdapter是什么?你应该使用一个标准的寻页适配器——FragmentPagerAdapter或FragmentStatePagerAdapter，这取决于你是否想要ViewPager不再需要的片段被保留(前者)或保存它们的状态(后者)并在再次需要时重新创建。

使用ViewPager的示例代码可以在这里找到

的确，跨活动实例管理视图寻呼机中的片段有点复杂，因为框架中的FragmentManager负责保存状态并恢复寻呼机所生成的任何活动片段。这实际上意味着，适配器在初始化时需要确保它与任何恢复的片段重新连接。您可以查看FragmentPagerAdapter或FragmentStatePagerAdapter的代码，以了解这是如何实现的。

When the FragmentPagerAdapter adds a fragment to the FragmentManager, it uses a special tag based on the particular position that the fragment will be placed. FragmentPagerAdapter.getItem(int position) is only called when a fragment for that position does not exist. After rotating, Android will notice that it already created/saved a fragment for this particular position and so it simply tries to reconnect with it with FragmentManager.findFragmentByTag(), instead of creating a new one. All of this comes free when using the FragmentPagerAdapter and is why it is usual to have your fragment initialisation code inside the getItem(int) method.

即使我们没有使用FragmentPagerAdapter，每次在Activity.onCreate(Bundle)中创建一个新的片段也不是一个好主意。正如你所注意到的，当一个片段被添加到FragmentManager时，它将在旋转后为你重新创建，不需要再次添加它。这样做是处理片段时出现错误的常见原因。

在处理片段时，通常的方法是:

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    ...

    CustomFragment fragment;
    if (savedInstanceState != null) {
        fragment = (CustomFragment) getSupportFragmentManager().findFragmentByTag("customtag");
    } else {
        fragment = new CustomFragment();
        getSupportFragmentManager().beginTransaction().add(R.id.container, fragment, "customtag").commit(); 
    }

    ...

}

When using a FragmentPagerAdapter, we relinquish fragment management to the adapter, and do not have to perform the above steps. By default, it will only preload one Fragment in front and behind the current position (although it does not destroy them unless you are using FragmentStatePagerAdapter). This is controlled by ViewPager.setOffscreenPageLimit(int). Because of this, directly calling methods on the fragments outside of the adapter is not guaranteed to be valid, because they may not even be alive.

To cut a long story short, your solution to use putFragment to be able to get a reference afterwards is not so crazy, and not so unlike the normal way to use fragments anyway (above). It is difficult to obtain a reference otherwise because the fragment is added by the adapter, and not you personally. Just make sure that the offscreenPageLimit is high enough to load your desired fragments at all times, since you rely on it being present. This bypasses lazy loading capabilities of the ViewPager, but seems to be what you desire for your application.

另一种方法是重写FragmentPageAdapter。instantiateItem(View, int)，并在返回之前保存对从super调用返回的片段的引用(如果已经存在，则具有查找片段的逻辑)。

为了获得更完整的图片，请查看FragmentPagerAdapter(短)和ViewPager(长)的一些源代码。

我想为一个可能略有不同的情况提供一个替代解决方案，因为我对答案的许多搜索一直将我引向这个主题。

我的情况 -我动态创建/添加页面，并将它们滑动到ViewPager，但当旋转(onConfigurationChange)，我最终会有一个新页面，因为当然OnCreate再次被调用。但是我想保持对旋转之前创建的所有页面的引用。

问题 -我没有为我创建的每个片段提供唯一的标识符，所以引用的唯一方法是以某种方式将引用存储在数组中，以便在旋转/配置更改后恢复。

解决方案 -关键的概念是让Activity(显示片段)也管理现有片段的引用数组，因为这个Activity可以利用onSaveInstanceState中的Bundles

public class MainActivity extends FragmentActivity

因此，在这个Activity中，我声明了一个私有成员来跟踪打开的页面

private List<Fragment> retainedPages = new ArrayList<Fragment>();

每次onSaveInstanceState被调用时都会更新，并在onCreate中恢复

@Override
protected void onSaveInstanceState(Bundle outState) {
    retainedPages = _adapter.exportList();
    outState.putSerializable("retainedPages", (Serializable) retainedPages);
    super.onSaveInstanceState(outState);
}

.．.所以一旦它被存储，它就可以被检索…

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (savedInstanceState != null) {
        retainedPages = (List<Fragment>) savedInstanceState.getSerializable("retainedPages");
    }
    _mViewPager = (CustomViewPager) findViewById(R.id.viewPager);
    _adapter = new ViewPagerAdapter(getApplicationContext(), getSupportFragmentManager());
    if (retainedPages.size() > 0) {
        _adapter.importList(retainedPages);
    }
    _mViewPager.setAdapter(_adapter);
    _mViewPager.setCurrentItem(_adapter.getCount()-1);
}

这些是对主活动的必要更改，因此我需要FragmentPagerAdapter中的成员和方法来工作，因此在

public class ViewPagerAdapter extends FragmentPagerAdapter

一个相同的构造(如上面的MainActivity中所示)

private List<Fragment> _pages = new ArrayList<Fragment>();

这种同步(如上面在onSaveInstanceState中使用的那样)是由方法特别支持的

public List<Fragment> exportList() {
    return _pages;
}

public void importList(List<Fragment> savedPages) {
    _pages = savedPages;
}

最后，在fragment类中

public class CustomFragment extends Fragment

为了使这一切顺利进行，有两个改变，首先

public class CustomFragment extends Fragment implements Serializable

然后将其添加到onCreate，这样Fragments就不会被破坏

setRetainInstance(true);

我仍然在思考Fragments和Android生命周期，所以这里需要注意的是，这种方法可能存在冗余/低效率。但它对我有用，我希望它能对其他有类似情况的人有所帮助。

对于你的问题，我找到了另一个相对简单的解决方法。

正如你从FragmentPagerAdapter源代码中看到的，由FragmentPagerAdapter管理的片段存储在FragmentManager的标签下，使用:

String tag="android:switcher:" + viewId + ":" + index;

viewId是container. getid()，容器是你的ViewPager实例。索引是片段的位置。因此，你可以保存对象id到outState:

@Override
protected void onSaveInstanceState(Bundle outState) {
    super.onSaveInstanceState(outState);
    outState.putInt("viewpagerid" , mViewPager.getId() );
}

@Override
    protected void onCreate(Bundle savedInstanceState) {
    setContentView(R.layout.activity_main);
    if (savedInstanceState != null)
        viewpagerid=savedInstanceState.getInt("viewpagerid", -1 );  

    MyFragmentPagerAdapter titleAdapter = new MyFragmentPagerAdapter (getSupportFragmentManager() , this);        
    mViewPager = (ViewPager) findViewById(R.id.pager);
    if (viewpagerid != -1 ){
        mViewPager.setId(viewpagerid);
    }else{
        viewpagerid=mViewPager.getId();
    }
    mViewPager.setAdapter(titleAdapter);

如果你想与这个片段通信，你可以从FragmentManager中获取，比如:

getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewpagerid + ":0")

我的解决方案是非常粗鲁的，但工作:作为我的片段动态创建从保留的数据，我只是删除所有片段从PageAdapter之前调用super.onSaveInstanceState()，然后重新创建他们的活动创建:

@Override
protected void onSaveInstanceState(Bundle outState) {
    outState.putInt("viewpagerpos", mViewPager.getCurrentItem() );
    mSectionsPagerAdapter.removeAllfragments();
    super.onSaveInstanceState(outState);
}

你不能在onDestroy()中删除它们，否则你会得到这个异常:

java.lang.IllegalStateException: onSaveInstanceState后不能执行此操作

下面是页面适配器中的代码:

public void removeAllfragments()
{
    if ( mFragmentList != null ) {
        for ( Fragment fragment : mFragmentList ) {
            mFm.beginTransaction().remove(fragment).commit();
        }
        mFragmentList.clear();
        notifyDataSetChanged();
    }
}

我只保存当前页面并在onCreate()中恢复它，在片段创建之后。

if (savedInstanceState != null)
    mViewPager.setCurrentItem( savedInstanceState.getInt("viewpagerpos", 0 ) );  

add:

   @SuppressLint("ValidFragment")

在你上课之前。

如果它不起作用，可以这样做:

@SuppressLint({ "ValidFragment", "HandlerLeak" })

我想提供一个解决方案，扩展antonyt的精彩答案，并提到重写FragmentPageAdapter。instantiateItem(View, int)来保存对已创建片段的引用，以便稍后对它们进行处理。这应该也适用于FragmentStatePagerAdapter;详情见注释。

下面是一个简单的例子，说明如何获得FragmentPagerAdapter返回的fragment的引用，它不依赖于在Fragments上设置的内部标记。关键是重写instantiateItem()并将引用保存在那里，而不是保存在getItem()中。

public class SomeActivity extends Activity {
    private FragmentA m1stFragment;
    private FragmentB m2ndFragment;

    // other code in your Activity...

    private class CustomPagerAdapter extends FragmentPagerAdapter {
        // other code in your custom FragmentPagerAdapter...

        public CustomPagerAdapter(FragmentManager fm) {
            super(fm);
        }

        @Override
        public Fragment getItem(int position) {
            // Do NOT try to save references to the Fragments in getItem(),
            // because getItem() is not always called. If the Fragment
            // was already created then it will be retrieved from the FragmentManger
            // and not here (i.e. getItem() won't be called again).
            switch (position) {
                case 0:
                    return new FragmentA();
                case 1:
                    return new FragmentB();
                default:
                    // This should never happen. Always account for each position above
                    return null;
            }
        }

        // Here we can finally safely save a reference to the created
        // Fragment, no matter where it came from (either getItem() or
        // FragmentManger). Simply save the returned Fragment from
        // super.instantiateItem() into an appropriate reference depending
        // on the ViewPager position.
        @Override
        public Object instantiateItem(ViewGroup container, int position) {
            Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
            // save the appropriate reference depending on position
            switch (position) {
                case 0:
                    m1stFragment = (FragmentA) createdFragment;
                    break;
                case 1:
                    m2ndFragment = (FragmentB) createdFragment;
                    break;
            }
            return createdFragment;
        }
    }

    public void someMethod() {
        // do work on the referenced Fragments, but first check if they
        // even exist yet, otherwise you'll get an NPE.

        if (m1stFragment != null) {
            // m1stFragment.doWork();
        }

        if (m2ndFragment != null) {
            // m2ndFragment.doSomeWorkToo();
        }
    }
}

或者如果你更喜欢使用标签而不是类成员变量/片段引用，你也可以用同样的方式获取FragmentPagerAdapter设置的标签: 注意:这并不适用于FragmentStatePagerAdapter，因为它在创建fragment时不设置标签。

@Override
public Object instantiateItem(ViewGroup container, int position) {
    Fragment createdFragment = (Fragment) super.instantiateItem(container, position);
    // get the tags set by FragmentPagerAdapter
    switch (position) {
        case 0:
            String firstTag = createdFragment.getTag();
            break;
        case 1:
            String secondTag = createdFragment.getTag();
            break;
    }
    // ... save the tags somewhere so you can reference them later
    return createdFragment;
}

注意，这个方法并不依赖于模仿FragmentPagerAdapter设置的内部标记，而是使用适当的api来检索它们。这样，即使标签在未来的SupportLibrary版本中发生了变化，您仍然是安全的。

不要忘记，根据Activity的设计，你要处理的Fragments可能存在，也可能不存在，所以你必须在使用引用之前做空检查。

同样，如果你正在使用FragmentStatePagerAdapter，那么你不希望保留对片段的硬引用，因为你可能有很多片段，而硬引用将不必要地将它们保存在内存中。将Fragment引用保存在WeakReference变量中，而不是保存在标准变量中。是这样的:

WeakReference<Fragment> m1stFragment = new WeakReference<Fragment>(createdFragment);
// ...and access them like so
Fragment firstFragment = m1stFragment.get();
if (firstFragment != null) {
    // reference hasn't been cleared yet; do work...
}

我想出了这个简单而优雅的解决方案。它假设活动负责创建片段，而适配器只是为它们服务。

这是适配器的代码(这里没有什么奇怪的，除了mFragments是由Activity维护的片段列表)

class MyFragmentPagerAdapter extends FragmentStatePagerAdapter {

    public MyFragmentPagerAdapter(FragmentManager fm) {
        super(fm);
    }

    @Override
    public Fragment getItem(int position) {
        return mFragments.get(position);
    }

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

    @Override
    public int getItemPosition(Object object) {
        return POSITION_NONE;
    }

    @Override
    public CharSequence getPageTitle(int position) {
        TabFragment fragment = (TabFragment)mFragments.get(position);
        return fragment.getTitle();
    }
} 

这个线程的整个问题是获得“旧”片段的引用，所以我在活动的onCreate中使用这段代码。

    if (savedInstanceState!=null) {
        if (getSupportFragmentManager().getFragments()!=null) {
            for (Fragment fragment : getSupportFragmentManager().getFragments()) {
                mFragments.add(fragment);
            }
        }
    }

当然，如果需要，您还可以进一步优化此代码，例如确保片段是特定类的实例。

要获得方向改变后的片段，必须使用. gettag()。

    getSupportFragmentManager().findFragmentByTag("android:switcher:" + viewPagerId + ":" + positionOfItemInViewPager)

为了更多的处理，我为我的PageAdapter写了我自己的数组列表，通过viewPagerId和FragmentClass在任何位置获得片段:

public class MyPageAdapter extends FragmentPagerAdapter implements Serializable {
private final String logTAG = MyPageAdapter.class.getName() + ".";

private ArrayList<MyPageBuilder> fragmentPages;

public MyPageAdapter(FragmentManager fm, ArrayList<MyPageBuilder> fragments) {
    super(fm);
    fragmentPages = fragments;
}

@Override
public Fragment getItem(int position) {
    return this.fragmentPages.get(position).getFragment();
}

@Override
public CharSequence getPageTitle(int position) {
    return this.fragmentPages.get(position).getPageTitle();
}

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


public int getItemPosition(Object object) {
    //benötigt, damit bei notifyDataSetChanged alle Fragemnts refrehsed werden

    Log.d(logTAG, object.getClass().getName());
    return POSITION_NONE;
}

public Fragment getFragment(int position) {
    return getItem(position);
}

public String getTag(int position, int viewPagerId) {
    //getSupportFragmentManager().findFragmentByTag("android:switcher:" + R.id.shares_detail_activity_viewpager + ":" + myViewPager.getCurrentItem())

    return "android:switcher:" + viewPagerId + ":" + position;
}

public MyPageBuilder getPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
    return new MyPageBuilder(pageTitle, icon, selectedIcon, frag);
}


public static class MyPageBuilder {

    private Fragment fragment;

    public Fragment getFragment() {
        return fragment;
    }

    public void setFragment(Fragment fragment) {
        this.fragment = fragment;
    }

    private String pageTitle;

    public String getPageTitle() {
        return pageTitle;
    }

    public void setPageTitle(String pageTitle) {
        this.pageTitle = pageTitle;
    }

    private int icon;

    public int getIconUnselected() {
        return icon;
    }

    public void setIconUnselected(int iconUnselected) {
        this.icon = iconUnselected;
    }

    private int iconSelected;

    public int getIconSelected() {
        return iconSelected;
    }

    public void setIconSelected(int iconSelected) {
        this.iconSelected = iconSelected;
    }

    public MyPageBuilder(String pageTitle, int icon, int selectedIcon, Fragment frag) {
        this.pageTitle = pageTitle;
        this.icon = icon;
        this.iconSelected = selectedIcon;
        this.fragment = frag;
    }
}

public static class MyPageArrayList extends ArrayList<MyPageBuilder> {
    private final String logTAG = MyPageArrayList.class.getName() + ".";

    public MyPageBuilder get(Class cls) {
        // Fragment über FragmentClass holen
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return super.get(indexOf(item));
            }
        }
        return null;
    }

    public String getTag(int viewPagerId, Class cls) {
        // Tag des Fragment unabhängig vom State z.B. nach bei Orientation change
        for (MyPageBuilder item : this) {
            if (item.fragment.getClass().getName().equalsIgnoreCase(cls.getName())) {
                return "android:switcher:" + viewPagerId + ":" + indexOf(item);
            }
        }
        return null;
    }
}

所以只要用这些片段创建一个MyPageArrayList:

    myFragPages = new MyPageAdapter.MyPageArrayList();

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_data_frag),
            R.drawable.ic_sd_storage_24dp,
            R.drawable.ic_sd_storage_selected_24dp,
            new WidgetDataFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_color_frag),
            R.drawable.ic_color_24dp,
            R.drawable.ic_color_selected_24dp,
            new WidgetColorFrag()));

    myFragPages.add(new MyPageAdapter.MyPageBuilder(
            getString(R.string.widget_config_textsize_frag),
            R.drawable.ic_settings_widget_24dp,
            R.drawable.ic_settings_selected_24dp,
            new WidgetTextSizeFrag()));

并将它们添加到viewPager:

    mAdapter = new MyPageAdapter(getSupportFragmentManager(), myFragPages);
    myViewPager.setAdapter(mAdapter);

在此之后，你可以通过使用它的类来获得正确的方向改变片段:

        WidgetDataFrag dataFragment = (WidgetDataFrag) getSupportFragmentManager()
            .findFragmentByTag(myFragPages.getTag(myViewPager.getId(), WidgetDataFrag.class));

如果有人有问题与他们的FragmentStatePagerAdapter不正确地恢复其碎片的状态…新的片段是由FragmentStatePagerAdapter创建的，而不是它从状态恢复它们…

确保在调用viewpage . setadapter (fragmentStatePagerAdapter)之前调用viewpage . setoffscreenpagelimit ()

调用viewpage . setoffscreenpagelimit()…ViewPager将立即查找它的适配器并尝试获取它的片段。这可能发生在ViewPager有机会从savedInstanceState恢复片段之前(因此创建的新片段不能从savedInstanceState重新初始化，因为它们是新的)。

有一点不同的意见，不要自己存储碎片，而是把它留给FragmentManager，当你需要对碎片做一些事情时，在FragmentManager中查找它们:

//make sure you have the right FragmentManager 
//getSupportFragmentManager or getChildFragmentManager depending on what you are using to manage this stack of fragments
List<Fragment> fragments = fragmentManager.getFragments();
if(fragments != null) {
   int count = fragments.size();
   for (int x = 0; x < count; x++) {
       Fragment fragment = fragments.get(x);
       //check if this is the fragment we want, 
       //it may be some other inspection, tag etc.
       if (fragment instanceof MyFragment) {
           //do whatever we need to do with it
       }
   }
}

如果你有很多fragment, instanceof check的成本可能不是你想要的，但是记住FragmentManager已经记录了Fragments，这是一件好事。