执行此操作的最简单方法是将会话 ID 传递给用于启动活动的注销活动：Intent

Intent intent = new Intent(getBaseContext(), SignoutActivity.class);
intent.putExtra("EXTRA_SESSION_ID", sessionId);
startActivity(intent);

在下一个活动中访问该意向：

String sessionId = getIntent().getStringExtra("EXTRA_SESSION_ID");

Intents 的文档提供了更多信息（请参阅标题为“Extras”的部分）。

请尝试执行以下操作：

创建一个简单的“helper”类（Intent的工厂），如下所示：

import android.content.Intent;

public class IntentHelper {
    public static final Intent createYourSpecialIntent(Intent src) {
          return new Intent("YourSpecialIntent").addCategory("YourSpecialCategory").putExtras(src);
    }
}

这将是您所有 Intent 的工厂。每次需要新的 Intent 时，请在 IntentHelper 中创建一个静态工厂方法。要创建一个新的 Intent，您应该这样说：

IntentHelper.createYourSpecialIntent(getIntent());

在您的活动中。当您想在“会话”中“保存”一些数据时，只需使用以下命令：

IntentHelper.createYourSpecialIntent(getIntent()).putExtra("YOUR_FIELD_NAME", fieldValueToSave);

并发送此意向。在目标“活动”中，您的字段将作为：

getIntent().getStringExtra("YOUR_FIELD_NAME");

因此，现在我们可以像使用相同的旧会话一样使用 Intent（例如在 servlet 或 JSP 中）。

正如 Erich 所指出的，传递 Intent extras 是一个很好的方法。

不过，Application 对象是另一种方式，在处理跨多个活动的相同状态时（而不是必须获取/放在任何地方），或者比基元和字符串更复杂的对象时，它有时会更容易。

您可以扩展 Application，然后在那里设置/获取您想要的任何内容，并使用 getApplication（） 从任何 Activity（在同一应用程序中）访问它。

另请记住，您可能看到的其他方法（如静态）可能会有问题，因为它们可能导致内存泄漏。应用程序也有助于解决这个问题。

更新请注意，我提到了 SharedPreference 的使用。它有一个简单的 API，可以在应用程序的活动中访问。但这是一个笨拙的解决方案，如果您传递敏感数据，则存在安全风险。最好使用 intent。它有一个广泛的重载方法列表，可用于更好地在活动之间传输许多不同的数据类型。请看一下 intent.putExtra。此链接很好地介绍了 putExtra 的使用。

在活动之间传递数据时，我的首选方法是为相关活动创建一个静态方法，其中包含启动意图所需的参数。然后，它提供了轻松设置和检索参数的功能。所以它可能看起来像这样

public class MyActivity extends Activity {
    public static final String ARG_PARAM1 = "arg_param1";
...
public static getIntent(Activity from, String param1, Long param2...) {
    Intent intent = new Intent(from, MyActivity.class);
        intent.putExtra(ARG_PARAM1, param1);
        intent.putExtra(ARG_PARAM2, param2);
        return intent;
}

....
// Use it like this.
startActivity(MyActvitiy.getIntent(FromActivity.this, varA, varB, ...));
...

然后，您可以为预期活动创建意向，并确保您拥有所有参数。您可以适应片段。上面一个简单的例子，但你明白了。

在当前 Activity 中，创建一个新的 ：Intent

String value="Hello world";
Intent i = new Intent(CurrentActivity.this, NewActivity.class);    
i.putExtra("key",value);
startActivity(i);

然后在新 Activity 中检索这些值：

Bundle extras = getIntent().getExtras();
if (extras != null) {
    String value = extras.getString("key");
    //The key argument here must match that used in the other activity
}

使用此技术将变量从一个 Activity 传递到另一个 Activity。

在活动之间传递数据的最便捷方式是传递意向。在要从中发送数据的第一个活动中，应添加代码，

String str = "My Data"; //Data you want to send
Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
intent.putExtra("name",str); //Here you will add the data into intent to pass bw activites
v.getContext().startActivity(intent);

您还应该导入

import android.content.Intent;

然后，在下一个 Acitvity（SecondActivity） 中，您应该使用以下代码从意图中检索数据。

String name = this.getIntent().getStringExtra("name");

另一种方法是使用用于存储数据的公共静态字段，即：

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

活动之间的数据传递主要是通过意图对象。

首先，您必须使用类将数据附加到意图对象。然后使用 either 或 方法调用活动。BundlestartActivity()startActivityForResult()

您可以找到有关它的详细信息，其中包含博客文章将数据传递到活动中的示例。

我最近发布了 Vapor API，这是一个 jQuery 风格的 Android 框架，它使各种任务变得更简单。如前所述，这是您可以做到这一点的一种方法。SharedPreferences

VaporSharedPreferences 是作为 Singleton 实现的，因此这是一个选项，在 Vapor API 中，它有一个重载的方法，因此您不必明确担心您提交的数据类型 - 前提是它受支持。它也很流畅，因此您可以链接调用：.put(...)

$.prefs(...).put("val1", 123).put("val2", "Hello World!").put("something", 3.34);

它还可以选择自动保存更改，并在后台统一读取和写入过程，因此您不需要像在标准 Android 中那样显式检索编辑器。

或者，您可以使用 .在 Vapor API 中，您还可以在 VaporIntent 上使用可链接的重载方法：Intent.put(...)

$.Intent().put("data", "myData").put("more", 568)...

并将其作为额外内容传递，如其他答案中所述。您可以从 中检索额外内容，此外，如果您使用的是 VaporActivity，则会自动为您完成，因此您可以使用：Activity

this.extras()

在另一端检索它们，请切换到。Activity

希望能引起一些:)

您只需要在调用您的意图时发送额外内容即可。

喜欢这个：

Intent intent = new Intent(getApplicationContext(), SecondActivity.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

现在，在你的方法上，你可以像这样获取额外的内容。OnCreateSecondActivity

如果发送的值为长整型：

long value = getIntent().getLongExtra("Variable name which you sent as an extra", defaultValue(you can give it anything));

如果发送的值是 String：

String value = getIntent().getStringExtra("Variable name which you sent as an extra");

如果发送的值是布尔值：

Boolean value = getIntent().getBooleanExtra("Variable name which you sent as an extra", defaultValue);

我在类中使用静态字段，并获取/设置它们：

喜欢：

public class Info
{
    public static int ID      = 0;
    public static String NAME = "TEST";
}

若要获取值，请在 Activity 中使用以下命令：

Info.ID
Info.NAME

要设置值：

Info.ID = 5;
Info.NAME = "USER!";

请考虑使用单例来保存所有活动都可以访问的会话信息。

与附加变量和静态变量相比，这种方法有几个优点：

1. 允许您扩展 Info 类，添加您需要的新用户信息设置。您可以创建一个继承它的新类，或者只编辑 Info 类，而无需更改所有位置的额外处理。

2. 易于使用 - 无需在每项活动中都获得额外费用。

   public class Info {
   
       private static Info instance;
       private int id;
       private String name;
   
       //Private constructor is to disallow instances creation outside create() or getInstance() methods
       private Info() {
   
       }
   
       //Method you use to get the same information from any Activity.
       //It returns the existing Info instance, or null if not created yet.
       public static Info getInstance() {
           return instance;
       }
   
       //Creates a new Info instance or returns the existing one if it exists.
       public static synchronized Info create(int id, String name) {
   
           if (null == instance) {
               instance = new Info();
               instance.id = id;
               instance.name = name;
           }
           return instance;
       }
   }
   

查理·柯林斯（Charlie Collins）用.我不知道我们可以那么容易地对它进行子类化。下面是使用自定义应用程序类的简化示例。Application.class

AndroidManifest.xml

指定属性以使用您自己的应用程序类。android:name

...
<application android:name="MyApplication"
    android:allowBackup="true"
    android:icon="@drawable/ic_launcher"
    android:label="@string/app_name"
    android:theme="@style/AppTheme" >
....

MyApplication.java

将其用作全局参考持有人。它在同一进程中工作正常。

public class MyApplication extends Application {
    private MainActivity mainActivity;

    @Override
    public void onCreate() {
        super.onCreate();
    }

    public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }
    public MainActivity getMainActivity() { return mainActivity; }
}

MainActivity.java

设置对应用程序实例的全局“单一实例”引用。

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ((MyApplication)getApplication()).setMainActivity(this);
    }
    ...

}

MyPreferences.java

一个简单的示例，我使用另一个活动实例中的主活动。

public class MyPreferences extends PreferenceActivity
            implements SharedPreferences.OnSharedPreferenceChangeListener {
    @SuppressWarnings("deprecation")
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.preferences);
        PreferenceManager.getDefaultSharedPreferences(this)
            .registerOnSharedPreferenceChangeListener(this);
    }

    @Override
    public void onSharedPreferenceChanged(SharedPreferences prefs, String key) {
        if (!key.equals("autostart")) {
            ((MyApplication)getApplication()).getMainActivity().refreshUI();
        }
    }
}

源类：

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("firstName", "Your First Name Here");
myIntent.putExtra("lastName", "Your Last Name Here");
startActivity(myIntent)

目标类（NewActivity 类）：

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.view);

    Intent intent = getIntent();

    String fName = intent.getStringExtra("firstName");
    String lName = intent.getStringExtra("lastName");
}

Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

您可以在其他活动中检索它。两种方式：

int id = getIntent.getIntExtra("id", /* defaltvalue */ 2);

第二种方式是：

Intent i = getIntent();
String name = i.getStringExtra("name");

/*
 * If you are from transferring data from one class that doesn't
 * extend Activity, then you need to do something like this.
 */ 

public class abc {
    Context context;

    public abc(Context context) {
        this.context = context;
    }

    public void something() {
        context.startactivity(new Intent(context, anyone.class).putextra("key", value));
    }
}

您可以使用 ...SharedPreferences

1. 伐木。时间存储会话 IDSharedPreferences

   SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
   Editor editor = preferences.edit();
   editor.putString("sessionId", sessionId);
   editor.commit();
   

2. 注销。sharedpreferences 中的时间提取会话 ID

   SharedPreferences preferences = getSharedPreferences("session", getApplicationContext().MODE_PRIVATE);
   String sessionId = preferences.getString("sessionId", null);
   

如果没有所需的会话 ID，请删除 sharedpreferences：

SharedPreferences settings = context.getSharedPreferences("session", Context.MODE_PRIVATE);
settings.edit().clear().commit();

这非常有用，因为有一次您保存了该值，然后检索了活动的任何位置。

使用全局类：

public class GlobalClass extends Application
{
    private float vitamin_a;


    public float getVitaminA() {
        return vitamin_a;
    }

    public void setVitaminA(float vitamin_a) {
        this.vitamin_a = vitamin_a;
    }
}

您可以从所有其他类中调用此类的 setter 和 getter。 这样做，你需要在每个 Actitity 中创建一个 GlobalClass-Object：

GlobalClass gc = (GlobalClass) getApplication();

然后你可以调用例如：

gc.getVitaminA()

标准方法。

Intent i = new Intent(this, ActivityTwo.class);
AutoCompleteTextView textView = (AutoCompleteTextView) findViewById(R.id.autocomplete);
String getrec=textView.getText().toString();
Bundle bundle = new Bundle();
bundle.putString(“stuff”, getrec);
i.putExtras(bundle);
startActivity(i);

现在，在第二个活动中，从捆绑包中检索数据：

获取捆绑包

Bundle bundle = getIntent().getExtras();

提取数据...

String stuff = bundle.getString(“stuff”); 

我使用公共静态字段来存储活动之间的共享数据，但为了尽量减少其副作用，您可以：

• 只创建一个字段，或尽可能少地创建，然后重用它们，使它们成为 object 类型，并在接收活动中将其转换为所需的类型。
• 每当其中任何一个不再有用时，请在下一次分配之前将其显式设置为 null，以便由垃圾回收器收集。

您可以使用 intent 对象在 Activity 之间发送数据。 假设您有两个活动，即 和 。FirstActivitySecondActivity

在 FirstActivity 内部：

使用 Intent：

i = new Intent(FirstActivity.this,SecondActivity.class);
i.putExtra("key", value);
startActivity(i)

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

现在，您可以使用不同的 bundle 类方法按 Key 获取从 FirstActivity 传递的值。

例如，、等。bundle.getString("key")bundle.getDouble("key")bundle.getInt("key")

如果要在 Activites/Fragments 之间传输位图

---

活动

在 Activites 之间传递位图

Intent intent = new Intent(this, Activity.class);
intent.putExtra("bitmap", bitmap);

在 Activity 类中

Bitmap bitmap = getIntent().getParcelableExtra("bitmap");

---

片段

在片段之间传递位图

SecondFragment fragment = new SecondFragment();
Bundle bundle = new Bundle();
bundle.putParcelable("bitmap", bitmap);
fragment.setArguments(bundle);

在 SecondFragment 中接收

Bitmap bitmap = getArguments().getParcelable("bitmap");

---

传输大位图

如果 binder 事务失败，这意味着通过将大型元素从一个活动转移到另一个活动，超出了 binder 事务缓冲区。

因此，在这种情况下，您必须将位图压缩为字节数组，然后在另一个活动中解压缩它，如下所示

在 FirstActivity 中

Intent intent = new Intent(this, SecondActivity.class);

ByteArrayOutputStream stream = new ByteArrayOutputStream();
bitmap.compress(Bitmap.CompressFormat.JPG, 100, stream);
byte[] bytes = stream.toByteArray(); 
intent.putExtra("bitmapbytes",bytes);

在第二个活动中

byte[] bytes = getIntent().getByteArrayExtra("bitmapbytes");
Bitmap bmp = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

您还可以通过创建可包裹类来传递自定义类对象。使其可打包的最佳方法是编写您的类，然后简单地将其粘贴到像 http://www.parcelabler.com/ 这样的站点。单击“构建”，您将获得新代码。复制所有这些内容并替换原始类内容。 然后-

Intent intent = new Intent(getBaseContext(), NextActivity.class);
Foo foo = new Foo();
intent.putExtra("foo", foo);
startActivity(intent);

并在 NextActivity 中获取结果，例如 -

Foo foo = getIntent().getExtras().getParcelable("foo");

现在，您可以像以前一样简单地使用 foo 对象。

您的问题是，您希望在登录后存储会话 ID，并将该会话 ID 用于要注销的每个活动。

问题的解决方案是，成功登录后，您必须将会话 ID 存储在公共变量中。每当您需要会话 ID 进行注销时，您都可以访问该变量并将变量值替换为零。

//Serializable class

public class YourClass  implements Serializable {
     public long session_id = 0;
}

从活动

int n= 10;
Intent in = new Intent(From_Activity.this,To_Activity.class);
Bundle b1 = new Bundle();
b1.putInt("integerNumber",n);
in.putExtras(b1);
startActivity(in);

到活动

Bundle b2 = getIntent().getExtras();
int m = 0;
if(b2 != null){
 m = b2.getInt("integerNumber");
}

这是我的最佳实践，当项目庞大而复杂时，它会有很大帮助。

假设我有 2 个活动，并且 . 我想将 2 个参数（用户名和密码）从 传递给 。LoginActivityHomeActivityLoginActivityHomeActivity

首先，我创建我的HomeIntent

public class HomeIntent extends Intent {

    private static final String ACTION_LOGIN = "action_login";
    private static final String ACTION_LOGOUT = "action_logout";

    private static final String ARG_USERNAME = "arg_username";
    private static final String ARG_PASSWORD = "arg_password";


    public HomeIntent(Context ctx, boolean isLogIn) {
        this(ctx);
        //set action type
        setAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);
    }

    public HomeIntent(Context ctx) {
        super(ctx, HomeActivity.class);
    }

    //This will be needed for receiving data
    public HomeIntent(Intent intent) {
        super(intent);
    }

    public void setData(String userName, String password) {
        putExtra(ARG_USERNAME, userName);
        putExtra(ARG_PASSWORD, password);
    }

    public String getUsername() {
        return getStringExtra(ARG_USERNAME);
    }

    public String getPassword() {
        return getStringExtra(ARG_PASSWORD);
    }

    //To separate the params is for which action, we should create action
    public boolean isActionLogIn() {
        return getAction().equals(ACTION_LOGIN);
    }

    public boolean isActionLogOut() {
        return getAction().equals(ACTION_LOGOUT);
    }
}

以下是我在 LoginActivity 中传递数据的方法

public class LoginActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);

        String username = "phearum";
        String password = "pwd1133";
        final boolean isActionLogin = true;
        //Passing data to HomeActivity
        final HomeIntent homeIntent = new HomeIntent(this, isActionLogin);
        homeIntent.setData(username, password);
        startActivity(homeIntent);

    }
}

最后一步，这是我如何接收数据HomeActivity

public class HomeActivity extends AppCompatActivity {

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

        //This is how we receive the data from LoginActivity
        //Make sure you pass getIntent() to the HomeIntent constructor
        final HomeIntent homeIntent = new HomeIntent(getIntent());
        Log.d("HomeActivity", "Is action login?  " + homeIntent.isActionLogIn());
        Log.d("HomeActivity", "username: " + homeIntent.getUsername());
        Log.d("HomeActivity", "password: " + homeIntent.getPassword());
    }
}

做！酷:)我只想分享我的经验。如果你从事小项目，这应该不是大问题。但是当你在做大项目时，当你想重构或修复错误时，真的很痛苦。

试试这个：

当前活动.java

Intent intent = new Intent(currentActivity.this, TargetActivity.class);
intent.putExtra("booktype", "favourate");
startActivity(intent);

目标活动.java

Bundle b = getIntent().getExtras();
String typesofbook = b.getString("booktype");

补充答案：键字符串的命名约定

传递数据的实际过程已经得到回答，但大多数答案都使用硬编码字符串作为 Intent 中的键名称。当仅在应用内使用时，这通常没问题。但是，文档建议对标准化数据类型使用常量。EXTRA_*

示例 1：使用 Intent.EXTRA_* 密钥

第一个活动

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(Intent.EXTRA_TEXT, "my text");
startActivity(intent);

第二项活动：

Intent intent = getIntent();
String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);

示例 2：定义自己的静态最终键

如果其中一个字符串不符合您的需求，您可以在第一个活动开始时定义自己的字符串。Intent.EXTRA_*

static final String EXTRA_STUFF = "com.myPackageName.EXTRA_STUFF";

如果仅在自己的应用中使用密钥，则包含包名称只是一种约定。但是，如果您要创建其他应用可以通过 Intent 调用的某种服务，则必须避免命名冲突。

第一项活动：

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(EXTRA_STUFF, "my text");
startActivity(intent);

第二项活动：

Intent intent = getIntent();
String myText = intent.getExtras().getString(FirstActivity.EXTRA_STUFF);

示例 3：使用 String 资源键

尽管文档中未提及，但此答案建议使用 String 资源来避免活动之间的依赖关系。

字符串.xml

 <string name="EXTRA_STUFF">com.myPackageName.MY_NAME</string>

第一个活动

Intent intent = new Intent(getActivity(), SecondActivity.class);
intent.putExtra(getString(R.string.EXTRA_STUFF), "my text");
startActivity(intent);

第二项活动

Intent intent = getIntent();
String myText = intent.getExtras().getString(getString(R.string.EXTRA_STUFF));

你可以使用Intent

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

另一种方法是使用单例模式：

public class DataHolder {

 private static DataHolder dataHolder;
 private List<Model> dataList;

 public void setDataList(List<Model>dataList) {
    this.dataList = dataList;
 }

 public List<Model> getDataList() {
    return dataList;
 }

 public synchronized static DataHolder getInstance() {
    if (dataHolder == null) {
       dataHolder = new DataHolder();
    }
    return dataHolder;
 }
}

从您的 FirstActivity 开始

private List<Model> dataList = new ArrayList<>();
DataHolder.getInstance().setDataList(dataList);

在 SecondActivity 上

private List<Model> dataList = DataHolder.getInstance().getDataList();

您可以尝试共享首选项，它可能是在活动之间共享数据的不错选择

要保存会话 ID -

SharedPreferences pref = myContexy.getSharedPreferences("Session 
Data",MODE_PRIVATE);
SharedPreferences.Editor edit = pref.edit();
edit.putInt("Session ID", session_id);
edit.commit();

为了得到他们——

SharedPreferences pref = myContexy.getSharedPreferences("Session Data", MODE_PRIVATE);
session_id = pref.getInt("Session ID", 0);

在 CurrentActivity.java 中编写以下代码

Intent i = new Intent(CurrentActivity.this, SignOutActivity.class);
i.putExtra("SESSION_ID",sessionId);
startActivity(i);

SignOutActivity.java 中的访问 SessionId 如下

public void onCreate(Bundle savedInstanceState){
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_sign_out);
    Intent intent = getIntent();
    
    // check intent is null or not
    if(intent != null){
        String sessionId = intent.getStringExtra("SESSION_ID");
        Log.d("Session_id : " + sessionId);
    }
    else{
        Toast.makeText(SignOutActivity.this, "Intent is null", Toast.LENGTH_SHORT).show();
    }
}

对于在所有活动中使用会话 ID，您可以按照以下步骤操作。

1-在应用程序的 APPLICATION 文件中定义一个 STATIC VARIABLE session（它将保存会话 ID 的值）。

2-现在使用要获取会话 ID 值的类引用调用会话变量并将其分配给静态变量。

3-现在，您只需通过以下方式调用静态变量，即可在任何地方使用此会话 ID 值

通过 Bundle 对象从此活动传递参数开始另一个活动

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "[email protected]");
startActivity(intent);

检索其他活动 （YourActivity）

String s = getIntent().getStringExtra("USER_NAME");

这对于简单的 kind 数据类型是可以的。 但是，如果要在活动之间传递复杂数据，则需要先对其进行序列化。

在这里，我们有员工模型

class Employee{
    private String empId;
    private int age;
    print Double salary;

    getters...
    setters...
}

你可以使用 google 提供的 Gson lib 来序列化复杂的数据 喜欢这个

String strEmp = new Gson().toJson(emp);
Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("EMP", strEmp);
startActivity(intent);

Bundle bundle = getIntent().getExtras();
String empStr = bundle.getString("EMP");
            Gson gson = new Gson();
            Type type = new TypeToken<Employee>() {
            }.getType();
            Employee selectedEmp = gson.fromJson(empStr, type);

如果您使用 kotlin：

在 MainActivity1 中：

var intent=Intent(this,MainActivity2::class.java)
intent.putExtra("EXTRA_SESSION_ID",sessionId)
startActivity(intent)

在 MainActivity2 中：

if (intent.hasExtra("EXTRA_SESSION_ID")){
    var name:String=intent.extras.getString("sessionId")
}

它帮助我在上下文中看待事物。这里有两个例子。

向前传递数据

主要活动

• 将要发送的数据放入具有键值对的 Intent 中。有关密钥的命名约定，请参阅此答案。
• 使用 开始第二个活动。startActivity

MainActivity.java

public class MainActivity extends AppCompatActivity {

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // get the text to pass
        EditText editText = (EditText) findViewById(R.id.editText);
        String textToPass = editText.getText().toString();

        // start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        intent.putExtra(Intent.EXTRA_TEXT, textToPass);
        startActivity(intent);
    }
}

第二项活动

• 你用来获取开始第二个活动的。然后，您可以使用在第一个活动中定义的键提取数据。由于我们的数据是一个字符串，我们将在这里使用。getIntent()IntentgetExtras()getStringExtra

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

        // get the text from MainActivity
        Intent intent = getIntent();
        String text = intent.getStringExtra(Intent.EXTRA_TEXT);

        // use the text in a TextView
        TextView textView = (TextView) findViewById(R.id.textView);
        textView.setText(text);
    }
}

传回数据

主要活动

• 使用 开始第二个活动，为其提供任意结果代码。startActivityForResult
• 覆盖。当第二个活动完成时，将调用此函数。您可以通过检查结果代码来确保它实际上是第二个活动。（当您从同一主活动启动多个不同的活动时，这很有用。onActivityResult
• 提取您从返回中获得的数据。使用键值对提取数据。我可以使用任何字符串作为键，但我将使用预定义的字符串，因为我正在发送文本。IntentIntent.EXTRA_TEXT

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private static final int SECOND_ACTIVITY_REQUEST_CODE = 0;

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

    // "Go to Second Activity" button click
    public void onButtonClick(View view) {

        // Start the SecondActivity
        Intent intent = new Intent(this, SecondActivity.class);
        startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);
    }

    // This method is called when the second activity finishes
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        // check that it is the SecondActivity with an OK result
        if (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {
            if (resultCode == RESULT_OK) {

                // get String data from Intent
                String returnString = data.getStringExtra(Intent.EXTRA_TEXT);

                // set text view with string
                TextView textView = (TextView) findViewById(R.id.textView);
                textView.setText(returnString);
            }
        }
    }
}

第二项活动

• 将要发送回上一个活动的数据放入 .数据存储在使用键值对中。我选择使用我的密钥。IntentIntentIntent.EXTRA_TEXT
• 将结果设置为并添加保存数据的意向。RESULT_OK
• 调用以关闭第二个活动。finish()

SecondActivity.java

public class SecondActivity extends AppCompatActivity {

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

    // "Send text back" button click
    public void onButtonClick(View view) {

        // get the text from the EditText
        EditText editText = (EditText) findViewById(R.id.editText);
        String stringToPassBack = editText.getText().toString();

        // put the String to pass back into an Intent and close this activity
        Intent intent = new Intent();
        intent.putExtra(Intent.EXTRA_TEXT, stringToPassBack);
        setResult(RESULT_OK, intent);
        finish();
    }
}

数据对象应扩展 Parcelable 或 Serializable 类。

Intent mIntent = new Intent(FirstActivity.this, SecondActivity.class);
mIntent.putExtra("data", data);
startActivity(mIntent);

要在 Java 中执行此操作，请执行以下操作：

startActivity(new Intent(this, MainActivity.class).putExtra("userId", "2"));

第一项活动：

Intent intent = new Intent(getApplicationContext(), ClassName.class);
intent.putExtra("Variable name", "Value you want to pass");
startActivity(intent);

第二项活动：

String str= getIntent().getStringExtra("Variable name which you sent as an extra");

您可以使用意向类在 Activity 之间发送数据。它基本上是发送给操作系统的消息，您可以在其中描述数据流的源和目标。就像从 A 到 B 活动的数据一样。

在活动 A（来源）中：

Intent intent = new Intent(A.this, B.class);
intent.putExtra("KEY","VALUE");
startActivity(intent);

在活动 B（目标）->中

Intent intent =getIntent();
String data =intent.getString("KEY");

在这里，您将获得键“KEY”的数据

为了更好地使用，为了简单起见，密钥应始终存储在类中，这将有助于将键入错误的风险降至最低

喜欢这个：

public class Constants{
public static String KEY="KEY"
}

现在在活动 A 中：

intent.putExtra(Constants.KEY,"VALUE");

在活动 B 中：

String data =intent.getString(Constants.KEY);

“目标”活动定义如下：

public class DestinationActivity extends AppCompatActivity{

    public static Model model;
    public static void open(final Context ctx, Model model){
          DestinationActivity.model = model;
          ctx.startActivity(new Intent(ctx, DestinationActivity.class))
    }

    public void onCreate(/*Parameters*/){
           //Use model here
           model.getSomething();
    }
}

在第一个活动中，开始第二个活动，如下所示：

DestinationActivity.open(this,model);

您可以通过意向在两个活动之间进行通信。每当您通过登录活动导航到任何其他活动时，您都可以将 sessionId 放入 intent 中，并通过 getIntent（） 在其他活动中获取它。以下是该代码的代码片段：

LoginActivity：

Intent intent = new Intent(YourLoginActivity.this,OtherActivity.class);
intent.putExtra("SESSION_ID",sessionId);
startActivity(intent);
finishAfterTransition();

其他活动：

在 onCreate（） 或任何需要它调用的地方 getIntent（）.getStringExtra（“SESSION_ID”）; 此外，请确保检查意向是否为 null，并且您在意向中传递的键在两个活动中应相同。以下是完整的代码片段：

if(getIntent!=null && getIntent.getStringExtra("SESSION_ID")!=null){
  sessionId = getIntent.getStringExtra("SESSION_ID");
}

但是，我建议您使用 AppSharedPreferences 来存储您的 sessionId，并在需要时从中获取它。

Kotlin

从第一个活动传递

val intent = Intent(this, SecondActivity::class.java)
intent.putExtra("key", "value")
startActivity(intent)

进入第二个活动

val value = intent.getStringExtra("key")

建议

始终将密钥放在常量文件中，以便以更管理的方式。

companion object {
    val KEY = "key"
}

使用回调在活动之间进行新的实时交互：

- STEP 01：实现共享接口

public interface SharedCallback {
    public String getSharedText(/*you can define arguments here*/);
}

- STEP 02：实现共享类

final class SharedMethode {
    private static WeakReference<Context> mContext;

    private static SharedMethode sharedMethode = new SharedMethode();

    private SharedMethode() {
        super();
    }

    public static SharedMethode getInstance() {
        return sharedMethode;
    }

    public void setContext(Context context) {
        if (mContext != null)
            return;

        mContext = new WeakReference<Context>(context);
    }

    public boolean contextAssigned() {
        return mContext != null && mContext.get() != null;
    }

    public Context getContext() {
        return mContext.get();
    }

    public void freeContext() {
        if (mContext != null) mContext.clear();
        mContext = null;
    }
}

- STEP 03 ：： 在第一个活动中玩代码

public class FirstActivity extends Activity implements SharedCallback {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.your_layout);

        // call playMe from here or there
        playMe();
    }

    private void playMe() {
        SharedMethode.getInstance().setContext(this);
        Intent intent = new Intent(this, SecondActivity.class);
        startActivity(intent);
    }

    @Override
    public String getSharedText(/*passed arguments*/) {
        return "your result";
    }

}

- STEP 04 ：： 在 SecondActivity 中完成游戏

public class SecondActivity extends Activity {

    private SharedCallback sharedCallback;

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

        if (SharedMethode.getInstance().contextAssigned()) {
            if (SharedMethode.getInstance().getContext() instanceof SharedCallback)
                sharedCallback = (SharedCallback) SharedMethode.getInstance().getContext();

            // to prevent memory leak
            SharedMethode.freeContext();
        }

        // You can now call your implemented methodes from anywhere at any time
        if (sharedCallback != null)
            Log.d("TAG", "Callback result = " + sharedCallback.getSharedText());

    }

    @Override
    protected void onDestroy() {
        sharedCallback = null;
        super.onDestroy();
    }

}

• STEP 05 ：： 您还可以实现一个 backword 回调（从 First 到 Second）来从 SecondAvtivity 获取一些结果或调用一些方法

第一种方式：在当前 Activity 中，当您创建意图对象以打开新屏幕时：

String value="xyz";
Intent intent = new Intent(CurrentActivity.this, NextActivity.class);    
intent.putExtra("key", value);
startActivity(intent);

然后，在 onCreate 方法的 nextActivity 中，检索从上一个活动传递的那些值：

if (getIntent().getExtras() != null) {
      String value = getIntent().getStringExtra("key");
      //The key argument must always match that used send and retrieve value from one activity to another.
  }

第二种方式：您可以创建一个 bundle 对象并将值放入 bundle 中，然后将 bundle 对象放入当前活动的意图中 -

String value="xyz";
Intent intent = new Intent(CurrentActivity.this, NextActivity.class);  
Bundle bundle = new Bundle();
bundle.putInt("key", value);  
intent.putExtra("bundle_key", bundle);
startActivity(intent);

然后，在 onCreate 方法的 nextActivity 中，检索从上一个活动传递的那些值：

if (getIntent().getExtras() != null) {
      Bundle bundle = getIntent().getStringExtra("bundle_key");    
      String value = bundle.getString("key");
      //The key argument must always match that used send and retrieve value from one activity to another.
  }

您还可以使用 Bean 类在使用序列化的类之间传递数据。

我们可以通过两种方式将值传递给另一个活动（已经发布了相同类型的答案，但我在这里发布了通过意图尝试的重新编码）

1.通过意图

  Activity1:
      startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));

InActivity 2:

String recString= getIntent().getStringExtra("title");

2.通过 SharedPreference

  Activity1:

SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); 
 // 0 - for private mode
Editor editor = pref.edit();
editor.putString("key_name", "string value"); // Storing string
editor.commit(); // commit changes

Activty2:
   SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0); 

pref.getString("key_name", null); // getting String

将数据传递给 one to 的最佳方式是使用 ，ActivityAnothetActivityIntent

检查截取的代码

活动一.java

Intent myIntent = new Intent(this, NewActivity.class);
myIntent.putExtra("key_name_one", "Your Data value here");
myIntent.putExtra("key_name_two", "Your data value here");
startActivity(myIntent)

关于你的第二次活动

SecondActivity.java

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.view);

    Intent intent = getIntent();

    String valueOne = intent.getStringExtra("key_name_one");
    String valueTwo = intent.getStringExtra("key_name_two");
}

若要访问所有活动中的会话 ID，必须将会话 ID 存储在 SharedPreference 中。

请参阅下面我用于管理会话的类，您也可以使用相同的类。

import android.content.Context;
import android.content.SharedPreferences;

public class SessionManager {

    public static String KEY_SESSIONID = "session_id";

    public static String PREF_NAME = "AppPref";

    SharedPreferences sharedPreference;
    SharedPreferences.Editor editor;
    Context mContext;

    public SessionManager(Context context) {
        this.mContext = context;

        sharedPreference = context.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
        editor = sharedPreference.edit();
    }


    public String getSessionId() {
        return sharedPreference.getString(KEY_SESSIONID, "");
    }

    public void setSessionID(String id) {
        editor.putString(KEY_SESSIONID, id);
        editor.commit();
        editor.apply();
    }   
}

//Now you can access your session using below methods in every activities.

    SessionManager sm = new SessionManager(MainActivity.this);
sm.getSessionId();



//below line us used to set session id on after success response on login page.

    sm.setSessionID("test");

 Intent intent = new Intent(getBaseContext(), SomeActivity.class);
 intent.putExtra("USER_ID", UserId);
 startActivity(intent);

 On SomeActivity : 

 String userId= getIntent().getStringExtra("("USER_ID");

在当前活动中创建新的。Intent

String myData="Your string/data here";
Intent intent = new Intent(this, SecondActivity.class);    
intent.putExtra("your_key",myData);
startActivity(intent);

在 Retrieve those value using key 中SecondActivity.javaonCreate()your_key

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

    Bundle extras = getIntent().getExtras();
    if (extras != null) {
        String myData = extras.getString("your_key");
    }  
}

您可以使用意向。

String sessionId = "my session id";
startActivity(new Intent(getApplicationContext(),SignOutActivity.class).putExtra("sessionId",sessionId));

使用 Bundle @link https://medium.com/@nikhildhyani365/pass-data-from-one-activity-to-another-using-bundle-18df2a701142
//从介质复制

           Intent I =  new Intent(MainActivity.this,Show_Details.class);

            Bundle b = new Bundle();


            int x = Integer.parseInt(age.getText().toString());
            int y = Integer.parseInt(className.getText().toString());

            b.putString("Name",name.getText().toString());

            b.putInt("Age",x);
            b.putInt("ClassName",y);

            I.putExtra("student",b);

            startActivity(I);

使用意图 @link https://android.jlelse.eu/passing-data-between-activities-using-intent-in-android-85cb097f3016

在 Activity 和 Android 应用程序的其他组件之间传递数据的方法不止一种。一种是使用意图和可包裹，正如很多答案中已经提到的。

另一种巧妙的方法是使用 Eventbus 库。

从发出活动：

EventBus.getDefault().postSticky("--your Object--");

在 recv 活动中：

EventBus.getDefault().removeStickyEvent("--Object class--")

其他需要考虑的要点：

1. 提供更多的自由度，您可以传递复杂的对象，而无需以任何形式修改它们。
2. 不仅限于在活动之间传递数据，设置库后，您可以使用它在应用程序管道中将数据从一个位置传递到另一个位置。例如，将其用于 BottomSheetMenu 进行活动通信。
3. 稳定的库。
4. 简化组件之间的通信
5. 分离事件发送方和接收方
6. 在处理 UI 工件（例如 Activity、Fragments）和后台线程时表现良好
7. 避免复杂且容易出错的依赖关系和生命周期问题
8. 速度快;专为高性能而优化
9. 很小（~60k 罐）
10. 在实践中，安装了 1,000,000,000+ 次的应用程序证明了这一点
11. 具有高级功能，如交付线程、订阅者优先级等。

换句话说，您可以使用接口传递数据。

我们有 2 个活动 A，B，那么我该怎么办，创建一个界面，如下所示：

public interface M{
    void data(String m);
}

然后你可以像下面的代码一样在 A 类中调用此方法的赋值：

public class A extends AppCompatActivity{
    
   M m;   //inteface name
  
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.a);
       
        m= (M) getActivity();

    //now call method in interface and send data im sending direct you can use same on click

    m.data("Rajeev");
    }
}

现在，您必须在类 B 中实现该接口：

public class B extends AppCompatActivity implements M{
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.b);
    }

    @Override
    public void data(String m) {
        you can use m as your data to toast the value here it will be same value what you sent from class A
    }
}