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

Question

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

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

Answer 1

Quel que soit le niveau de l'API, Check Tableaux de chaînes et tableaux d'objets dans SharedPreferences

---

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

---

CHARGER ARRAY

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

Answer 2

Donc, depuis le site du développeur Android sur Stockage des données :

Préférences de l'utilisateur

Préférences partagées ne servent pas uniquement à sauvegarder les "préférences de l'utilisateur". comme la sonnerie qu'un utilisateur a choisie. Si vous souhaitez créer des préférences d'utilisateur pour votre application, consultez PreferenceActivity, qui fournit un cadre d'activité permettant de créer des préférences d'utilisateur, qui seront automatiquement persistées (à l'aide de préférences partagées).

Je pense donc que c'est correct puisque ce sont simplement des paires clé-valeur qui sont persistées.

Pour l'affiche originale, ce n'est pas si difficile. Il suffit d'itérer dans votre liste de tableaux et d'ajouter les éléments. Dans cet exemple, j'utilise une carte pour des raisons de simplicité, mais vous pouvez utiliser une liste de tableaux et la modifier en conséquence :

// 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. Faites-moi savoir si cela fonctionne.

Mise à jour : Si vous utilisez le niveau 11 de l'API ou une version ultérieure, il y a une méthode pour écrire un ensemble de chaînes

Answer 3

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

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

Autre façon de faire la même chose :

//Retrieve the values
Gson gson = new Gson();
String jsonText = Prefs.getString("key", null);
String[] text = gson.fromJson(jsonText, String[].class);  //EDIT: gso to gson

//Set the values
Gson gson = new Gson();
List<String> textList = new ArrayList<String>(data);
String jsonText = gson.toJson(textList);
prefsEditor.putString("key", jsonText);
prefsEditor.apply();

Utilisation de GSON en Java :

public void saveArrayList(ArrayList<String> list, String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    SharedPreferences.Editor editor = prefs.edit();
    Gson gson = new Gson();
    String json = gson.toJson(list);
    editor.putString(key, json);
    editor.apply();    

}

public ArrayList<String> getArrayList(String key){
    SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(activity);
    Gson gson = new Gson();
    String json = prefs.getString(key, null);
    Type type = new TypeToken<ArrayList<String>>() {}.getType();
    return gson.fromJson(json, type);
}

Utilisation de GSON dans Kotlin

fun saveArrayList(list: java.util.ArrayList<String?>?, key: String?) {
    val prefs: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
    val editor: Editor = prefs.edit()
    val gson = Gson()
    val json: String = gson.toJson(list)
    editor.putString(key, json)
    editor.apply()
}

fun getArrayList(key: String?): java.util.ArrayList<String?>? {
    val prefs: SharedPreferences = PreferenceManager.getDefaultSharedPreferences(activity)
    val gson = Gson()
    val json: String = prefs.getString(key, null)
    val type: Type = object : TypeToken<java.util.ArrayList<String?>?>() {}.getType()
    return gson.fromJson(json, type)
}

Answer 4

Les préférences partagées ont introduit un getStringSet y putStringSet dans le niveau 11 de l'API, mais cette méthode n'est pas compatible avec les anciennes versions d'Android (qui sont toujours populaires) et est également limitée aux ensembles de chaînes de caractères.

Android ne fournit pas de meilleures méthodes, et le fait de boucler sur les cartes et les tableaux pour les sauvegarder et les charger n'est pas très facile et propre, surtout 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 sauvegarder n'importe quelle collection dans les préférences partagées avec ces cinq méthodes. Travailler avec JSONObject y JSONArray est très facile. Vous pouvez utiliser JSONArray (Collection copyFrom) pour créer un JSONArray hors de toute collection Java et utiliser 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 pour la plupart des cas habituels où vous voulez un stockage rapide et facile pour une collection dans votre application. Mais l'analyse JSON se fait ici, et les préférences dans Android sont stockées en XML en interne, donc je recommande d'utiliser d'autres mécanismes de stockage de données persistantes lorsque vous avez affaire à des mégaoctets de données.

Answer 5

Mode facile pour le stockage d'objets complexes en utilisant la bibliothèque Gson de 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/