如何在Android应用程序中的活动之间传递数据？

Question

我有一个场景,通过登录页面登录后button,每个都会有一个注销activity.

点击后sign-out,我将通过session id已登录用户登出.任何人都可以指导我如何让session id所有人都可以使用activities吗？

任何替代这种情况

Answer 1

在当前的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.

Answer 2

最简单的方法是将会话ID传递给Intent您用于启动活动的注销活动:

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

访问意图下一个活动

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

Intent 的文档有更多信息(请参阅标题为"Extras"的部分).

Answer 3

Erich指出,传递Intent附加功能是一种很好的方法.

该应用程序对象虽然是另一种方式,并跨多个活动相同的状态打交道时(而不是让获得/把它无处不在),有时更容易,或者比的对象原语和字符串更加复杂.

您可以扩展Application,然后设置/获取您想要的任何内容,并使用getApplication()从任何Activity(在同一个应用程序中)访问它.

另请注意,您可能会看到的其他方法(如静态)可能会出现问题,因为它们可能会导致内存泄漏.应用程序也有助于解决此问

Answer 4

来源类:

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

Answer 5

你只需要在调用你的意图时发送附加内容.

像这样:

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

现在OnCreate你的方法SecondActivity你可以像这样获取额外的东西.

如果您发送的值是long:

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:

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

Answer 6

更新注意我已经提到过使用SharedPreference.它有一个简单的API,可以在应用程序的活动中访问.但这是一个笨拙的解决方案,如果您传递敏感数据,则存在安全风险.最好使用意图.它有一个广泛的重载方法列表,可用于在活动之间更好地传输许多不同的数据类型.看看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, ...));
...

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

Answer 7

它帮助我在上下文中看到事物.这是两个例子.

传递数据

主要活动

• 将要发送的数据放入具有键值对的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()来Intent开始第二个活动.然后,您可以使用getExtras()您在第一个活动中定义的密钥和数据提取数据.由于我们的数据是String,我们将在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.当第二个活动完成时调用此方法.您可以通过检查结果代码确保它实际上是第二个活动.(当您从同一主活动中启动多个不同的活动时,这非常有用.)
• 提取从返回中获得的数据Intent.使用键值对提取数据.我可以使用任何字符串作为键,但我将使用预定义,Intent.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);
            }
        }
    }
}

第二项活动

• 将要发送回上一个活动的数据放入Intent.数据存储在Intent使用键值对中.我选择使用Intent.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();
    }
}

Answer 8

尝试执行以下操作:

创建一个简单的"帮助器"类(Intents的工厂),如下所示:

import android.content.Intent;

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

这将是您所有意图的工厂.每次需要新的Intent时,在IntentHelper中创建一个静态工厂方法.要创建一个新的Intent,你应该这样说:

IntentHelper.createYourSpecialIntent(getIntent());

在你的活动中.如果要在"会话"中"保存"某些数据,请使用以下命令:

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

并发送此意图.在目标活动中,您的字段将显示为:

getIntent().getStringExtra("YOUR_FIELD_NAME");

所以现在我们可以像使用相同的旧会话一样使用Intent(比如在servlet或JSP中).

Answer 9

您还可以通过创建parcelable类来传递自定义类对象.使其成为可分割的最佳方法是编写您的类,然后将其粘贴到像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对象.

Answer 10

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

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Answer 11

在活动之间传递数据最方便的方法是传递意图.在您要发送数据的第一个活动中,您应该添加代码,

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)中,您应该使用以下代码从intent中检索数据.

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

Answer 12

你可以用SharedPreferences......

1. 日志记录.时间存储会话IDSharedPreferences

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

2. 登出.共享偏好中的时间提取会话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();

这非常有用,因为有一次你保存了值然后检索活动的任何地方.

Answer 13

标准方法.

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

Answer 14

来自活动

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

Answer 15

您可以使用intent对象在活动之间发送数据.想想你有即两个活动FirstActivity和SecondActivity.

在FirstActivity内:

使用意图:

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

在SecondActivity里面

Bundle bundle= getIntent().getExtras();

现在,您可以使用不同的bundle类方法来获取Key从FirstActivity传递的值.

例如 bundle.getString("key"),bundle.getDouble("key"),bundle.getInt("key")等.

Answer 16

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

活动

在Activites之间传递位图

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

并在Activity类中

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

分段

在Fragments之间传递位图

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

在SecondFragment内部接收

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

传输大位图

如果您的活页夹事务失败,这意味着您将大型元素从一个活动转移到另一个活动,从而超出了活页夹事务缓冲区.

所以在这种情况下你必须将位图压缩为一个字节的数组,然后在另一个活动中解压缩它,就像这样

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

而在SecondActivity中

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

Answer 17

科特林

从第一个活动通过

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

进入第二个活动

val value = intent.getStringExtra("key")

建议

始终将密钥放在常量文件中以获得更多管理方式。

companion object {
    val KEY = "key"
}

Answer 18

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

Answer 19

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

假设我有2个活动,LoginActivity并且HomeActivity.我想从通过2个参数(用户名和密码)LoginActivity来HomeActivity.

首先,我创造了我的 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());
    }
}

完成!酷:)我只想分享我的经验.如果您从事小型项目,这不应该是一个大问题.但是当你在大项目上工作时,当你想要重构或修复bug时真的很痛苦.

Answer 20

补充答案:密钥字符串的命名约定

已经回答了传递数据的实际过程,但是大多数答案都使用硬编码字符串作为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:定义自己的static final密钥

如果其中一个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资源来避免活动之间的依赖关系.

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

Answer 21

您可以使用 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();

Answer 22

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

Answer 23

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

首先,您必须使用类将数据附加到intent对象Bundle.然后使用其中一个startActivity()或startActivityForResult()方法调用活动.

您可以通过博客文章将数据传递给活动中的示例找到有关它的更多信息.

Answer 24

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

保存会话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);

Answer 25

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

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

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

它还可以选择自动保存更改，并统一底层的读写过程，因此您无需像在标准 Android 中那样显式检索编辑器。

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

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

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

this.extras()

要在您切换到的另一端检索它们Activity。

希望有些人对此感兴趣:)

Answer 26

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

Answer 27

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

Intent intent = new Intent(getBaseContext(), YourActivity.class);
intent.putExtra("USER_NAME", "xyz@gmail.com");
startActivity(intent);

检索另一个活动（YourActivity）

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

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

这里有员工模型

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

Answer 28

第一个活动：

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

Answer 29

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

  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 retrive value from one activity to another.
  }

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

  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 retrive value from one activity to another.
  }

您还可以使用 bean 类通过序列化在类之间传递数据。