Salva ArrayList in SharedPreferences


318

Ho un ArrayListcon oggetti personalizzati. Ogni oggetto personalizzato contiene una varietà di stringhe e numeri. Ho bisogno che l'array rimanga attivo anche se l'utente lascia l'attività e poi vuole tornare in un secondo momento, tuttavia non ho bisogno dell'array disponibile dopo che l'applicazione è stata chiusa completamente. Risparmio molti altri oggetti in questo modo usando il SharedPreferencesma non riesco a capire come salvare il mio intero array in questo modo. È possibile? Forse SharedPreferencesnon è il modo di procedere? Esiste un metodo più semplice?


Si possono trovare risposta qui: stackoverflow.com/questions/14981233/...
Apurva Kolapkar

questo è l'esempio go completo attraverso l'url stackoverflow.com/a/41137562/4344659
Sanjeev Sangral

Se qualcuno sta cercando la soluzione, questa potrebbe essere la risposta che stai cercando con un esempio di utilizzo completo in kotlin. stackoverflow.com/a/56873719/3710341
Sagar Chapagain

Risposte:


432

Dopo l'API 11, SharedPreferences Editoraccetta Sets. Puoi convertire il tuo Elenco in HashSetqualcosa o qualcosa di simile e salvarlo in quel modo. Quando lo rileggi, convertilo in un ArrayList, ordinalo se necessario e sei a posto.

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

Puoi anche serializzare il tuo ArrayListe quindi salvarlo / leggerlo su / da SharedPreferences. Di seguito è la soluzione:

EDIT:
Ok, di seguito è la soluzione per salvare ArrayListcome oggetto serializzato SharedPreferencese quindi leggerlo da SharedPreferences.

Poiché l'API supporta solo l'archiviazione e il recupero di stringhe da / verso SharedPreferences (dopo API 11, la sua più semplice), dobbiamo serializzare e deserializzare l'oggetto ArrayList che ha l'elenco di attività in stringa.

Nel addTask()metodo della classe TaskManagerApplication, dobbiamo ottenere l'istanza della preferenza condivisa e quindi archiviare ArrayList serializzato usando il putString()metodo:

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

Allo stesso modo dobbiamo recuperare l'elenco delle attività dalla preferenza nel onCreate()metodo:

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

Puoi ottenere ObjectSerializerlezioni dal progetto Apache Pig ObjectSerializer.java


21
Tieni presente che è putStringSetstato aggiunto all'API 11. La maggior parte dei programmatori attuali ha come target l'API 8 (Froyo) in leasing.
Cristian,

2
Mi piace l'idea di questo metodo perché sembra essere il più pulito, ma l'array che sto cercando di memorizzare è un oggetto di classe personalizzato che contiene stringhe, doppie e booleane. Come faccio ad aggiungere tutti e 3 questi tipi a un set? Devo impostare ogni singolo oggetto sul proprio array e quindi aggiungerli singolarmente a set separati prima di archiviarlo, oppure esiste un modo più semplice?
Ryandlf,

5
Che cosa è scoreEditor?
Ruchir Baronia,

2
Per i lettori dopo l'ottobre 2016: questo commento ottiene già molti voti e puoi usarlo come me, ma ti preghiamo di fermarti e non farlo. HashSet eliminerà il valore duplicato, quindi ArrayList non sarà lo stesso. Dettagli qui: stackoverflow.com/questions/12940663/…
seoul

2
Come promemoria per coloro che si imbattono in questa risposta: un set non è ordinato, quindi il salvataggio di un StringSet perderà l'ordine che avevi con la tua ArrayList.
David Liu,

119

Usando questo oggetto -> TinyDB - Android-Shared-Preferences-Turbo è molto semplice.

TinyDB tinydb = new TinyDB(context);

mettere

tinydb.putList("MyUsers", mUsersArray);

ottenere

tinydb.getList("MyUsers");

AGGIORNARE

Alcuni esempi utili e risoluzione dei problemi possono essere trovati qui: Preferenze condivise Android TinyDB putListObject frunction


6
Questo è il miglior approccio. +1 dalla mia parte
Sritam Jagadev,

3
Anch'io. Estremamente utile !!
Juan Aguilar Guisado,

1
a seconda del contenuto dell'elenco, è necessario specificare il tipo di oggetto dell'elenco quando si chiama tinydb.putList()Guarda gli esempi nella pagina collegata.
kc ochibili,

buona lib, ma dovrei ricordare che a volte questa libreria ha problemi durante la memorizzazione di oggetti. per essere più specifici, potrebbe generare un'eccezione di overflow dello stack. e penso che sia perché usa la riflessione per capire come conservare l'oggetto, e se l'oggetto diventa troppo complicato, potrebbe gettare quell'eccezione.
Mr.Q,

1
Ti amo tantissimo!
mychemicalro,

93

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

Caricamento Arraydati daSharedPreferences

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
questo è un "hack" molto bello. Tenere presente che con questo metodo è sempre possibile gonfiare le SharedPreferences con valori vecchi non utilizzati. Ad esempio, un elenco potrebbe avere una dimensione di 100 in una corsa e quindi una dimensione di 50. Le 50 voci precedenti rimarranno nelle preferenze. Un modo è impostare un valore MAX e cancellare qualsiasi cosa fino a quello.
Iraklis,

3
@Iraklis In effetti, ma supponendo che tu memorizzi solo questo ArrayListin SharedPrefeneceste, potresti mEdit1.clear()evitarlo.
AlexAndro,

1
Mi piace questo "hack". Ma mEdit1.clear () cancellerà altri valori non rilevanti per questo scopo?
Bagusflyer,

1
Grazie! Se ti dispiace chiederti, c'è uno scopo necessario per .remove ()? La preferenza non sovrascriverà comunque?
Script Kitty,

62

Puoi convertirlo in JSON Stringe archiviare la stringa in SharedPreferences.


Sto cercando un sacco di codice per convertire ArrayLists in JSONArrays, ma hai un campione che potresti voler condividere su come convertire in JSONString in modo da poterlo archiviare in SharedPrefs?
Ryandlf,

5
usando toString ()
MByD il

3
Ma allora come posso recuperarlo da SharedPrefs e convertirlo nuovamente in una matrice?
Ryandlf,

Mi dispiace, non ho un SDK Android per testarlo ora, ma dai un'occhiata qui: benjii.me/2010/04/deserializing-json-in-android-using-gson . Dovresti iterare sull'array json e fare quello che fanno lì per ogni oggetto, speriamo di poter pubblicare una modifica alla mia risposta con un esempio completo domani.
MByD,

53

Come diceva @nirav, la migliore soluzione è archiviarlo in sharedPrefernces come testo json usando la classe di utilità Gson. Sotto il codice di esempio:

//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
Grazie a Dio, è stato un salvavita. Davvero molto semplice.
Parthiban M

2
Questa risposta dovrebbe essere molto in alto. Stupendo! Non avevo idea di poter usare Gson in questo modo. Anche la prima volta di vedere la notazione di array usata in questo modo. Grazie!
madu,

3
Per riconvertirlo in Elenco, Elenco <String> textList = Arrays.asList (gson.fromJson (jsonText, String []. Class));
Vamsi Challa,

22

Ehi amici, ho ottenuto la soluzione del problema precedente senza usare la Gsonlibreria. Qui inserisco il codice sorgente.

1. Dichiarazione variabile, ad es

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2. Inizializzazione variabile, ad es

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

3. Memorizzare il valore in sharedPreference usando 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.Valore positivo di sharedPreference utilizzando retriveSharedValue():

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

Spero ti sia utile ...


ottima soluzione! facile e veloce!
LoveAndroid,

5
Ciò eliminerebbe tutte le stringhe duplicate dall'elenco non appena si aggiunge a un set. Probabilmente non è una caratteristica desiderata
OneCricketeer,

È solo per un elenco di Strings?
CoolMind,

Perderai l'ordine in questo modo
Brian Reinhold,

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

GIAVA:

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
Sì, la migliore risposta
AlexPad,

questa è la risposta migliore, l'ho usata anche per conservare altri oggetti
Irfandi D. Vendy,

puoi fare questo che significa che memorizzerà tutta la classe del modello?
BlackBlind

13

Android SharedPreferances ti consente di salvare i tipi primitivi (Boolean, Float, Int, Long, String e StringSet che sono disponibili dall'API11) in memoria come file XML.

L'idea chiave di qualsiasi soluzione sarebbe quella di convertire i dati in uno di quei tipi primitivi.

Personalmente adoro convertire il mio elenco in formato json e quindi salvarlo come stringa in un valore SharedPreferences.

Per utilizzare la mia soluzione dovrai aggiungere Google Gson lib.

In gradle basta aggiungere la seguente dipendenza (si prega di utilizzare l'ultima versione di google):

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

Salva dati (dove HttpParam è il tuo oggetto):

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

Recupera dati (dove HttpParam è il tuo oggetto):

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

Grazie. Questa risposta mi ha aiutato a recuperare e salvare la mia lista <MyObject>.
visrahane

Grazie. Funziona benissimo
Velayutham M,

11

Questa è la tua soluzione perfetta .. provalo,

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

Puoi anche convertire l'arraylist in una stringa e salvarla in preferenza

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

Puoi salvare l'Arraylist dopo averlo convertito in stringa usando il convertToStringmetodo e recuperando la stringa e convertendolo in array usandoconvertToArray

Dopo l'API 11 puoi salvare il set direttamente su SharedPreferences !!! :)


6

Per String, int, boolean, la scelta migliore sarebbe SharedPreferences.

Se si desidera archiviare ArrayList o dati complessi. La scelta migliore sarebbe la biblioteca di carta.

Aggiungi dipendenza

implementation 'io.paperdb:paperdb:2.6'

Inizializza carta

Dovrebbe essere inizializzato una volta in Application.onCreate ():

Paper.init(context);

Salva

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

Caricamento dati

Utilizzare i valori predefiniti se l'oggetto non esiste nella memoria.

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

Ecco qui.

https://github.com/pilgr/Paper


5

Ho letto tutte le risposte sopra. È tutto corretto, ma ho trovato una soluzione più semplice come di seguito:

  1. Salvataggio dell'elenco di stringhe nelle preferenze condivise >>

    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. e per ottenere l'elenco delle stringhe dalla preferenza condivisa >>

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

Ecco Constants.APP_PREFSil nome del file da aprire; non può contenere separatori di percorso.


5

Anche con 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

il modo migliore è quello di convertire in stringa JSOn usando GSON e salvare questa stringa in SharedPreference. Uso anche questo modo per memorizzare nella cache le risposte.


4

È possibile salvare String e l'elenco di array personalizzati utilizzando la libreria Gson.

=> Innanzitutto è necessario creare una funzione per salvare l'elenco di array in 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 !!!

    }

=> È necessario creare una funzione per ottenere l'elenco di array da 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);

}

=> Come chiamare salva e recupera la funzione elenco array.

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

=> Non dimenticare di aggiungere la libreria gson nel build.gradle a livello di app.

implementazione "com.google.code.gson: gson: 2.8.2"


3

È possibile fare riferimento alle funzioni serializeKey () e deserializeKey () dalla classe SharedPreferencesTokenCache di Facebook SDK. Converte il supportType nell'oggetto JSON e archivia la stringa JSON in SharedPreferences . Puoi scaricare SDK da qui

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

Perché non attacchi il tuo arraylist a una classe di applicazione? Viene distrutto solo quando l'app viene davvero uccisa, quindi rimarrà in vita finché l'app sarà disponibile.


5
Che cosa succede se l'applicazione viene riavviata di nuovo.
Manohar Perepa,

2

Il modo migliore che sono stato in grado di trovare è creare un array di chiavi 2D e inserire gli elementi personalizzati dell'array nell'array di chiavi 2D e quindi recuperarlo attraverso l'array 2D all'avvio. Non mi piaceva l'idea di usare il set di stringhe perché la maggior parte degli utenti Android sono ancora su Gingerbread e l'uso del set di stringhe richiede il nido d'ape.

Codice di esempio: qui ditor è l'editor pref condiviso e rowitem è il mio oggetto personalizzato.

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

il seguente codice è la risposta accettata, con alcune righe in più per le nuove persone (me), ad es. mostra come riconvertire l'oggetto tipo set in arrayList e ulteriori indicazioni su ciò che precede '.putStringSet' e '.getStringSet'. (grazie male)

// 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

È possibile utilizzare la serializzazione o la libreria Gson per convertire l'elenco in stringa e viceversa e quindi salvare la stringa nelle preferenze.

Utilizzando la libreria Gson di google:

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

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

Utilizzando la serializzazione 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

Questo metodo viene utilizzato per archiviare / salvare l'elenco di array: -

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

Questo metodo viene utilizzato per recuperare l'elenco di array: -

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

È possibile convertirlo in un Mapoggetto per memorizzarlo, quindi modificare i valori in ArrayList quando si recupera il file SharedPreferences.


1

Usa questa classe personalizzata:

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

Come usare:

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

questo dovrebbe funzionare:

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

loro, per prenderlo solo:

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

per me funziona.


1

La mia classe utils per la lista di salvataggio in 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);
    }
}

utilizzando

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

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

.
Codice completo dei miei programmi di utilità // controlla usando l'esempio in Codice attività


1

Ho usato lo stesso modo di salvare e recuperare una stringa ma qui con arrayList ho usato HashSet come mediatore

Per salvare arrayList in SharedPreferences usiamo HashSet:

1- creiamo la variabile SharedPreferences (al posto in cui avviene la modifica dell'array)

2 - convertiamo arrayList in HashSet

3 - quindi inseriamo stringSet e applichiamo

4 - getStringSet in HashSet e ricrea ArrayList per impostare 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

Tutte le risposte sopra sono corrette. :) Io stesso ho usato uno di questi per la mia situazione. Tuttavia, quando ho letto la domanda, ho scoperto che l'OP sta effettivamente parlando di uno scenario diverso rispetto al titolo di questo post, se non ho sbagliato.

"Ho bisogno che l'array rimanga attivo anche se l'utente lascia l'attività e desidera tornare in un secondo momento"

In realtà vuole che i dati vengano archiviati fino a quando l'app non viene aperta, indipendentemente dal fatto che l'utente cambi le schermate all'interno dell'applicazione.

"tuttavia non ho bisogno dell'array disponibile dopo che l'applicazione è stata chiusa completamente"

Ma una volta chiusa l'applicazione, i dati non dovrebbero essere conservati, quindi mi sento di usare SharedPreferences non sia il modo ottimale per farlo.

Quello che si può fare per questo requisito è creare una classe che estende 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;
    }

}

Utilizzando il setter e il getter è possibile accedere a ArrayList da qualsiasi luogo all'interno dell'applicazione. E la parte migliore è una volta chiusa l'app, non dobbiamo preoccuparci dei dati archiviati. :)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.