dans votre activité actuelle, créez un nouveau Intent :

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

Puis dans la nouvelle Activité, récupérer ces valeurs:

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

Utiliser cette technique pour passer des variables d'une Activité à l'autre.

en Passant Intention extras est une bonne approche que Erich noté.

l'objet Application est une autre façon cependant, et il est parfois plus facile de traiter avec le même état à travers des activités multiples (par opposition à devoir obtenir/mettre partout), ou des objets plus complexes que des primitives et des chaînes.

vous pouvez étendre L'Application, puis Définir / obtenir ce que vous voulez et y accéder de toute activité (dans la même application) avec getApplication () .

gardez également à l'esprit que d'autres approches que vous pourriez voir, comme la statique, peut être problématique parce qu'ils peut conduire à des fuites de mémoire . L'Application aide aussi à résoudre ce problème.

Classe Source:

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

classe de Destination (nouvelle classe D'activité):

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

vous avez juste à envoyer des extras tout en appelant votre intention.

comme ceci:

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

maintenant sur la OnCreate méthode de votre SecondActivity vous pouvez aller chercher les extras comme ceci.

si la valeur que vous avez envoyé était long :

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

si la valeur que vous avez envoyé était un String :

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

si la valeur que vous avez envoyé était Boolean :

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

mise à Jour Notez que je l'avais mentionné l'utilisation de SharedPreference . Il a une API simple et est accessible à travers les activités d'une application. Mais c'est une solution maladroite, et c'est un risque de sécurité si vous transmettez des données sensibles. Il est préférable d'utiliser des intentions. Il dispose d'une longue liste de méthodes surchargées qui peuvent être utilisées pour mieux transférer de nombreux types de données entre les activités. Jetez un oeil à intention.putExtra . Ce lien présente l'utilisation de putExtra assez bien.

dans la transmission de données entre les activités, mon approche préférée est de créer une méthode statique pour l'activité pertinente qui inclut les paramètres requis lancer l'intention. Qui fournit ensuite facilement la configuration et les paramètres de récupération. Donc il peut ressembler à ceci

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

, Alors vous pouvez créer une intention pour l'activité prévue et vous assurer d'avoir tous les paramètre. Vous pouvez vous adapter pour les fragments. Un exemple simple ci-dessus, mais vous obtenez l'idée.

essayez de faire ce qui suit:

créer une classe "helper" simple (usine pour vos intentions), comme ceci:

import android.content.Intent;

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

ce sera l'usine pour tous vos intentions. Chaque fois que vous avez besoin d'une nouvelle intention, créez une méthode d'usine statique dans IntentHelper. Pour créer une nouvelle intention, vous devriez simplement le dire comme ceci:

IntentHelper.createYourSpecialIntent(getIntent());

dans votre activité. Lorsque vous voulez "enregistrer" certaines données dans une "session" utilisez simplement le suivant:

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

et envoyer cette intention. Dans L'activité cible votre domaine sera disponible comme:

getIntent().getStringExtra("YOUR_FIELD_NAME");

donc maintenant nous pouvons utiliser L'intention comme la même vieille session (comme dans servlets ou JSP ).

Il m'aide à voir les choses dans leur contexte. Voici deux exemples.

Transmission De Données

Activité Principale

• Mettre les données que vous voulez envoyer dans une Intention avec une paire clé-valeur. Voir cette réponse pour les conventions de nommage de la clé.
• démarrer la deuxième activité avec startActivity .

activité principale.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);
    }
}

Deuxième Activité

• vous utilisez getIntent() pour obtenir le Intent qui a commencé la deuxième activité. Ensuite, vous pouvez extraire les données getExtras() et la clé que vous avez défini dans la première activité. Puisque nos données sont une chaîne de caractères, Nous allons simplement utiliser getStringExtra ici.

Secondactivité.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);
    }
}

Transmission De Données

Activité Principale

• démarrer la deuxième activité avec startActivityForResult , en lui fournissant un code de résultat arbitraire.
• outrepasser onActivityResult . Cette fonction est appelée quand la Deuxième Activité de fin de. Vous pouvez vous assurer qu'il est en fait la Deuxième Activité en vérifiant le code de résultat. (Ceci est utile lorsque vous commencez plusieurs activités différentes à partir de la même activité principale.)
• extraire les données que vous avez reçues de la déclaration Intent . Les données sont extraites à l'aide d'une paire clé-valeur. Je pourrais utiliser n'importe quelle chaîne pour la clé mais j'utiliserai le prédéfini Intent.EXTRA_TEXT puisque j'envoie du texte.

activité principale.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);
            }
        }
    }
}

Deuxième Activité

• Mettre les données que vous souhaitez envoyer à l'activité précédente dans un Intent . Les données sont stockées dans le Intent à l'aide d'une paire clé-valeur. J'ai choisi d'utiliser Intent.EXTRA_TEXT pour ma clé.
• définissez le résultat à RESULT_OK et ajoutez l'intention de conserver vos données.
• Appel finish() pour fermer la Deuxième Activité.

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

vous pouvez également passer des objets custom class en faisant une classe séparable . La meilleure façon de le rendre Morcelable est d'écrire votre classe et puis simplement le coller sur un site comme http://www.parcelabler.com / . Cliquez sur Construire et vous obtiendrez un nouveau code. Copiez tout cela et remplacez le contenu original de la classe. Puis -

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

et obtenir le résultat dans NextActivity like -

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

Maintenant vous peut simplement utiliser l'objet foo comme vous l'auriez utilisé.

une autre façon est d'utiliser un champ public statique dans lequel vous stockez des données, i.e.:

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...

le moyen le plus pratique de transmettre des données entre les activités est de passer des intentions. Dans la première activité d'où vous voulez envoyer des données, vous devez ajouter le code,

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

vous devez également importer""

import android.content.Intent;

ensuite dans la prochaine activité(Secondactivité), vous devriez récupérer les données de l'intention en utilisant le code suivant.

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

vous pouvez utiliser SharedPreferences ...

1. de l'exploitation forestière. Time store numéro de session dans SharedPreferences

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

2. Signout. Le temps de récupérer l'id de session dans sharedpreferences

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

si vous n'avez pas l'id de session requis, puis supprimer sharedpreferences:

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

C'est très utile, parce qu'une fois vous économisez la valeur et ensuite récupérer n'importe où de l'activité.

l'approche standard.

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

maintenant dans votre deuxième activité récupérez vos données à partir du faisceau:

bundle

Bundle bundle = getIntent().getExtras();

extraire les données ...

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

De L'Activité

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

À L'Activité

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

vous pouvez envoyer des données entre les activités en utilisant l'objet intention. Considérez que vous avez deux activités à savoir FirstActivity et SecondActivity .

À L'Intérieur De FirstActivity:

À L'Aide De L'Intention:

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

Secondactivité Intérieure

Bundle bundle= getIntent().getExtras();

Maintenant vous pouvez utiliser différentes méthodes de classe de faisceau pour obtenir des valeurs passées de la première activité par clé.

E. G. bundle.getString("key") , bundle.getDouble("key") , bundle.getInt("key") etc.

si vous voulez transférer bitmap entre Activites / Fragments

activité

pour passer une bitmap entre les Activites

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

et dans la classe d'activité

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

Fragment

pour passer une image entre les Fragments

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

pour recevoir à l'intérieur du second fragment

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

Transférer Les Grandes Images Bitmap

Si vous obtenez échec de la transaction de reliure, cela signifie que vous dépassez le tampon de transaction de reliure en transférant un élément important d'une activité à une autre.

donc dans ce cas vous devez compresser le bitmap comme un tableau d'octets et puis décompresser dans une autre activité , comme ceci

dans la première activité

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

et dans la deuxième activité

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

, Vous pouvez le récupérer dans une autre activité. Deux voies:

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

la seconde voie est:

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

réponse supplémentaire: Conventions de nommage pour la chaîne de touches

le processus réel de transmission des données a déjà été répondu, mais la plupart des réponses utilisent des chaînes codées pour le nom de la clé dans l'intention. Ceci est généralement bien lorsqu'il est utilisé uniquement dans votre application. Toutefois, la documentation recommande en utilisant les constantes EXTRA_* pour les types de données standardisées.

Exemple 1: Utilisation Intent.EXTRA_* clés

première activité

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

deuxième activité:

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

exemple 2: définition de votre propre static final clé

si l'une des chaînes de caractères Intent.EXTRA_* ne répond pas à vos besoins, vous pouvez définir la vôtre au début de la première activité.

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

y compris le nom du paquet est juste une convention si vous utilisez seulement la clé dans votre propre application. Mais il est nécessaire d'éviter les conflits de nom si vous créez une sorte de service que d'autres applications peuvent appeler avec une intention.

première activité:

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

deuxième activité:

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

exemple 3: Utilisation D'une clé de Ressource String

bien que non mentionné dans la documentation, cette réponse recommande l'utilisation d'une ressource de chaîne de caractères pour éviter les dépendances entre les activités.

cordes.xml

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

première activité

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

deuxième activité

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

Vous pouvez essayer Partagé Préférence, il peut être une bonne alternative pour le partage des données entre les activités

pour enregistrer l'id de session -

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

pour les obtenir -

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

voici ma meilleure pratique et cela aide beaucoup quand le projet est énorme et complexe.

supposons que j'ai deux activités, LoginActivity et HomeActivity . Je veux passer 2 Paramètres (nom d'utilisateur et mot de passe) de LoginActivity à HomeActivity .

tout d'abord, je crée mon 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);
    }
}

Voici comment je transmets les données dans ma Loginactivité

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

    }
}

étape finale, voici comment Je reçois les données dans 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());
    }
}

fait! Cool :) je veux juste partager mon expérience. Si vous travaillez sur un petit projet, cela ne devrait pas être le gros problème. Mais quand vous travaillez sur un grand projet, ça fait vraiment mal quand vous voulez faire des retouches ou corriger des bogues.

la transmission de données entre activités se fait principalement au moyen d'un objet d'intention.

tout d'abord, vous devez joindre les données à l'objet d'intention avec l'utilisation de la classe Bundle . Ensuite, appelez l'activité en utilisant les méthodes startActivity() ou startActivityForResult() .

vous pouvez trouver plus d'informations à ce sujet, avec un exemple de l'article de blog passer des données à une activité .

Charlie Collins m'a donné une réponse parfaite 1519120920 "en utilisant le Application.class . Je ne savais pas que nous pouvions la classer aussi facilement. Voici un exemple simplifié utilisant une classe d'application personnalisée.

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

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

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

}

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

vous pouvez utiliser Intent

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

une autre façon pourrait être d'utiliser singleton pattern aussi:

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

de votre première activité

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

Sur La Secondactivité

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

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

j'utilise des champs statiques dans une classe, et les obtenir/les définir:

Comme:

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

pour obtenir une valeur, utilisez ceci dans une activité:

Info.ID
Info.NAME

pour fixer une valeur:

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

essayez ceci:

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

lancer une autre activité à partir de cette activité passer les paramètres via L'objet Bundle

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

rechercher sur une autre activité (votre activité)

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

c'est ok pour le type de données de type simple. Mais si vous voulez transmettre des données complexes entre deux activités, vous devez d'abord les sérialiser.

ici, nous avons le modèle employé

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

    getters...
    setters...
}

vous pouvez utiliser Gson lib fourni par google pour sérialiser le de données complexes comme ceci

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

j'ai récemment publié Vapor API , un cadre Android parfumé jQuery qui rend toutes sortes de tâches comme ce plus simple. Comme mentionné, SharedPreferences est une façon que vous pourriez faire.

VaporSharedPreferences est implémenté comme Singleton donc c'est une option, et dans L'API Vapor il a une méthode .put(...) lourdement chargée donc vous n'avez pas à vous soucier explicitement du type de données que vous propagez-à condition qu'il soit soutenu. Il est également couramment utilisé, de sorte que vous pouvez enchaîner les appels:

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

il peut aussi modifier les autosaves, et unifie le processus de lecture et d'écriture sous la hotte de sorte que vous n'avez pas besoin de récupérer explicitement un éditeur comme vous le faites dans Android standard.

vous pouvez aussi utiliser un Intent . Dans L'API Vapor, vous pouvez également utiliser la méthode .put(...) surchargée sur une VaporIntent :

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

et le passer comme un supplément, comme mentionné dans les autres réponses. Vous pouvez récupérer des extras de votre Activity , et de plus si vous utilisez VaporActivity cela est fait pour vous automatiquement de sorte que vous pouvez utiliser:

this.extras()

pour les récupérer à l'autre bout du Activity .

l'Espérance qui est d'intérêt pour certains :)

si vous utilisez kotlin:

Dans MainActivity1:

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

Dans MainActivity2:

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

vous pouvez transmettre des données entre les activités dans l'application de trois façons 1.Intention 2.SharedPreferences 3.Application

passer des données dans l'intention ont une certaine limite.Pour une grande quantité de données, vous pouvez utiliser le partage de données au niveau de L'Application et en le stockant dans sharedpref fait votre taille de l'application augmenter