Save ArrayList to SharedPreferences

Question

I have an ArrayList with custom objects. Each custom object contains a variety of strings and numbers. I need the array to stick around even if the user leaves the activity and then wants to come back at a later time, however I don't need the array available after the application has been closed completely. I save a lot of other objects this way by using the SharedPreferences but I can't figure out how to save my entire array this way. Is this possible? Maybe SharedPreferences isn't the way to go about this? Is there a simpler method?

You can find Answer here : http://stackoverflow.com/questions/14981233/android-arraylist-of-custom-objects-save-to-sharedpreferences-serializable/40237149#40237149 — Apurva Kolapkar, Oct 25 '16 at 10:10
this is the complete example go through the url http://stackoverflow.com/a/41137562/4344659 — Sanjeev Sangral, Dec 14 '16 at 11:53
If anyone is looking for the solution, this might be the answer you are seeking with full usage example in kotlin. https://stackoverflow.com/a/56873719/3710341 — Sagar Chapagain, Jul 04 '19 at 14:29

score 472 · Accepted Answer · edited Sep 06 '20 at 14:49

472

After API 11 the SharedPreferences Editor accepts Sets. You could convert your List into a HashSet or something similar and store it like that. When you read it back, convert it into an ArrayList, sort it if needed and you're good to go.

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

You can also serialize your ArrayList and then save/read it to/from SharedPreferences. Below is the solution:

EDIT:
Ok, below is the solution to save ArrayList as a serialized object to SharedPreferences and then read it from SharedPreferences.

Because API supports only storing and retrieving of strings to/from SharedPreferences (after API 11, it's simpler), we have to serialize and de-serialize the ArrayList object which has the list of tasks into a string.

In the addTask() method of the TaskManagerApplication class, we have to get the instance of the shared preference and then store the serialized ArrayList using the putString() method:

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

Similarly we have to retrieve the list of tasks from the preference in the onCreate() method:

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

You can get the ObjectSerializer class from the Apache Pig project ObjectSerializer.java

edited Sep 06 '20 at 14:49

answered Aug 14 '11 at 15:49

evilone

22,410
7
80
107

23

Keep in mind that `putStringSet` was added at API 11. Most current programmers target at lease API 8 (Froyo). – Cristian Aug 14 '11 at 15:51
2

I like the idea of this method because it seems to be the cleanest, but the array I am looking to store is a custom class object that contains strings, doubles, and booleans. How do I go about adding all 3 of these types to a set? Do I have to set every individual object to their own array and then add them individually to separate sets before I store, or is there a simpler way? – ryandlf Aug 15 '11 at 00:48
Like Christian said, this feature was added at API 11 and I don't recommend you to use this, because API 11 is used by very small group of devices. Look for my EDIT section - there's a suggestion for an earlier API versions. – evilone Aug 15 '11 at 05:42
@Cristian would that be said "at least API 8" or "at most API 8" ... or "use API 8 as their minimum requirements"? Gar I'm confused now. – Aug 24 '12 at 20:01
Second solution works, but I got error "cant cast ArrayList to Set" when trying the first solution. – macio.Jun Dec 05 '13 at 15:06
@evilone how can i save custom objects using the above method i m not dealing with string – Erum Dec 08 '14 at 05:43
@ErumHannan You could use for example Gson object and serialize your custom object to json string. Then you'll save it to the shared preferences as in my example. – evilone Dec 08 '14 at 09:44
Can we add a `ArrayList` of custom objects to shared preference? This solution only seems for a `ArrayList` of `String` type. – Parag Kadam Jan 13 '16 at 06:22
5

What is `scoreEditor`? – Ruchir Baronia Jan 30 '16 at 20:03
1

You can also use Google's Gson. – Meet Vora Sep 26 '16 at 06:34
5

To readers after Oct-2016: This comment already gets a lot of upvote and you may use it like me, but please halt and don't do this. HashSet will discard duplicate value, thus your ArrayList won't be same. Details here: http://stackoverflow.com/questions/12940663/does-adding-a-duplicate-value-to-a-hashset-hashmap-replace-the-previous-value – seoul Oct 09 '16 at 05:15
task must be serializable – masoud Cheragee Dec 15 '17 at 15:15
6

As a reminder to those coming across this answer: a Set is unordered, so saving a StringSet will lose the order you had with your ArrayList. – David Liu Sep 26 '18 at 19:15
I got error. java.lang.ArrayIndexOutOfBoundsException: length=107; index=107. when task deserialize – Gayathri Oct 10 '18 at 08:11
I like the way to save arraylist using set – Surajkaran Meghwanshi Jan 04 '23 at 08:38

score 134 · Answer 2 · edited Feb 13 '19 at 05:44

134

Using this object --> TinyDB--Android-Shared-Preferences-Turbo its very simple.

TinyDB tinydb = new TinyDB(context);

to put

tinydb.putList("MyUsers", mUsersArray);

to get

tinydb.getList("MyUsers");

UPDATE

Some useful examples and troubleshooting might be found here: Android Shared Preference TinyDB putListObject frunction

edited Feb 13 '19 at 05:44

frank17

107
12

answered Apr 21 '14 at 01:31

kc ochibili

3,103
2
25
25

1

depending on the content of your List, you have to specify the object type of your list when calling ``tinydb.putList()`` Look at the examples at the linked page. – kc ochibili Mar 24 '16 at 05:39
good lib, but i should mention that sometimes this library has issues when storing objects. to be more specific, it may throw stack overflow exception. and i think it is because it uses reflection to figure out how to store the object, and if the object gets too complicated it may throw that exception. – Mr.Q Jun 17 '16 at 14:18
What should i set as context parameter on TinyDB tinydb = new TinyDB(context); ? – Andreas Konstantakos Jun 03 '17 at 03:02
@AndreasKonstantakos ``getApplicationContext()`` that is ``new TinyDB(getApplicationContext());`` – kc ochibili Jun 03 '17 at 07:20
1

Currently, putList() became putListString() – Frank Eno Jul 15 '19 at 19:14
@xscoder there was never a ``putList()`` function. I said ``putList()`` in the example to keep things simple, because there are many other functions that start from the phrase ``putList`` in TInyDB. Example putListString(), putListInt(), and many others. – kc ochibili Jul 22 '19 at 03:27
How can I set default value to getList()? – Rawnak Yazdani Aug 11 '20 at 12:37
2

@RAWNAKYAZDANI by default, TinyDB will return an empty list for a value that doesn't exist, so check the size of the list returned; if it is 0, then you can assign what ever default value you want to the returned list variable. – kc ochibili Aug 12 '20 at 00:08
**Don't use this!** Especially not the `getListString()` and `setListString()` Why? It uses a magic separator pattern `‚‗‚` to separate string items and stores them in a plain String. The problem with this is that if your string ever contains this magic pattern it will break the implementation. A possible fix to avoid it from breaking would be to escape input strings (and do the reverse while reading). Another option which is easier to implement but less efficient, is to first transform the input strings to a format which is guaranteed to never have the magic pattern, such as Base64. – Rolf ツ Jan 30 '22 at 23:33
@Rolfツ lets be real here; what are the chances of a user accidentally entering ``‚‗‚`` as an input? Zero to be honest because those are rarely used unicode characters, and they are not bundled in any mainstream keyboard that I know of. Even if one of them is bundled, the user has to enter them in that exact order with the other rare unicode character. I had your fears in mind eight years ago when I created this library, that is why I used rare keys (unicodes) as list separators. – kc ochibili Jan 31 '22 at 08:18
@kcochibili it totally depends on your use-case? What if someone uses your library to store a string created from a random byte array? Basically to be able to store binary data? Suddenly it is not so rare anymore. Yes this may work for many developers, but it is not waterproof and it is a bug waiting to happen. – Rolf ツ Jan 31 '22 at 22:25
@Rolfツ Based on your argument, what do you have to say about JSON, which structures its data (including lists) using everyday characters like commas and parenthesis; The whole world uses JSON. What do you have to say about that? At least tinydb tries to make it hard for things to break. – kc ochibili Feb 04 '22 at 02:16
@kcochibili JSON is extremely safe as it is able to carry anything, including your magic separator pattern. How is JSON doing that? They escape characters that are part of the syntax. In strings (that can contain any character) they do this by using an escape sequence (double quotes are escaped). You can read more about that in the specification: https://www.ecma-international.org/publications-and-standards/standards/ecma-404/. This makes it possible for JSON to store any byte in any combination, without the need for magic separator patterns. – Rolf ツ Feb 05 '22 at 21:54

score 95 · Answer 3 · edited Mar 29 '18 at 10:25

95

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

Loading Array Data from 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<size;i++) 
    {
     sKey.add(mSharedPreference1.getString("Status_" + i, null));
    }

}

edited Mar 29 '18 at 10:25

CopsOnRoad

237,138
77
654
440

answered Jun 15 '12 at 12:42

Harneet Kaur

4,487
1
16
16

15

this is a very nice "hack". Be aware that with this method, there is always the posibility of bloating the SharedPreferences with unused old values. For example a list might have a size of 100 on a run, and then a size of 50. The 50 old entries will remain on the preferences. One way is setting a MAX value and clearing anything up to that. – Iraklis Feb 17 '13 at 12:17
3

@Iraklis Indeed, but assuming that you store only this `ArrayList` into `SharedPrefeneces` you could use `mEdit1.clear()` to avoid this. – AlexAndro Apr 04 '13 at 20:41
1

I like this "hack". But mEdit1.clear() will erase other values not relevant to this purpose? – Bagusflyer Oct 05 '13 at 05:42
2

Thanks! If you mind me asking, is there a necessary purpose for .remove()? Won't the preference just overwrite anyway? – Script Kitty Mar 13 '16 at 18:29

score 76 · Answer 4 · edited Nov 11 '20 at 02:45

76

As @nirav said, best solution is store it in sharedPrefernces as a json text by using Gson utility class. Below sample code:

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

edited Nov 11 '20 at 02:45

XXIV

63
7

answered Jan 10 '15 at 02:33

Ayman Al-Absi

2,630
24
22

3

This answer shoud be way up. Superb! Had no idea I can use Gson this way. First time to see the array notation used this way too. Thank you! – madu Jun 21 '17 at 14:55
5

To convert it back to List, List textList = Arrays.asList(gson.fromJson(jsonText, String[].class)); – Vamsi Challa Mar 25 '18 at 06:57
1

What is "data"? – CuriousNewbie Oct 24 '20 at 13:35

score 70 · Answer 5 · edited Jun 24 '18 at 06:26

70

You can convert it to JSON String and store the string in the SharedPreferences.

edited Jun 24 '18 at 06:26

CopsOnRoad

237,138
77
654
440

answered Aug 14 '11 at 15:47

MByD

135,866
28
264
277

I'm finding a ton of code on converting ArrayLists to JSONArrays, but do you have a sample you might be willing to share on how to convert over to JSONString so I can store it in the SharedPrefs? – ryandlf Aug 15 '11 at 12:22
5

using [toString()](http://developer.android.com/reference/org/json/JSONArray.html#toString()) – MByD Aug 15 '11 at 12:52
4

But then how do I get it back out of SharedPrefs and convert it back into an ArrayList? – ryandlf Aug 15 '11 at 12:55
I'm sorry, I don't have an Android SDK to test it now, but take a look here: http://benjii.me/2010/04/deserializing-json-in-android-using-gson/ . You should iterate over the json array and do what they do there for each object, hopefully I'll be able to post an edit to my answer with a full example tomorrow. – MByD Aug 15 '11 at 13:12
@MByD 12 years later... – acmpo6ou Mar 10 '23 at 15:19

Raviraj · Answer 6 · 2020-04-23T05:36:30.630

69

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

edited Apr 23 '20 at 05:36

answered Jun 20 '19 at 09:21

Raviraj

906
9
14

3

Yes, best answer – AlexPad Oct 05 '19 at 12:07
1

this is the best answer, I've been using it for storing other Objects too – Irfandi D. Vendy Apr 27 '20 at 04:44
1

can you make this that means it will store all model class ? – BlackBlind May 19 '20 at 09:04
1

Yes i tried it , perfect for storing data to sharedprefs! i voted up. – Maria Cecilia Ancheta Calianga Aug 29 '21 at 16:40
1

What is Type import? – Adam Noor Sep 15 '21 at 09:28
show lots of option for importing the `Type` which is inside the `getArrayList` method – mufazmi Aug 07 '22 at 14:56

score 23 · Answer 7 · edited Jul 12 '16 at 09:24

23

Hey friends I got the solution of above problem without using Gson library. Here I post source code.

1.Variable declaration i.e

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2.Variable initialization i.e

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

3.Store value to sharedPreference using 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.Retrive value of sharedPreference using retriveSharedValue():

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

I hope it will helpful for you...

edited Jul 12 '16 at 09:24

ישו אוהב אותך

28,609
11
78
96

answered Apr 26 '16 at 19:58

sachin pangare

1,527
15
11

great solution ! easy and fast ! – LoveAndroid Oct 21 '16 at 05:58
7

This would remove all duplicate strings from the list as soon as you add to a set. Probably not a wanted feature – OneCricketeer Oct 29 '16 at 00:32
Is it only for a list of `String`s? – CoolMind May 02 '17 at 19:02
You will lose order this way – Brian Reinhold Jun 21 '18 at 10:17

Avi Levin · Answer 8 · 2016-07-12T16:05:20.320

Android SharedPreferances allow you to save primitive types (Boolean, Float, Int, Long, String and StringSet which available since API11) in memory as an xml file.

The key idea of any solution would be to convert the data to one of those primitive types.

I personally love to convert the my list to json format and then save it as a String in a SharedPreferences value.

In order to use my solution you'll have to add Google Gson lib.

In gradle just add the following dependency (please use google's latest version):

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

Save data (where HttpParam is your object):

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

Retrieve Data (where HttpParam is your object):

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

Thanks. This answer helped me retrieve and save my List. – visrahane Apr 25 '18 at 06:22 — visrahane, Apr 25 '18 at 06:22

score 12 · Answer 9 · answered Dec 04 '18 at 06:02

This is your perfect solution.. try it,

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

score 10 · Answer 10 · answered Sep 05 '14 at 07:07

You can also convert the arraylist into a String and save that in preference

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

You can save the Arraylist after converting it to string using convertToString method and retrieve the string and convert it to array using convertToArray

After API 11 you can save set directly to SharedPreferences though !!! :)

A set is not a list. A list could contain duplicates and can be sorted. It doesn't make sense to set the delimiter in the loop. Should be a constant/define. Does it even work like this if the delimiter is contained in the string? — The incredible Jan, Nov 25 '20 at 07:58

score 9 · Answer 11 · edited Jun 03 '20 at 14:39

9

For String, int, boolean, the best choice would be sharedPreferences.

If you want to store ArrayList or any complex data. The best choice would be Paper library.

Add dependency

implementation 'io.paperdb:paperdb:2.6'

Initialize Paper

Should be initialized once in Application.onCreate():

Paper.init(context);

Save

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

Loading Data

Use default values if object doesn't exist in the storage.

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

Here you go.

https://github.com/pilgr/Paper

edited Jun 03 '20 at 14:39

Ricky Dev

45
1
6

answered Sep 11 '19 at 12:28

Abdullah Khan

249
2
8

This is something I was searching for. thank You :) – Saurabh Dhage Jul 18 '21 at 09:07

score 8 · Answer 12 · edited Dec 30 '19 at 10:24

Also with 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() }) 
}

score 7 · Answer 13 · answered Apr 19 '18 at 09:35

You can save String and custom array list using Gson library.

=>First you need to create function to save array list to 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 !!!

    }

=> You need to create function to get array list from 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);

}

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

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

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

implementation 'com.google.code.gson:gson:2.8.2'

score 6 · Answer 14 · answered Mar 21 '13 at 00:10

6

best way is that convert to JSOn string using GSON and save this string to SharedPreference. I also use this way to cache responses.

answered Mar 21 '13 at 00:10

Winston

1,800
2
20
30

Khemraj Sharma · Answer 15 · 2018-04-07T06:31:22.943

I have read all answers above. That is all correct but i found a more easy solution as below:

Saving String List in shared-preference>>

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

}

and for getting String List from Shared-preference>>

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

Here Constants.APP_PREFS is the name of the file to open; can not contain path separators.

Andre Thiele · Answer 16 · 2022-07-06T07:47:21.053

Using Kotlin and GSON:

fun <T> SharedPreferences.writeList(gson: Gson, key: String, data: List<T>) {
    val json = gson.toJson(data)
    edit { putString(key, json) }
}

inline fun <reified T> SharedPreferences.readList(gson: Gson, key: String): List<T> {
    val json = getString(key, "[]") ?: "[]"
    val type = object : TypeToken<List<T>>() {}.type
    
    return try {
        gson.fromJson(json, type)
    } catch(e: JsonSyntaxException) {
        emptyList()
    }
}

score 3 · Answer 17 · answered Nov 22 '12 at 07:40

You could refer the serializeKey() and deserializeKey() functions from FacebookSDK's SharedPreferencesTokenCache class. It converts the supportedType into the JSON object and store the JSON string into SharedPreferences. You could download SDK from here

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

Linh · Answer 18 · 2018-08-21T09:22:02.833

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

Using

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

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

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

score 2 · Answer 19 · answered Apr 06 '13 at 14:26

The best way i have been able to find is a make a 2D Array of keys and put the custom items of the array in the 2-D array of keys and then retrieve it through the 2D arra on startup. I did not like the idea of using string set because most of the android users are still on Gingerbread and using string set requires honeycomb.

Sample Code: here ditor is the shared pref editor and rowitem is my custom object.

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

score 2 · Answer 20 · answered Mar 14 '15 at 07:14

following code is the accepted answer, with a few more lines for new folks (me), eg. shows how to convert the set type object back to arrayList, and additional guidance on what goes before '.putStringSet' and '.getStringSet'. (thank you 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();

score 2 · Answer 21 · edited Oct 02 '15 at 09:51

2

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

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

edited Oct 02 '15 at 09:51

Onik

19,396
14
68
91

answered Oct 01 '15 at 10:13

Maulik Gohel

51
2

score 2 · Answer 22 · answered Aug 30 '16 at 10:03

You can use serialization or Gson library to convert list to string and vice versa and then save string in preferences.

Using google's Gson library:

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

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

Using Java serialization:

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

score 2 · Answer 23 · answered Nov 07 '17 at 10:17

Use this custom class:

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

How to use:

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

I tried several of the solutions posted, but this was the best by far. It does not require GSON, a special library, converting to something like a Map or SDK 29. I needed to store a custom class of three members and this was easy to modify to fit. This should be voted higher. Thanks, @Yuliia. — JAW, May 26 '21 at 22:18

score 2 · Answer 24 · edited Feb 05 '19 at 12:53

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

Anil Singhania · Answer 25 · 2018-06-29T07:44:18.807

This method is used to store/save array list:-

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

This method is used to retrieve array list:-

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

score 2 · Answer 26 · answered Aug 14 '11 at 19:53

2

Why don't you stick your arraylist on an Application class? It only get's destroyed when the app is really killed, so, it will stick around for as long as the app is available.

answered Aug 14 '11 at 19:53

Carlos Silva

544
3
12

5

What if the application is relaunched again. – Manu May 29 '15 at 09:47

score 1 · Answer 27 · edited May 23 '17 at 12:18

1

don't forget to implement Serializable:

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

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

edited May 23 '17 at 12:18

Community

1
1

answered Oct 05 '15 at 11:54

Manuel Schmitzberger

5,162
3
36
45

score 1 · Answer 28 · answered Jul 26 '18 at 07:59

this should work:

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

them, to catch it just:

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

it works for me.

score 1 · Answer 29 · answered Mar 10 '21 at 23:31

In case someone needs to save a list of lists, i.e. List<List < String > >. I did this:

To serialize

Gson gson = new Gson();
// Save the size of the array
sharedPreferencesEditor.putInt("ArraySize", myArray.size());

for (int i=0; i<myArray.size(); i++) {
  String key = "Array"+i;
  String json = gson.toJson(myArray.get(i));
  sharedPreferencesEditor.putString(key, json);
}

sharedPreferencesEditor.commit();

To Deserialize

// Get the size of the array to be deserialized. In my case, the default number should be 3
int arraySize = sharedPreferences.getInt("ArraySize",3);

myArray = new ArrayList<List<String>>();

for (int i=0; i<arraySize; i++) {
  String key = "Array"+i;
  String json = sharedPreferences.getString(key, null);
  List<String> arrayTemp= gson.fromJson(json, List.class);
  myArray.add(arrayTemp);
}

// My array may also include components with empty strings. 
// Gson makes them null values and it is not possible 
// to deserialize them as empty strings. 
// The following takes care of that:

for (int i=0; i<myArray.size();i++) {
   if (myArray.get(i) == null) {
      List<String> emptyComponent = new ArrayList<String>() {
         { add(""); }
      };
      myArray.set(i,emptyComponent);
   }
}

score 1 · Answer 30 · answered Aug 14 '11 at 15:52

1

You can convert it to a Map Object to store it, then change the values back to an ArrayList when you retrieve the SharedPreferences.

answered Aug 14 '11 at 15:52

Phil

35,852
23
123
164

score 0 · Answer 31 · answered Mar 25 '15 at 12:04

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

score 0 · Answer 32 · answered Jul 09 '15 at 09:31

All of the above answers are correct. :) I myself used one of these for my situation. However when I read the question I found that the OP is actually talking about a different scenario than the title of this post, if I didn't get it wrong.

"I need the array to stick around even if the user leaves the activity and then wants to come back at a later time"

He actually wants the data to be stored till the app is open, irrespective of user changing screens within the application.

"however I don't need the array available after the application has been closed completely"

But once the application is closed data should not be preserved.Hence I feel using SharedPreferences is not the optimal way for this.

What one can do for this requirement is create a class which extends Application class.

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

}

Using the setter and getter the ArrayList can be accessed from anywhere withing the Application. And the best part is once the app is closed, we do not have to worry about the data being stored. :)

score 0 · Answer 33 · answered Oct 03 '15 at 04:16

It's very simple using getStringSet and putStringSet in SharedPreferences, but in my case, I have to duplicate the Set object before I can add anything to the Set. Or else, the Set will not be saved if my app is force closed. Probably because of the note below in the API below. (It saved though if app is closed by back button).

Note that you must not modify the set instance returned by this call. The consistency of the stored data is not guaranteed if you do, nor is your ability to modify the instance at all. http://developer.android.com/reference/android/content/SharedPreferences.html#getStringSet

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getActivity());
SharedPreferences.Editor editor = prefs.edit();

Set<String> outSet = prefs.getStringSet("key", new HashSet<String>());
Set<String> workingSet = new HashSet<String>(outSet);
workingSet.add("Another String");

editor.putStringSet("key", workingSet);
editor.commit();

score 0 · Answer 34 · answered Feb 22 '18 at 10:17

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<String> list = getListFromPreference(context);
        if (!list.contains(id)) {
            list.add(id);
            SharedPreferences.Editor edit = sharedPreferences.edit();
            Set<String> set = new HashSet<>();
            set.addAll(list);
            edit.putStringSet(Constant.LIST, set);
            edit.commit();

        }
    }
    public static ArrayList<String> getListFromPreference(Context context) {
        SharedPreferences sharedPreferences = context.getSharedPreferences(Constants.MyPreference, Context.MODE_PRIVATE);
        Set<String> set = sharedPreferences.getStringSet(Constant.LIST, null);
        ArrayList<String> list = new ArrayList<>();
        if (set != null) {
            list = new ArrayList<>(set);
        }
        return list;
    }

My understanding is that 'Set' does not preserve order. LinkedHashSet will. And ShardePreferences will not restore a LinkedHashSet nor cast to it. SO I am not sure what will come back. — Brian Reinhold, Jun 21 '18 at 13:43

score 0 · Answer 35 · answered Apr 19 '18 at 20:35

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

class MyPrefs(context: Context) {
    val prefs = context.getSharedPreferences("x.y.z.PREFS_FILENAME", 0)
    var listOfFloats: List<Float>
        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

Vijendra patidar · Answer 36 · 2019-07-31T10:40:18.027

Please use these two methods for store data in ArrayList in kotlin

fun setDataInArrayList(list: ArrayList<ShopReisterRequest>, key: String, context: Context) {
    val prefs = PreferenceManager.getDefaultSharedPreferences(context)
    val editor = prefs.edit()
    val gson = Gson()
    val json = gson.toJson(list)
    editor.putString(key, json)
    editor.apply()   
}

fun getDataInArrayList(key: String, context: Context): ArrayList<ShopReisterRequest> {
    val prefs = PreferenceManager.getDefaultSharedPreferences(context)
    val gson = Gson()
    val json = prefs.getString(key, null)
    val type = object : TypeToken<ArrayList<ShopReisterRequest>>() {

    }.type
    return gson.fromJson<ArrayList<ShopReisterRequest>>(json, type)
}

score 0 · Answer 37 · answered Feb 26 '20 at 11:22

public static void WriteSharePrefrence1(Context context, String key, 
ArrayList<HashMap<String, String>> value)
{
    final SharedPreferences preferences = 
    PreferenceManager.getDefaultSharedPreferences(context);
    SharedPreferences.Editor editor = preferences.edit();
    Gson gson = new Gson();
    String json = gson.toJson(value);
    editor.putString(key, json);
    editor.commit();
}
public static ArrayList<HashMap<String, String>> ReadSharePrefrence1(Context context, 
 String key)
{
    String data;
    Gson gson = new Gson();
    ArrayList<HashMap<String, String>> items = new ArrayList<>();
    final SharedPreferences preferences = 
    PreferenceManager.getDefaultSharedPreferences(context);
    final SharedPreferences.Editor editor = preferences.edit();
    data = preferences.getString(key, "");

    Type type = new TypeToken<ArrayList<HashMap<String, String>>>() {}.getType();
    items = gson.fromJson(data, type);

    return items;
}

score -1 · Answer 38 · answered Jun 26 '19 at 06:32

public class VcareSharedPreference {
  private static VcareSharedPreference sharePref = new VcareSharedPreference(); 
  private static SharedPreferences sharedPreferences; 
  private static SharedPreferences.Editor editor;
  private VcareSharedPreference() {
 } 
public static VcareSharedPreference getInstance(Context context) {
    if (sharedPreferences == null) {
        sharedPreferences = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
        editor = sharedPreferences.edit();
    }
    return sharePref;
 }
public void save(String KEY, String text) {
    editor.putString(KEY, text);
    editor.commit();
}
 public String getValue(String PREFKEY) {
    String text;

    //settings = PreferenceManager.getDefaultSharedPreferences(context);
    text = sharedPreferences.getString(PREFKEY, null);
    return text;
}
public void removeValue(String KEY) {
    editor.remove(KEY);
    editor.commit();
}

public void clearAll() {
    editor.clear();
    editor.commit();
}
public void saveArrayList(String key, ArrayList<ModelWelcome> modelCourses) {
    Gson gson = new Gson();
    String json = gson.toJson(modelCourses);
    editor.putString(key, json);
    editor.apply();
}

public ArrayList<ModelWelcome> getArray(String key) {

    Gson gson = new Gson();
    String json = sharedPreferences.getString(key, null);
    Type type = new TypeToken<ArrayList<ModelWelcome>>() {
    }.getType();
 return gson.fromJson(json, type);}}

this is is the singleton class for sharedpreference for saving any value..Thanks — nithin joseph, Jun 26 '19 at 06:32

Save ArrayList to SharedPreferences

38 Answers38

Linked

Related