¿Es posible agregar una matriz u objeto a SharedPreferences en Android?

Yo tengo un ArrayList de objetos que tienen un nombre y un icono puntero y quiero guardarlo en SharedPreferences. ¿Como lo puedo hacer?

NOTA: no quiero usar la base de datos

Independientemente del nivel de API, compruebe Matrices de cadenas y matrices de objetos en SharedPreferences

GUARDAR MATRIZ

public boolean saveArray(String[] array, String arrayName, Context mContext) {   
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    SharedPreferences.Editor editor = prefs.edit();  
    editor.putInt(arrayName +"_size", array.length);  
    for(int i=0;i<array.length;i++)  
        editor.putString(arrayName + "_" + i, array[i]);  
    return editor.commit();  
} 

MATRIZ DE CARGA

public String[] loadArray(String arrayName, Context mContext) {  
    SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);  
    int size = prefs.getInt(arrayName + "_size", 0);  
    String array[] = new String[size];  
    for(int i=0;i<size;i++)  
        array[i] = prefs.getString(arrayName + "_" + i, null);  
    return array;  
}  

Escribir,

SharedPreferences prefs = PreferenceManager
        .getDefaultSharedPreferences(this);
JSONArray jsonArray = new JSONArray();
jsonArray.put(1);
jsonArray.put(2);
Editor editor = prefs.edit();
editor.putString("key", jsonArray.toString());
System.out.println(jsonArray.toString());
editor.commit();

Leer,

try {
    JSONArray jsonArray2 = new JSONArray(prefs.getString("key", "[]"));
    for (int i = 0; i < jsonArray2.length(); i++) {
         Log.d("your JSON Array", jsonArray2.getInt(i)+"");
    }
} catch (Exception e) {
    e.printStackTrace();
}

Otra forma de hacer lo mismo:

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


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

Usando GSON en Java:

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

}

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

Usando GSON en 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)
}

Entonces, desde el sitio para desarrolladores de Android en Almacenamiento de datos:

Preferencias del usuario

Preferencias compartidas no son estrictamente para guardar “preferencias de usuario”, como qué tono de llamada ha elegido un usuario. Si está interesado en crear preferencias de usuario para su aplicación, consulte PreferenceActivity, que proporciona un marco de actividad para que pueda crear preferencias de usuario, que se conservarán automáticamente (mediante preferencias compartidas).

Así que creo que está bien, ya que son simplemente pares clave-valor los que se mantienen.

Para el cartel original, esto no es tan difícil. Simplemente itere a través de su lista de arreglos y agregue los elementos. En este ejemplo, uso un mapa para simplificar, pero puede usar una lista de arreglos y cambiarla apropiadamente:

// my list of names, icon locations
Map<String, String> nameIcons = new HashMap<String, String>();
nameIcons.put("Noel", "/location/to/noel/icon.png");
nameIcons.put("Bob", "another/location/to/bob/icon.png");
nameIcons.put("another name", "last/location/icon.png");

SharedPreferences keyValues = getContext().getSharedPreferences("name_icons_list", Context.MODE_PRIVATE);
SharedPreferences.Editor keyValuesEditor = keyValues.edit();

for (String s : nameIcons.keySet()) {
    // use the name as the key, and the icon as the value
    keyValuesEditor.putString(s, nameIcons.get(s));
}
keyValuesEditor.commit()

Haría algo similar para volver a leer los pares clave-valor. Hazme saber si esto funciona.

Actualizar: Si está utilizando el nivel de API 11 o posterior, hay un método para escribir un conjunto de cadenas

Las preferencias compartidas introdujeron una getStringSet y putStringSet métodos en API Nivel 11, pero eso no es compatible con versiones anteriores de Android (que aún son populares), y también está limitado a conjuntos de cadenas.

Android no proporciona mejores métodos, y recorrer mapas y arreglos para guardarlos y cargarlos no es muy fácil ni limpio, especialmente para los arreglos. Pero una mejor implementación no es tan difícil:

package com.example.utils;

import org.json.JSONObject;
import org.json.JSONArray;
import org.json.JSONException;

import android.content.Context;
import android.content.SharedPreferences;

public class JSONSharedPreferences {
    private static final String PREFIX = "json";

    public static void saveJSONObject(Context c, String prefName, String key, JSONObject object) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, object.toString());
        editor.commit();
    }

    public static void saveJSONArray(Context c, String prefName, String key, JSONArray array) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        SharedPreferences.Editor editor = settings.edit();
        editor.putString(JSONSharedPreferences.PREFIX+key, array.toString());
        editor.commit();
    }

    public static JSONObject loadJSONObject(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONObject(settings.getString(JSONSharedPreferences.PREFIX+key, "{}"));
    }

    public static JSONArray loadJSONArray(Context c, String prefName, String key) throws JSONException {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        return new JSONArray(settings.getString(JSONSharedPreferences.PREFIX+key, "[]"));
    }

    public static void remove(Context c, String prefName, String key) {
        SharedPreferences settings = c.getSharedPreferences(prefName, 0);
        if (settings.contains(JSONSharedPreferences.PREFIX+key)) {
            SharedPreferences.Editor editor = settings.edit();
            editor.remove(JSONSharedPreferences.PREFIX+key);
            editor.commit();
        }
    }
}

Ahora puede guardar cualquier colección en preferencias compartidas con estos cinco métodos. Trabajando con JSONObject y JSONArray es muy fácil. Puedes usar JSONArray (Collection copyFrom) constructora pública para hacer un JSONArray fuera de cualquier colección y uso de Java JSONArray‘s get métodos para acceder a los elementos.

No hay límite de tamaño para las preferencias compartidas (además de los límites de almacenamiento del dispositivo), por lo que estos métodos pueden funcionar para la mayoría de los casos habituales en los que desea un almacenamiento rápido y fácil para alguna colección en su aplicación. Pero el análisis de JSON ocurre aquí, y las preferencias en Android se almacenan internamente como XML, por lo que recomiendo usar otros mecanismos de almacenamiento de datos persistentes cuando se trata de megabytes de datos.

Modo fácil para el almacenamiento de objetos complejos con el uso de la biblioteca de Google Gson [1]

public static void setComplexObject(Context ctx, ComplexObject obj){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    SharedPreferences.Editor editor = preferences.edit();
    editor.putString("COMPLEX_OBJECT",new Gson().toJson(obj)); 
    editor.commit();
}

public static ComplexObject getComplexObject (Context ctx){
    SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
    String sobj = preferences.getString("COMPLEX_OBJECT", "");
    if(sobj.equals(""))return null;
    else return new Gson().fromJson(sobj, ComplexObject.class);
}

[1] http://code.google.com/p/google-gson/

Cargué una matriz de tamaños de cintura (ya creados en mi array.xml) en mi archivo de preferencias.xml con el código a continuación. @array/pant_inch_size es la identificación de toda la matriz.

 <ListPreference 
 android:title="choosepantsize"
 android:summary="Choose Pant Size"
 android:key="pantSizePref" 
 android:defaultValue="34" 
 android:entries="@array/pant_inch_size"
 android:entryValues="@array/pant_inch_size" /> 

Esto llenó el menú con opciones de la matriz. Establecí el tamaño predeterminado en 34, por lo que cuando aparece el menú, ven que el tamaño 34 está preseleccionado.

La forma simple es convertirlo a JSON String como se muestra a continuación:

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

Luego almacene la cadena en las preferencias compartidas. Una vez que lo necesite, simplemente obtenga una cadena de preferencias compartidas y vuelva a convertir a JSONArray o JSONObject (según sus requisitos).