Ist es möglich, ein Array oder ein Objekt zu SharedPreferences auf Android hinzufügen
-
28-09-2019 - |
Frage
Ich habe eine ArrayList
von Objekten, die einen Namen und ein Symbol Zeiger haben und ich möchte es in SharedPreferences
speichern. Wie kann ich tun?
Hinweis: Ich will nicht Datenbank verwenden
Lösung
So aus der Android-Entwicklerwebsite auf Data Storage :
Benutzereinstellungen
Gemeinsame Einstellungen sind nicht streng für „Benutzereinstellungen“ Speichern wie, was ein Benutzer Klingelton hat sich dafür entschieden. Wenn Sie bei der Erstellung Benutzereinstellungen für Ihre Anwendung interessiert sind, sehen PreferenceActivity, die eine Aktivität Framework bietet Ihnen Benutzereinstellungen zu erstellen, die automatisch beibehalten werden (gemeinsam Präferenzen verwendet wird).
Also ich denke, es ist in Ordnung, da es einfach nur Schlüssel-Wert-Paare, die beibehalten werden.
Zum Originalplakat, das ist nicht so schwer. Sie einfach nur durch Ihre Array-Liste durchlaufen und die Elemente hinzuzufügen. In diesem Beispiel verwende ich eine Karte der Einfachheit halber aber Sie können eine Array-Liste verwenden und sie entsprechend ändern:
// my list of names, icon locations
Map<String, String> nameIcons = new HashMap<String, String>();
nameIcons.put("Noel", "/location/to/noel/icon.png");
nameIcons.put("Bob", "another/location/to/bob/icon.png");
nameIcons.put("another name", "last/location/icon.png");
SharedPreferences keyValues = getContext().getSharedPreferences("name_icons_list", Context.MODE_PRIVATE);
SharedPreferences.Editor keyValuesEditor = keyValues.edit();
for (String s : nameIcons.keySet()) {
// use the name as the key, and the icon as the value
keyValuesEditor.putString(s, nameIcons.get(s));
}
keyValuesEditor.commit()
Sie würden etwas Ähnliches wieder die Schlüssel-Wert-Paare zu lesen. Lassen Sie mich wissen, ob das funktioniert.
Update: Wenn Sie mit API-Level 11 oder höher, gibt es eine Methode einen String Set
Andere Tipps
Unabhängig von der API-Ebene, überprüfen String-Arrays und Object-Arrays in SharedPreferences
Speichern ARRAY
public boolean saveArray(String[] array, String arrayName, Context mContext) {
SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);
SharedPreferences.Editor editor = prefs.edit();
editor.putInt(arrayName +"_size", array.length);
for(int i=0;i<array.length;i++)
editor.putString(arrayName + "_" + i, array[i]);
return editor.commit();
}
LOAD ARRAY
public String[] loadArray(String arrayName, Context mContext) {
SharedPreferences prefs = mContext.getSharedPreferences("preferencename", 0);
int size = prefs.getInt(arrayName + "_size", 0);
String array[] = new String[size];
for(int i=0;i<size;i++)
array[i] = prefs.getString(arrayName + "_" + i, null);
return array;
}
zu schreiben,
SharedPreferences prefs = PreferenceManager
.getDefaultSharedPreferences(this);
JSONArray jsonArray = new JSONArray();
jsonArray.put(1);
jsonArray.put(2);
Editor editor = prefs.edit();
editor.putString("key", jsonArray.toString());
System.out.println(jsonArray.toString());
editor.commit();
zu lesen,
try {
JSONArray jsonArray2 = new JSONArray(prefs.getString("key", "[]"));
for (int i = 0; i < jsonArray2.length(); i++) {
Log.d("your JSON Array", jsonArray2.getInt(i)+"");
}
} catch (Exception e) {
e.printStackTrace();
}
Gemeinsame Präferenzen eingeführt, um eine getStringSet
und putStringSet
Methoden in API Ebene 11, aber das ist nicht kompatibel mit älteren Versionen von Android (die nach wie vor beliebt sind), und auch auf Sätze von Saiten beschränkt ist.
Android bietet keine besseren Methoden und Schleifen über Karten und Arrays zum Speichern und Laden sie nicht sehr einfach und sauber ist, speziell für Arrays. Aber eine bessere Umsetzung ist nicht so schwer:
package com.example.utils;
import org.json.JSONObject;
import org.json.JSONArray;
import org.json.JSONException;
import android.content.Context;
import android.content.SharedPreferences;
public class JSONSharedPreferences {
private static final String PREFIX = "json";
public static void saveJSONObject(Context c, String prefName, String key, JSONObject object) {
SharedPreferences settings = c.getSharedPreferences(prefName, 0);
SharedPreferences.Editor editor = settings.edit();
editor.putString(JSONSharedPreferences.PREFIX+key, object.toString());
editor.commit();
}
public static void saveJSONArray(Context c, String prefName, String key, JSONArray array) {
SharedPreferences settings = c.getSharedPreferences(prefName, 0);
SharedPreferences.Editor editor = settings.edit();
editor.putString(JSONSharedPreferences.PREFIX+key, array.toString());
editor.commit();
}
public static JSONObject loadJSONObject(Context c, String prefName, String key) throws JSONException {
SharedPreferences settings = c.getSharedPreferences(prefName, 0);
return new JSONObject(settings.getString(JSONSharedPreferences.PREFIX+key, "{}"));
}
public static JSONArray loadJSONArray(Context c, String prefName, String key) throws JSONException {
SharedPreferences settings = c.getSharedPreferences(prefName, 0);
return new JSONArray(settings.getString(JSONSharedPreferences.PREFIX+key, "[]"));
}
public static void remove(Context c, String prefName, String key) {
SharedPreferences settings = c.getSharedPreferences(prefName, 0);
if (settings.contains(JSONSharedPreferences.PREFIX+key)) {
SharedPreferences.Editor editor = settings.edit();
editor.remove(JSONSharedPreferences.PREFIX+key);
editor.commit();
}
}
}
Jetzt können Sie jede Sammlung in gemeinsamen Präferenzen mit diesen fünf Methoden speichern. Arbeiten mit JSONObject
und JSONArray
ist sehr einfach. Sie können JSONArray (Collection copyFrom)
öffentlichen Konstruktor, um eine JSONArray
aus jeder Java-Sammlung und Verwendung JSONArray
der get
Methoden verwenden, um die Elemente zuzugreifen.
Es gibt keine Größenbeschränkung für die gemeinsame Präferenzen (außer Gerätespeichergrenzen), so dass diese Methoden für die meisten üblichen Fällen arbeiten können, wo Sie eine schnelle und einfache Lagerung für einige Sammlung in Ihrer App möchten. Aber JSON Parsen geschehen hier, und Vorlieben in Android als XMLs intern gespeichert, so dass ich mit anderen persistenten Datenspeichermechanismen empfehlen, wenn man es zu tun mit Megabyte an Daten.
Easy-Modus für komplexe Objektspeicher mit Gson Google-Bibliothek [1]
public static void setComplexObject(Context ctx, ComplexObject obj){
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("COMPLEX_OBJECT",new Gson().toJson(obj));
editor.commit();
}
public static ComplexObject getComplexObject (Context ctx){
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(ctx);
String sobj = preferences.getString("COMPLEX_OBJECT", "");
if(sobj.equals(""))return null;
else return new Gson().fromJson(sobj, ComplexObject.class);
}
lud ich eine Reihe von Taillengrößen (bereits in meinem array.xml erstellt) in meine preferences.xml Datei mit dem folgenden Code. @ Array / pant_inch_size ist die ID des gesamten Arrays.
<ListPreference
android:title="choosepantsize"
android:summary="Choose Pant Size"
android:key="pantSizePref"
android:defaultValue="34"
android:entries="@array/pant_inch_size"
android:entryValues="@array/pant_inch_size" />
Dieses Menü mit Auswahl aus dem Array gefüllt. Ich habe die Standardgröße als 34, so dass, wenn das Menü erscheint, sie sehen Größe 34 vorselektiert.
Der einfache Weg ist, zu wandeln es in JSON String wie unten Beispiel:
Gson gson = new Gson();
String json = gson.toJson(myObj);
speichern Sie dann die Zeichenfolge in den gemeinsam genutzten Einstellungen. Sobald Sie es brauchen nur Zeichenfolge aus dem gemeinsamen Präferenzen erhalten und konvertieren zurück zu JSONArray oder JSONObject (wie pro Ihre Anforderung.)
Zum Schreiben:
private <T> void storeData(String key, T data) {
ByteArrayOutputStream serializedData = new ByteArrayOutputStream();
try {
ObjectOutputStream serializer = new ObjectOutputStream(serializedData);
serializer.writeObject(data);
} catch (IOException e) {
e.printStackTrace();
}
SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
SharedPreferences.Editor edit = sharedPreferences.edit();
edit.putString(key, Base64.encodeToString(serializedData.toByteArray(), Base64.DEFAULT));
edit.commit();
}
Zum Lesen:
private <T> T getStoredData(String key) {
SharedPreferences sharedPreferences = getSharedPreferences(TAG, 0);
String serializedData = sharedPreferences.getString(key, null);
T storedData = null;
try {
ByteArrayInputStream input = new ByteArrayInputStream(Base64.decode(serializedData, Base64.DEFAULT));
ObjectInputStream inputStream = new ObjectInputStream(input);
storedData = (T)inputStream.readObject();
} catch (IOException|ClassNotFoundException|java.lang.IllegalArgumentException e) {
e.printStackTrace();
}
return storedData;
}
Dies ist der gemeinsame Präferenzen Code i erfolgreich zu verwenden, finden Sie diesen Link
public class MainActivity extends Activity {
private static final int RESULT_SETTINGS = 1;
Button button;
public String a="dd";
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
button = (Button) findViewById(R.id.btnoptions);
setContentView(R.layout.activity_main);
// showUserSettings();
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.settings, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch (item.getItemId()) {
case R.id.menu_settings:
Intent i = new Intent(this, UserSettingActivity.class);
startActivityForResult(i, RESULT_SETTINGS);
break;
}
return true;
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
switch (requestCode) {
case RESULT_SETTINGS:
showUserSettings();
break;
}
}
private void showUserSettings() {
SharedPreferences sharedPrefs = PreferenceManager
.getDefaultSharedPreferences(this);
StringBuilder builder = new StringBuilder();
builder.append("\n Pet: "
+ sharedPrefs.getString("prefpetname", "NULL"));
builder.append("\n Address:"
+ sharedPrefs.getString("prefaddress","NULL" ));
builder.append("\n Your name: "
+ sharedPrefs.getString("prefname", "NULL"));
TextView settingsTextView = (TextView) findViewById(R.id.textUserSettings);
settingsTextView.setText(builder.toString());
}
}
HAPPY CODING!
Sie können verwenden putStringSet
Dies ermöglicht es Ihnen, eine HashSet in Ihre Einstellungen zu speichern, wie folgt aus:
Speichern
Set<String> values;
SharedPreferences sharedPref =
mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);
Editor editor = sharedPref.edit();
editor.putStringSet("YOUR_KEY", values);
editor.apply();
retrive
SharedPreferences sharedPref =
mContext.getSharedPreferences(PREF_KEY, Context.MODE_PRIVATE);
Editor editor = sharedPref.edit();
Set<String> newList = editor.getStringSet("YOUR_KEY", null);
Die putStringSet erlauben nur ein Set und das ist eine ungeordnete Liste.