Enregistrer ArrayList dans SharedPreferences


318

J'ai un ArrayListavec des objets personnalisés. Chaque objet personnalisé contient une variété de chaînes et de nombres. J'ai besoin que le tableau reste, même si l'utilisateur quitte l'activité et souhaite ensuite revenir plus tard, mais je n'ai pas besoin du tableau disponible après la fermeture complète de l'application. J'enregistre beaucoup d'autres objets de cette façon en utilisant le SharedPreferencesmais je ne peux pas comprendre comment enregistrer mon tableau entier de cette façon. Est-ce possible? Peut SharedPreferences- être que ce n'est pas la façon de procéder? Existe-t-il une méthode plus simple?


Vous pouvez trouver la réponse ici: stackoverflow.com/questions/14981233/…
Apurva Kolapkar

c'est l'exemple complet passez par l'url stackoverflow.com/a/41137562/4344659
Sanjeev Sangral

Si quelqu'un cherche la solution, cela pourrait être la réponse que vous cherchez avec un exemple d'utilisation complète dans kotlin. stackoverflow.com/a/56873719/3710341
Sagar Chapagain

Réponses:


432

Après l'API 11, SharedPreferences Editoracceptez Sets. Vous pouvez convertir votre liste en un HashSetou quelque chose de similaire et le stocker comme ça. Lorsque vous le relisez, convertissez-le en un ArrayList, triez-le si nécessaire et vous êtes prêt à partir.

//Retrieve the values
Set<String> set = myScores.getStringSet("key", null);

//Set the values
Set<String> set = new HashSet<String>();
set.addAll(listOfExistingScores);
scoreEditor.putStringSet("key", set);
scoreEditor.commit();

Vous pouvez également sérialiser votre ArrayList, puis l'enregistrer / le lire vers / depuis SharedPreferences. Voici la solution:

EDIT:
Ok, ci-dessous est la solution pour enregistrer en ArrayListtant qu'objet sérialisé SharedPreferences, puis le lire à partir de SharedPreferences.

Étant donné que l'API prend uniquement en charge le stockage et la récupération de chaînes vers / depuis SharedPreferences (après l'API 11, c'est plus simple), nous devons sérialiser et dé-sérialiser l'objet ArrayList qui contient la liste des tâches en chaîne.

Dans la addTask()méthode de la classe TaskManagerApplication, nous devons obtenir l'instance de la préférence partagée, puis stocker la liste de tableaux sérialisée à l'aide de la putString()méthode:

public void addTask(Task t) {
  if (null == currentTasks) {
    currentTasks = new ArrayList<task>();
  }
  currentTasks.add(t);

  // save the task list to preference
  SharedPreferences prefs = getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE);
  Editor editor = prefs.edit();
  try {
    editor.putString(TASKS, ObjectSerializer.serialize(currentTasks));
  } catch (IOException e) {
    e.printStackTrace();
  }
  editor.commit();
}

De même, nous devons récupérer la liste des tâches de la préférence dans la onCreate()méthode:

public void onCreate() {
  super.onCreate();
  if (null == currentTasks) {
    currentTasks = new ArrayList<task>();
  }

  // load tasks from preference
  SharedPreferences prefs = getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE);

  try {
    currentTasks = (ArrayList<task>) ObjectSerializer.deserialize(prefs.getString(TASKS, ObjectSerializer.serialize(new ArrayList<task>())));
  } catch (IOException e) {
    e.printStackTrace();
  } catch (ClassNotFoundException e) {
    e.printStackTrace();
  }
}

Vous pouvez obtenir une ObjectSerializerclasse à partir du projet Apache Pig ObjectSerializer.java


21
Gardez à l'esprit que l' putStringSetajout à l'API 11. La plupart des programmeurs actuels visent à louer l'API 8 (Froyo).
Cristian

2
J'aime l'idée de cette méthode car elle semble être la plus propre, mais le tableau que je cherche à stocker est un objet de classe personnalisé qui contient des chaînes, des doubles et des booléens. Comment puis-je ajouter les 3 de ces types à un ensemble? Dois-je définir chaque objet individuel dans son propre tableau, puis les ajouter individuellement à des ensembles distincts avant de les stocker, ou existe-t-il un moyen plus simple?
ryandlf

5
Qu'est-ce que c'est scoreEditor?
Ruchir Baronia

2
Aux lecteurs après octobre 2016: ce commentaire reçoit déjà beaucoup de votes positifs et vous pouvez l'utiliser comme moi, mais veuillez vous arrêter et ne pas le faire. HashSet supprimera la valeur en double, donc votre ArrayList ne sera pas la même. Détails ici: stackoverflow.com/questions/12940663/…
séoul

2
Pour rappel à ceux qui rencontrent cette réponse: un ensemble n'est pas ordonné, donc l'enregistrement d'un StringSet perdra l'ordre que vous aviez avec votre ArrayList.
David Liu

119

L'utilisation de cet objet -> TinyDB - Android-Shared-Preferences-Turbo est très simple.

TinyDB tinydb = new TinyDB(context);

mettre

tinydb.putList("MyUsers", mUsersArray);

obtenir

tinydb.getList("MyUsers");

METTRE À JOUR

Des exemples utiles et un dépannage peuvent être trouvés ici: Android Shared Preference TinyDB putListObject frunction


6
C'est la meilleure approche. +1 de mon côté
Sritam Jagadev

3
Moi aussi. Extrêmement utile !!
Juan Aguilar Guisado

1
selon le contenu de votre liste, vous devez spécifier le type d'objet de votre liste lors de l'appel tinydb.putList()Regardez les exemples sur la page liée.
kc ochibili

bonne bibliothèque, mais je dois mentionner que parfois cette bibliothèque a des problèmes lors du stockage d'objets. pour être plus précis, il peut lever une exception de dépassement de pile. et je pense que c'est parce qu'il utilise la réflexion pour comprendre comment stocker l'objet, et si l'objet devient trop compliqué, il peut lever cette exception.
Mr.Q

1
Je vous aime tellement!
mychemicalro

93

Enregistrement Arraydans SharedPreferences:

public static boolean saveArray()
{
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    SharedPreferences.Editor mEdit1 = sp.edit();
    /* sKey is an array */
    mEdit1.putInt("Status_size", sKey.size());  

    for(int i=0;i<sKey.size();i++)  
    {
        mEdit1.remove("Status_" + i);
        mEdit1.putString("Status_" + i, sKey.get(i));  
    }

    return mEdit1.commit();     
}

Chargement des Arraydonnées depuisSharedPreferences

public static void loadArray(Context mContext)
{  
    SharedPreferences mSharedPreference1 =   PreferenceManager.getDefaultSharedPreferences(mContext);
    sKey.clear();
    int size = mSharedPreference1.getInt("Status_size", 0);  

    for(int i=0;i<size;i++) 
    {
     sKey.add(mSharedPreference1.getString("Status_" + i, null));
    }

}

14
c'est un très joli "hack". Soyez conscient qu'avec cette méthode, il est toujours possible de gonfler les SharedPreferences avec les anciennes valeurs inutilisées. Par exemple, une liste peut avoir une taille de 100 lors d'une exécution, puis une taille de 50. Les 50 anciennes entrées resteront dans les préférences. Une façon consiste à définir une valeur MAX et à effacer quoi que ce soit.
Iraklis

3
@Iraklis En effet, mais en supposant que vous ne stockiez que cela ArrayListdans, SharedPrefenecesvous pouvez l'utiliser mEdit1.clear()pour éviter cela.
AlexAndro

1
J'aime ce "hack". Mais mEdit1.clear () effacera-t-il d'autres valeurs non pertinentes à cet effet?
Bagusflyer

1
Merci! Si vous me dérangez de demander, y a-t-il un but nécessaire pour .remove ()? La préférence ne sera-t-elle pas simplement remplacée de toute façon?
Script Kitty

62

Vous pouvez le convertir JSON Stringet stocker la chaîne dans le SharedPreferences.


Je trouve une tonne de code sur la conversion d'ArrayLists en JSONArrays, mais avez-vous un échantillon que vous voudrez peut-être partager sur la façon de convertir en JSONString afin que je puisse le stocker dans les SharedPrefs?
ryandlf

5
utilisant toString ()
MByD

3
Mais comment puis-je le récupérer hors de SharedPrefs et le reconvertir en ArrayList?
ryandlf

Je suis désolé, je n'ai pas de SDK Android pour le tester maintenant, mais jetez un œil ici: benjii.me/2010/04/deserializing-json-in-android-using-gson . Vous devriez parcourir le tableau json et faire ce qu'ils font là pour chaque objet, j'espère que je serai en mesure de publier une modification de ma réponse avec un exemple complet demain.
MByD

53

Comme l'a dit @nirav, la meilleure solution est de le stocker dans sharedPrefernces en tant que texte json en utilisant la classe d'utilitaires Gson. Exemple de code ci-dessous:

//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>();
textList.addAll(data);
String jsonText = gson.toJson(textList);
prefsEditor.putString("key", jsonText);
prefsEditor.apply();

2
Dieu merci, c'était une bouée de sauvetage. Très simple en effet.
Parthiban M

2
Cette réponse devrait être très élevée. Superbe! Je ne savais pas que je pouvais utiliser Gson de cette façon. C'est la première fois que la notation du tableau est utilisée de cette façon également. Je vous remercie!
mad

3
Pour le reconvertir en liste, List <String> textList = Arrays.asList (gson.fromJson (jsonText, String []. Class));
Vamsi Challa

22

Hé amis, j'ai obtenu la solution du problème ci-dessus sans utiliser la Gsonbibliothèque. Ici, je poste le code source.

1. déclaration variable ie

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2. Initialisation variable, c.-à-d.

 shared = getSharedPreferences("App_settings", MODE_PRIVATE);
 // add values for your ArrayList any where...
 arrPackage = new ArrayList<>();

3. stockez la valeur de sharedPreference en utilisant packagesharedPreferences():

 private void packagesharedPreferences() {
   SharedPreferences.Editor editor = shared.edit();
   Set<String> set = new HashSet<String>();
   set.addAll(arrPackage);
   editor.putStringSet("DATE_LIST", set);
   editor.apply();
   Log.d("storesharedPreferences",""+set);
 }

4. récupérer la valeur de sharedPreference en utilisant retriveSharedValue():

 private void retriveSharedValue() {
   Set<String> set = shared.getStringSet("DATE_LIST", null);
   arrPackage.addAll(set);
   Log.d("retrivesharedPreferences",""+set);
 }

J'espère que cela vous sera utile ...


bonne solution! facile et rapide!
LoveAndroid

5
Cela supprimerait toutes les chaînes en double de la liste dès que vous ajoutez à un ensemble. Probablement pas une fonctionnalité recherchée
OneCricketeer

Est-ce seulement pour une liste de Strings?
CoolMind

Vous perdrez l'ordre de cette façon
Brian Reinhold

16
/**
 *     Save and get ArrayList in SharedPreference
 */

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

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

1
Oui, meilleure réponse
AlexPad

c'est la meilleure réponse, je l'utilise aussi pour stocker d'autres objets
Irfandi D. Vendy

pouvez-vous faire cela qui signifie qu'il stockera toutes les classes de modèle?
BlackBlind

13

Android SharedPreferances vous permet d'enregistrer les types primitifs (Boolean, Float, Int, Long, String et StringSet qui sont disponibles depuis API11) en mémoire sous forme de fichier xml.

L'idée clé de toute solution serait de convertir les données en l'un de ces types primitifs.

Personnellement, j'adore convertir ma liste au format json, puis l'enregistrer en tant que chaîne dans une valeur SharedPreferences.

Pour utiliser ma solution, vous devrez ajouter Google Gson lib.

Dans gradle, ajoutez simplement la dépendance suivante (veuillez utiliser la dernière version de google):

compile 'com.google.code.gson:gson:2.6.2'

Enregistrer les données (où HttpParam est votre objet):

List<HttpParam> httpParamList = "**get your list**"
String httpParamJSONList = new Gson().toJson(httpParamList);

SharedPreferences prefs = getSharedPreferences(**"your_prefes_key"**, Context.MODE_PRIVATE);
SharedPreferences.Editor editor = prefs.edit();
editor.putString(**"your_prefes_key"**, httpParamJSONList);

editor.apply();

Récupérer des données (où HttpParam est votre objet):

SharedPreferences prefs = getSharedPreferences(**"your_prefes_key"**, Context.MODE_PRIVATE);
String httpParamJSONList = prefs.getString(**"your_prefes_key"**, ""); 

List<HttpParam> httpParamList =  
new Gson().fromJson(httpParamJSONList, new TypeToken<List<HttpParam>>() {
            }.getType());

Merci. Cette réponse m'a aidé à récupérer et à enregistrer ma liste <MonObjet>.
visrahane

Merci. Fonctionne bien
Velayutham M

11

Ceci est votre solution parfaite .. essayez-le,

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();     // This line is IMPORTANT !!!
}

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

9

Vous pouvez également convertir l'arraylist en une chaîne et l'enregistrer de préférence

private String convertToString(ArrayList<String> list) {

            StringBuilder sb = new StringBuilder();
            String delim = "";
            for (String s : list)
            {
                sb.append(delim);
                sb.append(s);;
                delim = ",";
            }
            return sb.toString();
        }

private ArrayList<String> convertToArray(String string) {

            ArrayList<String> list = new ArrayList<String>(Arrays.asList(string.split(",")));
            return list;
        }

Vous pouvez enregistrer l'arraylist après l'avoir converti en chaîne à l'aide de la convertToStringméthode et récupérer la chaîne et la convertir en tableau à l'aideconvertToArray

Après l'API 11, vous pouvez cependant enregistrer directement dans SharedPreferences !!! :)


6

Pour String, int, boolean, le meilleur choix serait sharedPreferences.

Si vous souhaitez stocker ArrayList ou toute donnée complexe. Le meilleur choix serait la bibliothèque papier.

Ajouter une dépendance

implementation 'io.paperdb:paperdb:2.6'

Initialiser le papier

Doit être initialisé une fois dans Application.onCreate ():

Paper.init(context);

sauver

List<Person> contacts = ...
Paper.book().write("contacts", contacts);

Chargement des données

Utilisez des valeurs par défaut si l'objet n'existe pas dans le stockage.

List<Person> contacts = Paper.book().read("contacts", new ArrayList<>());

Voici.

https://github.com/pilgr/Paper


5

J'ai lu toutes les réponses ci-dessus. C'est tout à fait correct mais j'ai trouvé une solution plus simple comme ci-dessous:

  1. Enregistrement de la liste de chaînes dans les préférences partagées >>

    public static void setSharedPreferenceStringList(Context pContext, String pKey, List<String> pData) {
    SharedPreferences.Editor editor = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit();
    editor.putInt(pKey + "size", pData.size());
    editor.commit();
    
    for (int i = 0; i < pData.size(); i++) {
        SharedPreferences.Editor editor1 = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit();
        editor1.putString(pKey + i, (pData.get(i)));
        editor1.commit();
    }

    }

  2. et pour obtenir la liste des chaînes à partir des préférences partagées >>

    public static List<String> getSharedPreferenceStringList(Context pContext, String pKey) {
    int size = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).getInt(pKey + "size", 0);
    List<String> list = new ArrayList<>();
    for (int i = 0; i < size; i++) {
        list.add(pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).getString(pKey + i, ""));
    }
    return list;
    }

Voici Constants.APP_PREFSle nom du fichier à ouvrir; ne peut pas contenir de séparateurs de chemin.


5

Aussi avec Kotlin:

fun SharedPreferences.Editor.putIntegerArrayList(key: String, list: ArrayList<Int>?): SharedPreferences.Editor {
    putString(key, list?.joinToString(",") ?: "")
    return this
}

fun SharedPreferences.getIntegerArrayList(key: String, defValue: ArrayList<Int>?): ArrayList<Int>? {
    val value = getString(key, null)
    if (value.isNullOrBlank())
        return defValue
    return ArrayList (value.split(",").map { it.toInt() }) 
}

4

la meilleure façon est de convertir en chaîne JSOn à l'aide de GSON et d'enregistrer cette chaîne dans SharedPreference. J'utilise également cette méthode pour mettre en cache les réponses.


4

Vous pouvez enregistrer une chaîne et une liste de tableaux personnalisés à l'aide de la bibliothèque Gson.

=> Vous devez d'abord créer une fonction pour enregistrer la liste des tableaux dans SharedPreferences.

public void saveListInLocal(ArrayList<String> list, String key) {

        SharedPreferences prefs = getSharedPreferences("AppName", Context.MODE_PRIVATE);
        SharedPreferences.Editor editor = prefs.edit();
        Gson gson = new Gson();
        String json = gson.toJson(list);
        editor.putString(key, json);
        editor.apply();     // This line is IMPORTANT !!!

    }

=> Vous devez créer une fonction pour obtenir la liste des tableaux à partir de SharedPreferences.

public ArrayList<String> getListFromLocal(String key)
{
    SharedPreferences prefs = getSharedPreferences("AppName", Context.MODE_PRIVATE);
    Gson gson = new Gson();
    String json = prefs.getString(key, null);
    Type type = new TypeToken<ArrayList<String>>() {}.getType();
    return gson.fromJson(json, type);

}

=> Comment appeler la fonction de sauvegarde et de récupération des listes de tableaux.

ArrayList<String> listSave=new ArrayList<>();
listSave.add("test1"));
listSave.add("test2"));
saveListInLocal(listSave,"key");
Log.e("saveArrayList:","Save ArrayList success");
ArrayList<String> listGet=new ArrayList<>();
listGet=getListFromLocal("key");
Log.e("getArrayList:","Get ArrayList size"+listGet.size());

=> N'oubliez pas d'ajouter la bibliothèque gson au niveau de votre application build.gradle.

implémentation "com.google.code.gson: gson: 2.8.2"


3

Vous pouvez référencer les fonctions serializeKey () et deserializeKey () de la classe SharedPreferencesTokenCache de FacebookSDK. Il convertit le supportedType en objet JSON et stocke la chaîne JSON dans SharedPreferences . Vous pouvez télécharger le SDK d' ici

private void serializeKey(String key, Bundle bundle, SharedPreferences.Editor editor)
    throws JSONException {
    Object value = bundle.get(key);
    if (value == null) {
        // Cannot serialize null values.
        return;
    }

    String supportedType = null;
    JSONArray jsonArray = null;
    JSONObject json = new JSONObject();

    if (value instanceof Byte) {
        supportedType = TYPE_BYTE;
        json.put(JSON_VALUE, ((Byte)value).intValue());
    } else if (value instanceof Short) {
        supportedType = TYPE_SHORT;
        json.put(JSON_VALUE, ((Short)value).intValue());
    } else if (value instanceof Integer) {
        supportedType = TYPE_INTEGER;
        json.put(JSON_VALUE, ((Integer)value).intValue());
    } else if (value instanceof Long) {
        supportedType = TYPE_LONG;
        json.put(JSON_VALUE, ((Long)value).longValue());
    } else if (value instanceof Float) {
        supportedType = TYPE_FLOAT;
        json.put(JSON_VALUE, ((Float)value).doubleValue());
    } else if (value instanceof Double) {
        supportedType = TYPE_DOUBLE;
        json.put(JSON_VALUE, ((Double)value).doubleValue());
    } else if (value instanceof Boolean) {
        supportedType = TYPE_BOOLEAN;
        json.put(JSON_VALUE, ((Boolean)value).booleanValue());
    } else if (value instanceof Character) {
        supportedType = TYPE_CHAR;
        json.put(JSON_VALUE, value.toString());
    } else if (value instanceof String) {
        supportedType = TYPE_STRING;
        json.put(JSON_VALUE, (String)value);
    } else {
        // Optimistically create a JSONArray. If not an array type, we can null
        // it out later
        jsonArray = new JSONArray();
        if (value instanceof byte[]) {
            supportedType = TYPE_BYTE_ARRAY;
            for (byte v : (byte[])value) {
                jsonArray.put((int)v);
            }
        } else if (value instanceof short[]) {
            supportedType = TYPE_SHORT_ARRAY;
            for (short v : (short[])value) {
                jsonArray.put((int)v);
            }
        } else if (value instanceof int[]) {
            supportedType = TYPE_INTEGER_ARRAY;
            for (int v : (int[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof long[]) {
            supportedType = TYPE_LONG_ARRAY;
            for (long v : (long[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof float[]) {
            supportedType = TYPE_FLOAT_ARRAY;
            for (float v : (float[])value) {
                jsonArray.put((double)v);
            }
        } else if (value instanceof double[]) {
            supportedType = TYPE_DOUBLE_ARRAY;
            for (double v : (double[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof boolean[]) {
            supportedType = TYPE_BOOLEAN_ARRAY;
            for (boolean v : (boolean[])value) {
                jsonArray.put(v);
            }
        } else if (value instanceof char[]) {
            supportedType = TYPE_CHAR_ARRAY;
            for (char v : (char[])value) {
                jsonArray.put(String.valueOf(v));
            }
        } else if (value instanceof List<?>) {
            supportedType = TYPE_STRING_LIST;
            @SuppressWarnings("unchecked")
            List<String> stringList = (List<String>)value;
            for (String v : stringList) {
                jsonArray.put((v == null) ? JSONObject.NULL : v);
            }
        } else {
            // Unsupported type. Clear out the array as a precaution even though
            // it is redundant with the null supportedType.
            jsonArray = null;
        }
    }

    if (supportedType != null) {
        json.put(JSON_VALUE_TYPE, supportedType);
        if (jsonArray != null) {
            // If we have an array, it has already been converted to JSON. So use
            // that instead.
            json.putOpt(JSON_VALUE, jsonArray);
        }

        String jsonString = json.toString();
        editor.putString(key, jsonString);
    }
}

private void deserializeKey(String key, Bundle bundle)
        throws JSONException {
    String jsonString = cache.getString(key, "{}");
    JSONObject json = new JSONObject(jsonString);

    String valueType = json.getString(JSON_VALUE_TYPE);

    if (valueType.equals(TYPE_BOOLEAN)) {
        bundle.putBoolean(key, json.getBoolean(JSON_VALUE));
    } else if (valueType.equals(TYPE_BOOLEAN_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        boolean[] array = new boolean[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getBoolean(i);
        }
        bundle.putBooleanArray(key, array);
    } else if (valueType.equals(TYPE_BYTE)) {
        bundle.putByte(key, (byte)json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_BYTE_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        byte[] array = new byte[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (byte)jsonArray.getInt(i);
        }
        bundle.putByteArray(key, array);
    } else if (valueType.equals(TYPE_SHORT)) {
        bundle.putShort(key, (short)json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_SHORT_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        short[] array = new short[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (short)jsonArray.getInt(i);
        }
        bundle.putShortArray(key, array);
    } else if (valueType.equals(TYPE_INTEGER)) {
        bundle.putInt(key, json.getInt(JSON_VALUE));
    } else if (valueType.equals(TYPE_INTEGER_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        int[] array = new int[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getInt(i);
        }
        bundle.putIntArray(key, array);
    } else if (valueType.equals(TYPE_LONG)) {
        bundle.putLong(key, json.getLong(JSON_VALUE));
    } else if (valueType.equals(TYPE_LONG_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        long[] array = new long[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getLong(i);
        }
        bundle.putLongArray(key, array);
    } else if (valueType.equals(TYPE_FLOAT)) {
        bundle.putFloat(key, (float)json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_FLOAT_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        float[] array = new float[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = (float)jsonArray.getDouble(i);
        }
        bundle.putFloatArray(key, array);
    } else if (valueType.equals(TYPE_DOUBLE)) {
        bundle.putDouble(key, json.getDouble(JSON_VALUE));
    } else if (valueType.equals(TYPE_DOUBLE_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        double[] array = new double[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            array[i] = jsonArray.getDouble(i);
        }
        bundle.putDoubleArray(key, array);
    } else if (valueType.equals(TYPE_CHAR)) {
        String charString = json.getString(JSON_VALUE);
        if (charString != null && charString.length() == 1) {
            bundle.putChar(key, charString.charAt(0));
        }
    } else if (valueType.equals(TYPE_CHAR_ARRAY)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        char[] array = new char[jsonArray.length()];
        for (int i = 0; i < array.length; i++) {
            String charString = jsonArray.getString(i);
            if (charString != null && charString.length() == 1) {
                array[i] = charString.charAt(0);
            }
        }
        bundle.putCharArray(key, array);
    } else if (valueType.equals(TYPE_STRING)) {
        bundle.putString(key, json.getString(JSON_VALUE));
    } else if (valueType.equals(TYPE_STRING_LIST)) {
        JSONArray jsonArray = json.getJSONArray(JSON_VALUE);
        int numStrings = jsonArray.length();
        ArrayList<String> stringList = new ArrayList<String>(numStrings);
        for (int i = 0; i < numStrings; i++) {
            Object jsonStringValue = jsonArray.get(i);
            stringList.add(i, jsonStringValue == JSONObject.NULL ? null : (String)jsonStringValue);
        }
        bundle.putStringArrayList(key, stringList);
    }
}

2

Pourquoi ne collez-vous pas votre liste sur une classe d'application? Il n'est détruit que lorsque l'application est vraiment détruite , il restera donc aussi longtemps que l'application sera disponible.


5
Et si l'application est relancée à nouveau.
Manohar Perepa,

2

Le meilleur moyen que j'ai pu trouver est de créer un tableau de clés 2D et de placer les éléments personnalisés du tableau dans le tableau de clés 2D, puis de le récupérer via le tableau 2D au démarrage. Je n'aimais pas l'idée d'utiliser un jeu de chaînes car la plupart des utilisateurs d'Android sont toujours sur Gingerbread et utiliser un jeu de chaînes nécessite un nid d'abeille.

Exemple de code: ici ditor est l'éditeur de préférences partagé et rowitem est mon objet personnalisé.

editor.putString(genrealfeedkey[j][1], Rowitemslist.get(j).getname());
        editor.putString(genrealfeedkey[j][2], Rowitemslist.get(j).getdescription());
        editor.putString(genrealfeedkey[j][3], Rowitemslist.get(j).getlink());
        editor.putString(genrealfeedkey[j][4], Rowitemslist.get(j).getid());
        editor.putString(genrealfeedkey[j][5], Rowitemslist.get(j).getmessage());

2

le code suivant est la réponse acceptée, avec quelques lignes supplémentaires pour les nouveaux (moi), par exemple. montre comment reconvertir l'objet de type défini en arrayList, et des conseils supplémentaires sur ce qui précède «.putStringSet» et «.getStringSet». (merci evilone)

// shared preferences
   private SharedPreferences preferences;
   private SharedPreferences.Editor nsuserdefaults;

// setup persistent data
        preferences = this.getSharedPreferences("MyPreferences", MainActivity.MODE_PRIVATE);
        nsuserdefaults = preferences.edit();

        arrayOfMemberUrlsUserIsFollowing = new ArrayList<String>();
        //Retrieve followers from sharedPreferences
        Set<String> set = preferences.getStringSet("following", null);

        if (set == null) {
            // lazy instantiate array
            arrayOfMemberUrlsUserIsFollowing = new ArrayList<String>();
        } else {
            // there is data from previous run
            arrayOfMemberUrlsUserIsFollowing = new ArrayList<>(set);
        }

// convert arraylist to set, and save arrayOfMemberUrlsUserIsFollowing to nsuserdefaults
                Set<String> set = new HashSet<String>();
                set.addAll(arrayOfMemberUrlsUserIsFollowing);
                nsuserdefaults.putStringSet("following", set);
                nsuserdefaults.commit();

2
//Set the values
intent.putParcelableArrayListExtra("key",collection);

//Retrieve the values
ArrayList<OnlineMember> onlineMembers = data.getParcelableArrayListExtra("key");


2

Vous pouvez utiliser la sérialisation ou la bibliothèque Gson pour convertir la liste en chaîne et vice versa, puis enregistrer la chaîne dans les préférences.

Utilisation de la bibliothèque Gson de Google:

//Converting list to string
new Gson().toJson(list);

//Converting string to list
new Gson().fromJson(listString, CustomObjectsList.class);

Utilisation de la sérialisation Java:

//Converting list to string
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(list);
oos.flush();
String string = Base64.encodeToString(bos.toByteArray(), Base64.DEFAULT);
oos.close();
bos.close();
return string;

//Converting string to list
byte[] bytesArray = Base64.decode(familiarVisitsString, Base64.DEFAULT);
ByteArrayInputStream bis = new ByteArrayInputStream(bytesArray);
ObjectInputStream ois = new ObjectInputStream(bis);
Object clone = ois.readObject();
ois.close();
bis.close();
return (CustomObjectsList) clone;

2

Cette méthode est utilisée pour stocker / enregistrer la liste des tableaux: -

 public static void saveSharedPreferencesLogList(Context context, List<String> collageList) {
            SharedPreferences mPrefs = context.getSharedPreferences("PhotoCollage", context.MODE_PRIVATE);
            SharedPreferences.Editor prefsEditor = mPrefs.edit();
            Gson gson = new Gson();
            String json = gson.toJson(collageList);
            prefsEditor.putString("myJson", json);
            prefsEditor.commit();
        }

Cette méthode est utilisée pour récupérer la liste des tableaux: -

public static List<String> loadSharedPreferencesLogList(Context context) {
        List<String> savedCollage = new ArrayList<String>();
        SharedPreferences mPrefs = context.getSharedPreferences("PhotoCollage", context.MODE_PRIVATE);
        Gson gson = new Gson();
        String json = mPrefs.getString("myJson", "");
        if (json.isEmpty()) {
            savedCollage = new ArrayList<String>();
        } else {
            Type type = new TypeToken<List<String>>() {
            }.getType();
            savedCollage = gson.fromJson(json, type);
        }

        return savedCollage;
    }

1

Vous pouvez le convertir en Mapobjet pour le stocker, puis redéfinir les valeurs en ArrayList lorsque vous récupérez le SharedPreferences.


1

Utilisez cette classe personnalisée:

public class SharedPreferencesUtil {

    public static void pushStringList(SharedPreferences sharedPref, 
                                      List<String> list, String uniqueListName) {

        SharedPreferences.Editor editor = sharedPref.edit();
        editor.putInt(uniqueListName + "_size", list.size());

        for (int i = 0; i < list.size(); i++) {
            editor.remove(uniqueListName + i);
            editor.putString(uniqueListName + i, list.get(i));
        }
        editor.apply();
    }

    public static List<String> pullStringList(SharedPreferences sharedPref, 
                                              String uniqueListName) {

        List<String> result = new ArrayList<>();
        int size = sharedPref.getInt(uniqueListName + "_size", 0);

        for (int i = 0; i < size; i++) {
            result.add(sharedPref.getString(uniqueListName + i, null));
        }
        return result;
    }
}

Comment utiliser:

SharedPreferences sharedPref = getPreferences(Context.MODE_PRIVATE);
SharedPreferencesUtil.pushStringList(sharedPref, list, getString(R.string.list_name));
List<String> list = SharedPreferencesUtil.pullStringList(sharedPref, getString(R.string.list_name));

1

cela devrait fonctionner:

public void setSections (Context c,  List<Section> sectionList){
    this.sectionList = sectionList;

    Type sectionListType = new TypeToken<ArrayList<Section>>(){}.getType();
    String sectionListString = new Gson().toJson(sectionList,sectionListType);

    SharedPreferences.Editor editor = getSharedPreferences(c).edit().putString(PREFS_KEY_SECTIONS, sectionListString);
    editor.apply();
}

eux, pour l'attraper juste:

public List<Section> getSections(Context c){

    if(this.sectionList == null){
        String sSections = getSharedPreferences(c).getString(PREFS_KEY_SECTIONS, null);

        if(sSections == null){
            return new ArrayList<>();
        }

        Type sectionListType = new TypeToken<ArrayList<Section>>(){}.getType();
        try {

            this.sectionList = new Gson().fromJson(sSections, sectionListType);

            if(this.sectionList == null){
                return new ArrayList<>();
            }
        }catch (JsonSyntaxException ex){

            return new ArrayList<>();

        }catch (JsonParseException exc){

            return new ArrayList<>();
        }
    }
    return this.sectionList;
}

ça marche pour moi.


1

Ma classe d'utilitaires pour la liste de sauvegarde SharedPreferences

public class SharedPrefApi {
    private SharedPreferences sharedPreferences;
    private Gson gson;

    public SharedPrefApi(Context context, Gson gson) {
        this.sharedPreferences = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        this.gson = gson;
    } 

    ...

    public <T> void putList(String key, List<T> list) {
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(key, gson.toJson(list));
        editor.apply();
    }

    public <T> List<T> getList(String key, Class<T> clazz) {
        Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType();
        return gson.fromJson(getString(key, null), typeOfT);
    }
}

En utilisant

// for save
sharedPrefApi.putList(SharedPrefApi.Key.USER_LIST, userList);

// for retrieve
List<User> userList = sharedPrefApi.getList(SharedPrefApi.Key.USER_LIST, User.class);

.
Code complet de mes utils // vérifier en utilisant l'exemple dans le code d'activité


1

J'ai utilisé la même manière de sauvegarder et de récupérer une chaîne, mais ici avec arrayList, j'ai utilisé HashSet comme médiateur

Pour enregistrer arrayList dans SharedPreferences, nous utilisons HashSet:

1- nous créons la variable SharedPreferences (à l'endroit où le changement se produit sur le tableau)

2 - nous convertissons le arrayList en HashSet

3 - puis nous mettons le stringSet et appliquons

4 - vous obtenezStringSet dans HashSet et recréez ArrayList pour définir le HashSet.

public class MainActivity extends AppCompatActivity {
    ArrayList<String> arrayList = new ArrayList<>();

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

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

        HashSet<String> set = new HashSet(arrayList);
        prefs.edit().putStringSet("names", set).apply();


        set = (HashSet<String>) prefs.getStringSet("names", null);
        arrayList = new ArrayList(set);

        Log.i("array list", arrayList.toString());
    }
}

0
    public  void saveUserName(Context con,String username)
    {
        try
        {
            usernameSharedPreferences= PreferenceManager.getDefaultSharedPreferences(con);
            usernameEditor = usernameSharedPreferences.edit();
            usernameEditor.putInt(PREFS_KEY_SIZE,(USERNAME.size()+1)); 
            int size=USERNAME.size();//USERNAME is arrayList
            usernameEditor.putString(PREFS_KEY_USERNAME+size,username);
            usernameEditor.commit();
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }

    }
    public void loadUserName(Context con)
    {  
        try
        {
            usernameSharedPreferences= PreferenceManager.getDefaultSharedPreferences(con);
            size=usernameSharedPreferences.getInt(PREFS_KEY_SIZE,size);
            USERNAME.clear();
            for(int i=0;i<size;i++)
            { 
                String username1="";
                username1=usernameSharedPreferences.getString(PREFS_KEY_USERNAME+i,username1);
                USERNAME.add(username1);
            }
            usernameArrayAdapter = new ArrayAdapter<String>(this, android.R.layout.simple_dropdown_item_1line, USERNAME);
            username.setAdapter(usernameArrayAdapter);
            username.setThreshold(0);

        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
    }

0

Toutes les réponses ci-dessus sont correctes. :) J'ai moi-même utilisé l'un d'eux pour ma situation. Cependant, lorsque j'ai lu la question, j'ai constaté que le PO parlait en fait d'un scénario différent du titre de cet article, si je ne me trompais pas.

"J'ai besoin que le tableau reste, même si l'utilisateur quitte l'activité et veut ensuite revenir plus tard"

Il souhaite en fait que les données soient stockées jusqu'à ce que l'application soit ouverte, indépendamment des changements d'écran de l'utilisateur dans l'application.

"mais je n'ai pas besoin du tableau disponible après la fermeture complète de l'application"

Mais une fois que l'application est fermée, les données ne doivent pas être conservées. Par conséquent, je pense que l'utilisation SharedPreferencesn'est pas le moyen optimal pour cela.

Ce que l'on peut faire pour cette exigence est de créer une classe qui étend la Applicationclasse.

public class MyApp extends Application {

    //Pardon me for using global ;)

    private ArrayList<CustomObject> globalArray;

    public void setGlobalArrayOfCustomObjects(ArrayList<CustomObject> newArray){
        globalArray = newArray; 
    }

    public ArrayList<CustomObject> getGlobalArrayOfCustomObjects(){
        return globalArray;
    }

}

En utilisant le setter et le getter, ArrayList est accessible de n'importe où avec l'application. Et la meilleure partie est qu'une fois l'application fermée, nous n'avons pas à nous soucier des données stockées. :)

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.