Lưu ArrayList vào SharedPreferences

Tôi có một ArrayListvới các đối tượng tùy chỉnh. Mỗi đối tượng tùy chỉnh chứa nhiều chuỗi và số. Tôi cần mảng bám xung quanh ngay cả khi người dùng rời khỏi hoạt động và sau đó muốn quay lại sau, tuy nhiên tôi không cần mảng có sẵn sau khi ứng dụng đã bị đóng hoàn toàn. Tôi lưu rất nhiều đối tượng khác theo cách này bằng cách sử dụng SharedPreferencesnhưng tôi không thể tìm ra cách lưu toàn bộ mảng của mình theo cách này. Điều này có thể không? Có lẽ SharedPreferenceskhông phải là cách để đi về điều này? Có một phương pháp đơn giản hơn?

Sau API 11, SharedPreferences Editorchấp nhận Sets. Bạn có thể chuyển đổi Danh sách của bạn thành một HashSethoặc một cái gì đó tương tự và lưu trữ nó như thế. Khi bạn đọc lại, hãy chuyển đổi nó thành một ArrayList, sắp xếp nó nếu cần và bạn sẽ ổn.

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

Bạn cũng có thể tuần tự hóa ArrayListvà sau đó lưu / đọc nó đến / từ SharedPreferences. Dưới đây là giải pháp:

EDIT:
Ok, bên dưới là giải pháp lưu ArrayListdưới dạng đối tượng được tuần tự hóa SharedPreferencesvà sau đó đọc nó từ SharedPreferences.

Vì API chỉ hỗ trợ lưu trữ và truy xuất chuỗi đến / từ SharedPreferences (sau API 11, đơn giản hơn), chúng tôi phải tuần tự hóa và hủy tuần tự hóa đối tượng ArrayList có danh sách các tác vụ thành chuỗi.

Trong addTask()phương thức của lớp TaskManagerApplication, chúng ta phải lấy thể hiện của tùy chọn chia sẻ và sau đó lưu trữ ArrayList được tuần tự hóa bằng putString()phương thức:

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

Tương tự, chúng ta phải lấy danh sách các tác vụ từ tùy chọn trong onCreate()phương thức:

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

Bạn có thể nhận ObjectSerializerlớp từ dự án Apache Pig ObjectSerializer.java

Sử dụng đối tượng này -> TinyDB - Android-Shared-Preferences-Turbo rất đơn giản.

TinyDB tinydb = new TinyDB(context);

để đặt

tinydb.putList("MyUsers", mUsersArray);

để có được

tinydb.getList("MyUsers");

CẬP NHẬT

Một số ví dụ hữu ích và khắc phục sự cố có thể được tìm thấy ở đây: Giao diện chia sẻ Android TinyDB putListObject

Tiết kiệm Arraytrong 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();     
}

Đang tải Arraydữ liệu từ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));
    }

}

Bạn có thể chuyển đổi nó JSON Stringvà lưu trữ chuỗi trong SharedPreferences.

Như @nirav đã nói, giải pháp tốt nhất là lưu trữ nó trong sharedPrefernces dưới dạng văn bản json bằng cách sử dụng lớp tiện ích Gson. Dưới đây là mẫu mã:

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

Này các bạn, tôi có giải pháp cho vấn đề trên mà không cần sử dụng Gson thư viện. Ở đây tôi đăng mã nguồn.

1. Khai báo tức là

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2. Khởi tạo có nghĩa là

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

3.Store value to sharedPreference bằng cách sử dụng 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. Giá trị phát triển của sharedPreference bằng cách sử dụng retriveSharedValue():

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

Tôi hy vọng nó sẽ hữu ích cho bạn ...

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

Android SharedPreferances cho phép bạn lưu các loại nguyên thủy (Boolean, Float, Int, Long, String và Stringset có sẵn từ API11) trong bộ nhớ dưới dạng tệp xml.

Ý tưởng chính của bất kỳ giải pháp nào là chuyển đổi dữ liệu thành một trong những kiểu nguyên thủy đó.

Cá nhân tôi thích chuyển đổi danh sách của mình sang định dạng json và sau đó lưu nó dưới dạng Chuỗi trong giá trị SharedPreferences.

Để sử dụng giải pháp của tôi, bạn sẽ phải thêm Google Gson lib .

Trong lớp, chỉ cần thêm phụ thuộc sau (vui lòng sử dụng phiên bản mới nhất của google):

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

Lưu dữ liệu (trong đó httpParam là đối tượng của bạn):

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

Truy xuất dữ liệu (trong đó httpParam là đối tượng của bạn):

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

Đây là giải pháp hoàn hảo của bạn .. hãy thử nó,

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

Bạn cũng có thể chuyển đổi danh sách mảng thành Chuỗi và lưu tùy chọn đó vào tùy chọn

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

Bạn có thể lưu Arraylist sau khi chuyển đổi nó thành chuỗi bằng cách sử dụng convertToString phương thức và truy xuất chuỗi và chuyển đổi nó thành mảng bằng cách sử dụngconvertToArray

Sau API 11, bạn có thể lưu được đặt trực tiếp vào SharedPreferences !!! :)

Đối với String, int, boolean, sự lựa chọn tốt nhất sẽ là sharedPreferences.

Nếu bạn muốn lưu trữ ArrayList hoặc bất kỳ dữ liệu phức tạp nào. Sự lựa chọn tốt nhất sẽ là thư viện Giấy.

Thêm phụ thuộc

implementation 'io.paperdb:paperdb:2.6'

Khởi tạo giấy

Nên được khởi tạo một lần trong Application.onCreate ():

Paper.init(context);

Tiết kiệm

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

Đang tải dữ liệu

Sử dụng các giá trị mặc định nếu đối tượng không tồn tại trong bộ lưu trữ.

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

Bạn đi đây

https://github.com/pilgr/Paper

Tôi đã đọc tất cả các câu trả lời ở trên. Đó là tất cả chính xác nhưng tôi tìm thấy một giải pháp dễ dàng hơn như dưới đây:

1. Lưu danh sách chuỗi trong tùy chọn chia sẻ >>

   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. và để nhận Danh sách chuỗi từ tùy chọn chia sẻ >>

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

Đây Constants.APP_PREFSlà tên của tệp để mở; không thể chứa dấu phân cách đường dẫn.

Ngoài ra với 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() }) 
}

cách tốt nhất là chuyển đổi sang chuỗi JSOn bằng GSON và lưu chuỗi này vào SharedPreference. Tôi cũng sử dụng cách này để phản hồi bộ đệm.

Bạn có thể lưu Chuỗi và danh sách mảng tùy chỉnh bằng thư viện Gson.

=> Trước tiên, bạn cần tạo chức năng để lưu danh sách mảng vào 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 !!!

    }

=> Bạn cần tạo chức năng để lấy danh sách mảng từ 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);

}

=> Cách gọi chức năng lưu và truy xuất danh sách mảng.

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

=> Đừng quên thêm thư viện gson trong cấp độ ứng dụng build.gradle.

triển khai 'com.google.code.gson: gson: 2.8.2'

Bạn có thể tham khảo các hàm serializeKey () và deserializeKey () từ lớp SharedPreferencesTokenCache của FacebookSDK. Nó chuyển đổi hỗ trợType thành đối tượng JSON và lưu trữ chuỗi JSON vào SharedPreferences . Bạn có thể tải xuống SDK từ đây

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

Tại sao bạn không dán danh sách mảng của mình vào một lớp Ứng dụng? Nó chỉ bị phá hủy khi ứng dụng thực sự bị giết, vì vậy, nó sẽ tồn tại chừng nào ứng dụng có sẵn.

Cách tốt nhất mà tôi có thể tìm thấy là tạo một mảng 2D các phím và đặt các mục tùy chỉnh của mảng vào mảng 2-D và sau đó lấy nó thông qua arra 2D khi khởi động. Tôi không thích ý tưởng sử dụng bộ chuỗi vì hầu hết người dùng Android vẫn sử dụng Gingerbread và sử dụng bộ chuỗi yêu cầu tổ ong.

Mã mẫu: ở đây ditor là trình soạn thảo pref được chia sẻ và rowitem là đối tượng tùy chỉnh của tôi.

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

mã sau đây là câu trả lời được chấp nhận, với một vài dòng nữa cho những người mới (tôi), vd. chỉ ra cách chuyển đổi đối tượng loại thiết lập trở lại mảngList và hướng dẫn bổ sung về những gì đi trước '.putStringset' và '.getStringset'. (cảm ơn ác quỷ)

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

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

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

đừng quên thực hiện nối tiếp:

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

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

Bạn có thể sử dụng tuần tự hóa hoặc thư viện Gson để chuyển đổi danh sách thành chuỗi và ngược lại và sau đó lưu chuỗi trong tùy chọn.

Sử dụng thư viện Gson của google:

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

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

Sử dụng tuần tự hóa 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;

Phương pháp này được sử dụng để lưu trữ / lưu danh sách mảng: -

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

Phương pháp này được sử dụng để truy xuất danh sách mảng: -

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

Bạn có thể chuyển đổi nó thành MapObject để lưu trữ nó, sau đó thay đổi các giá trị trở lại thành ArrayList khi bạn truy xuất SharedPreferences.

Sử dụng lớp tùy chỉnh này:

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

Cách sử dụng:

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

cái này nên hoạt động:

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

Họ, để bắt nó chỉ:

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

nó làm việc cho tôi

Lớp utils của tôi để lưu danh sách vào 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);
    }
}

Sử dụng

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

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

.
Mã đầy đủ các tiện ích của tôi // kiểm tra bằng ví dụ trong Mã hoạt động

Tôi đã sử dụng cùng một cách lưu và truy xuất một Chuỗi nhưng ở đây với mảng ListList tôi đã sử dụng Hashset làm trung gian hòa giải

Để lưu mảng ListList vào SharedPreferences, chúng tôi sử dụng Hashset:

1- chúng tôi tạo biến SharedPreferences (tại nơi thay đổi xảy ra với mảng)

2 - chúng tôi chuyển đổi mảng List sang Hashset

3 - sau đó chúng tôi đặt chuỗi Set và áp dụng

4 - bạn getStringSet trong Hashset và tạo lại ArrayList để đặt 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());
    }
}

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

Tất cả các câu trả lời trên là chính xác. :) Bản thân tôi đã sử dụng một trong những thứ này cho tình huống của mình. Tuy nhiên khi tôi đọc câu hỏi tôi thấy rằng OP thực sự đang nói về một kịch bản khác với tiêu đề của bài đăng này, nếu tôi không hiểu sai.

"Tôi cần mảng bám xung quanh ngay cả khi người dùng rời khỏi hoạt động và sau đó muốn quay lại sau"

Anh ta thực sự muốn dữ liệu được lưu trữ cho đến khi ứng dụng được mở, bất kể người dùng thay đổi màn hình trong ứng dụng.

"tuy nhiên tôi không cần mảng có sẵn sau khi ứng dụng đã bị đóng hoàn toàn"

Nhưng một khi ứng dụng bị đóng dữ liệu thì không nên bảo quản. Tôi cảm thấy sử dụng SharedPreferences không phải là cách tối ưu cho việc này.

Những gì người ta có thể làm cho yêu cầu này là tạo ra một lớp mở rộng Applicationlớp.

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

}

Sử dụng setter và getter, ArrayList có thể được truy cập từ bất cứ nơi nào có ứng dụng. Và phần tốt nhất là khi ứng dụng đã đóng, chúng ta không phải lo lắng về việc dữ liệu được lưu trữ. :)