В своей текущей деятельности создайте новый 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
}

Используйте эту технику для передачи переменных из одного действия в другое.

Передача Intent extras - хороший подход, как отметил Эрих.

Объект Application - это еще один способ, и иногда бывает проще иметь дело с одним и тем же состоянием в нескольких действиях (в отличие от чтобы получить/поместить его повсюду) или объекты более сложные, чем примитивы и строки.

Вы можете расширить Application, а затем установить/получить все, что хотите, и получить доступ к нему из любого Activity (в том же приложении) с помощью getApplication().

Также имейте в виду, что другие подходы, которые вы можете увидеть, например, статика, могут быть проблематичными, поскольку они могут привести к утечке памяти. Приложение также помогает решить эту проблему.

Класс источника:

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

Обновлено примечание, что я упомянул об использовании 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, ...));
...

Затем вы можете создать намерение для предполагаемой деятельности и убедиться, что у вас есть все параметры. Вы можете приспособиться к фрагментам. Простой пример выше, но вы поняли идею.

Попробуйте сделать следующее:

Создайте простой "вспомогательный" класс (factory для ваших намерений), например:

import android.content.Intent;

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

Это будет factory для всех ваших намерений. Каждый раз, когда вам нужно новое намерение, создайте статический метод factory в IntentHelper. Чтобы создать новый Intent, вы должны просто сказать следующее:

IntentHelper.createYourSpecialIntent(getIntent());

В вашей деятельности. Если вы хотите "сохранить" некоторые данные в "сеансе", просто используйте следующее:

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

И отправьте это намерение. В целевом мероприятии ваше поле будет доступно как:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Итак, теперь мы можем использовать Intent как тот же старый сеанс (например, в сервлетах или JSP).

Это помогает мне видеть вещи в контексте. Вот два примера.

Передача данных вперед

Основная деятельность

• Поместите данные, которые вы хотите отправить в 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() и ключа, который вы определили в первом 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();
    }
}

Вы также можете передавать пользовательские объекты класса, создавая класс parableable. Лучший способ сделать его более простым - написать свой класс, а затем просто вставить его на сайт, например 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 объект, который вы бы использовали.

Другим способом является использование открытого статического поля, в котором вы храните данные, то есть:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

Самый удобный способ передачи данных между действиями - это передача намерений. В первом действии, откуда вы хотите отправить данные, вы должны добавить код,

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

Вы можете использовать SharedPreferences...

• Logging

  . Идентификатор сеанса хранения времени в SharedPreferences

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

• SignOut. Идентификатор сеанса выборки времени в sharedpreferences

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

Если у вас нет требуемого идентификатора сеанса, удалите sharedpreferences:

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

Это очень полезно, потому что один раз вы сохраняете значение, а затем извлекаете откуда угодно.

Стандартный подход.

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

Из действия

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

Вы можете отправлять данные между действиями с использованием объекта-объекта. У вас есть два вида действий: FirstActivity и SecondActivity.

Внутри FirstActivity:

Использование намерения:

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

Внутри SecondActivity

Bundle bundle= getIntent().getExtras();

Теперь вы можете использовать различные методы класса пакетов для получения значений, переданных из 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);

Чтобы получить внутри второго фрагмента

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

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

Вот моя лучшая практика, и это помогает много, когда проект огромен и сложный.

Предположим, что у меня есть 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());
    }
}

Готово! Классно :) Я просто хочу поделиться своим опытом. Если вы работаете над небольшим проектом, это не должно быть большой проблемой. Но когда вы работаете над большим проектом, это действительно боль, когда вы хотите делать рефакторинг или исправлять ошибки.

Вы можете попробовать Совместное предпочтение, это может быть хорошей альтернативой для обмена данными между действиями

Чтобы сохранить идентификатор сеанса -

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

Вы можете использовать Intent

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

Другим способом может быть использование шаблона singleton:

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

По второстепенности

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

Дополнительный ответ: Соглашения об именах для строки клавиш

Фактический процесс передачи данных уже был дан ответ, однако большинство ответов использует жестко закодированные строки для имени ключа в 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, чтобы избежать зависимостей между действиями.

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

Передача данных между действиями происходит главным образом с помощью объекта-объекта.

Сначала вам нужно прикрепить данные к объекту намерения с использованием класса Bundle. Затем вызовите действие с помощью методов startActivity() или startActivityForResult().

Вы можете найти дополнительную информацию об этом, например, из сообщения блога Передача данных в Activity.

Запустите другое действие из этих параметров прохода активности через объект Bundle

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

Получить другую активность (YourActivity)

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

Это нормально для простого типа данных. Но если вы хотите передать сложные данные между действиями, вам нужно сначала ее сериализовать.

Здесь у нас есть модель сотрудника

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

    getters...
    setters...
}

Вы можете использовать Gson lib, предоставляемый google для сериализации сложных данных как это

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

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

Чарли Коллинз дал мне прекрасный ответ, используя 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

Установите глобальную ссылку "singleton" на экземпляр приложения.

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

Я использую статические поля в классе и получаю/устанавливаю их:

Как

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

Для получения значения используйте это в Управлении:

Info.ID
Info.NAME

Для установки значения:

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

Первая активность:

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

Попробуйте следующее:

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

Недавно я выпустил Vapor API, основанную на jQuery платформу Android, которая упрощает всевозможные задачи. Как уже упоминалось, SharedPreferences - это один из способов сделать это.

VaporSharedPreferences реализуется как Singleton, так что это один из вариантов, а в Vapor API имеет сильно перегруженный .put(...) поэтому вам не нужно явно беспокоиться о том, какой тип данных вы совершаете - при условии, что он поддерживается. Он также свободен, поэтому вы можете звонить в сети:

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

Он также может автоматически сохранять изменения и унифицировать процесс чтения и записи под капотом, поэтому вам не нужно явно получать редактор, как в стандартном Android.

В качестве альтернативы вы можете использовать Intent. В API Vapor вы также можете использовать цепной перегруженный .put(...) на VaporIntent:

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

И передайте это как дополнительное, как упомянуто в других ответах. Вы можете извлекать дополнительные функции из своей Activity, и, кроме того, если вы используете VaporActivity это делается для вас автоматически, чтобы вы могли использовать:

this.extras()

Чтобы получить их на другом конце в Activity вы переключитесь на.

Надеюсь, что это интересно для некоторых :)

Котлин

Проход от первого занятия

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

Получить во второй деятельности

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

Предложение

Всегда помещайте ключи в постоянный файл для более управляемого пути.

companion object {
    val KEY = "key"
}

Вы можете общаться между двумя действиями через намерение. Всякий раз, когда вы переходите к любому другому действию через свое действие входа в систему, вы можете поместить свой sessionId в намерение и получить это в других действиях, хотя getIntent(). Ниже приведен фрагмент кода для этого:

LoginActivity:

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

ДругиеДеятельность:

В onCreate() или там, где вам нужно, вызовите getIntent(). GetStringExtra ("SESSION_ID"); Также убедитесь, что проверено, является ли намерение пустым, и ключ, который вы передаете в намерении, должен быть одинаковым в обоих действиях. Вот полный фрагмент кода:

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

Тем не менее, я бы предложил вам использовать AppSharedPreferences для хранения вашего sessionId и получать его оттуда, где это необходимо.

Вы можете передавать данные между действиями в приложении тремя способами. 1.Intent 2.SharedPreferences 3.Application

передача данных в намерении имеет некоторый предел. Для большого количества данных вы можете использовать общий доступ к данным уровня приложения и, сохраняя его в sharedpref, увеличивает размер вашего приложения

Если вы используете 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")
}

Использовать глобальный класс:

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

Вы можете вызвать сеттеры и получатели этого класса из всех других классов. Сделайте это, вам нужно создать объект GlobalClass в каждом Actitity:

GlobalClass gc = (GlobalClass) getApplication();

Затем вы можете позвонить, например:

gc.getVitaminA()

Вы можете использовать класс намерения для отправки данных между действиями. Это в основном сообщение для ОС, где вы описываете источник и назначение потока данных. Подобно данным от A до B.

В ДЕЯТЕЛЬНОСТИ А (источник):

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

Для этого в Java:

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

Ваш объект данных должен расширить класс Parcelable или Serializable

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

Для использования идентификатора сеанса во всех действиях вы можете выполнить следующие шаги.

1-Определите один сеанс STATIC VARIABLE (который будет содержать значение идентификатора сеанса) в файле APPLICATION вашего приложения.

2. Теперь вызовите переменную сеанса с помощью ссылки на класс, в которой вы извлекаете значение идентификатора сеанса и назначаете его статической переменной.

3. Теперь вы можете использовать это значение идентификатора сеанса в любом месте, просто вызвав статическую переменную

Существует несколько способов передачи данных между действиями, а документация содержит многие из них.

В большинстве случаев достаточно Intent.putExtras.

Рассмотрите возможность использования одноэлементного режима для хранения информации о сеансе, доступной для всех видов деятельности.

Этот подход имеет несколько преимуществ по сравнению с дополнительными и статическими переменными:

• Позволяет расширить класс 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;
      }
  }
  

Новое взаимодействие в реальном времени между активами с использованием обратных вызовов:

- ШАГ 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();
    }

}

• ШАГ 05 :: Вы также можете реализовать обратный вызов обратного слова (от первого до второго), чтобы получить некоторые результаты из SecondAvtivity или вызвать некоторые методы

В Деятельности Назначения определите как это

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

Хорошим способом обмена данными между Activity является создание класса с статическими полями и методами.

В моем примере я хочу поделиться ArrayLists <String> между действиями.

public class Values {
    private static Map<String, ArrayList<String>> xValues;

    public static init(){
        if(xValues == null)
            xValues = new HashMap<String, ArrayList<String>>();
    }

    public static ArrayList<String> getStringList(String key){
        return xValues.get(key);
    }

    public static void putStringList(ArrayList<String> value, String key){
        xValues.put(key, value);
    }
}

И затем в основном классе вы только один раз инициализируете. Затем вы просто используете свои статические методы в других классах:

В главном

(Не создавайте объект, потому что вы будете использовать статические методы и поля.):

Values.init();

В любой деятельности или даже в любом классе для размещения нового ArrayList

ArrayList<String> list = new ArrayList<String>();
list.add("Text");
Values.putStringList(list, "mylist");

В любой деятельности или даже в любом классе для получения

for(String s:Values.getStringList("mylist"))
Log.d("My list",s);

Появится запись в журнале: Мой список: Текст.

Заключение. Хорошим способом является использование возможностей Java: статический метод и поля могут быть доступны во всех наших действиях в пакете.

Введите следующий код в CurrentActivity.java

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

Доступ к SessionId в SignOutActivity.java выполняется следующим образом

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

//Ваша проблема заключается в том, что вы хотите сохранить идентификатор сеанса после входа в систему и получить доступ к этому идентификатору сеанса для каждого действия, в котором вы хотите выйти.

//Решение вашей проблемы заключается в том, что вы должны сохранить свой идентификатор сеанса после успешного входа в общедоступную переменную. и всякий раз, когда вам нужен идентификатор сеанса для выхода из системы, вы можете получить доступ к этой переменной и заменить значение переменной на ноль.

//Serializable class

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

Я использую общедоступные статические поля для хранения общих данных между действиями, но чтобы свести к минимуму его побочные эффекты, вы можете:

• Сделайте только одно поле или как можно меньше и повторите их использование, сделайте их объектом типа и передайте его желаемому типу в принимающей активности.
• Всякий раз, когда какой-либо из них больше не полезен, установите его явно в null, которое будет собираться сборщиком мусора, перед следующим назначением.

Этот самый простой способ передать идентификатор сеанса во все Деятельность.

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

Итак, из LogoutActivity вы можете получить session_id, и это будет использоваться далее для работы Sign OUT.

Надеюсь, это будет полезно... спасибо