프래그먼트간에 값을 전달하는 방법

저는 Fragments를 처음 사용합니다.

Fragments를 사용하는 간단한 샘플 애플리케이션을 빌드하려고합니다. 내 시나리오는 각 활동 내에 하나의 조각이있는 두 개의 활동이 있습니다. 첫 번째 조각에는 편집 텍스트와 버튼이 있습니다. 두 번째 조각에는 텍스트보기가 있습니다. edittext에 이름을 입력하고 버튼을 클릭하면 두 번째 조각의 textview에 첫 번째 조각의 edittext에 입력 된 이름이 표시됩니다.

첫 번째 조각의 값을 해당 활동으로 보낸 다음 해당 활동에서 두 번째 활동으로 보낼 수있었습니다. 이제 두 번째 조각 내에서이 값을 어떻게 사용합니까?

다음은 Java 코드입니다. :::

package com.example.fragmentexample;

import android.app.Activity;
import android.app.Fragment;
import android.app.FragmentManager;
import android.content.Intent;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;

public class Fragment_1 extends Fragment{

    OnFragmentChangedListener mCallback;

    // Container Activity must implement this interface
    public interface OnFragmentChangedListener {
        public void onButtonClicked(String name);
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);

        // This makes sure that the container activity has implemented
        // the callback interface. If not, it throws an exception
        try {
            mCallback = (OnFragmentChangedListener) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString()
                    + " must implement OnHeadlineSelectedListener");
        }
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // TODO Auto-generated method stub      

        View view = inflater.inflate(R.layout.fragment_fragment_1, container, false);

        final EditText edtxtPersonName_Fragment = (EditText) view.findViewById(R.id.edtxtPersonName);
        Button btnSayHi_Fragment = (Button) view.findViewById(R.id.btnSayHi);

        btnSayHi_Fragment.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub

                String name = edtxtPersonName_Fragment.getText().toString();

                FragmentManager fm = getFragmentManager();
                Fragment_2 f2 = (Fragment_2) fm.findFragmentById(R.id.fragment_content_2);

                Activity activity = getActivity();

                if(activity != null)
                {
                    Toast.makeText(activity, "Say&ing Hi in Progress...", Toast.LENGTH_LONG).show();
                }


                if(f2 != null && f2.isInLayout())
                {
                    f2.setName(name);
                }
                else
                {
                    mCallback.onButtonClicked(name);
                }
            }
        });

        return view;


    }

}

MainActivity.Java

package com.example.fragmentexample;

import android.os.Bundle;
import android.app.Activity;
import android.content.Intent;

import android.view.Choreographer.FrameCallback;
import android.view.Menu;

public class MainActivity extends Activity implements Fragment_1.OnFragmentChangedListener {

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

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.activity_main, menu);
        return true;
    }

    @Override
    public void onButtonClicked(String name) {
        // TODO Auto-generated method stub

        Intent i = new Intent(this, SecondActivity.class);
        i.putExtra("", name);
        startActivity(i);
    }

}

SecondActivity.Java

package com.example.fragmentexample;

import android.app.Activity;
import android.os.Bundle;

public class SecondActivity extends Activity{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_second);

        Bundle b = getIntent().getExtras();

        Fragment_2 f2 = new Fragment_2();
        f2.setArguments(b);
    }
}

Fragment_2.Java

package com.example.fragmentexample;

import android.app.Activity;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class Fragment_2 extends Fragment{

    View view;
    TextView txtName;


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        // TODO Auto-generated method stub

        view = inflater.inflate(R.layout.fragment_fragment_2, container, false);

            // Exception at this line
        String name = getArguments().getString("message");
        txtName = (TextView) view.findViewById(R.id.txtViewResult);
        txtName.setText(name);

        return view;
    }

    @Override
    public void onAttach(Activity activity) {
        // TODO Auto-generated method stub
        super.onAttach(activity);       
    }

    public void setName(String name)
    {   
        txtName.setText("Hi " + name);
    }

}

다음 예외가 발생합니다. :::

04-16 18:10:24.573: E/AndroidRuntime(713): FATAL EXCEPTION: main
04-16 18:10:24.573: E/AndroidRuntime(713): java.lang.RuntimeException: Unable to start activity ComponentInfo{com.example.fragmentexample/com.example.fragmentexample.SecondActivity}: android.view.InflateException: Binary XML file line #8: Error inflating class fragment
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1815)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:1831)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread.access$500(ActivityThread.java:122)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1024)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.os.Handler.dispatchMessage(Handler.java:99)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.os.Looper.loop(Looper.java:132)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread.main(ActivityThread.java:4123)
04-16 18:10:24.573: E/AndroidRuntime(713):  at java.lang.reflect.Method.invokeNative(Native Method)
04-16 18:10:24.573: E/AndroidRuntime(713):  at java.lang.reflect.Method.invoke(Method.java:491)
04-16 18:10:24.573: E/AndroidRuntime(713):  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:841)
04-16 18:10:24.573: E/AndroidRuntime(713):  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:599)
04-16 18:10:24.573: E/AndroidRuntime(713):  at dalvik.system.NativeStart.main(Native Method)
04-16 18:10:24.573: E/AndroidRuntime(713): Caused by: android.view.InflateException: Binary XML file line #8: Error inflating class fragment
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.createViewFromTag(LayoutInflater.java:688)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.rInflate(LayoutInflater.java:724)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.inflate(LayoutInflater.java:479)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.inflate(LayoutInflater.java:391)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.inflate(LayoutInflater.java:347)
04-16 18:10:24.573: E/AndroidRuntime(713):  at com.android.internal.policy.impl.PhoneWindow.setContentView(PhoneWindow.java:223)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.Activity.setContentView(Activity.java:1786)
04-16 18:10:24.573: E/AndroidRuntime(713):  at com.example.fragmentexample.SecondActivity.onCreate(SecondActivity.java:13)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.Activity.performCreate(Activity.java:4397)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1048)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:1779)
04-16 18:10:24.573: E/AndroidRuntime(713):  ... 11 more
04-16 18:10:24.573: E/AndroidRuntime(713): Caused by: java.lang.NullPointerException
04-16 18:10:24.573: E/AndroidRuntime(713):  at com.example.fragmentexample.Fragment_2.onCreateView(Fragment_2.java:24)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.FragmentManagerImpl.moveToState(FragmentManager.java:754)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.FragmentManagerImpl.moveToState(FragmentManager.java:956)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.FragmentManagerImpl.addFragment(FragmentManager.java:1035)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.app.Activity.onCreateView(Activity.java:4177)
04-16 18:10:24.573: E/AndroidRuntime(713):  at android.view.LayoutInflater.createViewFromTag(LayoutInflater.java:664)
04-16 18:10:24.573: E/AndroidRuntime(713):  ... 21 more

SecondActivity.java의 번들에서 Fragment_2.Java로 값을 어떻게 가져 옵니까?

1 단계 : 프래그먼트에서 활동으로 데이터 보내기

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

2 단계 : 활동에서이 데이터를 수신하려면 :

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가 다른 Fragment와 통신하기를 원할 것입니다. 모든 Fragment-to-Fragment 통신은 관련 활동을 통해 이루어집니다. 두 조각은 직접 통신해서는 안됩니다.

프래그먼트 간의 통신은 연관된 활동을 통해 수행되어야합니다.

다음 구성 요소가 있습니다.

활동 은 조각을 호스팅하고 조각 통신을 허용합니다.

Fragment 데이터를 보낼 첫 번째 조각

FragmentA 에서 데이터를 수신 할 FragmentB 두 번째 조각

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));
        }
    }
}

도움이 되었으면합니다 ..

// 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-to-Fragment 통신은 관련 활동을 통해 이루어집니다. 두 조각은 직접 통신해서는 안됩니다.

활동의 도움으로 조각간에 통신 할 수 있습니다. 다음을 사용하여 활동과 프래그먼트간에 통신 할 수 있습니다.이것을 접근 방식을 .

이 링크도 확인하십시오 .

먼저 모든 대답이 맞습니다 Intent. 을 사용하여 사용자 지정 개체를 제외한 데이터를 전달할 수 있습니다 . 사용자 지정 개체를 전달하려면 Serialazable또는 Parcelable사용자 지정 개체 클래스 를 구현 해야합니다. 너무 복잡하다고 생각했는데 ...

따라서 프로젝트가 간단하다면 DataCache. 그것은 데이터를 전달하는 매우 간단한 방법을 제공합니다. 참고 : Github 프로젝트 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

조각 간 데이터 전달을위한 최신 솔루션은 ViewModel 및 LiveData와 같은 Android 아키텍처 구성 요소를 사용하여 구현할 수 있습니다. 이 솔루션을 사용하면 통신을위한 인터페이스를 정의 할 필요가 없으며 구성 변경으로 인한 데이터 생존과 같은 뷰 모델을 사용하는 이점을 얻을 수 있습니다.

이 솔루션에서 통신에 관련된 프래그먼트는 활동 라이프 사이클에 연결된 동일한 viewmodel 객체를 공유합니다. 보기 모델 개체에는 livedata 개체가 포함됩니다. 하나의 프래그먼트는 라이브 데이터 객체에 전달할 데이터를 설정하고 두 번째 프래그먼트 옵저버는 라이브 데이터를 변경하고 데이터를 수신합니다.

다음은 완전한 예입니다. http://www.zoftino.com/passing-data-between-android-fragments-using-viewmodel

조각 간 인수 전달. 이 질문에 답하기에는 상당히 늦었지만 누군가를 도울 수 있습니다! 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
            }
        });
    }
}

프래그먼트 간의 통신은 상당히 복잡합니다 (리스너 개념을 구현하기가 약간 어렵습니다).

이러한 통신을 추상화하기 위해 '이벤트 버스'를 사용하는 것이 일반적입니다.이 통신을 처리하는 타사 라이브러리입니다.

'Otto'는이 작업을 수행하는 데 자주 사용되며 살펴볼 가치가 있습니다. http://square.github.io/otto/

Fragment에서 다른 Fragment로 데이터 전달

• 첫 번째 조각에서

  // Set data to pass
  MyFragment fragment = new MyFragment(); //Your Fragment
  Bundle bundle = new Bundle();
  bundle.putInt("year", 2017)  // Key, value
  fragment.setArguments(bundle); 
  // Pass data to other Fragment
  getFragmentManager()
   .beginTransaction()
   .replace(R.id.content, fragment)
   .commit(); 

• 두 번째 조각에서

  @Override
  public void onCreate(@Nullable Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
  
       Bundle bundle = this.getArguments();
       if (bundle != null) {
           Int receivedYear = bundle.getInt("year", ""); // Key, default value
       } 
  }

이 간단한 구현은 간단한 방법으로 조각간에 데이터를 전달하는 데 도움이됩니다. '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

Kotlin 방식

SharedViewModel공식 ViewModel 문서에 제안 된 사용

활동의 두 개 이상의 조각이 서로 통신해야하는 것은 매우 일반적입니다. 사용자가 목록에서 항목을 선택하는 조각과 선택한 항목의 내용을 표시하는 다른 조각이있는 마스터-디테일 조각의 일반적인 경우를 상상해보십시오. 두 조각 모두 인터페이스 설명을 정의해야하고 소유자 활동이 두 조각을 함께 바인딩해야하므로이 경우는 결코 사소한 일이 아닙니다. 또한 두 조각 모두 다른 조각이 아직 생성되거나 표시되지 않은 시나리오를 처리해야합니다.

이러한 일반적인 문제점은 ViewModel 개체를 사용하여 해결할 수 있습니다. 이러한 프래그먼트는이 통신을 처리하기 위해 활동 범위를 사용하여 ViewModel을 공유 할 수 있습니다.

먼저 fragment-ktx 를 구현 하여 뷰 모델을 더 쉽게 인스턴스화하십시오.

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

그런 다음 다른 조각과 공유 할 데이터를 viewmodel 안에 넣어야합니다.

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
            })
        }
    }

반대로 할 수도 있습니다

100 % 작업 솔루션 : (도움이된다면 upvote를 누르는 것을 잊지 마십시오)

첫 번째 조각에 다음 코드를 넣으십시오.

    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);

                }
            });

Second Fragment에서 아래와 같은 방법을 만듭니다.

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) {            }
        }
    }

Arnav Rao에 의해 삭제 된 ViewModel 및 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 

        });
    }
}

여기에서 너무 많은 파고를 한 후 간단한 해결책을 찾았습니다. 실제로 조각에서 조각으로 데이터를 전달해서는 안되며 항상 나쁜 생각입니다. 조각 A에서 활동으로 데이터를 전달하고 조각 B의 활동에서 데이터를 가져올 수 있습니다.

For Example
//fragment A
//your method that will be called in Main Activity for getting data from this fragment
public List<customDataModel> getlist(){
return mlist; //your custom list 
}
buttonopen.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            //before calling  your new fragment, send a Broadcast signal to your main activity
 mContext.sendBroadcast(new Intent("call.myfragment.action"));
//here you are now changing the fragment
Fragment fragment1 = new VolunteerListDetailsFragment();

            FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
            ft.replace(R.id.content_frame, fragment1);
            ft.commit();
        }
    });

// 주요 활동

this.registerReceiver(mBroadcastReceiver, new IntentFilter("call.myfragment.action"));//this line should be in your onCreate method
   BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() {

    @Override
    public void onReceive(Context context, Intent intent) {
//init the fragment A
FragmenA fragment =
                (FragmentA) getSupportFragmentManager().findFragmentById(R.id.content_frame);
        mlistdetails = fragment.getlist();//this is my method in fragmentA which is retuning me a custom list, init this list type in top of on create fragment


    }
};
//here you are creating method that is returning the list that you just recieved From fragmentA
public List<customDataModel> getcustomlist(){
return mlistdetails; //you are returning the same list that you recived from fragmentA
}

// 지금 FragmentB에서

 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

    View rootView = (View) inflater.inflate(R.layout.vol_listdetails, container, false);

    mlistdetails=((MainActivity)getActivity()).getcustomlist();//here you are calling the method that you have created in Main Activity

    Toast.makeText(getActivity().getApplicationContext(), mlistdetails.get(0).getItemqty(), Toast.LENGTH_SHORT).show();
    return rootView;

}

나는 나 같은 초보자를 위해 정말 쉬운 것을 만들었다. 나는 내 activity_main.xml에 textview를 만들고

id=index
visibility=invisible

그런 다음 첫 번째 조각 에서이 textview를 얻습니다.

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();

도움이 되길 바랍니다!