У меня есть ArrayList с пользовательскими объектами. Каждый пользовательский объект содержит множество строк и чисел. Мне нужен массив, чтобы придерживаться, даже если пользователь покидает активность, а затем хочет вернуться позже, однако мне не нужен массив, доступный после того, как приложение было полностью закрыто. Я сохраняю много других объектов таким образом, используя SharedPreferences, но я не могу понять, как сохранить весь этот массив. Это возможно? Может быть, SharedPreferences - это не способ сделать это? Есть ли более простой метод?
Сохранить ArrayList в SharedPreferences
Ответ 1
После API 11 SharedPreferences Editor принять Sets. Вы можете преобразовать свой список в HashSet или что-то подобное и сохранить его таким образом. Когда вы его прочитаете, преобразуйте его в ArrayList, при необходимости отсортируйте, и вам будет хорошо.
//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();
Вы также можете сериализовать свой ArrayList, а затем сохранить/прочитать его в/из SharedPreferences. Ниже приведено решение:
EDIT:
Итак, ниже находится решение сохранить ArrayList как сериализованный объект до SharedPreferences, а затем прочитать его из SharedPreferences.
Поскольку API поддерживает только сохранение и извлечение строк в/из SharedPreferences (после более простого API-интерфейса API 11), мы должны сериализовать и де-сериализовать объект ArrayList, который имеет список задач в строку.
В методе addTask() класса TaskManagerApplication мы должны получить экземпляр общей настройки и затем сохранить сериализованный ArrayList с помощью метода putString():
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();
}
Аналогичным образом мы должны получить список задач из предпочтения в методе onCreate():
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();
}
}
Вы можете получить класс ObjectSerializer из проекта Apache Pig ObjectSerializer.java
Ответ 2
Используя этот объект → TinyDB - Android-Shared-Preferences-Turbo это очень просто.
TinyDB tinydb = new TinyDB(context);
класть
tinydb.putList("MyUsers", mUsersArray);
получить
tinydb.getList("MyUsers");
ОБНОВИТЬ
Некоторые полезные примеры и устранение неполадок могут быть найдены здесь: Android Shared Preference TinyDB putListObject frunction
Ответ 3
Сохранение Array в 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();
}
Загрузка данных Array из 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));
}
}
Ответ 4
Вы можете преобразовать его в JSON String и сохранить строку в SharedPreferences.
Ответ 5
Как сказал @nirav, лучшим решением является сохранение его в sharedPrefernces в виде текста json с использованием класса утилиты Gson. Ниже пример кода:
//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();
Ответ 6
Привет, друзья. Я получил решение выше проблемы без использования библиотеки Gson. Здесь я отправляю исходный код.
1.Варифное объявление i.e
SharedPreferences shared;
ArrayList<String> arrPackage;
2. Переменная инициализация iee
shared = getSharedPreferences("App_settings", MODE_PRIVATE);
// add values for your ArrayList any where...
arrPackage = new ArrayList<>();
Значение 3.Store для sharedPreference с помощью 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 значение sharedPreference с помощью retriveSharedValue():
private void retriveSharedValue() {
Set<String> set = shared.getStringSet("DATE_LIST", null);
arrPackage.addAll(set);
Log.d("retrivesharedPreferences",""+set);
}
Надеюсь, это поможет вам...
Ответ 7
Android SharedPreferances позволяет сохранять примитивные типы (Boolean, Float, Int, Long, String и StringSet, которые доступны с API11) в виде XML файла.
Ключевой идеей любого решения было бы преобразование данных в один из этих примитивных типов.
Мне лично нравится преобразовывать свой список в формат json, а затем сохранять его как строку в значении SharedPreferences.
Чтобы использовать мое решение, вам нужно будет добавить Google Gson lib.
В gradle просто добавьте следующую зависимость (пожалуйста, используйте последнюю версию Google):
compile 'com.google.code.gson:gson:2.6.2'
Сохранить данные (где HttpParam - ваш объект):
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();
Получить данные (где HttpParam - ваш объект):
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());
Ответ 8
Вы также можете преобразовать arraylist в String и сохранить это в предпочтении
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;
}
Вы можете сохранить Arraylist после преобразования его в строку с convertToString метода convertToString и получить строку и преобразовать ее в массив с помощью convertToArray
После API 11 вы можете сохранить набор непосредственно в SharedPreferences, хотя !!! :)
Ответ 9
Это ваше идеальное решение. Попробуйте,
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);
}
Ответ 10
Я прочитал все ответы выше. Это все правильно, но я нашел более легкое решение, как показано ниже:
-
Сохранение списка строк в общих предпочтениях >>
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(); }}
-
и для получения списка строк из общего предпочтения >>
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; }
Здесь Constants.APP_PREFS - это имя открытого файла; не может содержать разделители путей.
Ответ 11
/**
* Save and get ArrayList in SharedPreference
*/
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);
}
Ответ 12
лучшим способом является преобразование в строку JSOn с использованием GSON и сохранение этой строки в SharedPreference. Я также использую этот способ для кэширования ответов.
Ответ 13
Вы можете ссылаться на функции serializeKey() и deserializeKey() из класса SharedPreferencesTokenCache от FacebookSDK. Он преобразует поддерживаемый тип в объект JSON и сохраняет строку JSON в SharedPreferences. Вы можете скачать SDK из здесь
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);
}
}
Ответ 14
Почему бы вам не наклеить свой arraylist на класс приложения? Он только уничтожается, когда приложение действительно убито, поэтому он будет придерживаться до тех пор, пока приложение доступно.
Ответ 15
Лучшим способом, который я смог найти, является создание двумерного массива ключей и размещение пользовательских элементов массива в 2-мерном массиве ключей, а затем извлечение его через 2D-arra при запуске. Мне не понравилась идея использовать набор строк, потому что большинство пользователей андроида все еще на Gingerbread, а для использования набора строк требуется сота.
Пример кода: здесь ditor - это общий редактор pref, а rowitem - мой пользовательский объект.
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());
Ответ 16
следующий код - это принятый ответ, а еще несколько строк для новых людей (меня), например. показывает, как преобразовать объект типа set обратно в arrayList и дополнительные указания относительно того, что происходит до '.putStringSet' и '.getStringSet'. (спасибо, безнадежно)
// 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();
Ответ 17
//Set the values
intent.putParcelableArrayListExtra("key",collection);
//Retrieve the values
ArrayList<OnlineMember> onlineMembers = data.getParcelableArrayListExtra("key");
Ответ 18
не забудьте реализовать Serializable:
Class dataBean implements Serializable{
public String name;
}
ArrayList<dataBean> dataBeanArrayList = new ArrayList();
Ответ 19
Вы можете использовать сериализацию или библиотеку Gson для преобразования списка в строку и наоборот, а затем сохранить строку в настройках.
Использование библиотеки Google Gson:
//Converting list to string
new Gson().toJson(list);
//Converting string to list
new Gson().fromJson(listString, CustomObjectsList.class);
Использование сериализации 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;
Ответ 20
Вы можете сохранить список String и custom array, используя библиотеку Gson.
=> Сначала вам нужно создать функцию для сохранения списка массивов в 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 !!!
}
=> Вам нужно создать функцию для получения списка массивов из 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);
}
=> Как вызвать функцию сохранения и извлечения списка массивов.
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());
=> Не забывайте добавлять gson-библиотеку в ваш уровень приложения build.gradle.
реализация 'com.google.code.gson: gson: 2.8.2'
Ответ 21
Также с Котлином:
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 value.split(",").map { it.toInt() }.toArrayList()
}
Ответ 22
Этот метод используется для хранения/сохранения списка массивов:
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();
}
Этот метод используется для извлечения списка массивов:
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;
}
Ответ 23
Вы можете преобразовать его в объект Map для его сохранения, а затем вернуть значения обратно в ArrayList при извлечении SharedPreferences.
Ответ 24
Используйте этот настраиваемый класс:
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;
}
}
Как использовать:
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));
Ответ 25
Я использовал тот же способ сохранения и извлечения строки, но здесь с arrayList я использовал HashSet в качестве посредника
Чтобы сохранить arrayList в SharedPreferences, мы используем HashSet:
1- мы создаем переменную SharedPreferences (там, где изменение происходит с массивом)
2 - конвертируем arrayList в HashSet
3 - тогда мы ставим строку Set и применяем
4 - вы получаете StStringSet внутри HashSet и воссоздаете ArrayList для установки 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());
}
}
Ответ 26
Мой класс utils для списка сохранения в 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);
}
}
С помощью
// for save
sharedPrefApi.putList(SharedPrefApi.Key.USER_LIST, userList);
// for retrieve
List<User> userList = sharedPrefApi.getList(SharedPrefApi.Key.USER_LIST, User.class);
Полный код моего utils//проверить пример в Activity Code
Ответ 27
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();
}
}
Ответ 28
Все приведенные выше ответы верны.:) Я сам использовал один из них для своей ситуации. Однако, когда я прочитал вопрос, я обнаружил, что OP фактически говорит о другом сценарии, чем название этого сообщения, если я не ошибаюсь.
"Мне нужен массив, чтобы придерживаться, даже если пользователь покидает активность, а затем хочет вернуться позже"
Он действительно хочет, чтобы данные хранились до открытия приложения, независимо от изменения пользователем экрана в приложении.
"однако мне не нужен массив, доступный после того, как приложение было полностью закрыто"
Но как только приложение закрыто, данные не должны быть сохранены. Мне кажется, что использование SharedPreferences не является оптимальным для этого.
Для этого можно создать класс, который расширяет класс Application.
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;
}
}
Используя setter и getter, доступ к ArrayList можно получить из любого места в приложении. И самое главное, когда приложение закрыто, нам не нужно беспокоиться о хранящихся данных.:)
Ответ 29
Это очень просто, используя getStringSet и putStringSet в SharedPreferences, но в моем случае я должен дублировать объект Set, прежде чем я могу добавить все, что угодно. Или же, Set не будет сохранен, если мое приложение будет принудительно закрыто. Вероятно, из-за приведенной ниже информации в API ниже. (Он сохраняется, если приложение закрыто кнопкой "Назад" ).
Обратите внимание, что вы не должны изменять экземпляр набора, возвращенный этим вызовом. Согласованность сохраненных данных не гарантируется, если вы это сделаете, а также ваша способность изменять экземпляр вообще. 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();
Ответ 30
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;
}