it-swarm.com.de

Wie übergebe ich Daten zwischen Aktivitäten in der Anwendung Android?

Ich habe ein Szenario, in dem nach dem Anmelden über eine Anmeldeseite auf jedem button eine Abmeldung activity erfolgt.

Wenn ich auf sign-out klicke, gebe ich den session id des angemeldeten Benutzers zum Abmelden weiter. Kann mich jemand anleiten, wie ich session id für alle activities verfügbar halte?

Eine Alternative zu diesem Fall

1258
UMAR

Am einfachsten ist es, die Sitzungs-ID an die Abmeldeaktivität in dem Intent zu übergeben, mit dem Sie die Aktivität starten:

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

Greifen Sie auf diese Absicht bei der nächsten Aktivität zu:

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

In docs for Intents finden Sie weitere Informationen (siehe Abschnitt "Extras").

1175
Erich Douglass

Erstellen Sie in Ihrer aktuellen Aktivität ein neues Intent:

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

Rufen Sie dann in der neuen Aktivität diese Werte ab:

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

Verwenden Sie diese Technik, um Variablen von einer Aktivität an die andere zu übergeben.

1376
user914425

Passing Intent Extras ist ein guter Ansatz, wie Erich bemerkte.

Das Application -Objekt ist jedoch eine andere Möglichkeit, und es ist manchmal einfacher, wenn derselbe Zustand über mehrere Aktivitäten hinweg behandelt wird (anstatt ihn überall abrufen/ablegen zu müssen), oder Objekte, die komplexer sind als Primitive und Strings .

Sie können Application erweitern und dann dort festlegen/abrufen, was Sie möchten, und von einer beliebigen Aktivität (in derselben Anwendung) mit getApplication () darauf zugreifen.

Denken Sie auch daran, dass andere Ansätze, wie z. B. die Statik, problematisch sein können, da sie zu Speicherverlusten führen können . Anwendung hilft auch dies zu lösen.

136
Charlie Collins

Quellklasse:

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

Zielklasse (NewActivity-Klasse):

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");
}
92
Md. Rahman

Sie müssen nur Extras senden, während Sie Ihre Absicht anrufen.

So was:

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

Jetzt können Sie auf der OnCreate -Methode Ihres SecondActivity die Extras wie folgt abrufen.

Wenn der von Ihnen gesendete Wert in long war:

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

Wenn der von Ihnen gesendete Wert String war:

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

Wenn der von Ihnen gesendete Wert Boolean war:

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

Aktualisiert Beachten Sie, dass ich die Verwendung von SharedPreference erwähnt hatte. Es verfügt über eine einfache API und ist für alle Aktivitäten einer Anwendung verfügbar. Dies ist jedoch eine umständliche Lösung und stellt ein Sicherheitsrisiko dar, wenn Sie vertrauliche Daten weitergeben. Verwenden Sie am besten Absichten. Es verfügt über eine umfangreiche Liste überladener Methoden, mit denen viele verschiedene Datentypen besser zwischen Aktivitäten übertragen werden können. Schauen Sie sich intent.putExtra an. Dieses link zeigt die Verwendung von putExtra recht gut.

Wenn ich Daten zwischen Aktivitäten übergebe, ist mein bevorzugter Ansatz, eine statische Methode für die relevante Aktivität zu erstellen, die die erforderlichen Parameter enthält, um die Absicht auszulösen. Damit lassen sich Parameter einfach einrichten und abrufen. So kann es also aussehen

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

Dann können Sie eine Absicht für die beabsichtigte Aktivität erstellen und sicherstellen, dass Sie alle Parameter haben. Sie können für Fragmente anpassen. Ein einfaches Beispiel oben, aber Sie bekommen die Idee.

44
angryITguy

Es hilft mir, die Dinge im Kontext zu sehen. Hier sind zwei Beispiele.

Weitergabe von Daten

enter image description here

Hauptaktivität

  • Fügen Sie die Daten, die Sie senden möchten, in eine Absicht mit einem Schlüssel-Wert-Paar ein. In diese Antwort finden Sie die Namenskonventionen für den Schlüssel.
  • Starten Sie die zweite Aktivität mit 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);
    }
}

Zweite Aktivität

  • Sie verwenden getIntent(), um die Intent abzurufen, mit der die zweite Aktivität gestartet wurde. Dann können Sie die Daten mit getExtras() und dem Schlüssel extrahieren, den Sie in der ersten Aktivität definiert haben. Da es sich bei unseren Daten um einen String handelt, wird hier nur getStringExtra verwendet.

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

Daten zurückgeben

enter image description here

Hauptaktivität

  • Starten Sie die zweite Aktivität mit startActivityForResult und geben Sie einen beliebigen Ergebniscode ein.
  • onActivityResult überschreiben. Dies wird aufgerufen, wenn die zweite Aktivität beendet ist. Sie können sicherstellen, dass es sich tatsächlich um die zweite Aktivität handelt, indem Sie den Ergebniscode überprüfen. (Dies ist nützlich, wenn Sie mehrere verschiedene Aktivitäten von derselben Hauptaktivität aus starten.)
  • Extrahieren Sie die Daten, die Sie aus der Rückgabe Intent erhalten haben. Die Daten werden mit einem Schlüssel-Wert-Paar extrahiert. Ich könnte einen beliebigen String für den Schlüssel verwenden, aber ich werde den vordefinierten Intent.EXTRA_TEXT verwenden, da ich Text sende.

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

Zweite Aktivität

  • Fügen Sie die Daten, die Sie an die vorherige Aktivität zurücksenden möchten, in ein Intent ein. Die Daten werden unter Verwendung eines Schlüssel-Wert-Paares in Intent gespeichert. Ich habe mich entschieden, Intent.EXTRA_TEXT für meinen Schlüssel zu verwenden.
  • Setzen Sie das Ergebnis auf RESULT_OK und fügen Sie die Absicht hinzu, die Ihre Daten enthält.
  • Rufen Sie finish() auf, um die zweite Aktivität zu schließen.

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

Versuchen Sie Folgendes:

Erstellen Sie eine einfache "Helfer" -Klasse (Factory für Ihre Zwecke), wie folgt:

import Android.content.Intent;

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

Dies wird die Fabrik für alle Ihre Absichten sein. Wenn Sie einen neuen Intent benötigen, erstellen Sie in IntentHelper eine statische Factory-Methode. Um eine neue Absicht zu erstellen, solltest du es einfach so sagen:

IntentHelper.createYourSpecialIntent(getIntent());

In Ihrer Tätigkeit. Wenn Sie einige Daten in einer "Sitzung" "speichern" möchten, verwenden Sie einfach Folgendes:

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

Und senden Sie diese Absicht. In der Zielaktivität ist Ihr Feld verfügbar als:

getIntent().getStringExtra("YOUR_FIELD_NAME");

Jetzt können wir Intent wie dieselbe alte Sitzung verwenden (wie in Servlets oder JSP ).

37
ponkin

Sie können benutzerdefinierte Klassenobjekte auch übergeben, indem Sie eine parcelable Klasse erstellen. Der beste Weg, um es paketfähig zu machen, besteht darin, Ihre Klasse zu schreiben und sie dann einfach in eine Site wie http://www.parcelabler.com/ einzufügen. Klicken Sie auf Build und Sie erhalten neuen Code. Kopieren Sie alles und ersetzen Sie den ursprünglichen Klasseninhalt. Dann-

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

und erhalten das Ergebnis in NextActivity like-

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

Jetzt können Sie einfach das foo Objekt verwenden, wie Sie es verwendet hätten.

26
Vaibhav Sharma

Eine andere Möglichkeit besteht darin, ein öffentliches statisches Feld zu verwenden, in dem Sie Daten speichern, z.

public class MyActivity extends Activity {

  public static String SharedString;
  public static SomeObject SharedObject;

//...
23
ComputerSaysNo

Der bequemste Weg, Daten zwischen Aktivitäten zu übertragen, ist die Übergabe von Absichten. In der ersten Aktivität, von der aus Sie Daten senden möchten, sollten Sie Code hinzufügen,

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

Sie sollten auch importieren

import Android.content.Intent;

Anschließend sollten Sie in der nächsten Aktivität (SecondActivity) die Daten mit dem folgenden Code aus der Absicht abrufen.

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

Sie können SharedPreferences... verwenden.

  1. Protokollierung. Zeitspeicher-Sitzungs-ID in SharedPreferences

    SharedPreferences preferences = getSharedPreferences("session",getApplicationContext().MODE_PRIVATE);
    Editor editor = preferences.edit();
    editor.putString("sessionId", sessionId);
    editor.commit();
    
  2. Ausloggen. Zeitabruf-Sitzungs-ID in freigegebenen Einstellungen

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

Wenn Sie nicht die erforderliche Sitzungs-ID haben, entfernen Sie freigegebene Einstellungen:

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

Das ist sehr nützlich, weil Sie den Wert einmal speichern und dann eine beliebige Aktivität abrufen.

18
Ravi Parsania

Der Standardansatz.

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

Rufen Sie jetzt in Ihrer zweiten Aktivität Ihre Daten aus dem Bundle ab:

Holen Sie sich das Bundle

Bundle bundle = getIntent().getExtras();

Extrahieren Sie die Daten ...

String stuff = bundle.getString(“stuff”); 
17
Ajay Venugopal

Aus Aktivität

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

zur Aktivität

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

Sie können Daten zwischen Aktivitäten mit dem Absichtsobjekt senden. Angenommen, Sie haben zwei Aktivitäten, nämlich FirstActivity und SecondActivity.

Innerhalb von FirstActivity:

Verwendungszweck:

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

Innerhalb von SecondActivity

Bundle bundle= getIntent().getExtras();

Jetzt können Sie verschiedene Bundle-Klassenmethoden verwenden, um Werte von FirstActivity per Key zu übergeben.

Z.B. bundle.getString("key"), bundle.getDouble("key"), bundle.getInt("key") usw.

11
Krishna

Wenn Sie eine Bitmap zwischen Activites/Fragments übertragen möchten


Aktivität

Übergeben einer Bitmap zwischen Aktivitäten

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

und in der Aktivitätsklasse

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

Fragment

Um eine Bitmap zwischen Fragmenten zu übergeben

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

Innerhalb des zweiten Fragmentes empfangen

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

Übertragung großer Bitmaps

Wenn Sie eine fehlgeschlagene Binder-Transaktion erhalten, bedeutet dies, dass Sie den Binder-Transaktionspuffer überschreiten, indem Sie ein großes Element von einer Aktivität zu einer anderen Aktivität übertragen.

In diesem Fall müssen Sie die Bitmap als Array eines Bytes komprimieren und dann in einer anderen Aktivität dekomprimieren., so

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

Und in der SecondActivity

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

Hier ist meine beste Praxis und es hilft sehr, wenn das Projekt riesig und komplex ist.

Angenommen, ich habe 2 Aktivitäten, LoginActivity und HomeActivity. Ich möchte 2 Parameter (Benutzername und Passwort) von LoginActivity an HomeActivity übergeben.

Zuerst erstelle ich mein 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);
    }
}

So übergebe ich die Daten in meine 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);

    }
}

Letzter Schritt, hier ist, wie ich die Daten in HomeActivity erhalte

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

Getan! Cool :) Ich möchte nur meine Erfahrungen teilen. Wenn Sie an kleinen Projekten arbeiten, sollte dies nicht das große Problem sein. Aber wenn Sie an einem großen Projekt arbeiten, tut es wirklich weh, wenn Sie Fehler überarbeiten oder beheben möchten.

8
THANN Phearum
Intent intent = new Intent(YourCurrentActivity.this, YourActivityName.class);
intent.putExtra("NAme","John");
intent.putExtra("Id",1);
startActivity(intent);

Sie können es in einer anderen Aktivität abrufen. Zwei Wege:

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

Der zweite Weg ist:

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

Sie können Intent verwenden.

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

Ein anderer Weg könnte sein, Singleton-Muster auch zu verwenden:

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

Aus Ihrer FirstActivity

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

Auf SecondActivity

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

Ergänzende Antwort: Namenskonventionen für die Schlüsselzeichenfolge

Der eigentliche Datenübergabevorgang wurde bereits beantwortet, die meisten Antworten verwenden jedoch fest codierte Zeichenfolgen für den Schlüsselnamen im Intent. Dies ist normalerweise in Ordnung, wenn es nur in Ihrer App verwendet wird. Die Dokumentation empfiehlt Verwendung der EXTRA_*-Konstanten für standardisierte Datentypen.

Beispiel 1: Verwenden der Tasten Intent.EXTRA_*

Erste Aktivität

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

Zweite Aktivität:

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

Beispiel 2: Definieren Sie Ihren eigenen static final Schlüssel

Wenn eine der Zeichenfolgen Intent.EXTRA_* nicht Ihren Anforderungen entspricht, können Sie zu Beginn der ersten Aktivität eine eigene definieren.

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

Das Einfügen des Paketnamens ist nur dann eine Konvention, wenn Sie den Schlüssel nur in Ihrer eigenen App verwenden. Es ist jedoch wichtig, Namenskonflikte zu vermeiden, wenn Sie einen Dienst erstellen, den andere Apps mit Absicht aufrufen können.

Erste Aktivität:

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

Zweite Aktivität:

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

Beispiel 3: Verwenden eines String-Ressourcenschlüssels

Obwohl in der Dokumentation nicht erwähnt, empfiehlt diese Antwort die Verwendung einer String-Ressource, um Abhängigkeiten zwischen Aktivitäten zu vermeiden.

strings.xml

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

Erste Aktivität

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

Zweite Aktivität

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

Die Weitergabe von Daten zwischen Aktivitäten erfolgt hauptsächlich über ein Absichtsobjekt.

Zuerst müssen Sie die Daten mit der Klasse Bundle an das Intent-Objekt anhängen. Rufen Sie dann die Aktivität mit den Methoden startActivity() oder startActivityForResult() auf.

Weitere Informationen dazu finden Sie in einem Beispiel aus dem Blog-Beitrag Daten an eine Aktivität übergeben.

6
PRABEESH R K

Sie können Shared Preference ausprobieren. Dies ist möglicherweise eine gute Alternative, um Daten zwischen den Aktivitäten auszutauschen

So speichern Sie die Sitzungs-ID:

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

Um sie zu bekommen -

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

Starten Sie eine andere Aktivität aus diesen Aktivitätsübergabeparametern über das Bundle-Objekt

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

Bei einer anderen Aktivität abrufen (YourActivity)

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

Dies ist in Ordnung für den einfachen Datentyp. Wenn Sie jedoch komplexe Daten zwischen den Aktivitäten weitergeben möchten, müssen Sie diese zuerst serialisieren.

Hier haben wir Angestelltenmodell

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

    getters...
    setters...
}

Sie können die von Google bereitgestellte Gson lib verwenden, um die komplexen Daten wie folgt zu serialisieren

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

Charlie Collins gab mir ein perfektes Antwort mit dem Application.class. Mir war nicht bewusst, dass wir es so einfach unterordnen könnten. Hier ist ein vereinfachtes Beispiel mit einer benutzerdefinierten Anwendungsklasse.

AndroidManifest.xml

Geben Sie das Android:name -Attribut an, um Ihre eigene Anwendungsklasse zu verwenden.

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

MyApplication.Java

Verwenden Sie dies als globalen Referenzinhaber. Es funktioniert gut in einem gleichen Prozess.

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

Setzen Sie den globalen "Singleton" -Verweis auf die Anwendungsinstanz.

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

Ein einfaches Beispiel, in dem ich eine Hauptaktivität aus einer anderen Aktivitätsinstanz verwende.

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();
        }
    }
}
4
Whome
/*
 * 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));
    }
}
4
Dip Pokhrel

Kotlin

Pass von der ersten Aktivität

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

Get in Second Activity

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

Vorschlag

Legen Sie die Schlüssel immer in einer konstanten Datei ab, um die Verwaltung zu vereinfachen.

companion object {
    val KEY = "key"
}
4
Khemraj

Ich verwende statische Felder in einer Klasse und erhalte/setze sie:

Mögen:

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

Verwenden Sie diese Option in einer Aktivität, um einen Wert zu erhalten:

Info.ID
Info.NAME

Zum Einstellen eines Wertes:

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

Erste Aktivität:

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

Zweite Aktivität:

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

Ich habe kürzlich die Vapor API veröffentlicht, ein Framework mit jQuery-Geschmack Android, das alle Arten von Aufgaben wie diese einfacher macht. Wie bereits erwähnt, ist SharedPreferences eine Möglichkeit, dies zu tun.

VaporSharedPreferences ist als Singleton implementiert. Dies ist eine Option, und in der Vapor-API ist die .put(...) -Methode stark überladen, sodass Sie keine haben um sich explizit über den Datentyp Gedanken zu machen, den Sie festschreiben - sofern er unterstützt wird. Es ist auch fließend, so dass Sie Anrufe verketten können:

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

Optional werden Änderungen automatisch gespeichert und der Lese- und Schreibprozess unter der Haube vereinheitlicht, sodass Sie nicht explizit einen Editor aufrufen müssen, wie Sie es in Standard-Android tun.

Alternativ können Sie auch ein Intent verwenden. In der Vapor API können Sie auch die verkettbare überladene .put(...) -Methode für eine VaporIntent verwenden:

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

Und geben Sie es als Extra weiter, wie in den anderen Antworten erwähnt. Sie können Extras von Ihrem Activity abrufen. Wenn Sie außerdem VaporActivity verwenden, geschieht dies automatisch für Sie, sodass Sie Folgendes verwenden können:

this.extras()

Um sie am anderen Ende in der Activity abzurufen, wechseln Sie zu.

Hoffe das ist für manche interessant :)

4
Darius

sie können zwischen zwei Aktivitäten absichtlich kommunizieren. Wann immer Sie über Ihre Anmeldeaktivität zu einer anderen Aktivität navigieren, können Sie Ihre sessionId in die Absicht versetzen und diese in anderen Aktivitäten mithilfe von getIntent () ermitteln. Es folgt das Code-Snippet dafür:

LoginActivity:

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

OtherActivity:

In onCreate () oder wo immer Sie es brauchen, rufen Sie getIntent () auf. GetStringExtra ("SESSION_ID"); Überprüfen Sie auch, ob die Absicht null ist und der Schlüssel, den Sie in der Absicht übergeben, in beiden Aktivitäten identisch sein sollte. Hier ist das vollständige Code-Snippet:

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

Ich empfehle Ihnen jedoch, AppSharedPreferences zu verwenden, um Ihre sessionId zu speichern und von dort abzurufen, wo immer dies erforderlich ist.

3

Verwenden Sie eine globale Klasse:

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

Sie können die Setter und Getter dieser Klasse aus allen anderen Klassen aufrufen. Dazu müssen Sie in jeder Aktivität ein GlobalClass-Objekt erstellen:

GlobalClass gc = (GlobalClass) getApplication();

Dann können Sie zum Beispiel anrufen:

gc.getVitaminA()
3

Versuche dies:

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

Beste Möglichkeit, Daten an einen Activity bis AnothetActivity zu übergeben, indem Intent verwendet wird,

Überprüfen Sie den abgeschnittenen Code

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)

Auf Ihrer 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");
}
3
Mehul Solanki

Sie können Daten zwischen Aktivitäten in einer Anwendung auf drei Arten übertragen: 1.Intent 2.SharedPreferences 3.Application

die absichtliche Weitergabe von Daten ist begrenzt. Bei großen Datenmengen können Sie die Datenfreigabe auf Anwendungsebene verwenden und durch Speichern in sharedpref die Größe Ihrer App erhöhen

3

1. Weg: - In Ihrer aktuellen Aktivität, wenn Sie ein Objekt erstellen, um einen neuen Bildschirm zu öffnen:

  String value="xyz";
  Intent intent = new Intent(CurrentActivity.this, NextActivity.class);    
  intent.putExtra("key", value);
  startActivity(intent);

Rufen Sie dann in der nextActivity in onCreate-Methode die Werte ab, die Sie aus der vorherigen Aktivität übergeben haben:

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

2. Möglichkeit: - Sie können Bündelobjekte erstellen und Werte in Bündel einfügen und dann Bündelobjekte aus Ihrer aktuellen Aktivität in Absicht einfügen: -

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

Rufen Sie dann in der nextActivity in onCreate-Methode die Werte ab, die Sie aus der vorherigen Aktivität übergeben haben:

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

Sie können die Bean-Klasse auch verwenden, um Daten mithilfe der Serialisierung zwischen Klassen zu übertragen.

2
Rahul Sharma

Ihr Datenobjekt sollte die Klasse Parcelable oder Serializable erweitern

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

Wenn Sie Kotlin verwenden:

In MainActivity1:

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

In MainActivity2:

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

Um dies in Java zu tun:

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

Erstellen Sie in Ihrer aktuellen Aktivität ein neues Intent

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

In Ihrem SecondActivity.JavaonCreate() Rufen Sie diesen Wert mit der Taste your_key ab.

@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");
    }  
}
1
Vipul Prajapati

Sie können die Intent-Klasse verwenden, um Daten zwischen Aktivitäten zu senden. Dies ist im Grunde eine Nachricht an das Betriebssystem, in der Sie die Quelle und das Ziel des Datenflusses beschreiben. Wie Daten von A nach B Aktivität.

In AKTIVITÄT A (die Quelle):

Intent intent = new Intent(A.this, B.class);

intent.putExtra("KEY","VALUE");

startActivity(intent);

In Aktivität B (das Ziel) ->

Intent intent =getIntent();

String data =intent.getString("KEY");

Hier erhalten Sie Daten zum Schlüssel "KEY"

FÜR EINE BESSERE VERWENDUNG SOLLTEN SCHLÜSSEL DER EINFACHHEIT halber IMMER IN EINER KLASSE AUFBEWAHRT WERDEN, UND ES WIRD BEI DER MINIMIERUNG DES RISIKOS VON SCHREIBFEHLERN HILFEN

So was:

public class Constants{
public static String KEY="KEY"
}

Jetzt in AKTIVITÄT A:

intent.putExtra(Constants.KEY,"VALUE");

In Aktivität B:

String data =intent.getString(Constants.KEY);
1
Nitish

Um die Sitzungs-ID in allen Aktivitäten zu verwenden, können Sie die folgenden Schritte ausführen.

1-Definieren Sie eine STATIC VARIABLE-Sitzung (die den Wert der Sitzungs-ID enthält) in der APPLICATION-Datei Ihrer App.

2-Rufen Sie jetzt die Sitzungsvariable mit der Klassenreferenz auf, in der Sie den Sitzungs-ID-Wert abrufen, und weisen Sie ihn der statischen Variablen zu.

3-Jetzt können Sie diesen Sitzungs-ID-Wert überall verwenden, indem Sie einfach die statische Variable von aufrufen

1
MageNative

Neue und Echtzeit-Interaktion zwischen Aktivitäten mithilfe von Rückrufen:

- SCHRITT 01: Implementieren Sie eine gemeinsame Schnittstelle

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

- SCHRITT 02: Implementieren Sie eine gemeinsam genutzte Klasse

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

- SCHRITT 03 :: Spielen Sie mit Code in der ersten Aktivität

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

}

- SCHRITT 04 :: Beende das Spiel in 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();
    }

}
  • SCHRITT 05 :: Sie können auch einen Rückruf für ein Backword (von First zu Second) implementieren, um einige Ergebnisse von SecondAvtivity zu erhalten, oder einige Methoden aufrufen
1
tdjprog

Verwenden Sie einen Singleton, um Ihre Sitzungsinformationen für alle Aktivitäten zugänglich zu halten.

Dieser Ansatz hat gegenüber Extras und statischen Variablen mehrere Vorteile:

  1. Hiermit können Sie die Info-Klasse erweitern und neue Einstellungen für Benutzerinformationen hinzufügen, die Sie benötigen. Sie können eine neue Klasse erstellen, die sie erbt, oder einfach die Info-Klasse bearbeiten, ohne die Behandlung von Extras an allen Stellen ändern zu müssen.
  2. Einfache Bedienung - Sie müssen nicht bei jeder Aktivität Extras erwerben.

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

Es gibt mehrere Möglichkeiten, Daten zwischen Aktivitäten zu übertragen, und die Dokumentation enthält viele davon.

In den meisten Fällen reicht Intent.putExtras aus.

1

Definieren Sie dies in der Aktivität "Ziel"

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

Starten Sie in der ersten Aktivität die zweite Aktivität wie unten

DestinationActivity.open(this,model);
0
Vincent Mungai

// Ihr Problem ist, dass Sie die Sitzungs-ID nach der Anmeldung speichern und diese Sitzungs-ID für jede Aktivität zur Verfügung stellen möchten, bei der Sie sich abmelden möchten.

// Die Lösung Ihres Problems ist, dass Sie Ihre Sitzungs-ID nach erfolgreicher Anmeldung in einer öffentlichen Variablen speichern müssen. und wann immer Sie eine Sitzungs-ID zum Abmelden benötigen, können Sie auf diese Variable zugreifen und den Variablenwert durch Null ersetzen.

//Serializable class

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

Schreiben Sie folgenden Code in CurrentActivity.Java

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

Der Zugriff auf SessionId in SignOutActivity.Java erfolgt folgendermaßen

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();
    }
}
 Intent intent = new Intent(getBaseContext(), SomeActivity.class);
 intent.putExtra("USER_ID", UserId);
 startActivity(intent);

 On SomeActivity : 

 String userId= getIntent().getStringExtra("("USER_ID");
0
Raviraj Desai

Sie können mit Absicht arbeiten

String sessionId = "my session id";

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

Dies ist der einfachste Weg um Sitzungs-ID an alle Aktivität zu übergeben.

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

Aus LogoutActivity können Sie also die session_id abrufen, die für die Abmeldung weiter verwendet wird Betrieb.

Hoffe das wird hilfreich sein ... danke

0
sahu

Wir können die Werte auf zwei Arten an eine andere Aktivität weitergeben (die gleiche Art von Antwort wurde bereits gepostet, aber der hier veröffentlichte Redcing-Code wurde durch Vorsatz ausprobiert).

1. durch Absicht

  Activity1:
      startActivity(new Intent(getApplicationContext(),Activity2.class).putExtra("title","values"));

InActivity 2:

String recString= getIntent().getStringExtra("title");

2.Durch 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
0
MurugananthamS
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");
0
Parth_Darji

Ich verwende öffentliche statische Felder, um gemeinsame Daten zwischen Aktivitäten zu speichern, aber um die Nebenwirkungen zu minimieren, können Sie:

  • Machen Sie nur ein Feld oder so wenig wie möglich und verwenden Sie sie erneut, machen Sie sie zum Typ Objekt und setzen Sie sie in der empfangenden Aktivität auf den gewünschten Typ.
  • Wenn einer von ihnen nicht mehr nützlich ist, setzen Sie ihn explizit auf null, damit er vor der nächsten Zuweisung vom Garbage Collector gesammelt wird.
0
Mohamed Selim