传递数据

Question

我有一个场景，在通过登录页面登录后，每个button都会有一个退出activity。

点击sign-out后，我将通过已登录用户的session id进行退出。任何人都可以指导我如何让所有session id {/ 1}}都可以使用activities吗？

此案例的替代方案

Answer 1

在您当前的活动中，创建一个新的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");

Intents的docs有更多信息（请查看标题为“Extras”的部分）。

Answer 3

正如埃里希所说，传递Intent额外内容是一种很好的方法。

Application对象是另一种方式，有时在跨多个活动处理相同状态时更容易（相对于必须将其放到任何地方），或者比原语和字符串更复杂的对象。

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

另请注意，您可能会看到的其他方法（如静态）可能会出现问题，因为它们can lead to memory leaks。应用程序也有助于解决这个问题。

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的{{1}}方法，你可以像这样获取额外内容。

如果您发送的值在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

Answer 6

已更新请注意，我已提及使用SharedPreference。它有一个简单的API，可以在应用程序的活动中访问。但这是一个笨拙的解决方案，如果您传递敏感数据，则存在安全风险。最好使用意图。它有一个广泛的重载方法列表，可用于在活动之间更好地传输许多不同的数据类型。看看intent.putExtra。这个link很好地展示了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中。有关密钥的命名约定，请参阅this answer。
使用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()和第一个活动中定义的密钥提取数据。由于我们的数据是字符串，因此我们将在这里使用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 ...

记录日志。时间商店会话ID在SharedPreferences

中

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

Signout。共享偏好中的时间提取会话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。

Inside FirstActivity：

使用意图：

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

Inside SecondActivity

Bundle bundle= getIntent().getExtras();

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

E.g。 bundle.getString("key")，bundle.getDouble("key")，bundle.getInt("key")等。

Answer 16

如果您想在活动/片段之间转移位图

<强>活动

在Activites

之间传递位图

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

并在“活动课程”

中

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

转移大型位图

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

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

在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

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 18

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

假设我有2项活动，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 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 19

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

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

您可以通过博客文章 Passing data to an Activity 中的示例找到有关它的更多信息。

Answer 20

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

已经回答了传递数据的实际过程，但是大多数答案都使用硬编码字符串作为Intent中的键名。只在您的应用中使用时，这通常很好。但是，documentation recommends使用标准数据类型的/home/hanbing/Documents/train/train.txt常量。

示例1：使用EXTRA_*键

第一项活动

Intent.EXTRA_*

第二项活动：

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

示例2：定义您自己的Intent intent = getIntent(); String myText = intent.getExtras().getString(Intent.EXTRA_TEXT);密钥

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

Intent.EXTRA_*

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

第一项活动：

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

第二项活动：

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

示例3：使用字符串资源键

虽然文档中没有提到，this answer建议使用String资源来避免活动之间的依赖关系。

的strings.xml

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

第一项活动

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

Answer 21

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

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

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

Answer 23

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

On SecondActivity

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

Answer 24

/*
 * 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 25

查理柯林斯使用Application.class给了我一个完美的answer。我不知道我们可以轻松地将它子类化。以下是使用自定义应用程序类的简化示例。

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

Answer 26

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

像：

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

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

Info.ID
Info.NAME

用于设置值：

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

Answer 27

科特林

通过“第一项活动”通过

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

参与第二活动

val value = getIntent().getStringExtra("key")

建议

始终将密钥放置在常量文件中，以实现更多托管方式。

companion object {
    val KEY = "key"
}

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

Try this:

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

Answer 30

我最近发布了Vapor API，一个jQuery风格的Android框架，可以让各种各样的任务变得更简单。如上所述，SharedPreferences是您可以这样做的一种方式。

VaporSharedPreferences是作为Singleton实现的，因此这是一个选项，并且在Vapor API中它有一个严重过载的.put(...)方法，因此您不必明确担心您提交的数据类型 - 提供它受到支持。它也很流利，所以你可以链接电话：

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

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

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

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

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

this.extras()

要在Activity转到的另一端检索它们。

希望某些人感兴趣：）

Answer 31

使用全局类：

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

Answer 32

您可以通过3种方式在应用程序中的活动之间传递数据 1.Intent 2.SharedPreferences 3.应用

在意图中传递数据有一些限制。对于大量数据，您可以使用应用程序级数据共享并将其存储在sharedpref中，使您的应用程序大小增加

Answer 33

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

LoginActivity ：

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

OtherActivity ：

在onCreate（）或您需要的任何地方调用   getIntent（）。getStringExtra（“ SESSION_ID”）;       还要确保检查意图是否为空，并且您在两个活动中传递的意图关键字都应该相同。这里是   完整代码段：

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

但是，我建议您使用AppSharedPreferences进行存储您的sessionId，并从任何需要的位置获取。

Answer 34

在当前活动中创建新的Intent

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

在您的SecondActivity.java onCreate()内部，使用密钥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");
    }  
}

Answer 35

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

  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类通过序列化在类之间传递数据。

Answer 36

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

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

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

3 - 现在只需通过

调用静态变量，就可以在任何地方使用此会话ID值

Answer 37

如果你使用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")
}

Answer 38

有多种方法可以在活动之间传递数据，the documentation有许多方法。

对于大多数情况，Intent.putExtras就足够了。

Answer 39

您的数据对象应扩展Parcelable或Serializable类

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

Answer 40

在Java中执行此操作：

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

Answer 41

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

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

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

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

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

Answer 42

您可以使用Intent类在Activity之间发送数据。基本上，这是发给OS的消息，您可以在其中描述数据流的源和目标。像数据从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);

Answer 43

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

-步骤01：实现共享接口

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

-步骤02：实现共享类

final class SharedMethode {
    private static 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 = context;
    }

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

    public Context getContext() {
        return mContext;
    }

    public void freeContext() {
        mContext = null;
    }
}

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

}

-步骤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中获得一些结果或调用某些方法

Answer 44

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

 On SomeActivity : 

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

Answer 45

在Destination活动中，定义如下

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

Answer 46

您可以专心工作

String sessionId = "my session id";

    startActivity(new Intent(getApplicationContext(),SignOutActivity.class).putExtra("sessionId",sessionId));

Answer 47

使用套装 @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

Answer 48

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

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

来自发射活动：

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

在接收活动中：

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

要考虑的其他要点：

赋予更多自由，您可以传递复杂的对象而无需以任何形式对其进行修改。
不仅限于在活动之间传递数据，一旦设置了库，就可以使用它在应用程序管道中将数据从一个地方传递到另一个地方。例如，将其用于BottomSheetMenu进行活动交流。
稳定的库。
简化了组件之间的通信
解耦事件发送者和接收者
在UI工件（例如“活动”，“片段”）和后台线程中表现良好
避免复杂且容易出错的依赖性和生命周期问题
速度很快；专为高性能而优化的
很小（约60k罐）
在实践中已被安装超过1,000,000,000次的应用程序证明
具有高级功能，例如传递线程，订户优先级等。

Answer 49

通过其他方式，您可以使用接口传递数据。

我们有 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
    }
}

Answer 50

To access session id in all activities you have to store session id in SharedPreference

Please see below class that i am using for managing sessions, you can also use same.



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

Answer 51

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

检查代码是否被删除

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上

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

Answer 52

我们可以通过两种方式将值传递给另一个Activity（已经发布了相同的答案，但是我在这里发布了代码，试图通过intent进行尝试）

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

Answer 53

//您的问题是您希望在登录后存储会话ID，并为您要注销的每个活动提供该会话ID。

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

//Serializable class

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

Answer 54

在 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 = i.getStringExtra("SESSION_ID");
        Log.d("Session_id : " + sessionId);
    }
    else{
        Toast.makeText(SignOutActivity.this, "Intent is null", Toast.LENGTH_SHORT).show();
    }
}

Answer 55

这是最简单的方法将会话ID 传递给所有活动。

Intent mIntent = new Intent(getApplicationContext(), LogoutActivity.class);
mIntent.putExtra("session_id", session_id);
startActivity(mIntent);

因此，从 LogoutActivity ，您可以获取 session_id ，这将进一步用于Sign OUT操作。

希望这会有所帮助......谢谢

Answer 56

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

只制作一个字段，或尽可能少，并重复使用它们，使它们成为对象类型并将其转换为接收活动中所需的类型。
只要它们中的任何一个不再有用，在下一次分配之前，将它显式设置为null以便由垃圾收集器收集。

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

56 个答案:

传递数据

主要活动

第二项活动

传递数据

主要活动

第二项活动

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

`AndroidManifest.xml`

`MyApplication.java`

`MainActivity.java`

`MyPreferences.java`

科特林

-步骤01：实现共享接口

-步骤02：实现共享类

-步骤03 ::在“首次活动”中玩代码

-步骤04 ::在SecondActivity中完成游戏