공유 기본 설정에 어레이 목록 저장
나는 있습니다.ArrayList사용자 지정 개체를 사용합니다.각 사용자 지정 개체에는 다양한 문자열과 숫자가 포함됩니다.사용자가 활동을 종료한 후 나중에 다시 오고 싶어도 어레이를 유지해야 하지만 애플리케이션이 완전히 닫힌 후 어레이를 사용할 수 있어야 합니다.이러한 방식으로 다른 많은 개체를 저장합니다.SharedPreferences이런 식으로 배열 전체를 저장하는 방법을 모르겠어요이것이 가능합니까?아마도요.SharedPreferences방법은 이것에 관한 것이 아닙니까?더 간단한 방법이 있습니까?
11 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공유 기본 설정에서 해당 정보를 읽습니다.
API는 SharedPreferences(API 11 이후에는 단순)에 대한 문자열 저장 및 검색만 지원하기 때문에 작업 목록이 있는 ArrayList 개체를 문자열로 직렬화하고 직렬화 해제해야 합니다.
addTask() 설정의 TaskManagerApplication을 .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();
}
}
다음 정보를 얻을 수 있습니다.ObjectSerializerApache Pig 프로젝트 ObjectSerializer.java의 클래스입니다.
이 개체 --> TinyDB--Android-Shared-Preferences-Turbo를 사용하는 것은 매우 간단합니다.
TinyDB tinydb = new TinyDB(context);
말하자면
tinydb.putList("MyUsers", mUsersArray);
갖기 위해
tinydb.getList("MyUsers");
갱신하다
몇 가지 유용한 예와 문제 해결 방법은 여기에서 찾을 수 있습니다: Android Shared Preference TinyDB putListObject 함수
중 »ArraySharedPreferences:
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));
}
}
@nirav가 말했듯이, 가장 좋은 해결책은 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>(data);
String jsonText = gson.toJson(textList);
prefsEditor.putString("key", jsonText);
prefsEditor.apply();
다음으로 변환할 수 있습니다.JSON String을 그리고 그 저 끈 합 니 다장 을▁the 다▁and ▁the ▁storeSharedPreferences.
/**
* 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);
}
코틀린
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)
}
아, 나는 를 사용하지 도 해결할 수 .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.을 사용하여 공유 합니다.다음을 사용하여 공유 환경설정에 값 저장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. 4를 사용하여 합니다. 다음을 사용하여 공유 선호도의 가치 검색retriveSharedValue():
private void retriveSharedValue() {
Set<String> set = shared.getStringSet("DATE_LIST", null);
arrPackage.addAll(set);
Log.d("retrivesharedPreferences",""+set);
}
당신에게 도움이 되길 바랍니다...
Android Shared Preferences를 사용하면 기본 유형(API11 이후 사용 가능한 Boolean, Float, Int, Long, String 및 StringSet)을 xml 파일로 메모리에 저장할 수 있습니다.
솔루션의 핵심 아이디어는 데이터를 그러한 원시적인 유형 중 하나로 변환하는 것입니다.
개인적으로 내 목록을 json 형식으로 변환한 다음 공유 기본 설정 값의 문자열로 저장하는 것을 좋아합니다.
내 솔루션을 사용하려면 Google Gson lib를 추가해야 합니다.
다음 종속성만 추가하면 됩니다(구글의 최신 버전을 사용하십시오).
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);
}
배열 목록을 문자열로 변환하여 기본 설정으로 저장할 수도 있습니다.
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;
}
한 후 할 수 .convertToString메소드를 합니다.convertToArray
API 11 이후에는 세트를 공유 환경설정에 직접 저장할 수 있습니다!!! :)
String, int, boolean의 경우 sharedPreferences가 가장 좋습니다.
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
또한 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() })
}
Gson 라이브러리를 사용하여 String 및 사용자 정의 배열 목록을 저장할 수 있습니다.
=>먼저 배열 목록을 Shared Preferences에 저장하는 기능을 만들어야 합니다.
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 !!!
}
=> Shared Preferences에서 배열 목록을 가져오려면 함수를 만들어야 합니다.
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());
=> 앱 레벨 build.gradle에 gson 라이브러리를 추가하는 것을 잊지 마십시오.
구현 'com.google.code.gson:gson:2.8.2'
GSON을 사용하여 JSON 문자열로 변환하고 이 문자열을 Shared Preference에 저장하는 것이 가장 좋습니다.또한 이 방법을 사용하여 응답을 캐시합니다.
위의 모든 답변을 읽었습니다.그것은 모두 옳지만 아래와 같이 더 쉬운 해결책을 찾았습니다.
공유 환경설정에서 문자열 목록 저장 >>
public static void setSharedPreferenceStringList(Context pContext, String pKey, List<String> pData) { SharedPreferences.Editor editor = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit(); editor.putInt(pKey + "size", pData.size()); editor.commit(); for (int i = 0; i < pData.size(); i++) { SharedPreferences.Editor editor1 = pContext.getSharedPreferences(Constants.APP_PREFS, Activity.MODE_PRIVATE).edit(); editor1.putString(pKey + i, (pData.get(i))); editor1.commit(); }}
공유 환경설정에서 문자열 목록 가져오기 >>
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 및 GSON 사용:
fun <T> SharedPreferences.writeList(gson: Gson, key: String, data: List<T>) {
val json = gson.toJson(data)
edit { putString(key, json) }
}
inline fun <reified T> SharedPreferences.readList(gson: Gson, key: String): List<T> {
val json = getString(key, "[]") ?: "[]"
val type = object : TypeToken<List<T>>() {}.type
return try {
gson.fromJson(json, type)
} catch(e: JsonSyntaxException) {
emptyList()
}
}
Facebook에서 serializeKey() 및 deserializeKey() 함수를 참조할 수 있습니다.SDK의 공유 기본 설정TokenCache 클래스입니다.지원되는 데이터를 변환합니다.JSON 개체를 입력하고 JSON 문자열을 Shared Preferences에 저장합니다.여기에서 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);
}
}
목록 저장을 위한 내 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);
.
활동 코드의 예제를 사용하여 // 내 유틸리티의 전체 코드 확인
어레이 목록을 애플리케이션 클래스에 추가하는 것은 어떻습니까?그것은 앱이 실제로 종료되었을 때만 파괴되므로, 앱이 사용 가능한 한 계속 유지됩니다.
제가 찾은 가장 좋은 방법은 키의 2D 배열을 만들고 배열의 사용자 지정 항목을 키의 2D 배열에 넣은 다음 시작 시 2D 배열을 통해 검색하는 것입니다.저는 대부분의 안드로이드 사용자들이 아직 진저브레드를 사용하고 있고 문자열 세트를 사용하려면 벌집이 필요하기 때문에 문자열 세트를 사용하는 것이 마음에 들지 않았습니다.
샘플 코드: 여기서 편집기는 공유 사전 편집기이고 행 항목은 사용자 지정 개체입니다.
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' 앞에 가는 내용에 대한 추가 지침을 보여줍니다.(고맙습니다 사악한 자)
// 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");
직렬화 또는 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;
다음 사용자 지정 클래스 사용:
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 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;
}
문자열을 저장하고 검색하는 방법과 동일한 방법을 사용했지만 여기서는 arrayList를 사용하여 HashSet을 중재자로 사용했습니다.
ArrayList를 공유 기본 설정에 저장하려면 HashSet:
1 - Shared Preferences 변수를 만듭니다(어레이가 변경되는 위치).
2 - arrayList를 HashSet으로 변환합니다.
3 - 그런 다음 StringSet을 넣고 적용합니다.
4 - HashSet 내에서 StringSet을 가져오고 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());
}
}
수있다니습으로 할 수 .Map "ArrayList"를 합니다. 그런 다음 검색할 때 값을 ArrayList로 다시 변경합니다.SharedPreferences.
Serializable을(를) 구현하는 것을 잊지 마십시오.
Class dataBean implements Serializable{
public String name;
}
ArrayList<dataBean> dataBeanArrayList = new ArrayList();
https://stackoverflow.com/a/7635154/4639974
이것은 작동할 것입니다.
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;
}
저한테는 효과가 있어요.
누군가가 목록 목록을 저장해야 하는 경우, 즉 목록<목록<문자열>. 이렇게 했습니다.
연재하기
Gson gson = new Gson();
// Save the size of the array
sharedPreferencesEditor.putInt("ArraySize", myArray.size());
for (int i=0; i<myArray.size(); i++) {
String key = "Array"+i;
String json = gson.toJson(myArray.get(i));
sharedPreferencesEditor.putString(key, json);
}
sharedPreferencesEditor.commit();
역직렬화 방법
// Get the size of the array to be deserialized. In my case, the default number should be 3
int arraySize = sharedPreferences.getInt("ArraySize",3);
myArray = new ArrayList<List<String>>();
for (int i=0; i<arraySize; i++) {
String key = "Array"+i;
String json = sharedPreferences.getString(key, null);
List<String> arrayTemp= gson.fromJson(json, List.class);
myArray.add(arrayTemp);
}
// My array may also include components with empty strings.
// Gson makes them null values and it is not possible
// to deserialize them as empty strings.
// The following takes care of that:
for (int i=0; i<myArray.size();i++) {
if (myArray.get(i) == null) {
List<String> emptyComponent = new ArrayList<String>() {
{ add(""); }
};
myArray.set(i,emptyComponent);
}
}
언급URL : https://stackoverflow.com/questions/7057845/save-arraylist-to-sharedpreferences
'programing' 카테고리의 다른 글
| Gitflow 릴리스 분기 및 태그 - "v" 접두사 사용 여부와 상관없이 (0) | 2023.08.22 |
|---|---|
| 최대 높이의 자식: 100%가 상위 항목으로 넘칩니다. (0) | 2023.08.22 |
| 서버 이벤트 시 서버에서 클라이언트로 알림 전송 (0) | 2023.08.17 |
| okhttp3 mockserver java.dll.NoClassDefFoundError: okhttp3/내부/동시/TaskRunner$RealBackend (0) | 2023.08.17 |
| PHP Symfony 4에서 POST 글로벌 변수를 가져오는 방법은 무엇입니까? (0) | 2023.08.17 |