บันทึก ArrayList ไปยัง SharedPreferences

ฉันมีArrayListวัตถุที่กำหนดเอง แต่ละวัตถุที่กำหนดเองมีความหลากหลายของสตริงและตัวเลข ฉันต้องการอาเรย์เพื่อติดตั้งแม้ว่าผู้ใช้ออกจากกิจกรรมแล้วต้องการกลับมาใหม่ในภายหลัง แต่ฉันไม่ต้องการอาเรย์ที่มีอยู่หลังจากแอปพลิเคชันถูกปิดอย่างสมบูรณ์ ฉันบันทึกวัตถุอื่นอีกมากมายด้วยวิธีนี้โดยใช้SharedPreferencesแต่ฉันไม่สามารถหาวิธีบันทึกอาร์เรย์ทั้งหมดของฉันด้วยวิธีนี้ เป็นไปได้ไหม อาจSharedPreferencesจะไม่ใช่วิธีที่จะไปเกี่ยวกับเรื่องนี้? มีวิธีที่ง่ายกว่านี้ไหม?

หลังจาก 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จาก ด้านล่างเป็นวิธีแก้ปัญหา:

แก้ไข:
ตกลงด้านล่างเป็นวิธีการบันทึกArrayListเป็นวัตถุที่เป็นอนุกรมSharedPreferencesแล้วอ่านจาก SharedPreferences

เนื่องจาก API รองรับเฉพาะการจัดเก็บและการดึงสตริงไปยัง / จาก SharedPreferences (หลังจาก 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 project ObjectSerializer.java

การใช้วัตถุนี้ -> TinyDB - Android-Shared-Preferences-Turbo มันง่ายมาก

TinyDB tinydb = new TinyDB(context);

ที่จะนำ

tinydb.putList("MyUsers", mUsersArray);

เพื่อรับ

tinydb.getList("MyUsers");

UPDATE

ตัวอย่างที่เป็นประโยชน์และการแก้ไขปัญหาอาจพบได้ที่นี่: Android Preference TinyDB putListObject frference

ออมทรัพย์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));
    }

}

คุณสามารถแปลงเป็นและเก็บสตริงในที่JSON StringSharedPreferences

ตามที่ @ 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();

เฮ้เพื่อนฉันได้รับการแก้ไขปัญหาข้างต้นโดยไม่ต้องใช้Gsonห้องสมุด นี่ฉันโพสต์ซอร์สโค้ด

1. การประกาศที่หลากหลายเช่น

  SharedPreferences shared;
  ArrayList<String> arrPackage;

2. การเริ่มต้นที่หลากหลายเช่น

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

3. เก็บค่าไปยัง 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 value ของ sharedPreference โดยใช้ retriveSharedValue() :

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

ฉันหวังว่ามันจะเป็นประโยชน์สำหรับคุณ ...

/**
 *     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 ช่วยให้คุณสามารถบันทึกประเภทดั้งเดิม (Boolean, Float, Int, Long, String และ StringSet ซึ่งมีให้บริการตั้งแต่ API11) ในหน่วยความจำเป็นไฟล์ xml

แนวคิดหลักของการแก้ปัญหาคือการแปลงข้อมูลให้เป็นหนึ่งในประเภทดั้งเดิม

ฉันชอบแปลงรายการของฉันให้เป็นรูปแบบ json แล้วบันทึกเป็น String ในค่า 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());

นี่คือทางออกที่สมบูรณ์แบบของคุณ .. ลอง

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

คุณยังสามารถแปลง 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วิธีการและดึงข้อมูลสตริงและแปลงเป็นอาร์เรย์โดยใช้convertToArray

หลังจาก API 11 คุณสามารถบันทึกชุดโดยตรงกับSharedPreferencesแม้ว่า !!! :)

สำหรับ String, int, บูลีนตัวเลือกที่ดีที่สุดคือการแชร์การตั้งค่า

หากคุณต้องการจัดเก็บ ArrayList หรือข้อมูลที่ซับซ้อนใด ๆ ทางเลือกที่ดีที่สุดคือห้องสมุดกระดาษ

เพิ่มการพึ่งพา

implementation 'io.paperdb:paperdb:2.6'

เริ่มต้นกระดาษ

ควรเริ่มต้นหนึ่งครั้งใน Application.onCreate ():

Paper.init(context);

บันทึก

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

กำลังโหลดข้อมูล

ใช้ค่าเริ่มต้นหากวัตถุไม่มีอยู่ในที่เก็บข้อมูล

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

ไปเลย

https://github.com/pilgr/Paper

ฉันได้อ่านคำตอบทั้งหมดข้างต้น ถูกต้องทั้งหมด แต่ฉันพบวิธีแก้ปัญหาที่ง่ายขึ้นดังต่อไปนี้:

1. การบันทึกรายการสตริงในการกำหนดค่าแบบแบ่งใช้ >>

   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. และสำหรับการรับรายการสตริงจาก Shared-preferences >>

   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คือชื่อของไฟล์ที่จะเปิด; ไม่สามารถมีตัวคั่นเส้นทาง

ยังมี 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() }) 
}

วิธีที่ดีที่สุดคือแปลงเป็นสตริง JSOn โดยใช้ GSON และบันทึกสตริงนี้เป็น SharedPreference ฉันยังใช้วิธีนี้ในการแคชคำตอบ

คุณสามารถบันทึก String และรายการอาร์เรย์ที่กำหนดเองโดยใช้ห้องสมุด 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'

คุณสามารถอ้างอิงฟังก์ชั่น serializeKey () และ deserializeKey () จากคลาส SharedPreferencesTokenCache ของ FacebookSDK มันจะแปลง supportedType ลงในวัตถุ 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);
    }
}

ทำไมคุณไม่ติดรายการอาร์เรย์ในคลาสแอปพลิเคชัน มันจะถูกทำลายเมื่อแอพถูกฆ่าจริง ๆเท่านั้นดังนั้นมันจะติดไปเรื่อย ๆ ตราบใดที่แอพพร้อมใช้งาน

วิธีที่ดีที่สุดที่ฉันสามารถค้นหาได้คือสร้างอาเรย์แบบสองมิติของคีย์และวางไอเท็มแบบกำหนดเองของอาเรย์ในอาเรย์แบบ 2 มิติของคีย์จากนั้นเรียกมันผ่านทางอารา 2D ฉันไม่ชอบความคิดในการใช้ชุดสตริงเนื่องจากผู้ใช้ Android ส่วนใหญ่ยังคงใช้ 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());

รหัสต่อไปนี้เป็นคำตอบที่ได้รับการยอมรับมีอีกสองสามบรรทัดสำหรับคนใหม่ (ฉัน) เช่น แสดงวิธีแปลงวัตถุประเภทชุดกลับไปเป็น arrayList และคำแนะนำเพิ่มเติมเกี่ยวกับสิ่งที่เกิดขึ้นก่อนหน้า '.putStringSet' และ '.getStringSet' (ขอบคุณ 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();

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

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

อย่าลืมติดตั้ง Serializable:

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

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

คุณสามารถใช้การทำให้เป็นอันดับหรือไลบรารี Gson เพื่อแปลงรายการเป็นสตริงและในทางกลับกันแล้วบันทึกสตริงในการกำหนดลักษณะ

ใช้ห้องสมุด Gson ของ Google:

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

วิธีนี้ใช้ในการจัดเก็บ / บันทึกรายการอาเรย์: -

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

คุณสามารถแปลงเป็นMapวัตถุที่จะเก็บมันแล้วเปลี่ยนค่ากลับไปที่ ArrayList SharedPreferencesเมื่อคุณเรียก

ใช้คลาสที่กำหนดเองนี้:

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

สิ่งนี้ควรใช้งานได้:

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

พวกเขาจะจับมันเพียง:

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

มันใช้งานได้สำหรับฉัน

ชั้น 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 ของฉัน // ตรวจสอบโดยใช้ตัวอย่างในรหัสกิจกรรม

ฉันใช้วิธีการเดียวกับการบันทึกและดึงข้อมูลสตริง แต่ที่นี่ด้วย arrayList ฉันใช้ HashSet เป็นสื่อกลาง

ในการบันทึก arrayList ไปยัง SharedPreferences เราใช้ HashSet:

1- เราสร้างตัวแปร SharedPreferences (ในตำแหน่งที่การเปลี่ยนแปลงเกิดขึ้นกับอาร์เรย์)

2 - เราแปลง arrayList เป็น HashSet

3 - จากนั้นเราใส่ stringSet และนำไปใช้

4 - คุณ getStringSet ภายใน 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());
    }
}

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

คำตอบทั้งหมดข้างต้นถูกต้อง :) ฉันใช้สิ่งเหล่านี้กับสถานการณ์ของฉัน อย่างไรก็ตามเมื่อฉันอ่านคำถามฉันพบว่า 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 สามารถเข้าถึงได้จากทุกที่ภายในแอปพลิเคชัน และส่วนที่ดีที่สุดคือเมื่อปิดแอพเราไม่ต้องกังวลกับข้อมูลที่จัดเก็บ :)