Salvar ArrayList em SharedPreferences


318

Eu tenho um ArrayListcom objetos personalizados. Cada objeto personalizado contém uma variedade de cadeias e números. Eu preciso que a matriz permaneça, mesmo que o usuário saia da atividade e depois queira voltar mais tarde; no entanto, não preciso da matriz disponível depois que o aplicativo for completamente fechado. Salvei muitos outros objetos dessa maneira usando o SharedPreferencesmas não consigo descobrir como salvar toda a minha matriz dessa maneira. Isso é possível? Talvez SharedPreferencesnão seja esse o caminho? Existe um método mais simples?


Você pode encontrar respostas aqui: stackoverflow.com/questions/14981233/...
Apurva Kolapkar

este é o exemplo go completa através da url stackoverflow.com/a/41137562/4344659
Sanjeev Sangral

Se alguém estiver procurando a solução, esta pode ser a resposta que você está procurando com um exemplo de uso completo no kotlin. stackoverflow.com/a/56873719/3710341
Sagar Chapagain

Respostas:


432

Após a API 11, SharedPreferences Editoraceite Sets. Você pode converter sua lista em HashSetalgo semelhante e armazená-la assim. Quando você ler novamente, converta-o em um ArrayList, classifique-o se necessário e pronto.

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

Você também pode serializar seu ArrayListe salvar / ler de / para SharedPreferences. Abaixo está a solução:

EDIT:
Ok, abaixo está a solução para salvar ArrayListcomo objeto serializado SharedPreferencese, em seguida, lê-lo em SharedPreferences.

Como a API suporta apenas o armazenamento e a recuperação de strings de / para SharedPreferences (após a API 11, sua mais simples), precisamos serializar e desserializar o objeto ArrayList que possui a lista de tarefas na string.

No addTask()método da classe TaskManagerApplication, precisamos obter a instância da preferência compartilhada e, em seguida, armazenar o ArrayList serializado usando o putString()método:

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

Da mesma forma, temos que recuperar a lista de tarefas da preferência no onCreate()método:

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

Você pode obter ObjectSerializerclasse no projeto Object Apex Pig ObjectSerializer.java


21
Lembre-se de que putStringSetfoi adicionado à API 11. A maioria dos programadores atuais visa a concessão da API 8 (Froyo).
Cristian

2
Gosto da ideia desse método porque parece ser o mais limpo, mas a matriz que estou procurando armazenar é um objeto de classe personalizado que contém seqüências de caracteres, duplos e booleanos. Como adiciono todos esses três tipos a um conjunto? Preciso definir cada objeto individual para sua própria matriz e adicioná-los individualmente a conjuntos separados antes de armazenar, ou existe uma maneira mais simples?
precisa saber é o seguinte

5
O que é scoreEditor?
Ruchir Baronia

2
Para os leitores após outubro de 2016: este comentário já recebe muitos votos positivos e você pode usá-lo como eu, mas pare e não faça isso. O HashSet descartará o valor duplicado, portanto, seu ArrayList não será o mesmo. Detalhes aqui: stackoverflow.com/questions/12940663/…
seoul

2
Como um lembrete para quem se deparar com esta resposta: um conjunto não é ordenado; portanto, salvar um StringSet perderá a ordem que você teve com seu ArrayList.
David Liu

119

Usando este objeto -> TinyDB - Android-Shared-Preferences-Turbo é muito simples.

TinyDB tinydb = new TinyDB(context);

colocar

tinydb.putList("MyUsers", mUsersArray);

para obter

tinydb.getList("MyUsers");

ATUALIZAR

Alguns exemplos úteis e solução de problemas podem ser encontrados aqui: Preferência compartilhada do Android TinyDB putListObject frunction


6
Esta é a melhor abordagem. 1 do meu lado
Sritam Jagadev 03/04

3
Eu também. Extremamente útil !!
Juan Aguilar Guisado

1
dependendo do conteúdo da sua lista, você deve especificar o tipo de objeto da sua lista ao chamar tinydb.putList()Veja os exemplos na página vinculada.
Kc ochibili 24/03

boa lib, mas devo mencionar que às vezes essa biblioteca tem problemas ao armazenar objetos. para ser mais específico, pode lançar uma exceção de estouro de pilha. e acho que é porque usa a reflexão para descobrir como armazenar o objeto e, se o objeto ficar muito complicado, poderá gerar essa exceção.
Mr.Q

1
Te amo muito!
Mychemicalro 30/05

93

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

Carregando Arraydados deSharedPreferences

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
Este é um "hack" muito bom. Esteja ciente de que, com esse método, sempre há a possibilidade de inchar as SharedPreferences com valores antigos não utilizados. Por exemplo, uma lista pode ter um tamanho de 100 em uma execução e, em seguida, um tamanho de 50. As 50 entradas antigas permanecerão nas preferências. Uma maneira é definir um valor MAX e esclarecer qualquer coisa.
21413 Iraklis

3
@Iraklis fato, mas supondo que você armazenar apenas este ArrayListem SharedPrefenecesque você pode usar mEdit1.clear()para evitar isso.
AlexAndro 04/04

1
Eu gosto desse "hack". Mas mEdit1.clear () apagará outros valores não relevantes para esse propósito?
fácil

1
Obrigado! Se você se importa de me perguntar, existe um propósito necessário para .remove ()? A preferência não será substituída de qualquer maneira?
Script Kitty

62

Você pode convertê-lo JSON Stringe armazenar a string no arquivo SharedPreferences.


Estou encontrando uma tonelada de código na conversão de ArrayLists para JSONArrays, mas você tem uma amostra que deseja compartilhar sobre como converter para JSONString para que eu possa armazená-lo nos SharedPrefs?
ryandlf


3
Mas como recuperá-lo do SharedPrefs e convertê-lo novamente em um ArrayList?
precisa saber é o seguinte

Sinto muito, não tenho um SDK do Android para testá-lo agora, mas dê uma olhada aqui: benjii.me/2010/04/deserializing-json-in-android-using-gson . Você deve percorrer a matriz json e fazer o que eles fazem lá para cada objeto, espero que eu consiga postar uma edição na minha resposta com um exemplo completo amanhã.
MByD 15/08/11

53

Como o @nirav disse, a melhor solução é armazená-lo no sharedPrefernces como um texto json usando a classe de utilitário Gson. Abaixo código de exemplo:

//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
Graças a Deus, isso salvou a vida. Muito simples mesmo.
precisa

2
Essa resposta deve estar bem alta. Soberbo! Não tinha ideia de que posso usar o Gson dessa maneira. Primeira vez que a notação de matriz também foi usada dessa maneira. Obrigado!
Madu

3
Para convertê-lo novamente em List, List <> textList = Arrays.asList (gson.fromJson (jsonText, String []. Class));
Vamsi Challa

22

Ei amigos, eu tenho a solução do problema acima sem usar a Gsonbiblioteca. Aqui eu posto o código fonte.

1.Variável declaração ou seja

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2. Inicialização variável, isto é

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

3. Armazene o valor em 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);
 }

Valor 4.Retrive de sharedPreference usando retriveSharedValue():

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

Espero que seja útil para você ...


ótima solução! fácil e rápido!
LoveAndroid 21/10

5
Isso removeria todas as seqüências de caracteres duplicadas da lista assim que você adicionasse a um conjunto. Provavelmente não é um recurso desejado
OneCricketeer 29/10

É apenas para uma lista de Strings?
CoolMind 2/17

Você vai perder ordem desta forma
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
Sim, melhor resposta
AlexPad 5/10/19

esta é a melhor resposta, eu também a tenho usado para armazenar outros objetos
Irfandi D. Vendy 27/04

você pode fazer isso significa que ele armazenará toda a classe de modelo?
BlackBlind

13

O Android SharedPreferances permite salvar tipos primitivos (Boolean, Float, Int, Long, String e StringSet, disponíveis desde a API11) na memória como um arquivo xml.

A idéia principal de qualquer solução seria converter os dados em um desses tipos primitivos.

Pessoalmente, adoro converter a minha lista no formato json e salvá-la como uma String em um valor SharedPreferences.

Para usar minha solução, você precisará adicionar a lib do Google Gson .

Em gradle, adicione a seguinte dependência (use a versão mais recente do google):

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

Salve os dados (onde HttpParam é seu objeto):

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

Recuperar dados (onde HttpParam é seu objeto):

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

Obrigado. Esta resposta me ajudou a recuperar e salvar minha lista <MyObject>.
visrahane

Obrigado. Trabalhando bem #
Velayutham M

11

Esta é a sua solução perfeita. Experimente,

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

Você também pode converter o arraylist em uma String e salvá-lo na preferência

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

Você pode salvar a Lista de matriz após convertê-la em sequência usando o convertToStringmétodo e recuperar a sequência e convertê-la em matriz usandoconvertToArray

Após a API 11, você pode salvar o conjunto diretamente em SharedPreferences !!! :)


6

Para String, int, boolean, a melhor opção seria sharedPreferences.

Se você deseja armazenar ArrayList ou qualquer dado complexo. A melhor opção seria a biblioteca de papel.

Adicionar dependência

implementation 'io.paperdb:paperdb:2.6'

Inicializar trabalho

Deve ser inicializado uma vez em Application.onCreate ():

Paper.init(context);

Salve 

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

Carregando dados

Use valores padrão se o objeto não existir no armazenamento.

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

Aqui está.

https://github.com/pilgr/Paper


5

Eu li todas as respostas acima. Está tudo correto, mas eu encontrei uma solução mais fácil, como abaixo:

  1. Salvando a lista de strings na preferência compartilhada >>

    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 para obter a Lista de cadeias de preferência compartilhada >>

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

Aqui Constants.APP_PREFSestá o nome do arquivo a ser aberto; não pode conter separadores de caminho.


5

Também com 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

A melhor maneira é converter para string JSOn usando GSON e salvar essa string em SharedPreference. Eu também uso esse caminho para armazenar respostas em cache.


4

Você pode salvar String e lista de matrizes personalizadas usando a biblioteca Gson.

=> Primeiro você precisa criar uma função para salvar a lista de matrizes em 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 !!!

    }

=> Você precisa criar uma função para obter a lista de matrizes 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);

}

=> Como chamar a função de salvar e recuperar a lista de matrizes.

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ão se esqueça de adicionar a biblioteca gson no seu build.gradle no nível do aplicativo.

implementação 'com.google.code.gson: gson: 2.8.2'


3

Você pode consultar as funções serializeKey () e deserializeKey () da classe SharedPreferencesTokenCache do FacebookSDK. Ele converte o supportedType no objeto JSON e armazena a sequência JSON em SharedPreferences . Você pode fazer o download do SDK aqui

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

Por que você não coloca sua lista de matrizes em uma classe Application? Ele só é destruído quando o aplicativo é realmente morto; portanto, ele permanecerá por enquanto o aplicativo estiver disponível.


5
E se o aplicativo for reiniciado novamente.
Manohar Perepa

2

A melhor maneira que eu consegui encontrar é criar uma matriz de chaves 2D e colocar os itens personalizados da matriz na matriz de chaves 2D e, em seguida, recuperá-la através da matriz 2D na inicialização. Eu não gostei da idéia de usar o conjunto de strings, porque a maioria dos usuários do Android ainda está no Gingerbread e o uso do conjunto de strings requer favo de mel.

Código de amostra: aqui o ditor é o editor pref compartilhado e o rowitem é o meu 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());

2

O código a seguir é a resposta aceita, com mais algumas linhas para pessoas novas (eu), por exemplo. mostra como converter o objeto do tipo set novamente em arrayList e orientações adicionais sobre o que antecede '.putStringSet' e '.getStringSet'. (obrigado 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

Você pode usar a serialização ou a biblioteca Gson para converter a lista em sequência e vice-versa e salvar a sequência nas preferências.

Usando a biblioteca Gson do google:

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

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

Usando serialização 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

Este método é usado para armazenar / salvar a lista de matrizes: -

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

Este método é usado para recuperar a lista de matrizes: -

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

Você pode convertê-lo em um Mapobjeto para armazená-lo e alterar os valores novamente para um ArrayList quando recuperar o SharedPreferences.


1

Use esta classe personalizada:

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

Como usar:

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

isso deve funcionar:

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

eles, para entender apenas:

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

funciona para mim.


1

Minha classe utils para salvar a lista em 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);
    }
}

Usando

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

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

.
Código completo dos meus utilitários // verifique usando o exemplo no código de atividade


1

Eu usei a mesma maneira de salvar e recuperar uma String, mas aqui com arrayList eu usei o HashSet como mediador

Para salvar arrayList em SharedPreferences, usamos HashSet:

1- criamos a variável SharedPreferences (no local em que a alteração ocorre na matriz)

2 - convertemos o arrayList em HashSet

3 - depois colocamos o stringSet e aplicamos

4 - você obtémStringSet no HashSet e recria ArrayList para definir o 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

Todas as respostas acima estão corretas. :) Eu mesmo usei um desses para a minha situação. No entanto, quando li a pergunta, descobri que o OP realmente está falando sobre um cenário diferente do título deste post, se eu não entendi errado.

"Eu preciso que a matriz permaneça, mesmo que o usuário saia da atividade e depois queira voltar mais tarde"

Na verdade, ele deseja que os dados sejam armazenados até que o aplicativo seja aberto, independentemente da alteração das telas do usuário no aplicativo.

"no entanto, não preciso da matriz disponível depois que o aplicativo foi completamente fechado"

Mas, quando o aplicativo é fechado, os dados não devem ser preservados. SharedPreferences .

O que se pode fazer por esse requisito é criar uma classe que estenda a 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;
    }

}

Usando o setter e o getter, o ArrayList pode ser acessado de qualquer lugar dentro do Aplicativo. E a melhor parte é que, quando o aplicativo é fechado, não precisamos nos preocupar com os dados que estão sendo armazenados. :)

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.