如何在 Fragment 之间传递值

第 1 步：将数据从片段发送到活动

Intent intent = new Intent(getActivity().getBaseContext(),
                           TargetActivity.class);
intent.putExtra("message", message);
getActivity().startActivity(intent);

第 2 步：要在 Activity 中接收此数据：

Intent intent = getIntent();
String message = intent.getStringExtra("message");

第 3 步：要将数据从一个活动发送到另一个活动，请遵循正常方法

Intent intent = new Intent(MainActivity.this,
                           TargetActivity.class);
intent.putExtra("message", message);
startActivity(intent);

第 4 步：在活动中接收此数据

  Intent intent = getIntent();
  String message = intent.getStringExtra("message");

第 5 步：您可以从 Activity 将数据发送到 Fragment，其意图如下：

Bundle bundle = new Bundle();
bundle.putString("message", "From Activity");

// Set Fragmentclass Arguments
Fragmentclass fragobj = new Fragmentclass();
fragobj.setArguments(bundle);

并在 Fragment onCreateView 方法中接收一个片段：

@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
    String strtext = getArguments().getString("message");

    return inflater.inflate(R.layout.fragment, container, false);
}

---

// 在 Fragment_1.java 中

Bundle bundle = new Bundle();
bundle.putString("key","abc"); // Put anything what you want

Fragment_2 fragment2 = new Fragment_2();
fragment2.setArguments(bundle);

getFragmentManager()
      .beginTransaction()
      .replace(R.id.content, fragment2)
      .commit();

// 在 Fragment_2.java 中

Bundle bundle = this.getArguments();

if(bundle != null){
     // handle your code here.
}

希望这对您有所帮助。

---

如开发者网站所述

通常，您会希望一个 Fragment 与另一个 Fragment 进行通信，例如根据用户事件更改内容。所有 Fragment 到 Fragment 的通信都是通过关联的 Activity 完成的。两个 Fragment 永远不应该直接通信。

Fragment之间的通信应该通过关联的Activity来完成。

让我们有以下组件：

活动托管片段并允许片段通信 FragmentA 第一个片段将发送数据 FragmentB 第二个片段将从FragmentA接收数据

FragmentA 的实现是：

public class FragmentA extends Fragment 
{
    DataPassListener mCallback;
    
    public interface DataPassListener{
        public void passData(String data);
    }

    @Override
    public void onAttach(Context context) 
    {
        super.onAttach(context);
        // This makes sure that the host activity has implemented the callback interface
        // If not, it throws an exception
        try 
        {
            mCallback = (OnImageClickListener) context;
        }
        catch (ClassCastException e) 
        {
            throw new ClassCastException(context.toString()+ " must implement OnImageClickListener");
        }
    }
    
    public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) 
    {
        // Suppose that when a button clicked second FragmentB will be inflated
        // some data on FragmentA will pass FragmentB
        // Button passDataButton = (Button).........
        
        passDataButton.setOnClickListener(new OnClickListener() {
            @Override
            public void onClick(View v) {
                if (view.getId() == R.id.passDataButton) {
                    mCallback.passData("Text to pass FragmentB");
                }
            }
        });
    }
}

MainActivity 的实现是：

public class MainActivity extends ActionBarActivity implements DataPassListener{
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        if (findViewById(R.id.container) != null) {
            if (savedInstanceState != null) {
                return;
            }
            getFragmentManager().beginTransaction()
                    .add(R.id.container, new FragmentA()).commit();
        }
    }
    
    @Override
    public void passData(String data) {
        FragmentB fragmentB = new FragmentB ();
        Bundle args = new Bundle();
        args.putString(FragmentB.DATA_RECEIVE, data);
        fragmentB .setArguments(args);
        getFragmentManager().beginTransaction()
            .replace(R.id.container, fragmentB )
            .commit();
    }
}

FragmentB 的实现是：

public class FragmentB extends Fragment{
    final static String DATA_RECEIVE = "data_receive";
    TextView showReceivedData;
    
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_B, container, false);
        showReceivedData = (TextView) view.findViewById(R.id.showReceivedData);
    }
    
    @Override
    public void onStart() {
        super.onStart();
        Bundle args = getArguments();
        if (args != null) {
            showReceivedData.setText(args.getString(DATA_RECEIVE));
        }
    }
}

我希望这个能帮上忙..

---

从 Developers website：

通常，您会希望一个 Fragment 与另一个 Fragment 进行通信，例如根据用户事件更改内容。所有 Fragment 到 Fragment 的通信都是通过关联的 Activity 完成的。两个 Fragment 永远不应该直接通信。

您可以借助其 Activity 在 Fragment 之间进行通信。您可以使用 this approach 在 Activity 和 Fragment 之间进行通信。

另请检查 this link。

---

最新的 Fragment 之间传递数据的解决方案可以通过使用 ViewModel 和 LiveData 等 Android 架构组件来实现。使用此解决方案，您无需为通信定义接口，并且可以获得使用视图模型的优势，例如由于配置更改而导致的数据生存。

在这个解决方案中，通信中涉及的片段共享同一个视图模型对象，该对象与它们的活动生命周期相关联。视图模型对象包含 livedata 对象。一个片段设置要在 livedata 对象上传递的数据，第二个片段观察者 livedata 更改并接收数据。

以下是完整示例：Passing data between Android fragments using ViewModel

---

首先，所有答案都是正确的。您可以使用 Intent 传递除自定义对象之外的数据。

如果要传递自定义对象，则必须将 Serialazable 或 Parcelable 实现到自定义对象类。我还以为太复杂了。。。

因此，如果您的项目很简单，请尝试使用 DataCache。这为传递数据提供了一种超级简单的方法。 参考： GitHub project CachePot

1-将此设置为将发送数据的视图或活动或片段

DataCache.getInstance().push(obj);

2- 在任何地方获取数据，如下所示

public class MainFragment extends Fragment
{
    private YourObject obj;

    @Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        obj = DataCache.getInstance().pop(YourObject.class);

    } //end onCreate()
} //end class MainFragment

---

科特林方式

使用在 official ViewModel documentation 提出的 SharedViewModel

一个活动中的两个或多个片段需要相互通信是很常见的。想象一个主从片段的常见情况，您有一个片段，其中用户从列表中选择一个项目，另一个片段显示所选项目的内容。这种情况绝非易事，因为两个片段都需要定义一些接口描述，并且所有者活动必须将两者绑定在一起。此外，两个片段都必须处理另一个片段尚未创建或不可见的情况。这个常见的痛点可以通过使用 ViewModel 对象来解决。这些片段可以使用它们的活动范围共享一个 ViewModel 来处理这种通信

首先实现 fragment-ktx 以更轻松地实例化您的视图模型

dependencies {
    implementation "androidx.fragment:fragment-ktx:1.2.2"
}

然后，您只需将要与其他片段共享的数据放入视图模型中：

class SharedViewModel : ViewModel() {
    val selected = MutableLiveData<Item>()

    fun select(item: Item) {
        selected.value = item
    }
}

然后，最后，只需在每个片段中实例化您的 viewModel，并从您要设置数据的片段中设置 selected 的值

片段 A

class MasterFragment : Fragment() {

    private val model: SharedViewModel by activityViewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        itemSelector.setOnClickListener { item ->
        model.select(item)
      }

    }
}

然后，只需在 Fragment 目的地监听这个值

片段 B

 class DetailFragment : Fragment() {

        private val model: SharedViewModel by activityViewModels()

        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
            super.onViewCreated(view, savedInstanceState)
            model.selected.observe(viewLifecycleOwner, Observer<Item> { item ->
                // Update the UI
            })
        }
    }

你也可以用相反的方式来做

---

特别是现在 Android 团队更倾向于坚持单一的活动模型，片段之间的通信变得更加重要。 LiveData 和 Interfaces 是解决这个问题的完美方法。但现在谷歌终于解决了这个问题，并尝试使用 FragmentManager 带来更简单的解决方案。这是在 Kotlin 中如何完成的。

在接收者片段中，添加一个监听器：

setFragmentResultListener(
    "data_request_key",
    lifecycleOwner,
    FragmentResultListener { requestKey: String, bundle: Bundle ->
        // Unpack the bundle and use data
        val frag1Str = bundle.getString("frag1_data_key")

    })

在发送方片段 (frag1) 中：

setFragmentResult(
    "data_request_key",
    bundleOf("frag1_data_key" to value)
)

请记住，此功能仅在 fragment-ktx 版本 1.3.0-alpha04 及更高版本中可用。

学分和进一步阅读：

A New Way to Pass Data Between Fragments

Android Fragments: Fragment Result

---

在片段之间传递参数。回答这个问题已经相当晚了，但它可以帮助某人！ Fragment_1.java

Bundle i = new Bundle(); 
            i.putString("name", "Emmanuel");

            Fragment_1 frag = new Fragment_1();
            frag.setArguments(i);
            FragmentManager fragmentManager = getFragmentManager();
            fragmentManager.beginTransaction()
                    .replace(R.id.content_frame
                            , new Fragment_2())
                    .commit();

然后在您的 Fragment_2.java 中，您可以在您的 onActivityCreated 中正常获取参数，例如

 Intent intent = getActivity().getIntent();
    if (intent.getExtras() != null) {
        String name =intent.getStringExtra("name");
    }

---

我认为解决这个问题的一个好方法是使用自定义界面。

假设您有两个片段（A 和 B），它们位于同一个活动中，并且您希望将数据从 A 发送到 B。

界面：

public interface OnDataSentListener{
    void onDataSent(Object data);
}

活动：

    public class MyActivity extends AppCompatActivity{

            private OnDataSentListener onDataSentListener;

            @Override
            protected void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
                setContentView(R.layout.activity_activity);

                FragmentTransaction trans = getFragmentManager().beginTransaction();

                FragmentA fa = new FragmentA();
                FragmentB fb = new FragmentB();

               fa.setOnDataSentListener(new Listeners.OnDataSentListener() {
                    @Override
                    public void onDataSent(Object data) {
                         if(onDataSentListener != null)  onDataSentListener.onDataSent(data);
                    }
               });

                transaction.add(R.id.frame_a, fa);
                transaction.add(R.id.frame_b, fb);

                transaction.commit();
            }

            public void setOnDataSentListener(OnDataSentListener listener){
                this.onDataSentListener = listener;
            }
        }

片段 A：

public class FragmentA extends Fragment{

    private OnDataSentListener onDataSentListener;

    private void sendDataToFragmentB(Object data){
        if(onDataSentListener != null) onDataSentListener.onDataSent(data);
    }

    public void setOnDataSentListener(OnDataSentListener listener){
        this.onDataSentListener = listener;
    }
}

片段 B：

public class FragmentB extends Fragment{

    private void initReceiver(){
        ((MyActivity) getActivity()).setOnDataSentListener(new OnDataSentListener() {
            @Override
            public void onDataSent(Object data) {
                // Here you receive the data from fragment A
            }
        });
    }
}

---

将数据从 Fragment 传递到另一个 Fragment

From first Fragment // 设置数据传递 MyFragment fragment = new MyFragment(); //你的 Fragment Bundle bundle = new Bundle(); bundle.putInt("year", 2017) // 键、值 fragment.setArguments(bundle); // 将数据传递给其他 Fragment getFragmentManager() .beginTransaction() .replace(R.id.content, fragment) .commit();

在第二个片段上 @Override public void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState);捆绑包 = this.getArguments(); if (bundle != null) { Int receivedYear = bundle.getInt("year", ""); // 键，默认值 } }

---

片段之间的通信相当复杂（我发现侦听器的概念很难实现）。

通常使用“事件总线”来抽象这些通信。这是一个为您处理这种通信的第三方库。

'Otto' 是经常用于执行此操作的，可能值得研究：http://square.github.io/otto/

---

这个简单的实现有助于以简单的方式在片段之间传递数据。认为您想将数据从“Frgment1”传递到“Fragment2”

在 Fragment1（设置要发送的数据）

 Bundle bundle = new Bundle();
 bundle.putString("key","Jhon Doe"); // set your parameteres

 Fragment2 nextFragment = new Fragment2();
 nextFragment.setArguments(bundle);

 FragmentManager fragmentManager = getActivity().getSupportFragmentManager();
 fragmentManager.beginTransaction().replace(R.id.content_drawer, nextFragment).commit();

在 Fragment2 onCreateView 方法中（获取参数）

String value = this.getArguments().getString("key");//get your parameters
Toast.makeText(getActivity(), value+" ", Toast.LENGTH_LONG).show();//show data in tost

---

您可以通过 ViewModel 和已清除 by Arnav Rao 的 Live Data 来实现您的目标。现在我举一个例子来更整洁地清除它。

首先，假定的 ViewModel 被命名为 SharedViewModel.java。

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<Item> selected = new MutableLiveData<Item>();

    public void select(Item item) {
        selected.setValue(item);
    }
    public LiveData<Item> getSelected() {
        return selected;
    }
}

那么源片段就是我们要发送数据的MasterFragment.java。

public class MasterFragment extends Fragment {
    private SharedViewModel model;

    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
        itemSelector.setOnClickListener(item -> {

            // Data is sent

            model.select(item);
        });
    }
}

最后，目标片段是我们想要接收数据的 DetailFragment.java。

public class DetailFragment extends Fragment {

    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        SharedViewModel model = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
        model.getSelected().observe(getViewLifecycleOwner(), { item ->

           // Data is received

        });
    }
}

---

您可以使用几种方法来实现相同的目的：

一种方法是在您的父活动中实现一个接口，以便 fragment1 可以通过调用这些接口方法将信息传递给其父活动。同样，您可以让 fragment2 实现一个接口，以便父活动可以将数据发送到 fragment2。另一种更简单的方法是在彼此之间直接调用方法。您可以从 fragment1 使用框架 API 获取其父 Activity，然后通过在父 Activity 中定义您的辅助方法，您可以直接从 Fragment1 调用该方法并将您的信息传递给父 Activity。同样，在父活动中，您可以使用框架 API 来获取对其任何子片段的引用，在您的情况下是片段 2。然后，您可以在 fragment2 中定义自己的帮助方法，以便您可以从父活动中调用相同的方法并将信息传递给 fragment2。

---

在您的第一个片段中，输入以下代码：

editprofile.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View v) {

        Fragment_editprofile Fragment = new Fragment_editprofile();
            .
            .
            .
        Fragment.getintentdetails(tv_name.getText().toString(),
            tv_mob.getText().toString(), tv_email.getText().toString(), tv_dob.getText().toString(),
            tv_gender.getText().toString(), photointent);

    }
});

在第二个片段中，创建如下方法：

public void getintentdetails(String name, String mobile, String email, String dob,
                             String gender, String photointent) {

    this.name_str = name;
    this.mob_str = mobile;
    this.email_str = email;
    this.dob_str = dob;
    this.gender_str = gender;
    this.photo_str = photointent;
}

然后在类级别定义一个变量：

String name_str, mob_str, dob_str, photo_str, email_str, gender_str;

然后在第二个片段中创建另一个方法来设置一个值：

setexistingdetails();

private void setexistingdetails() {

    if(!name_str.equalsIgnoreCase(""))
        (et_name).setText(name_str);
    if(!mob_str.equalsIgnoreCase(""))
        et_mobile.setText(mob_str);
    if(!email_str.equalsIgnoreCase(""))
        email_et.setText(email_str);
    if(!dob_str.equalsIgnoreCase(""))
        dob_et.setText(dob_str);
    if(!gender_str.equalsIgnoreCase("")) {
        if (gender_str.equalsIgnoreCase("m")){
            male_radio.setChecked(true);
        }
        else {
            female_radio.setChecked(true);
        }
    }
    if(!photo_str.equalsIgnoreCase("")) {
        try {
            Picasso.get().load(Const.BASE_PATH+"include/sub-domain/GENIUS/"+photo_str).into(adminpropic_edit);
        }
        catch (Exception e) {
        }
    }
}

---

Bundle bundle = new Bundle();
bundle.putString("mykey","abc"); 
bundle.putString("mykey2","abc"); // Put anything what you want

Fragment fragment = new Fragment();
fragment2.setArguments(bundle);

getFragmentManager()
  .beginTransaction()
  .replace(R.id.content, fragment2)
  .commit();

Bundle bundle = this.getArguments(); // in your fragment oncreate

if(bundle != null){
  String mykey = bundle.getString("mykey");
  String mykey2 = bundle.getString("mykey2");
  }

---

我已经为像我这样的初学者做了一些非常容易的事情。我在我的 activity_main.xml 文件中创建了一个 textview 并放入：

id = index
visibility = invisible

然后我从第一个片段中得到这个文本视图：

index = (Textview) getActivity().findviewbyid(R.id.index)
index.setText("fill me with the value")

然后在第二个片段中，我得到了值：

index = (Textview) getActivity().findviewbyid(R.id.index)
String get_the_value= index.getText().toString();

---