Guarde ArrayList en SharedPreferences

Tengo una ArrayList con objetos personalizados. Cada objeto personalizado contiene una variedad de cadenas y números. Necesito que la matriz se quede aunque el usuario abandone la actividad y luego quiera volver más tarde, sin embargo, no necesito la matriz disponible después de que la aplicación se haya cerrado por completo. SharedPreferences muchos otros objetos de esta manera usando las SharedPreferences pero no puedo entender cómo guardar toda mi matriz de esta manera. es posible? ¿Tal vez SharedPreferences no es la forma de hacerlo? ¿Hay un método más simple?

Después de API 11, el SharedPreferences Editor acepta Sets . Podrías convertir tu Lista en un HashSet o algo similar y almacenarlo así. Cuando lo leas, conviértelo en una ArrayList , ArrayList si es necesario y listo.

 //Retrieve the values Set set = myScores.getStringSet("key", null); //Set the values Set set = new HashSet(); set.addAll(listOfExistingScores); scoreEditor.putStringSet("key", set); scoreEditor.commit(); 

También puede serializar su ArrayList y luego guardarla / leerla en / desde SharedPreferences . A continuación está la solución:

EDITAR:
Bien, a continuación se muestra la solución para guardar ArrayList como objeto serializado en SharedPreferences y luego leerlo desde SharedPreferences.

Debido a que API solo permite almacenar y recuperar cadenas de / desde SharedPreferences (después de API 11, es más simple), tenemos que serializar y deserializar el objeto ArrayList que tiene la lista de tareas en cadena.

En el método addTask() de la clase TaskManagerApplication, debemos obtener la instancia de la preferencia compartida y luego almacenar la ArrayList serializada usando el método putString() :

 public void addTask(Task t) { if (null == currentTasks) { currentTasks = new ArrayList(); } 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(); } 

Del mismo modo, tenemos que recuperar la lista de tareas de la preferencia en el método onCreate() :

 public void onCreate() { super.onCreate(); if (null == currentTasks) { currentTasks = new ArrayList(); } // load tasks from preference SharedPreferences prefs = getSharedPreferences(SHARED_PREFS_FILE, Context.MODE_PRIVATE); try { currentTasks = (ArrayList) ObjectSerializer.deserialize(prefs.getString(TASKS, ObjectSerializer.serialize(new ArrayList()))); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } } 

Puede obtener la clase ObjectSerializer del proyecto Apache Pig ObjectSerializer.java

Usar este objeto -> TinyDB – Android-Shared-Preferences-Turbo es muy simple.

 TinyDB tinydb = new TinyDB(context); 

poner

 tinydb.putList("MyUsers", mUsersArray); 

Llegar

 tinydb.getList("MyUsers"); 

Guardar Array en 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 

Cargando datos de Array desde SharedPreferences

 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 

Puede convertirlo a JSON String y almacenar la cadena en SharedPreferences .

Como dijo @nirav, la mejor solución es almacenarlo en sharedPrefernces como un texto json usando la clase de utilidad Gson. Por debajo del código de muestra:

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

Hola amigos, obtuve la solución del problema anterior sin usar la biblioteca de Gson . Aquí publico el código fuente.

1.Variable statement es decir

  SharedPreferences shared; ArrayList arrPackage; 

2.Variable inicialización es decir

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

3.Almacene el valor a sharedPreference usando packagesharedPreferences() :

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

4. Recupere el valor de sharedPreference utilizando retriveSharedValue() :

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

Espero que te sea útil …

Android SharedPreferances le permite guardar tipos primitivos (Boolean, Float, Int, Long, String y StringSet, que están disponibles desde API11) en la memoria como un archivo xml.

La idea clave de cualquier solución sería convertir los datos a uno de esos tipos primitivos.

Personalmente, me encanta convertir mi lista al formato json y luego guardarla como una cadena en un valor SharedPreferences.

Para utilizar mi solución, deberás agregar Google Gson lib.

En gradle solo agrega la siguiente dependencia (usa la última versión de google):

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

Guardar datos (donde HttpParam es su objeto):

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

Recuperar datos (donde HttpParam es su objeto):

 SharedPreferences prefs = getSharedPreferences(**"your_prefes_key"**, Context.MODE_PRIVATE); String httpParamJSONList = prefs.getString(**"your_prefes_key"**, ""); List httpParamList = new Gson().fromJson(httpParamJSONList, new TypeToken>() { }.getType()); 

También puede convertir el arraylist en un String y guardarlo de preferencia

 private String convertToString(ArrayList list) { StringBuilder sb = new StringBuilder(); String delim = ""; for (String s : list) { sb.append(delim); sb.append(s);; delim = ","; } return sb.toString(); } private ArrayList convertToArray(String string) { ArrayList list = new ArrayList(Arrays.asList(string.split(","))); return list; } 

Puede guardar el Arraylist después de convertirlo a una cadena usando el método convertToString y recuperar la cadena y convertirla a una matriz mediante convertToArray

¡Después de API 11 puedes guardar el conjunto directamente en SharedPreferences ! 🙂

La mejor manera es convertir a cadena JSOn utilizando GSON y guardar esta cadena en SharedPreference. También uso esta forma para guardar respuestas en caché.

He leído todas las respuestas anteriores. Eso es todo correcto, pero encontré una solución más fácil de la siguiente manera:

  1. Guardando lista de cadenas en preferencia compartida >>

     public static void setSharedPreferenceStringList(Context pContext, String pKey, List 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. y para obtener la lista de cadenas de preferencia compartida >>

     public static List getSharedPreferenceStringList(Context pContext, String pKey) { int size = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).getInt(pKey + "size", 0); List 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; } 

Aquí Constants.APP_PREFS es el nombre del archivo para abrir; no puede contener separadores de ruta.

Puede referir las funciones serializeKey () y deserializeKey () de la clase SharedPreferencesTokenCache de FacebookSDK. Convierte el supportedType en el objeto JSON y almacena la cadena JSON en SharedPreferences . Puede descargar SDK desde aquí

 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 stringList = (List)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 stringList = new ArrayList(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); } } 

¿Por qué no pegas tu arraylist en una clase de aplicación? Solo se destruye cuando la aplicación realmente muere, por lo tanto, se mantendrá mientras la aplicación esté disponible.

La mejor manera que he podido encontrar es crear una matriz 2D de claves y colocar los elementos personalizados de la matriz en la matriz bidimensional de claves y luego recuperarla a través de la matriz 2D al inicio. No me gustó la idea de usar conjunto de cuerdas porque la mayoría de los usuarios de Android todavía están en Gingerbread y usar el conjunto de cuerdas requiere panal.

Código de muestra: aquí ditor es el editor de pref compartido y rowitem es mi objeto personalizado.

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

El siguiente código es la respuesta aceptada, con algunas líneas más para gente nueva (yo), por ej. muestra cómo convertir el objeto tipo set a arrayList, y guía adicional sobre lo que ocurre antes de ‘.putStringSet’ y ‘.getStringSet’. (gracias malvado)

 // 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(); //Retrieve followers from sharedPreferences Set set = preferences.getStringSet("following", null); if (set == null) { // lazy instantiate array arrayOfMemberUrlsUserIsFollowing = new ArrayList(); } else { // there is data from previous run arrayOfMemberUrlsUserIsFollowing = new ArrayList<>(set); } // convert arraylist to set, and save arrayOfMemberUrlsUserIsFollowing to nsuserdefaults Set set = new HashSet(); set.addAll(arrayOfMemberUrlsUserIsFollowing); nsuserdefaults.putStringSet("following", set); nsuserdefaults.commit(); 
 //Set the values intent.putParcelableArrayListExtra("key",collection); //Retrieve the values ArrayList onlineMembers = data.getParcelableArrayListExtra("key"); 

no te olvides de implementar Serializable:

 Class dataBean implements Serializable{ public String name; } ArrayList dataBeanArrayList = new ArrayList(); 

https://stackoverflow.com/a/7635154/4639974

Puede convertirlo en un objeto de Map para almacenarlo, luego, puede volver a cambiar los valores a una ArrayList cuando recupere las SharedPreferences .

Puede usar la serialización o la biblioteca Gson para convertir la lista en cadena y viceversa y luego guardar cadena en las preferencias.

Usando la biblioteca Gson de google:

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

Usando la serialización de 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; 

Usa esta clase personalizada:

 public class SharedPreferencesUtil { public static void pushStringList(SharedPreferences sharedPref, List 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 pullStringList(SharedPreferences sharedPref, String uniqueListName) { List 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; } } 

Cómo utilizar:

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

También con Kotlin:

 fun SharedPreferences.Editor.putIntegerArrayList(key: String, list: ArrayList?): SharedPreferences.Editor { putString(key, list?.joinToString(",") ?: "") return this } fun SharedPreferences.getIntegerArrayList(key: String, defValue: ArrayList?): ArrayList? { val value = getString(key, null) if (value.isNullOrBlank()) return defValue return value.split(",").map { it.toInt() }.toArrayList() } 

Este método se usa para almacenar / guardar una lista de arreglos:

  public static void saveSharedPreferencesLogList(Context context, List 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(); } 

Este método se usa para recuperar una lista de matriz:

 public static List loadSharedPreferencesLogList(Context context) { List savedCollage = new ArrayList(); SharedPreferences mPrefs = context.getSharedPreferences("PhotoCollage", context.MODE_PRIVATE); Gson gson = new Gson(); String json = mPrefs.getString("myJson", ""); if (json.isEmpty()) { savedCollage = new ArrayList(); } else { Type type = new TypeToken>() { }.getType(); savedCollage = gson.fromJson(json, type); } return savedCollage; } 
  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(this, android.R.layout.simple_dropdown_item_1line, USERNAME); username.setAdapter(usernameArrayAdapter); username.setThreshold(0); } catch(Exception e) { e.printStackTrace(); } } 

Todas las respuestas anteriores son correctas. 🙂 Yo mismo usé uno de estos para mi situación. Sin embargo, cuando leí la pregunta, encontré que el OP realmente está hablando de un escenario diferente al título de esta publicación, si no me equivoqué.

“Necesito que la matriz se quede aunque el usuario abandone la actividad y luego quiera regresar en otro momento”

Él realmente quiere que los datos se almacenen hasta que la aplicación esté abierta, independientemente de las pantallas que cambien de usuario dentro de la aplicación.

“sin embargo, no necesito la matriz disponible después de que la aplicación se haya cerrado por completo”

Pero una vez que la aplicación está cerrada, los datos no deben conservarse. Por lo tanto, creo que el uso de las SharedPreferences no es la mejor manera de hacerlo.

Lo que se puede hacer para este requisito es crear una clase que amplíe la clase de Application .

 public class MyApp extends Application { //Pardon me for using global ;) private ArrayList globalArray; public void setGlobalArrayOfCustomObjects(ArrayList newArray){ globalArray = newArray; } public ArrayList getGlobalArrayOfCustomObjects(){ return globalArray; } } 

Usando setter y getter, se puede acceder a ArrayList desde cualquier lugar dentro de la aplicación. Y la mejor parte es que una vez que la aplicación se cierra, no tenemos que preocuparnos por la información que se almacena. 🙂

Es muy simple usar getStringSet y putStringSet en SharedPreferences , pero en mi caso, tengo que duplicar el objeto Set antes de poder agregar algo al conjunto. O bien, el conjunto no se guardará si mi aplicación se cierra forzadamente. Probablemente debido a la nota a continuación en la API a continuación. (Aunque se guardó si la aplicación está cerrada con el botón Atrás).

Tenga en cuenta que no debe modificar la instancia establecida devuelta por esta llamada. La consistencia de los datos almacenados no está garantizada si lo hace, ni su capacidad para modificar la instancia en absoluto. http://developer.android.com/reference/android/content/SharedPreferences.html#getStringSet

 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getActivity()); SharedPreferences.Editor editor = prefs.edit(); Set outSet = prefs.getStringSet("key", new HashSet()); Set workingSet = new HashSet(outSet); workingSet.add("Another String"); editor.putStringSet("key", workingSet); editor.commit(); 
 Saving and retrieving the ArrayList From SharedPreference 
  public static void addToPreference(String id,Context context) { SharedPreferences sharedPreferences = context.getSharedPreferences(Constants.MyPreference, Context.MODE_PRIVATE); ArrayList list = getListFromPreference(context); if (!list.contains(id)) { list.add(id); SharedPreferences.Editor edit = sharedPreferences.edit(); Set set = new HashSet<>(); set.addAll(list); edit.putStringSet(Constant.LIST, set); edit.commit(); } } public static ArrayList getListFromPreference(Context context) { SharedPreferences sharedPreferences = context.getSharedPreferences(Constants.MyPreference, Context.MODE_PRIVATE); Set set = sharedPreferences.getStringSet(Constant.LIST, null); ArrayList list = new ArrayList<>(); if (set != null) { list = new ArrayList<>(set); } return list; } 

Puede guardar cadenas y listas de arreglos personalizados usando la biblioteca Gson.

=> Primero necesita crear una función para guardar la lista de arreglos en SharedPreferences.

 public void saveListInLocal(ArrayList 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 !!! } 

=> Necesita crear una función para obtener una lista de arreglos de SharedPreferences.

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

=> How to call save and retrieve array list function.

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

=> Don’t forgot to add gson library in you app level build.gradle.

implementation ‘com.google.code.gson:gson:2.8.2’

With Kotlin, for simple arrays and lists, you can do something like:

 class MyPrefs(context: Context) { val prefs = context.getSharedPreferences("xyzPREFS_FILENAME", 0) var listOfFloats: List get() = prefs.getString("listOfFloats", "").split(",").map { it.toFloat() } set(value) = prefs.edit().putString("listOfFloats", value.joinToString(",")).apply() } 

and then access the preference easily:

 MyPrefs(context).listOfFloats = .... val list = MyPrefs(context).listOfFloats 

I used the same manner of saving and retrieving a String but here with arrayList I’ve used HashSet as a mediator

To save arrayList to SharedPreferences we use HashSet:

1- we create SharedPreferences variable (in place where the change happens to the array)

2 – we convert the arrayList to HashSet

3 – then we put the stringSet and apply

4 – you getStringSet within HashSet and recreate ArrayList to set the HashSet.

public class MainActivity extends AppCompatActivity { ArrayList 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 set = new HashSet(arrayList); prefs.edit().putStringSet("names", set).apply(); set = (HashSet) prefs.getStringSet("names", null); arrayList = new ArrayList(set); Log.i("array list", arrayList.toString()); } 

this should work:

 public void setSections (Context c, List
sectionList){ this.sectionList = sectionList; Type sectionListType = new TypeToken
>(){}.getType(); String sectionListString = new Gson().toJson(sectionList,sectionListType); SharedPreferences.Editor editor = getSharedPreferences(c).edit().putString(PREFS_KEY_SECTIONS, sectionListString); editor.apply(); }

them, to catch it just:

 public List
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
>(){}.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; }

esto funciona para mi.

My utils class for save list to 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  void putList(String key, List list) { SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putString(key, gson.toJson(list)); editor.apply(); } public  List getList(String key, Class clazz) { Type typeOfT = TypeToken.getParameterized(List.class, clazz).getType(); return gson.fromJson(getString(key, null), typeOfT); } } 

Utilizando

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

.
Full code of my utils // check using example in Activity code