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

StackOverflow https://stackoverflow.com/questions/3876680

Question

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

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

Était-ce utile?

La solution

à partir du site développeur Android sur de stockage des données :

  

Préférences utilisateur

     

préférences partagées ne sont pas strictement pour l'enregistrement « préférences utilisateur » comme ce que sonnerie utilisateur a choisi. Si vous souhaitez créer des préférences utilisateur pour votre application, consultez PreferenceActivity, qui fournit un cadre d'activité pour vous de créer des préférences de l'utilisateur, qui sera automatiquement persistées (en utilisant les préférences partagées).

Je pense donc qu'il est correct car il est tout simplement des paires clé-valeur persités.

A l'affiche originale, ce n'est pas si difficile. Il vous suffit simplement itérer dans votre liste de tableau et d'ajouter les éléments. Dans cet exemple, j'utilise une carte pour plus de simplicité, mais vous pouvez utiliser une liste de tableau et changer de façon 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 à lire à nouveau les paires valeur clé. Faites-moi savoir si cela fonctionne.

Mise à jour: Si vous utilisez le niveau API 11 ou plus tard, il y a un méthode pour écrire un ensemble chaîne

Autres conseils

Quel que soit le niveau de l'API, Vérifiez tableaux de chaînes de caractères et les tableaux d'objets dans SharedPreferences

STOCKER VARIABLES 

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

CHARGER VARIABLES 

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

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

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

préférences partagées introduit un getStringSet et des méthodes putStringSet dans l'API de niveau 11, mais ce n'est pas compatible avec les anciennes versions d'Android (qui sont encore populaires), et est également limité à des ensembles de chaînes.

Android ne fournit pas de meilleures méthodes, et en boucle sur des cartes et des tableaux pour la sauvegarde et les charger est pas très facile et propre, spécialement pour les tableaux. Mais une meilleure mise en œuvre est pas 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();
        }
    }
}

Vous pouvez maintenant enregistrer une 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 faire une JSONArray de toute collection Java et l'utilisation des méthodes de JSONArray de 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), de sorte que ces méthodes peuvent fonctionner pour la plupart des cas habituels où vous voulez un stockage rapide et facile pour une collection dans votre application. Mais l'analyse syntaxique JSON qui se passe ici, et les préférences dans Android sont stockées sous forme XMLs interne, donc je recommande d'utiliser d'autres mécanismes de stockage de données persistantes lorsque vous êtes de négociation avec méga-octets de données.

mode facile pour le stockage de l'objet complexe avec l'aide de la bibliothèque Gson Google [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/

Je chargé un tableau de tailles de taille (déjà créées dans mon array.xml) dans mon fichier preferences.xml avec le code ci-dessous. @ Tableau / pant_inch_size est l'identifiant 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" />

peuplé le menu avec choix du tableau. Je mis la taille par défaut de 34, de sorte que lorsque le menu apparaît, ils voient la taille 34 est pré-sélectionné.

La façon simple est, pour le convertir en JSON chaîne comme exemple ci-dessous: 

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

stocker ensuite la chaîne dans les préférences partagées. Une fois que vous en avez besoin juste obtenir chaîne de préférences partagées et arrière converti à JSONArray ou JSONObject (selon vos besoins).

Par écrit: 

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

Pour la lecture: 

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

Ceci est le code de préférences partagé j'utilise avec succès, reportez-vous ce lien : 

  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!

Vous pouvez utiliser putStringSet

Cela vous permet d'enregistrer un HashSet dans vos préférences, comme ceci:

Enregistrer 

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

Le putStringSet permet seulement un ensemble et ceci est un non ordonnée liste.

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top