Comment les opérations popBackStack() et replace() diffèrent-elles?

replace() fait 2 choses:

1. supprimer le fragment (a) actuellement ajouté du conteneur (c) que vous avez indiqué
2. Ajouter un nouveau fragment (B) au même conteneur

Ces 2 opérations sont ce qui est enregistré en tant Qu'enregistrement / transaction Backstack. Notez que le fragment A reste dans l'état created, et sa vue est détruite.

Maintenant popBackStack() inverse votre dernière transaction que vous avez ajoutée à BackStack.

Dans ce cas, ce serait 2 étapes:

1. Supprimer B de C
2. Ajouter A à C

Après cela, le fragment B devient detached, et si vous n'avez pas conservé de références, il sera collecté.

Pour répondre à la première partie de votre question, il n'y a pas d'appel onCreate(), Car FragmentB est resté dans l'état created. Et la réponse à la deuxième partie de la question est un peu plus longue.

Tout d'abord, il est important de comprendre que vous n'ajoutez pas réellement Fragments à Backstack, vous ajoutez FragmentTransactions. Ainsi, lorsque vous pensez que vous "remplacez par le Fragment B, en ajoutant le Fragment A à la pile arrière" , vous ajoutez en fait toute cette opération à backstack - c'est-à-dire remplacement De A avec B. Ce remplacement se compose de 2 actions-supprimer A et ajouter B.

Ensuite, l'étape suivante consiste à afficher la transaction contenant ce remplacement. Donc, vous ne sautez pas FragmentA, vous inversez "Supprimer A, Ajouter B", qui est inversé "supprimer B, ajouter A".

Et puis l'étape finale devrait être plus claire-il n'y a pas B dont FragmentManager est conscient, donc lorsque vous l'ajoutez en remplaçant A par B à votre dernière étape, B doit passer par ses méthodes de cycle de vie précoce - onAttach() et onCreate().

Le Code ci-dessous illustre ce qui se passe.

FragmentManager fm  = getFragmentManager();
FragmentA fragmentA = new FragmentA();
FragmentB fragmentB = new FragmentB();

// 1. Show A
fm.beginTransaction()
  .add(fragmentA, R.id.container)
  .commit();

// 2. Replace A with B
// FragmentManager keeps reference to fragmentA;
// it stays attached and created; fragmentB goes 
// through lifecycle methods onAttach(), onCreate()
// and so on.
fm.beginTransaction()
  .replace(fragmentB, R.id.container)
  .addToBackstack(null)
  .commit();

// 2'. Alternative to replace() method
fm.beginTransaction()
  .remove(fragmentA)
  .add(fragmentB, R.id.container)
  .addToBackstack(null)
  .commit();

// 3. Reverse (2); Result - A is visible
// What happens:
//   1) fragmentB is removed from container, it is detached now;
//      FragmentManager doesn't keep reference to it anymore
//   2) Instance of FragmentA is placed back in the container
// Now your Backstack is empty, FragmentManager is aware only
// of FragmentA instance
fm.popBackStack();

// 4. Show B
// Since fragmentB was detached, it goes through its early
// lifecycle methods: onAttach() and onCreate().
fm.beginTransaction()
  .replace(fragmentB, R.id.container)
  .addToBackstack(null)
  .commit();