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

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

在单击sign-out时，我将传递登录用户的session id以注销。有人可以指导我如何让session id对所有activities可用吗？

这个案子的任何替代方案

1196722 次浏览
小开
最佳答案

最简单的方法是将会话ID传递给您用于启动活动的Intent中的Signout活动：

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

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

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

意图的文档有更多信息（查看标题为“额外”的部分）。

小开

尝试执行以下操作：

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

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）。

小开

正如埃里希所指出的那样，传递意图额外内容是一个很好的方法。

申请方式对象是另一种方式，当处理多个活动中的相同状态（而不是必须在任何地方获取/放置它）或比原语和字符串更复杂的对象时，有时会更容易。

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

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

小开

更新中请注意，我提到了共享首选项的使用。它有一个简单的API，可以在应用程序的活动中访问。但这是一个笨拙的解决方案，如果你传递敏感数据，会有安全风险。最好使用意图。它有一个广泛的重载方法列表，可以用来更好地在活动之间传输许多不同的数据类型。看看intent.put额外。这个链接很好地展示了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, ...));...

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

小开

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

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

然后在新的活动中，检索这些值：

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

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

小开

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

String str = "My Data"; //Data you want to sendIntent 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 activitesv.getContext().startActivity(intent);

您还应该导入

import android.content.Intent;

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

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

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

public class MyActivity extends Activity {
public static String SharedString;public static SomeObject SharedObject;
//...
小开

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

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

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

小开

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

#0是作为Singleton实现的，所以这是一种选择，在Vapor API中，它有一个严重重载的.put(...)方法，所以你不必明确担心你正在提交的数据类型——只要它得到支持。它也很流畅，所以你可以链接调用：

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

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

或者，您可以使用Intent。在Vapor API中，您还可以在#2上使用chainable重载.put(...)方法：

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

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

this.extras()

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

希望对一些人感兴趣：）

小开

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

像这样：

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

现在在SecondActivity的OnCreate方法上，您可以像这样获取额外内容。

如果您发送的值是#0：

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

如果您发送的值是#0：

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

如果您发送的值是#0：

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

要获取值，请在活动中使用它：

Info.IDInfo.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() methodsprivate 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;
@Overridepublic void onCreate() {super.onCreate();}
public void setMainActivity(MainActivity activity) { this.mainActivity=activity; }public MainActivity getMainActivity() { return mainActivity; }}

MainActivity.java

将全局“单例”引用设置为应用程序实例。

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

MyPreferences.java

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

public class MyPreferences extends PreferenceActivityimplements SharedPreferences.OnSharedPreferenceChangeListener {@SuppressWarnings("deprecation")@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);addPreferencesFromResource(R.xml.preferences);PreferenceManager.getDefaultSharedPreferences(this).registerOnSharedPreferenceChangeListener(this);}
@Overridepublic 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)

目标类（NewActive类）：

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. 记录。SharedPreferences中的时间存储会话ID

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

  2. Signout. Time fetch session id in sharedpreferences

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

If you don't have the required session id, then remove 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 bundle = getIntent().getExtras();

提取数据…

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

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

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

您可以使用意图对象在活动之间发送数据。假设您有两个活动，即FirstActivity和SecondActivity。

第一个活动内部：

使用意图：

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

秒级内部活动

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

在活动类中

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

碎片

在Fragments之间传递位图

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

在第二个片段中接收

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

传输大位图

如果您获得失败的绑定器事务，这意味着您通过将大元素从一个活动传输到另一个活动来超过绑定器事务缓冲区。

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

在第一个活动中

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

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

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

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

假设我有两个活动，LoginActivity和HomeActivity。我想从LoginActivity传递2个参数（用户名和密码）到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 typesetAction(isLogIn ? ACTION_LOGIN : ACTION_LOGOUT);}
public HomeIntent(Context ctx) {super(ctx, HomeActivity.class);}
//This will be needed for receiving datapublic 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 actionpublic boolean isActionLogIn() {return getAction().equals(ACTION_LOGIN);}
public boolean isActionLogOut() {return getAction().equals(ACTION_LOGOUT);}}

这是我在LoginActivity中传递数据的方式

public class LoginActivity extends AppCompatActivity {@Overrideprotected 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 HomeActivityfinal HomeIntent homeIntent = new HomeIntent(this, isActionLogin);homeIntent.setData(username, password);startActivity(homeIntent);
}}

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

public class HomeActivity extends AppCompatActivity {
@Overrideprotected 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 constructorfinal 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());}}

完成！酷：）我只想分享我的经验。如果你在小项目上工作，这应该不是什么大问题。但是当你在大项目上工作时，当你想重构或修复错误时，真的很痛苦。

小开

试试这个：

CurrentActivity.java

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

TargetActivity.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：定义自己的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：使用字符串资源密钥

虽然在留档中没有提到，但这个答案建议使用字符串资源来避免活动之间的依赖关系。

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

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

从你的第一次活动 

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

第二个活动

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

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

保存会话ID-

SharedPreferences pref = myContexy.getSharedPreferences("SessionData",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 notif(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-在应用程序的应用程序文件中定义一个STATIC VARIABLE会话（它将保存会话ID的值）。

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

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

小开

通过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...}

您可以使用谷歌提供的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 {
@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);}
// "Go to Second Activity" button clickpublic void onButtonClick(View view) {
// get the text to passEditText editText = (EditText) findViewById(R.id.editText);String textToPass = editText.getText().toString();
// start the SecondActivityIntent intent = new Intent(this, SecondActivity.class);intent.putExtra(Intent.EXTRA_TEXT, textToPass);startActivity(intent);}}

第二次活动

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

SecondActivity.java

public class SecondActivity extends AppCompatActivity {
@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_second);
// get the text from MainActivityIntent intent = getIntent();String text = intent.getStringExtra(Intent.EXTRA_TEXT);
// use the text in a TextViewTextView 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;
@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);}
// "Go to Second Activity" button clickpublic void onButtonClick(View view) {
// Start the SecondActivityIntent intent = new Intent(this, SecondActivity.class);startActivityForResult(intent, SECOND_ACTIVITY_REQUEST_CODE);}
// This method is called when the second activity finishes@Overrideprotected void onActivityResult(int requestCode, int resultCode, Intent data) {super.onActivityResult(requestCode, resultCode, data);
// check that it is the SecondActivity with an OK resultif (requestCode == SECOND_ACTIVITY_REQUEST_CODE) {if (resultCode == RESULT_OK) {
// get String data from IntentString returnString = data.getStringExtra(Intent.EXTRA_TEXT);
// set text view with stringTextView textView = (TextView) findViewById(R.id.textView);textView.setText(returnString);}}}}

第二次活动

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

SecondActivity.java

public class SecondActivity extends AppCompatActivity {
@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_second);}
// "Send text back" button clickpublic void onButtonClick(View view) {
// get the text from the EditTextEditText editText = (EditText) findViewById(R.id.editText);String stringToPassBack = editText.getText().toString();
// put the String to pass back into an Intent and close this activityIntent 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");
小开

您可以使用意图类在活动之间发送数据。它基本上是一条到操作系统的消息，您可以在其中描述数据流的来源和目的地。就像从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 heremodel.getSomething();}}

在第一个活动中，像下面这样开始第二个活动：

DestinationActivity.open(this,model);
小开

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

登录状态：

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

其他业务：

在onCreate（）或任何需要它调用的地方get Intent（）. get String Extra（"SESSION_ID"）；此外，请确保检查意图是否为空，并且你在意图中传递的键在两个活动中应该相同。这是完整的代码片段：

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

但是，我建议您使用AppSharedPretions来存储您的会话ID，并从需要的任何地方获取它。

小开

静态编程语言

通过第一次活动

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

进入第二个活动

val value = intent.getStringExtra("key")

强烈推荐

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

companion object {val KEY = "key"}
小开

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

-步骤01：实现共享接口

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

步骤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;}}

步骤03:: 在第一个活动中播放代码

public class FirstActivity extends Activity implements SharedCallback {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.your_layout);
// call playMe from here or thereplayMe();}
private void playMe() {SharedMethode.getInstance().setContext(this);Intent intent = new Intent(this, SecondActivity.class);startActivity(intent);}
@Overridepublic String getSharedText(/*passed arguments*/) {return "your result";}
}

-步骤04:: 完成游戏的第二个活动

public class SecondActivity extends Activity {
private SharedCallback sharedCallback;
@Overrideprotected 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 leakSharedMethode.freeContext();}
// You can now call your implemented methodes from anywhere at any timeif (sharedCallback != null)Log.d("TAG", "Callback result = " + sharedCallback.getSharedText());
}
@Overrideprotected void onDestroy() {sharedCallback = null;super.onDestroy();}
}
  • STEP 05:: 你也可以实现一个backword回调（从First到Two），以获得一些结果，或者调用一些方法
小开

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

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.through意图

  Activity1:startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));
InActivity 2:
String recString= getIntent().getStringExtra("title");

2.通过共享偏好

  Activity1:
SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0);// 0 - for private modeEditor editor = pref.edit();editor.putString("key_name", "string value"); // Storing stringeditor.commit(); // commit changes
Activty2:SharedPreferences pref = getApplicationContext().getSharedPreferences("MyPref", 0);
pref.getString("key_name", null); // getting String
小开

使用Intent将数据传递给Activity到AnothetActivity的最佳方式，

检查剪下的代码

ActivityOne.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存储在共享偏好中。

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

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

在你的SecondActivity.javaonCreate()内使用键your_key检索这些值

@Overrideprotected 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@linkhttps://medium.com/@nikheldhyani365/从一个活动传递数据到另一个使用捆绑包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);

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

小开

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

另一种优雅的方法是使用Eventbus库。

从发射活动：

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

在recv活动中：

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

其他需要考虑的要点：

  1. 提供更多的自由，您可以传递复杂的对象，而无需以任何形式修改它们。
  2. 不限于仅在活动之间传递数据，设置库后，您可以使用它在应用程序管道中将数据从一个地方传递到另一个地方。例如，将此用于BottomSheetMenu到活动通信。
  3. 稳定库。
  4. 简化组件之间的通信
  5. 解耦事件发送者和接收者
  6. 在UI工件（例如活动、片段）和后台线程中表现良好
  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  
@Overrideprotected 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{@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.b);}
@Overridepublic 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}}

提交答案