web-dev-qa-db-fra.com

Est-il possible d'ajouter un tableau ou un objet à SharedPreferences sur Android

J'ai une ArrayList d'objets qui ont un nom et un pointeur d'icône et je veux l'enregistrer dans SharedPreferences. Comment puis-je faire?

NOTE: Je ne veux pas utiliser la base de données

androidandroid-preferencessharedpreferences
72
zsniperx

Donc, depuis le site de développement Android sur Stockage de données :

Préférences de l'utilisateur

Les préférences partagées ne servent pas uniquement à enregistrer les "préférences de l'utilisateur" telles que la sonnerie choisie par l'utilisateur. Si vous souhaitez créer des préférences utilisateur pour votre application, voir PreferenceActivity, qui fournit un cadre d'activité permettant de créer des préférences utilisateur, qui seront automatiquement conservées (à l'aide des préférences partagées).

Donc, je pense que ça va, car ce sont simplement des paires clé-valeur qui persistent.

Pour l'affiche originale, ce n'est pas si difficile. Il vous suffit simplement de parcourir votre liste de tableaux et d'ajouter les éléments. Dans cet exemple, j'utilise une carte pour plus de simplicité, mais vous pouvez utiliser une liste de tableaux et la modifier de manière appropriée:

// my list of names, icon locations
Map<String, String> nameIcons = new HashMap<String, String>();
nameIcons.put("Noel", "/location/to/noel/icon.png");
nameIcons.put("Bob", "another/location/to/bob/icon.png");
nameIcons.put("another name", "last/location/icon.png");

SharedPreferences keyValues = getContext().getSharedPreferences("name_icons_list", Context.MODE_PRIVATE);
SharedPreferences.Editor keyValuesEditor = keyValues.edit();

for (String s : nameIcons.keySet()) {
    // use the name as the key, and the icon as the value
    keyValuesEditor.putString(s, nameIcons.get(s));
}
keyValuesEditor.commit()

Vous feriez quelque chose de similaire pour relire les paires clé-valeur. Laissez-moi savoir si cela fonctionne.

Update: Si vous utilisez une API de niveau 11 ou supérieur, il existe une méthode pour écrire un jeu de chaînes. 

56
Noel

Quel que soit le niveau de l’API, vérifiez Tableaux de chaînes et Tableaux d’objets dans SharedPreferences

SAVE ARRAY

public boolean saveArray(String[] array, String arrayName, Context mContext) {   
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    SharedPreferences.Editor editor = prefs.edit();  
    editor.putInt(arrayName +"_size", array.length);  
    for(int i=0;i<array.length;i++)  
        editor.putString(arrayName + "_" + i, array[i]);  
    return editor.commit();  
}

RANGEMENT DE CHARGE

public String[] loadArray(String arrayName, Context mContext) {  
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    int size = prefs.getInt(arrayName + "_size", 0);  
    String array[] = new String[size];  
    for(int i=0;i<size;i++)  
        array[i] = prefs.getString(arrayName + "_" + i, null);  
    return array;  
}
69
Sherif elKhatib

Écrire,

SharedPreferences prefs = PreferenceManager
        .getDefaultSharedPreferences(this);
JSONArray jsonArray = new JSONArray();
jsonArray.put(1);
jsonArray.put(2);
Editor editor = prefs.edit();
editor.putString("key", jsonArray.toString());
System.out.println(jsonArray.toString());
editor.commit();

Lire,

try {
    JSONArray jsonArray2 = new JSONArray(prefs.getString("key", "[]"));
    for (int i = 0; i < jsonArray2.length(); i++) {
         Log.d("your JSON Array", jsonArray2.getInt(i)+"");
    }
} catch (Exception e) {
    e.printStackTrace();
}
55
Rohit

Les préférences partagées ont introduit les méthodes getStringSet et putStringSet dans l'API Level 11, mais elles ne sont pas compatibles avec les anciennes versions d'Android (qui sont toujours populaires) et sont également limitées à des ensembles de chaînes.

Android ne fournit pas de meilleures méthodes, et parcourir les cartes et les tableaux pour les sauvegarder et les charger n'est pas très facile et propre, spécialement pour les tableaux. Mais une meilleure implémentation n’est pas si difficile:

package com.example.utils;

import org.json.JSONObject;
import org.json.JSONArray;
import org.json.JSONException;

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

public class JSONSharedPreferences {
    private static final String PREFIX = "json";

    public static void saveJSONObject(Context c, String prefName, String key, JSONObject object) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, object.toString());
        editor.commit();
    }

    public static void saveJSONArray(Context c, String prefName, String key, JSONArray array) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, array.toString());
        editor.commit();
    }

    public static JSONObject loadJSONObject(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONObject(settings.getString(JSONSharedPreferences.PREFIX+key, "{}"));
    }

    public static JSONArray loadJSONArray(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONArray(settings.getString(JSONSharedPreferences.PREFIX+key, "[]"));
    }

    public static void remove(Context c, String prefName, String key) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        if (settings.contains(JSONSharedPreferences.PREFIX+key)) {
            SharedPreferences.Editor editor = settings.edit();
            editor.remove(JSONSharedPreferences.PREFIX+key);
            editor.commit();
        }
    }
}

Maintenant, vous pouvez enregistrer n'importe quelle collection dans les préférences partagées avec ces cinq méthodes. Travailler avec JSONObject et JSONArray est très facile. Vous pouvez utiliser le constructeur public JSONArray (Collection copyFrom) pour créer un JSONArray à partir de toute collection Java et utiliser les méthodes JSONArray's get pour accéder aux éléments.

Il n'y a pas de limite de taille pour les préférences partagées (en dehors des limites de stockage de l'appareil), donc ces méthodes peuvent fonctionner dans la plupart des cas habituels où vous souhaitez un stockage rapide et facile pour une collection dans votre application. Mais l'analyse JSON a lieu ici, et les préférences dans Android sont stockées sous forme de fichiers XML en interne. Je recommande donc d'utiliser d'autres mécanismes de stockage de données persistantes lorsque vous traitez des mégaoctets de données.

31
Mostafa

Mode facile pour le stockage d'objets complexes avec l'utilisation de la bibliothèque Google Gson [1]

public static void setComplexObject(Context ctx, ComplexObject obj){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    SharedPreferences.Editor editor = preferences.edit();
    editor.putString("COMPLEX_OBJECT",new Gson().toJson(obj)); 
    editor.commit();
}

public static ComplexObject getComplexObject (Context ctx){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    String sobj = preferences.getString("COMPLEX_OBJECT", "");
    if(sobj.equals(""))return null;
    else return new Gson().fromJson(sobj, ComplexObject.class);
}

[1] http://code.google.com/p/google-gson/

13
Hpsaturn

J'ai chargé un tableau de tailles de tour de taille (déjà créé dans mon tableau.xml) dans mon fichier preferences.xml avec le code ci-dessous. @ array/pant_inch_size est l'id du tableau entier. 

 <ListPreference 
 Android:title="choosepantsize"
 Android:summary="Choose Pant Size"
 Android:key="pantSizePref" 
 Android:defaultValue="34" 
 Android:entries="@array/pant_inch_size"
 Android:entryValues="@array/pant_inch_size" />

Cela a rempli le menu avec les choix du tableau. J'ai défini la taille par défaut sur 34. Ainsi, lorsque le menu apparaît, la taille 34 est présélectionnée. 

3
Keith

La méthode simple consiste à le convertir en chaîne JSON comme dans l'exemple ci-dessous:

Gson gson = new Gson();
String json = gson.toJson(myObj);

Puis stockez la chaîne dans les préférences partagées . Une fois que vous en avez besoin, récupérez simplement la chaîne dans les préférences partagées et reconvertissez-la en JSONArray ou JSONObject (selon vos besoins)

2
Gaurav Darji

Pour écrire:

 private <T> void storeData(String key, T data) {
    ByteArrayOutputStream serializedData = new ByteArrayOutputStream();

    try {
        ObjectOutputStream serializer = new ObjectOutputStream(serializedData);
        serializer.writeObject(data);
    } catch (IOException e) {
        e.printStackTrace();
    }

    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    SharedPreferences.Editor edit = sharedPreferences.edit();

    edit.putString(key, Base64.encodeToString(serializedData.toByteArray(), Base64.DEFAULT));
    edit.commit();
}

A lire:

private <T> T getStoredData(String key) {
    SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
    String serializedData = sharedPreferences.getString(key, null);
    T storedData = null;
    try {
        ByteArrayInputStream input = new ByteArrayInputStream(Base64.decode(serializedData, Base64.DEFAULT));
        ObjectInputStream inputStream = new ObjectInputStream(input);
        storedData = (T)inputStream.readObject();
    } catch (IOException|ClassNotFoundException|Java.lang.IllegalArgumentException e) {
        e.printStackTrace();
    }

    return storedData;
}
1
Benav

C’est le code de préférences partagé que j’utilise avec succès, reportez-vous à ce link :

  public class MainActivity extends Activity {

private static final int RESULT_SETTINGS = 1;
Button button;
public String a="dd";

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

 button = (Button) findViewById(R.id.btnoptions);


setContentView(R.layout.activity_main);

  // showUserSettings();
  }

@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.settings, menu);
return true;
 }

@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {

case R.id.menu_settings:
 Intent i = new Intent(this, UserSettingActivity.class);
 startActivityForResult(i, RESULT_SETTINGS);
 break;

 }

return true;
}

@Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data)     {
  super.onActivityResult(requestCode, resultCode, data);

 switch (requestCode) {
 case RESULT_SETTINGS:
 showUserSettings();
 break;

 } 

  }

  private void showUserSettings() {
 SharedPreferences sharedPrefs = PreferenceManager
.getDefaultSharedPreferences(this);

 StringBuilder builder = new StringBuilder();

 builder.append("\n Pet: "
  + sharedPrefs.getString("prefpetname", "NULL"));

 builder.append("\n Address:"
 + sharedPrefs.getString("prefaddress","NULL" ));

 builder.append("\n Your name: "
 + sharedPrefs.getString("prefname", "NULL"));

 TextView settingsTextView = (TextView) findViewById(R.id.textUserSettings);


  settingsTextView.setText(builder.toString());


    }

   }

CODAGE HEUREUX!

1
dondondon

Vous pouvez utiliser putStringSet

Cela vous permet de sauvegarder un HashSet dans vos préférences, comme ceci:

Sauvegarder

Set<String> values;

SharedPreferences sharedPref = 
    mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);

Editor editor = sharedPref.edit();

editor.putStringSet("YOUR_KEY", values);
editor.apply();

Retrive

SharedPreferences sharedPref = 
    mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);

Editor editor = sharedPref.edit();

Set<String> newList = editor.getStringSet("YOUR_KEY", null);

PutStringSet autorise uniquement un ensemble et il s’agit d’une liste unordered.

0
Daniel Beltrami