web-dev-qa-db-fra.com

Comment utiliser SharedPreferences dans Android pour stocker, récupérer et modifier des valeurs

Je veux stocker une valeur de temps et dois le récupérer et le modifier. Comment puis-je utiliser SharedPreferences pour le faire?

androidsharedpreferences
600
Muhammad Maqsoodur Rehman

Pour obtenir les préférences partagées, appliquez la méthode suivante dans votre activité:

SharedPreferences prefs = this.getSharedPreferences(
      "com.example.app", Context.MODE_PRIVATE);

Pour lire les préférences:

String dateTimeKey = "com.example.app.datetime";

// use a default value using new Date()
long l = prefs.getLong(dateTimeKey, new Date().getTime());

Pour modifier et enregistrer les préférences

Date dt = getSomeDate();
prefs.edit().putLong(dateTimeKey, dt.getTime()).apply();

Le répertoire exemple de Android sdk contient un exemple de récupération et de stockage des préférences partagées. Il est situé dans le:

<Android-sdk-home>/samples/Android-<platformversion>/ApiDemos directory

Modifier ==>

J'ai remarqué qu'il était également important d'écrire la différence entre commit() et apply().

commit() renvoie true si la valeur a été enregistrée avec succès sinon false. Il enregistre les valeurs dans SharedPreferences de manière synchrone .

apply() a été ajouté dans la version 2.3 et ne renvoie aucune valeur en cas de succès ou d’échec. Il enregistre immédiatement les valeurs dans SharedPreferences mais commence une validation asynchrone . Plus de détail est ici .

825
naikus

Pour stocker des valeurs dans des préférences partagées:

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Name","Harneet");
editor.apply();

Pour récupérer des valeurs à partir de préférences partagées:

SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
String name = preferences.getString("Name", "");
if(!name.equalsIgnoreCase(""))
{
    name = name + "  Sethi";  /* Edit the value here*/
}
274
Harneet Kaur

Pour éditer données de sharedpreference

 SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();
 editor.putString("text", mSaved.getText().toString());
 editor.putInt("selection-start", mSaved.getSelectionStart());
 editor.putInt("selection-end", mSaved.getSelectionEnd());
 editor.apply();

Pour récupérer données de sharedpreference

SharedPreferences prefs = getPreferences(MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) 
{
  //mSaved.setText(restoredText, TextView.BufferType.EDITABLE);
  int selectionStart = prefs.getInt("selection-start", -1);
  int selectionEnd = prefs.getInt("selection-end", -1);
  /*if (selectionStart != -1 && selectionEnd != -1)
  {
     mSaved.setSelection(selectionStart, selectionEnd);
  }*/
}

Éditer

J'ai pris cet extrait de l'exemple de démonstration API. Il y avait une boîte EditText. Dans cette context il n'est pas nécessaire. Je commente la même chose.

162
DeRagan

Pour écrire:

SharedPreferences preferences = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_WORLD_WRITEABLE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Authentication_Id",userid.getText().toString());
editor.putString("Authentication_Password",password.getText().toString());
editor.putString("Authentication_Status","true");
editor.apply();

À lire:

SharedPreferences prfs = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_PRIVATE);
String Astatus = prfs.getString("Authentication_Status", "");
38
stackoverflow

Manière la plus simple:

Sauver:

getPreferences(MODE_PRIVATE).edit().putString("Name of variable",value).commit();

À récupérer:

your_variable = getPreferences(MODE_PRIVATE).getString("Name of variable",default value);
26
ArcDare

Définition de valeurs dans Préférence:

// MY_PREFS_NAME - a static String variable like: 
//public static final String MY_PREFS_NAME = "MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
 editor.putString("name", "Elena");
 editor.putInt("idName", 12);
 editor.commit();

Récupérer des données de préférence:

SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE); 
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
  String name = prefs.getString("name", "No name defined");//"No name defined" is the default value.
  int idName = prefs.getInt("idName", 0); //0 is the default value.
}

plus d'informations:

Utilisation des préférences partagées

Préférences partagées

17
Jorgesys

Pour stocker des informations

SharedPreferences preferences = getSharedPreferences(PREFS_NAME,Context.MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("username", username.getText().toString());
editor.putString("password", password.getText().toString());
editor.putString("logged", "logged");
editor.commit();

Pour réinitialiser vos préférences

SharedPreferences.Editor editor = preferences.edit();
editor.clear();
editor.commit();
15
fidazik

Classe de préférences partagées singleton. cela peut aider d'autres à l'avenir.

import Android.app.Activity;
import Android.content.Context;
import Android.content.SharedPreferences;

public class SharedPref
{
    private static SharedPreferences mSharedPref;
    public static final String NAME = "NAME";
    public static final String AGE = "AGE";
    public static final String IS_SELECT = "IS_SELECT";

    private SharedPref()
    {

    }

    public static void init(Context context)
    {
        if(mSharedPref == null)
            mSharedPref = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
    }

    public static String read(String key, String defValue) {
        return mSharedPref.getString(key, defValue);
    }

    public static void write(String key, String value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putString(key, value);
        prefsEditor.commit();
    }

    public static boolean read(String key, boolean defValue) {
        return mSharedPref.getBoolean(key, defValue);
    }

    public static void write(String key, boolean value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putBoolean(key, value);
        prefsEditor.commit();
    }

    public static Integer read(String key, int defValue) {
        return mSharedPref.getInt(key, defValue);
    }

    public static void write(String key, Integer value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putInt(key, value).commit();
    }
}

Appelez simplement SharedPref.init() sur MainActivity une fois

SharedPref.init(getApplicationContext());

Écrire des données

SharedPref.write(SharedPref.NAME, "XXXX");//save string in shared preference.
SharedPref.write(SharedPref.AGE, 25);//save int in shared preference.
SharedPref.write(SharedPref.IS_SELECT, true);//save boolean in shared preference.

Lire des données

String name = SharedPref.read(SharedPref.NAME, null);//read string in shared preference.
int age = SharedPref.read(SharedPref.AGE, 0);//read int in shared preference.
boolean isSelect = SharedPref.read(SharedPref.IS_SELECT, false);//read boolean in shared preference.
14
Magesh Pandian

Dans toute application, il existe des préférences par défaut accessibles via l'instance PreferenceManager et sa méthode associée getDefaultSharedPreferences(Context).

Avec l'instance SharedPreference, il est possible de récupérer la valeur int de n'importe quelle préférence avec getInt (String key, int defVal). La préférence qui nous intéresse dans ce cas est le compteur.

Dans notre cas, nous pouvons modifier l'instance SharedPreference dans notre cas à l'aide de la commande edit () et utiliser la fonction putInt(String key, int newVal) Nous avons augmenté le nombre pour notre application qui existe au-delà de la demande et s'affiche en conséquence.

Pour plus de démonstration, redémarrez et votre application à nouveau, vous remarquerez que le nombre augmentera chaque fois que vous redémarrez l'application.

PreferencesDemo.Java

Code:

package org.example.preferences;
import Android.app.Activity;
import Android.content.SharedPreferences;
import Android.os.Bundle;
import Android.preference.PreferenceManager;
import Android.widget.TextView;

public class PreferencesDemo extends Activity {
   /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get the app's shared preferences
        SharedPreferences app_preferences = 
        PreferenceManager.getDefaultSharedPreferences(this);

        // Get the value for the run counter
        int counter = app_preferences.getInt("counter", 0);

        // Update the TextView
        TextView text = (TextView) findViewById(R.id.text);
        text.setText("This app has been started " + counter + " times.");

        // Increment the counter
        SharedPreferences.Editor editor = app_preferences.edit();
        editor.putInt("counter", ++counter);
        editor.commit(); // Very important
    }
}

main.xml

Code:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:Android="http://schemas.Android.com/apk/res/Android"
      Android:orientation="vertical"
      Android:layout_width="fill_parent"
      Android:layout_height="fill_parent" >

        <TextView
            Android:id="@+id/text"  
            Android:layout_width="fill_parent" 
            Android:layout_height="wrap_content" 
            Android:text="@string/hello" />
</LinearLayout>
12
Sathish

Si vous créez une application volumineuse avec d'autres développeurs de votre équipe et souhaitez que tout soit bien organisé sans code dispersé ni autre instance SharedPreferences, vous pouvez procéder de la manière suivante:

//SharedPreferences manager class
public class SharedPrefs {

    //SharedPreferences file name
    private static String SHARED_PREFS_FILE_NAME = "my_app_shared_prefs";

    //here you can centralize all your shared prefs keys
    public static String KEY_MY_SHARED_BOOLEAN = "my_shared_boolean";
    public static String KEY_MY_SHARED_FOO = "my_shared_foo";

    //get the SharedPreferences object instance
    //create SharedPreferences file if not present


    private static SharedPreferences getPrefs(Context context) {
        return context.getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE);
    }

    //Save Booleans
    public static void savePref(Context context, String key, boolean value) {
        getPrefs(context).edit().putBoolean(key, value).commit();       
    }

    //Get Booleans
    public static boolean getBoolean(Context context, String key) {
        return getPrefs(context).getBoolean(key, false);
    }

    //Get Booleans if not found return a predefined default value
    public static boolean getBoolean(Context context, String key, boolean defaultValue) {
        return getPrefs(context).getBoolean(key, defaultValue);
    }

    //Strings
    public static void save(Context context, String key, String value) {
        getPrefs(context).edit().putString(key, value).commit();
    }

    public static String getString(Context context, String key) {
        return getPrefs(context).getString(key, "");
    }

    public static String getString(Context context, String key, String defaultValue) {
        return getPrefs(context).getString(key, defaultValue);
    }

    //Integers
    public static void save(Context context, String key, int value) {
        getPrefs(context).edit().putInt(key, value).commit();
    }

    public static int getInt(Context context, String key) {
        return getPrefs(context).getInt(key, 0);
    }

    public static int getInt(Context context, String key, int defaultValue) {
        return getPrefs(context).getInt(key, defaultValue);
    }

    //Floats
    public static void save(Context context, String key, float value) {
        getPrefs(context).edit().putFloat(key, value).commit();
    }

    public static float getFloat(Context context, String key) {
        return getPrefs(context).getFloat(key, 0);
    }

    public static float getFloat(Context context, String key, float defaultValue) {
        return getPrefs(context).getFloat(key, defaultValue);
    }

    //Longs
    public static void save(Context context, String key, long value) {
        getPrefs(context).edit().putLong(key, value).commit();
    }

    public static long getLong(Context context, String key) {
        return getPrefs(context).getLong(key, 0);
    }

    public static long getLong(Context context, String key, long defaultValue) {
        return getPrefs(context).getLong(key, defaultValue);
    }

    //StringSets
    public static void save(Context context, String key, Set<String> value) {
        getPrefs(context).edit().putStringSet(key, value).commit();
    }

    public static Set<String> getStringSet(Context context, String key) {
        return getPrefs(context).getStringSet(key, null);
    }

    public static Set<String> getStringSet(Context context, String key, Set<String> defaultValue) {
        return getPrefs(context).getStringSet(key, defaultValue);
    }
}

Dans votre activité, vous pouvez enregistrer les préférences partagées de cette manière.

//saving a boolean into prefs
SharedPrefs.savePref(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN, booleanVar);

et vous pouvez récupérer vos SharedPreferences de cette façon

//getting a boolean from prefs
booleanVar = SharedPrefs.getBoolean(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN);
12
alexm

Stocker dans SharedPreferences

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

Récupération dans SharedPreferences

SharedPreferences preferences=getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
String name=preferences.getString("name",null);

Remarque: "temp" correspond au nom de préférences partagées et "nom" à la valeur d'entrée. si la valeur ne quitte pas, retourne null

8
Ravi Parsania

Solution simple de la façon de stocker la valeur de connexion dans par SharedPreferences.

Vous pouvez étendre la classe MainActivity ou une autre classe dans laquelle vous stockerez la "valeur de quelque chose que vous souhaitez conserver". Mettez ceci dans les classes d'écrivain et de lecteur:

public static final String GAME_PREFERENCES_LOGIN = "Login";

Ici, InputClass est une entrée et OutputClass est une classe de sortie, respectivement.

// This is a storage, put this in a class which you can extend or in both classes:
//(input and output)
public static final String GAME_PREFERENCES_LOGIN = "Login";

// String from the text input (can be from anywhere)
String login = inputLogin.getText().toString();

// then to add a value in InputCalss "SAVE",
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
Editor editor = example.edit();
editor.putString("value", login);
editor.commit();

Maintenant, vous pouvez l'utiliser ailleurs, comme une autre classe. Ce qui suit est OutputClass.

SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
String userString = example.getString("value", "defValue");

// the following will print it out in console
Logger.getLogger("Name of a OutputClass".class.getName()).log(Level.INFO, userString);
8
Zly-Zly

Modifier

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("yourValue", value);
editor.commit();

Lis

SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
value= pref.getString("yourValue", "");
7
Faxriddin Abdullayev

Vous pouvez économiser de la valeur en utilisant cette méthode:

public void savePreferencesForReasonCode(Context context,
    String key, String value) {
    SharedPreferences sharedPreferences = PreferenceManager
    .getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = sharedPreferences.edit();
    editor.putString(key, value);
    editor.commit();
    }

Et en utilisant cette méthode, vous pouvez obtenir de la valeur de SharedPreferences:

public String getPreferences(Context context, String prefKey) {
  SharedPreferences sharedPreferences = PreferenceManager
 .getDefaultSharedPreferences(context);
 return sharedPreferences.getString(prefKey, "");
}

Ici prefKey est la clé que vous avez utilisée pour enregistrer la valeur spécifique. Merci.

6
Md. Sajedul Karim

L'idée de base de SharedPreferences est de stocker des choses sur un fichier XML.

  1. Déclarez le chemin du fichier xml (si vous n'avez pas ce fichier, Android le créera. Si vous avez ce fichier, Android y aura accès.)

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

  2. Écrire une valeur dans les préférences partagées

    prefs.edit().putLong("preference_file_key", 1010101).apply();

    le preference_file_key est le nom des fichiers de préférences partagés. Et le 1010101 est la valeur que vous devez stocker.

    apply() consiste enfin à enregistrer les modifications. Si vous obtenez une erreur de apply(), remplacez-la par commit(). Donc, cette phrase alternative est

    prefs.edit().putLong("preference_file_key", 1010101).commit();

  3. Lecture à partir de préférences partagées

    SharedPreferences sp = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
long lsp = sp.getLong("preference_file_key", -1);

    lsp sera -1 si preference_file_key n'a pas de valeur. Si 'preference_file_key' a une valeur, il en retournera la valeur.

Le code entier pour l'écriture est

    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    prefs.edit().putLong("preference_file_key", 1010101).apply();    // Write the value to key.

Le code de lecture est

    SharedPreferences sf = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
    long lsp = sp.getLong("preference_file_key", -1);    // Read the key and store in lsp
6
kakarott
editor.putString("text", mSaved.getText().toString());

Ici, mSaved peut être n'importe quel TextView ou EditText à partir duquel on peut extraire une chaîne. vous pouvez simplement spécifier une chaîne. Ici, le texte sera la clé contenant la valeur obtenue à partir de mSaved (TextView ou EditText).

SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

De plus, il n’est pas nécessaire de sauvegarder le fichier de préférences sous le nom de package, c’est-à-dire "com.example.app". Vous pouvez mentionner votre propre nom préféré. J'espère que cela t'aides !

6
java dev

Pour stocker des valeurs dans des préférences partagées:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = sp.edit();
editor.putString("Name","Jayesh");
editor.commit();

Pour récupérer des valeurs à partir de préférences partagées:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
String name = sp.getString("Name", ""); // Second parameter is the default value.
5
Muhammad Hassan

Il existe plusieurs façons de recommander l'utilisation de SharedPreferences . J'ai fait un projet de démonstration ici . Le point clé dans l'exemple consiste à utiliser objet ApplicationContext & single sharedpreferences . Ceci montre comment utiliser SharedPreferences avec les fonctionnalités suivantes: -

  • Utiliser singelton class pour accéder/mettre à jour les SharedPreferences
  • Pas besoin de toujours passer le contexte pour les références partagées en lecture/écriture
  • Il utilise apply () au lieu de commit ()
  • apply () est une sauvegarde asynchrone, ne retourne rien, elle met à jour la valeur en mémoire en premier et les modifications sont écrites sur le disque ultérieurement, de manière asynchrone.
  • commit () est synchronus save, il retourne vrai/faux en fonction du résultat. Les modifications sont écrites sur le disque de manière synchrone
  • fonctionne sur Android 2.3+ versions

Exemple d'utilisation ci-dessous: -

MyAppPreference.getInstance().setSampleStringKey("some_value");
String value= MyAppPreference.getInstance().getSampleStringKey();

Obtenir le code source ici & Des API détaillées peuvent être trouvées ici sur developer.Android.com

5
Akhil

Meilleure pratique à ce jour

Créez Interface nommé avec PreferenceManager:

// Interface to save values in shared preferences and also for retrieve values from shared preferences
public interface PreferenceManager {

    SharedPreferences getPreferences();
    Editor editPreferences();

    void setString(String key, String value);
    String getString(String key);

    void setBoolean(String key, boolean value);
    boolean getBoolean(String key);

    void setInteger(String key, int value);
    int getInteger(String key);

    void setFloat(String key, float value);
    float getFloat(String key);

}

Comment utiliser avec Activité/Fragment:

public class HomeActivity extends AppCompatActivity implements PreferenceManager{

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout_activity_home);
    }

    @Override
    public SharedPreferences getPreferences(){
        return getSharedPreferences("SP_TITLE", Context.MODE_PRIVATE);
    }

    @Override
    public SharedPreferences.Editor editPreferences(){
        return getPreferences().edit();
    }

    @Override
    public void setString(String key, String value) {
        editPreferences().putString(key, value).commit();
    }

    @Override
    public String getString(String key) {
        return getPreferences().getString(key, "");
    }

    @Override
    public void setBoolean(String key, boolean value) {
        editPreferences().putBoolean(key, value).commit();
    }

    @Override
    public boolean getBoolean(String key) {
        return  getPreferences().getBoolean(key, false);
    }

    @Override
    public void setInteger(String key, int value) {
        editPreferences().putInt(key, value).commit();
    }

    @Override
    public int getInteger(String key) {
        return getPreferences().getInt(key, 0);
    }

    @Override
    public void setFloat(String key, float value) {
        editPreferences().putFloat(key, value).commit();
    }

    @Override
    public float getFloat(String key) {
        return getPreferences().getFloat(key, 0);
    }
}

Remarque: Remplacez votre clé de SharedPreference par SP_TITLE.

Exemples:

Chaîne de magasin dans shareperence:

setString("my_key", "my_value");

Get string à partir de shareperence:

String strValue = getString("my_key");

J'espère que cela vous aidera.

5
Hiren Patel

pour sauvegarder

PreferenceManager.getDefaultSharedPreferences(this).edit().putString("VarName","your value").apply();

à récupérer:

String name = PreferenceManager.getDefaultSharedPreferences(this).getString("VarName","defaultValue");

la valeur par défaut est: Valeurs à retourner si cette préférence n'existe pas.

vous pouvez changer " this " avec getActivity () ou getApplicationContext () dans certains cas

4
Nadir Belhaj

Utilisez utilisé cet exemple simple et clair et vérifié 

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:Android="http://schemas.Android.com/apk/res/Android"
   package="com.example.sairamkrishna.myapplication" >

   <application
      Android:allowBackup="true"
      Android:icon="@mipmap/ic_launcher"
      Android:label="@string/app_name"
      Android:theme="@style/AppTheme" >

      <activity
         Android:name=".MainActivity"
         Android:label="@string/app_name" >

         <intent-filter>
            <action Android:name="Android.intent.action.MAIN" />
            <category Android:name="Android.intent.category.LAUNCHER" />
         </intent-filter>

      </activity>

   </application>
</manifest>

public class MainActivity extends AppCompatActivity {
   EditText ed1,ed2,ed3;
   Button b1;

   public static final String MyPREFERENCES = "MyPrefs" ;
   public static final String Name = "nameKey";
   public static final String Phone = "phoneKey";
   public static final String Email = "emailKey";

   SharedPreferences sharedpreferences;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.activity_main);

      ed1=(EditText)findViewById(R.id.editText);
      ed2=(EditText)findViewById(R.id.editText2);
      ed3=(EditText)findViewById(R.id.editText3);

      b1=(Button)findViewById(R.id.button);
      sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);

      b1.setOnClickListener(new View.OnClickListener() {
         @Override
         public void onClick(View v) {
            String n  = ed1.getText().toString();
            String ph  = ed2.getText().toString();
            String e  = ed3.getText().toString();

            SharedPreferences.Editor editor = sharedpreferences.edit();

            editor.putString(Name, n);
            editor.putString(Phone, ph);
            editor.putString(Email, e);
            editor.commit();
            Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
         }
      });
   }

}
3
Sohaib Aslam

2.pour stocker en prefrence partagée

SharedPreferences.Editor editor = 
getSharedPreferences("DeviceToken",MODE_PRIVATE).edit();
                    editor.putString("DeviceTokenkey","ABABABABABABABB12345");
editor.apply();

2.pour retrouver le même usage

    SharedPreferences prefs = getSharedPreferences("DeviceToken", 
 MODE_PRIVATE);
  String deviceToken = prefs.getString("DeviceTokenkey", null);
2
Syed Danish Haider
SharedPreferences.Editor editor = getSharedPreferences("identifier", 
MODE_PRIVATE).edit();
//identifier is the unique to fetch data from your SharedPreference.


editor.putInt("keyword", 0); 
// saved value place with 0.
//use this "keyword" to fetch saved value again.
editor.commit();//important line without this line your value is not stored in preference   

// fetch the stored data using ....

SharedPreferences prefs = getSharedPreferences("identifier", MODE_PRIVATE); 
// here both identifier will same

int fetchvalue = prefs.getInt("keyword", 0);
// here keyword will same as used above.
// 0 is default value when you nothing save in preference that time fetch value is 0.

vous devez utiliser SharedPreferences dans AdapterClass ou tout autre. cette fois, utilisez cette déclaration et utilisez le même âne ci-dessus.

SharedPreferences.Editor editor = context.getSharedPreferences("idetifier", 
Context.MODE_PRIVATE).edit();
SharedPreferences prefs = context.getSharedPreferences("identifier", Context.MODE_PRIVATE);

//here context is your application context

pour chaîne ou valeur booléenne

editor.putString("stringkeyword", "your string"); 
editor.putBoolean("booleankeyword","your boolean value");
editor.commit();

récupérer les données comme ci-dessus

String fetchvalue = prefs.getString("keyword", "");
Boolean fetchvalue = prefs.getBoolean("keyword", "");
2
Vishal 05

Je voulais ajouter ici que la plupart des extraits de cette question auront quelque chose comme MODE_PRIVATE lors de l'utilisation de SharedPreferences. MODE_PRIVATE signifie que tout ce que vous écrivez dans cette préférence partagée ne peut être lu que par votre application.

Quelle que soit la clé que vous transmettiez à la méthode getSharedPreferences (), Android crée un fichier portant ce nom et y stocke les données de préférence. N'oubliez pas non plus que getSharedPreferences () est censé être utilisé lorsque vous souhaitez créer plusieurs fichiers de préférences pour votre application. Si vous avez l'intention d'utiliser un fichier de préférences unique et d'y stocker toutes les paires clé-valeur, utilisez la méthode getSharedPreference (). C'est étrange que tout le monde (y compris moi-même) utilise simplement la saveur getSharedPreferences () sans même comprendre la différence entre les deux précédents.

Le didacticiel vidéo suivant devrait vous aider https://www.youtube.com/watch?v=2PcAQ1NBy98

2
Sandeep

En utilisant ceci bibliothèque simple , voici comment vous appelez SharedPreferences ..

TinyDB tinydb = new TinyDB(context);

tinydb.putInt("clickCount", 2);

tinydb.putString("userName", "john");
tinydb.putBoolean("isUserMale", true); 

tinydb.putList("MyUsers", mUsersArray);
tinydb.putImagePNG("DropBox/WorkImages", "MeAtlunch.png", lunchBitmap);

//These plus the corresponding get methods are all Included
2
kc ochibili

J'écris une classe d'assistance pour les préférences partagées:

import Android.content.Context;
import Android.content.SharedPreferences;

/**
 * Created by mete_ on 23.12.2016.
 */
public class HelperSharedPref {

Context mContext;

public HelperSharedPref(Context mContext) {
    this.mContext = mContext;
}

/**
 *
 * @param key Constant RC
 * @param value Only String, Integer, Long, Float, Boolean types
 */
public void saveToSharedPref(String key, Object value) throws Exception {
    SharedPreferences.Editor editor = mContext.getSharedPreferences(key, Context.MODE_PRIVATE).edit();
    if (value instanceof String) {
        editor.putString(key, (String) value);
    } else if (value instanceof Integer) {
        editor.putInt(key, (Integer) value);
    } else if (value instanceof Long) {
        editor.putLong(key, (Long) value);
    } else if (value instanceof Float) {
        editor.putFloat(key, (Float) value);
    } else if (value instanceof Boolean) {
        editor.putBoolean(key, (Boolean) value);
    } else {
        throw new Exception("Unacceptable object type");
    }

    editor.commit();
}

/**
 * Return String
 * @param key
 * @return null default is null
 */
public String loadStringFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    String restoredText = prefs.getString(key, null);

    return restoredText;
}

/**
 * Return int
 * @param key
 * @return null default is -1
 */
public Integer loadIntegerFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Integer restoredText = prefs.getInt(key, -1);

    return restoredText;
}

/**
 * Return float
 * @param key
 * @return null default is -1
 */
public Float loadFloatFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Float restoredText = prefs.getFloat(key, -1);

    return restoredText;
}

/**
 * Return long
 * @param key
 * @return null default is -1
 */
public Long loadLongFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Long restoredText = prefs.getLong(key, -1);

    return restoredText;
}

/**
 * Return boolean
 * @param key
 * @return null default is false
 */
public Boolean loadBooleanFromSharedPref(String key) throws Exception {
    SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
    Boolean restoredText = prefs.getBoolean(key, false);

    return restoredText;
}

}
2
Mete

Simple et sans problème :: Bibliothèque "Android-SharedPreferences-Helper"

Mieux vaut tard que jamais: j'ai créé la bibliothèque "Android-SharedPreferences-Helper" pour aider à réduire la complexité et les efforts liés à l'utilisation de SharedPreferences. Il fournit également des fonctionnalités étendues. Peu de choses qu'il offre sont les suivantes:

  • Initialisation et configuration sur une ligne
  • Sélectionnez facilement si vous souhaitez utiliser les préférences par défaut ou un fichier de préférences personnalisé
  • Valeurs prédéfinies (type de données par défaut) et personnalisables (ce que vous pouvez choisir) pour chaque type de données
  • Possibilité de définir différentes valeurs par défaut pour un usage unique avec seulement un paramètre supplémentaire
  • Vous pouvez enregistrer et désinscrire OnSharedPreferenceChangeListener comme vous le faites pour la classe par défaut
dependencies {
    ...
    ...
    compile(group: 'com.viralypatel.sharedpreferenceshelper', name: 'library', version: '1.1.0', ext: 'aar')
}

Déclaration d'objet SharedPreferencesHelper: (recommandé au niveau de la classe)

SharedPreferencesHelper sph;

Instanciation de l'objet SharedPreferencesHelper: (recommandé dans la méthode onCreate ())

// use one of the following ways to instantiate
sph = new SharedPreferencesHelper(this); //this will use default shared preferences
sph = new SharedPreferencesHelper(this, "myappprefs"); // this will create a named shared preference file
sph = new SharedPreferencesHelper(this, "myappprefs", 0); // this will allow you to specify a mode

Mettre des valeurs dans des préférences partagées

Assez simple! Contrairement à la méthode par défaut (lorsque vous utilisez la classe SharedPreferences), vous n'avez PAS besoin d'appeler .edit() et .commit() à tout moment.

sph.putBoolean("boolKey", true);
sph.putInt("intKey", 123);
sph.putString("stringKey", "string value");
sph.putLong("longKey", 456876451);
sph.putFloat("floatKey", 1.51f);

// putStringSet is supported only for Android versions above HONEYCOMB
Set name = new HashSet();
name.add("Viral");
name.add("Patel");
sph.putStringSet("name", name);

C'est ça! Vos valeurs sont stockées dans les préférences partagées.

Obtenir des valeurs à partir de préférences partagées

Encore une fois, juste un simple appel de méthode avec le nom de la clé.

sph.getBoolean("boolKey");
sph.getInt("intKey");
sph.getString("stringKey");
sph.getLong("longKey");
sph.getFloat("floatKey");

// getStringSet is supported only for Android versions above HONEYCOMB
sph.getStringSet("name");

Il a beaucoup d'autres fonctionnalités étendues

Vérifiez les détails des fonctionnalités étendues, des instructions d’utilisation et d’installation, etc. sur la page du référentiel GitHub .

2
AndroidMechanic - Viral Patel

Pour stocker et récupérer des variables globales de manière fonctionnelle. Pour tester, assurez-vous d’avoir des éléments Textview sur votre page, décommentez les deux lignes du code et exécutez-le. Puis commentez à nouveau les deux lignes et courez.
Ici, l'identifiant de TextView est nom d'utilisateur et mot de passe.

Dans chaque classe où vous souhaitez l'utiliser, ajoutez ces deux routines à la fin. Je voudrais que cette routine soit globale, mais je ne sais pas comment. Cela marche.

Les variabels sont disponibles partout. Il stocke les variables dans "MyFile". Vous pouvez le changer à votre façon.

Vous l'appelez en utilisant

 storeSession("username","frans");
 storeSession("password","!2#4%");***

la variable nom d'utilisateur sera remplie avec "frans" et le mot de passe avec "! 2 # 4%". Même après un redémarrage, ils sont disponibles.

et vous le récupérez en utilisant

 password.setText(getSession(("password")));
 usernames.setText(getSession(("username")));

ci-dessous le code entier de ma grille.Java

    package nl.yentel.yenteldb2;
    import Android.content.SharedPreferences;
    import Android.os.Bundle;
    import Android.support.design.widget.FloatingActionButton;
    import Android.support.design.widget.Snackbar;
    import Android.support.v7.app.AppCompatActivity;
    import Android.support.v7.widget.Toolbar;
    import Android.view.View;
    import Android.widget.EditText;
    import Android.widget.TextView;

    public class Grid extends AppCompatActivity {
    private TextView usernames;
    private TextView password;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_grid);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);

      ***//  storeSession("username","[email protected]");
        //storeSession("password","mijn wachtwoord");***
        password = (TextView) findViewById(R.id.password);
        password.setText(getSession(("password")));
        usernames=(TextView) findViewById(R.id.username);
        usernames.setText(getSession(("username")));
    }

    public void storeSession(String key, String waarde) { 
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        editor.putString(key, waarde);
        editor.commit();
    }

    public String getSession(String key) {
//http://androidexample.com/Android_SharedPreferences_Basics/index.php?view=article_discription&aid=126&aaid=146
        SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
        SharedPreferences.Editor editor = pref.edit();
        String output = pref.getString(key, null);
        return output;
    }

    }

ci-dessous vous trouvez les articles textview

<TextView
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:text="usernames"
    Android:id="@+id/username"
    Android:layout_below="@+id/textView"
    Android:layout_alignParentStart="true"
    Android:layout_marginTop="39dp"
    Android:hint="hier komt de username" />

 <TextView
    Android:layout_width="wrap_content"
    Android:layout_height="wrap_content"
    Android:text="password"
    Android:id="@+id/password"
    Android:layout_below="@+id/user"
    Android:layout_alignParentStart="true"
    Android:hint="hier komt het wachtwoord" />
1
frans eilering

Ici, j'ai créé une classe Helper pour utiliser les préférences dans Android.

C'est la classe d'assistance:

public class PrefsUtil {

public static SharedPreferences getPreference() {
    return PreferenceManager.getDefaultSharedPreferences(Applicatoin.getAppContext());
}

public static void putBoolean(String key, boolean value) {
    getPreference().edit().putBoolean(key, value)
            .apply();
}

public static boolean getBoolean(String key) {
    return getPreference().getBoolean(key, false);
}

public static void putInt(String key, int value) {

    getPreference().edit().putInt(key, value).apply();

}

public static void delKey(String key) {

    getPreference().edit().remove(key).apply();

}

}
1
Manokar

Pour stocker des valeurs dans des préférences partagées:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = sp.edit();
editor.putString("Name","Jayesh");
editor.commit();

Pour récupérer des valeurs à partir de préférences partagées:

SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
String name = sp.getString("Name", "");
1
Jayesh

J'ai créé une classe d'assistance pour rendre ma vie facile. Il s'agit d'une classe générique et de nombreuses méthodes sont couramment utilisées dans les applications telles que les préférences partagées, la validité de l'e-mail et le format de date/heure. Copiez cette classe dans votre code et accédez à ses méthodes partout où vous en avez besoin.

 import Android.app.AlertDialog;
 import Android.app.ProgressDialog;
 import Android.content.Context;
 import Android.content.DialogInterface;
 import Android.content.SharedPreferences;
 import Android.support.v4.app.FragmentActivity;
 import Android.view.inputmethod.InputMethodManager;
 import Android.widget.EditText;
 import Android.widget.Toast;

 import Java.text.ParseException;
 import Java.text.SimpleDateFormat;
 import Java.util.Date;
 import Java.util.Random;
 import Java.util.regex.Matcher;
 import Java.util.regex.Pattern;
 import Java.util.regex.PatternSyntaxException;

/**
* Created by Zohaib Hassan on 3/4/2016.
*/
 public class Helper {

private static ProgressDialog pd;

public static void saveData(String key, String value, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.putString(key, value);
    editor.commit();
}

public static void deleteData(String key, Context context){
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    SharedPreferences.Editor editor;
    editor = sp.edit();
    editor.remove(key);
    editor.commit();

}

public static String getSaveData(String key, Context context) {
    SharedPreferences sp = context.getApplicationContext()
            .getSharedPreferences("appData", 0);
    String data = sp.getString(key, "");
    return data;

}




public static long dateToUnix(String dt, String format) {
    SimpleDateFormat formatter;
    Date date = null;
    long unixtime;
    formatter = new SimpleDateFormat(format);
    try {
        date = formatter.parse(dt);
    } catch (Exception ex) {

        ex.printStackTrace();
    }
    unixtime = date.getTime();
    return unixtime;

}

public static String getData(long unixTime, String formate) {

    long unixSeconds = unixTime;
    Date date = new Date(unixSeconds);
    SimpleDateFormat sdf = new SimpleDateFormat(formate);
    String formattedDate = sdf.format(date);
    return formattedDate;
}

public static String getFormattedDate(String date, String currentFormat,
                                      String desiredFormat) {
    return getData(dateToUnix(date, currentFormat), desiredFormat);
}




public static double distance(double lat1, double lon1, double lat2,
                              double lon2, char unit) {
    double theta = lon1 - lon2;
    double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
            + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
            * Math.cos(deg2rad(theta));
    dist = Math.acos(dist);
    dist = rad2deg(dist);
    dist = dist * 60 * 1.1515;
    if (unit == 'K') {
        dist = dist * 1.609344;
    } else if (unit == 'N') {
        dist = dist * 0.8684;
    }
    return (dist);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts decimal degrees to radians : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double deg2rad(double deg) {
    return (deg * Math.PI / 180.0);
}

/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
/* :: This function converts radians to decimal degrees : */
/* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
private static double rad2deg(double rad) {
    return (rad * 180.0 / Math.PI);
}

public static int getRendNumber() {
    Random r = new Random();
    return r.nextInt(360);
}

public static void hideKeyboard(Context context, EditText editText) {
    InputMethodManager imm = (InputMethodManager) context
            .getSystemService(Context.INPUT_METHOD_SERVICE);
    imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
}

public static void showLoder(Context context, String message) {
    pd = new ProgressDialog(context);

    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void showLoderImage(Context context, String message) {
    pd = new ProgressDialog(context);
    pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
    pd.setCancelable(false);
    pd.setMessage(message);
    pd.show();
}

public static void dismissLoder() {
    pd.dismiss();
}

public static void toast(Context context, String text) {

    Toast.makeText(context, text, Toast.LENGTH_LONG).show();
}
/*
     public static Boolean connection(Context context) {
    ConnectionDetector connection = new ConnectionDetector(context);
    if (!connection.isConnectingToInternet()) {

        Helper.showAlert(context, "No Internet access...!");
        //Helper.toast(context, "No internet access..!");
        return false;
    } else
        return true;
}*/

public static void removeMapFrgment(FragmentActivity fa, int id) {

    Android.support.v4.app.Fragment fragment;
    Android.support.v4.app.FragmentManager fm;
    Android.support.v4.app.FragmentTransaction ft;
    fm = fa.getSupportFragmentManager();
    fragment = fm.findFragmentById(id);
    ft = fa.getSupportFragmentManager().beginTransaction();
    ft.remove(fragment);
    ft.commit();

}

public static AlertDialog showDialog(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setMessage(message);

    builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

        @Override
        public void onClick(DialogInterface dialog, int id) {
            // TODO Auto-generated method stub

        }
    });

    return builder.create();
}

public static void showAlert(Context context, String message) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context);
    builder.setTitle("Alert");
    builder.setMessage(message)
            .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    dialog.dismiss();
                }
            }).show();
}

public static boolean isURL(String url) {
    if (url == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern
                .compile(
                        "\\b(?:(https?|ftp|file)://|www\\.)?[-A-Z0-9+&#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]\\.[-A-Z0-9+&@#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]",
                        Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(url);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean atLeastOneChr(String string) {
    if (string == null)
        return false;

    boolean foundMatch = false;
    try {
        Pattern regex = Pattern.compile("[a-zA-Z0-9]",
                Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        Matcher regexMatcher = regex.matcher(string);
        foundMatch = regexMatcher.matches();
        return foundMatch;
    } catch (PatternSyntaxException ex) {
        // Syntax error in the regular expression
        return false;
    }
}

public static boolean isValidEmail(String email, Context context) {
    String expression = "^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        // Helper.toast(context, "Email is not valid..!");

        return false;
    }
}

public static boolean isValidUserName(String email, Context context) {
    String expression = "^[0-9a-zA-Z]+$";
    CharSequence inputStr = email;
    Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
    Matcher matcher = pattern.matcher(inputStr);
    if (matcher.matches()) {
        return true;
    } else {
        Helper.toast(context, "Username is not valid..!");
        return false;
    }
}

public static boolean isValidDateSlash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd/mm/yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDash(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd-mm-yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

public static boolean isValidDateDot(String inDate) {
    SimpleDateFormat dateFormat = new SimpleDateFormat("dd.mm.yyyy");
    dateFormat.setLenient(false);
    try {
        dateFormat.parse(inDate.trim());
    } catch (ParseException pe) {
        return false;
    }
    return true;
}

}
1
Zohaib Hassan