Android
Gemeinsame Einstellungen
Suche…
Einführung
SharedPreferences bieten eine Möglichkeit, Daten in Form von Schlüsselwertpaaren auf der Festplatte zu speichern.
Syntax
Kontextmethode
- public SharedPreferences getSharedPreferences (Stringname, int-Modus)
Aktivitätsmethode
- public SharedPreferences getPreferences ()
SharedPreferences-Methoden
- public SharedPreferences.Editor edit ()
- public boolean enthält ()
- public Map <String,?> getAll ()
- public boolean getBoolean (String-Schlüssel, boolean defValue)
- public float getFloat (String-Schlüssel, float defValue)
- public int getInt (String-Schlüssel, int defValue)
- public long getLong (String key, long defValue)
- public String getString (String-Schlüssel, String defValue)
- public Set getStringSet (String-Schlüssel, DefValues setzen)
- public void registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener-Listener)
- public void unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener-Listener)
SharedPreferences.Editor-Methoden
- öffentlich ungültig gelten ()
- Öffentliches boolesches Commit ()
- public SharedPreferences.Editor clear ()
- public SharedPreferences.Editor putBoolean (String-Schlüssel, boolescher Wert)
- public SharedPreferences.Editor putFloat (String-Schlüssel, Gleitkommawert)
- public SharedPreferences.Editor putInt (String-Schlüssel, int-Wert)
- public SharedPreferences.Editor putLong (String-Schlüssel, langer Wert)
- public SharedPreferences.Editor putString (String-Schlüssel, String-Wert)
- public SharedPreferences.Editor putStringSet (String-Schlüssel, Werte setzen)
- public SharedPreferences.Editor remove (String-Schlüssel)
Parameter
Parameter | Einzelheiten |
---|---|
Schlüssel | Eine nicht leere String , die den Parameter identifiziert. Es kann Leerzeichen oder nicht druckbare Dateien enthalten. Dies wird nur in Ihrer App (und in der XML-Datei) verwendet und muss daher nicht mit einem Namensbereich versehen werden. Es ist jedoch eine gute Idee, es als Konstante im Quellcode zu haben. Lokalisieren Sie es nicht. |
defValue | Alle get-Funktionen erhalten einen Standardwert, der zurückgegeben wird, wenn der angegebene Schlüssel nicht in den SharedPreferences . Es wird nicht zurückgegeben, wenn der Schlüssel vorhanden ist, aber der Wert hat den falschen Typ: In diesem Fall erhalten Sie eine ClassCastException . |
Bemerkungen
SharedPreferences
sollten nicht zum Speichern großer Datenmengen verwendet werden. Für solche Zwecke ist es viel besser,SQLiteDatabase
zu verwenden.SharedPreferences
sind nur ein Prozess, es sei denn, Sie verwenden den veralteten ModusMODE_MULTI_PROCESS
. Wenn Ihre App also über mehrere Prozesse verfügt, können Sie dieSharedPreferences
desSharedPreferences
in einem anderen Prozess lesen. In solchen Fällen sollten Sie einen anderen Mechanismus zumMODE_MULTI_PROCESS
Daten zwischen Prozessen verwenden,MODE_MULTI_PROCESS
jedoch nicht verwenden, da dies nicht zuverlässig und nicht mehr veraltet ist.Es ist besser , verwenden
SharedPreferences
Instanz inSingleton
Klasse überall auf die Anwendung zugreifencontext
. Wenn Sie es nur für bestimmte Aktivitäten verwenden möchten, gehen Sie zugetPreferences()
.Speichern Sie vertrauliche Informationen bei der Verwendung von
SharedPreferences
im Klartext, da sie leicht lesbar sind.
Offizielle Dokumentation
https://developer.android.com/reference/android/content/SharedPreferences.html
Lesen und Schreiben von Werten in SharedPreferences
public class MyActivity extends Activity {
private static final String PREFS_FILE = "NameOfYourPrefrenceFile";
// PREFS_MODE defines which apps can access the file
private static final int PREFS_MODE = Context.MODE_PRIVATE;
// you can use live template "key" for quickly creating keys
private static final String KEY_BOOLEAN = "KEY_FOR_YOUR_BOOLEAN";
private static final String KEY_STRING = "KEY_FOR_YOUR_STRING";
private static final String KEY_FLOAT = "KEY_FOR_YOUR_FLOAT";
private static final String KEY_INT = "KEY_FOR_YOUR_INT";
private static final String KEY_LONG = "KEY_FOR_YOUR_LONG";
@Override
protected void onStart() {
super.onStart();
// Get the saved flag (or default value if it hasn't been saved yet)
SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
// read a boolean value (default false)
boolean booleanVal = settings.getBoolean(KEY_BOOLEAN, false);
// read an int value (Default 0)
int intVal = settings.getInt(KEY_INT, 0);
// read a string value (default "my string")
String str = settings.getString(KEY_STRING, "my string");
// read a long value (default 123456)
long longVal = settings.getLong(KEY_LONG, 123456);
// read a float value (default 3.14f)
float floatVal = settings.getFloat(KEY_FLOAT, 3.14f);
}
@Override
protected void onStop() {
super.onStop();
// Save the flag
SharedPreferences settings = getSharedPreferences(PREFS_FILE, PREFS_MODE);
SharedPreferences.Editor editor = settings.edit();
// write a boolean value
editor.putBoolean(KEY_BOOLEAN, true);
// write an integer value
editor.putInt(KEY_INT, 123);
// write a string
editor.putString(KEY_STRING, "string value");
// write a long value
editor.putLong(KEY_LONG, 456876451);
// write a float value
editor.putFloat(KEY_FLOAT, 1.51f);
editor.apply();
}
}
getSharedPreferences()
ist eine Methode aus der Context
Klasse, die Activity
erweitert. Wenn Sie die zugreifen müssen getSharedPreferences()
Methode aus anderen Klassen, können Sie context.getSharedPreferences()
mit einem Context
Objektverweis von einer Activity
, View
oder Application
.
Schlüssel entfernen
private static final String MY_PREF = "MyPref";
// ...
SharedPreferences prefs = ...;
// ...
SharedPreferences.Editor editor = prefs.edit();
editor.putString(MY_PREF, "value");
editor.remove(MY_PREF);
editor.apply();
Nach dem apply()
enthält prefs
zusätzlich zu dem bereits enthaltenen prefs
"key" -> "value". Obwohl es so aussieht, als hätte ich "Schlüssel" hinzugefügt und dann entfernt, geschieht das Entfernen tatsächlich zuerst. Die Änderungen im Editor
werden alle auf einmal angewendet, nicht in der Reihenfolge, in der Sie sie hinzugefügt haben. Alle Entfernungen passieren vor allen Puts.
Einstellungsbildschirm mit SharedPreferences implementieren
SharedPreferences
zum SharedPreferences
eines Bildschirms "Einstellungen" in Ihrer App verwenden, in dem der Benutzer seine Einstellungen / Optionen festlegen kann. So was:
Ein PreferenceScreen speichert Benutzervorgaben in SharedPreferences
. Um einen PreferenceScreen zu erstellen, benötigen Sie einige Dinge:
Eine XML-Datei zum Definieren der verfügbaren Optionen:
Dies gilt für /res/xml/preferences.xml
. Für den obigen Einstellungsbildschirm sieht das so aus:
<PreferenceScreen
xmlns:android="http://schemas.android.com/apk/res/android">
<PreferenceCategory
android:title="General options">
<CheckBoxPreference
android:key = "silent_mode"
android:defaultValue="false"
android:title="Silent Mode"
android:summary="Mute all sounds from this app" />
<SwitchPreference
android:key="awesome_mode"
android:defaultValue="false"
android:switchTextOn="Yes"
android:switchTextOff="No"
android:title="Awesome mode™"
android:summary="Enable the Awesome Mode™ feature"/>
<EditTextPreference
android:key="custom_storage"
android:defaultValue="/sdcard/data/"
android:title="Custom storage location"
android:summary="Enter the directory path where you want data to be saved. If it does not exist, it will be created."
android:dialogTitle="Enter directory path (eg. /sdcard/data/ )"/>
</PreferenceCategory>
</PreferenceScreen>
Dies definiert die verfügbaren Optionen im Einstellungsbildschirm. Es gibt viele andere Preference
die in der Android Developers-Dokumentation in der Präferenzklasse aufgeführt sind .
Als Nächstes benötigen wir eine Aktivität zum Hosten unserer Benutzerschnittstelle für Einstellungen . In diesem Fall ist es ziemlich kurz und sieht so aus:
package com.example.preferences;
import android.preference.PreferenceActivity;
import android.os.Bundle;
public class PreferencesActivity extends PreferenceActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.preferences);
}
}
Es erweitert PreferenceActivity
und stellt die Benutzeroberfläche für den PreferenceActivity
bereit. Es kann wie eine normale Aktivität gestartet werden, in diesem Fall mit:
Intent i = new Intent(this, PreferencesActivity.class);
startActivity(i);
Vergessen Sie nicht, PreferencesActivity
zu Ihrer AndroidManifest.xml
.
Die Werte der Voreinstellungen in Ihrer App zu erhalten, ist ziemlich einfach. Rufen Sie zunächst setDefaultValues()
, um die in Ihrer XML definierten Standardwerte festzulegen, und SharedPreferences
dann die Standard- SharedPreferences
. Ein Beispiel:
//set the default values we defined in the XML
PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
//get the values of the settings options
boolean silentMode = preferences.getBoolean("silent_mode", false);
boolean awesomeMode = preferences.getBoolean("awesome_mode", false);
String customStorage = preferences.getString("custom_storage", "");
Rufen Sie alle gespeicherten Einträge aus einer bestimmten SharedPreferences-Datei ab
Die getAll()
-Methode ruft alle Werte aus den Voreinstellungen ab. Wir können damit beispielsweise den aktuellen Inhalt der SharedPreferences
:
private static final String PREFS_FILE = "MyPrefs";
public static void logSharedPreferences(final Context context) {
SharedPreferences sharedPreferences = context.getSharedPreferences(PREFS_FILE, Context.MODE_PRIVATE);
Map<String, ?> allEntries = sharedPreferences.getAll();
for (Map.Entry<String, ?> entry : allEntries.entrySet()) {
final String key = entry.getKey();
final Object value = entry.getValue();
Log.d("map values", key + ": " + value);
}
}
Die Dokumentation warnt Sie vor der Modifizierung Collection
von zurück getAll
:
Beachten Sie, dass Sie die von dieser Methode zurückgegebene Auflistung nicht ändern oder deren Inhalt ändern dürfen. Die Konsistenz Ihrer gespeicherten Daten wird in diesem Fall nicht garantiert.
Auf Änderungen von SharedPreferences warten
SharedPreferences sharedPreferences = ...;
sharedPreferences.registerOnSharedPreferenceChangeListener(mOnSharedPreferenceChangeListener);
private final SharedPreferences.OnSharedPreferenceChangeListener mOnSharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
@Override
public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
//TODO
}
}
Bitte beachten Sie:
- Der Listener wird nur ausgelöst, wenn ein Wert hinzugefügt oder geändert wurde. Wenn Sie denselben Wert festlegen, wird er nicht aufgerufen.
- Der Listener muss in einer Membervariablen und NICHT mit einer anonymen Klasse
registerOnSharedPreferenceChangeListener
werden, da sie vonregisterOnSharedPreferenceChangeListener
mit einem schwachen VerweisregisterOnSharedPreferenceChangeListener
. - Anstatt eine Member-Variable zu verwenden, kann sie auch direkt von der Klasse implementiert werden und dann
registerOnSharedPreferenceChangeListener(this);
aufrufenregisterOnSharedPreferenceChangeListener(this);
- Denken Sie daran, den Listener aufzuheben, wenn er nicht mehr mit
unregisterOnSharedPreferenceChangeListener
benötigt wird.
Lesen und Schreiben von Daten in SharedPreferences mit Singleton
SharedPreferences Manager (Singleton) -Klasse zum Lesen und Schreiben aller Arten von Daten.
import android.content.Context;
import android.content.SharedPreferences;
import android.util.Log;
import com.google.gson.Gson;
import java.lang.reflect.Type;
/**
* Singleton Class for accessing SharedPreferences,
* should be initialized once in the beginning by any application component using static
* method initialize(applicationContext)
*/
public class SharedPrefsManager {
private static final String TAG = SharedPrefsManager.class.getName();
private SharedPreferences prefs;
private static SharedPrefsManager uniqueInstance;
public static final String PREF_NAME = "com.example.app";
private SharedPrefsManager(Context appContext) {
prefs = appContext.getSharedPreferences(PREF_NAME, Context.MODE_PRIVATE);
}
/**
* Throws IllegalStateException if this class is not initialized
*
* @return unique SharedPrefsManager instance
*/
public static SharedPrefsManager getInstance() {
if (uniqueInstance == null) {
throw new IllegalStateException(
"SharedPrefsManager is not initialized, call initialize(applicationContext) " +
"static method first");
}
return uniqueInstance;
}
/**
* Initialize this class using application Context,
* should be called once in the beginning by any application Component
*
* @param appContext application context
*/
public static void initialize(Context appContext) {
if (appContext == null) {
throw new NullPointerException("Provided application context is null");
}
if (uniqueInstance == null) {
synchronized (SharedPrefsManager.class) {
if (uniqueInstance == null) {
uniqueInstance = new SharedPrefsManager(appContext);
}
}
}
}
private SharedPreferences getPrefs() {
return prefs;
}
/**
* Clears all data in SharedPreferences
*/
public void clearPrefs() {
SharedPreferences.Editor editor = getPrefs().edit();
editor.clear();
editor.commit();
}
public void removeKey(String key) {
getPrefs().edit().remove(key).commit();
}
public boolean containsKey(String key) {
return getPrefs().contains(key);
}
public String getString(String key, String defValue) {
return getPrefs().getString(key, defValue);
}
public String getString(String key) {
return getString(key, null);
}
public void setString(String key, String value) {
SharedPreferences.Editor editor = getPrefs().edit();
editor.putString(key, value);
editor.apply();
}
public int getInt(String key, int defValue) {
return getPrefs().getInt(key, defValue);
}
public int getInt(String key) {
return getInt(key, 0);
}
public void setInt(String key, int value) {
SharedPreferences.Editor editor = getPrefs().edit();
editor.putInt(key, value);
editor.apply();
}
public long getLong(String key, long defValue) {
return getPrefs().getLong(key, defValue);
}
public long getLong(String key) {
return getLong(key, 0L);
}
public void setLong(String key, long value) {
SharedPreferences.Editor editor = getPrefs().edit();
editor.putLong(key, value);
editor.apply();
}
public boolean getBoolean(String key, boolean defValue) {
return getPrefs().getBoolean(key, defValue);
}
public boolean getBoolean(String key) {
return getBoolean(key, false);
}
public void setBoolean(String key, boolean value) {
SharedPreferences.Editor editor = getPrefs().edit();
editor.putBoolean(key, value);
editor.apply();
}
public boolean getFloat(String key) {
return getFloat(key, 0f);
}
public boolean getFloat(String key, float defValue) {
return getFloat(key, defValue);
}
public void setFloat(String key, Float value) {
SharedPreferences.Editor editor = getPrefs().edit();
editor.putFloat(key, value);
editor.apply();
}
/**
* Persists an Object in prefs at the specified key, class of given Object must implement Model
* interface
*
* @param key String
* @param modelObject Object to persist
* @param <M> Generic for Object
*/
public <M extends Model> void setObject(String key, M modelObject) {
String value = createJSONStringFromObject(modelObject);
SharedPreferences.Editor editor = getPrefs().edit();
editor.putString(key, value);
editor.apply();
}
/**
* Fetches the previously stored Object of given Class from prefs
*
* @param key String
* @param classOfModelObject Class of persisted Object
* @param <M> Generic for Object
* @return Object of given class
*/
public <M extends Model> M getObject(String key, Class<M> classOfModelObject) {
String jsonData = getPrefs().getString(key, null);
if (null != jsonData) {
try {
Gson gson = new Gson();
M customObject = gson.fromJson(jsonData, classOfModelObject);
return customObject;
} catch (ClassCastException cce) {
Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
classOfModelObject.getName() + "\n" + cce.getMessage());
}
}
return null;
}
/**
* Persists a Collection object in prefs at the specified key
*
* @param key String
* @param dataCollection Collection Object
* @param <C> Generic for Collection object
*/
public <C> void setCollection(String key, C dataCollection) {
SharedPreferences.Editor editor = getPrefs().edit();
String value = createJSONStringFromObject(dataCollection);
editor.putString(key, value);
editor.apply();
}
/**
* Fetches the previously stored Collection Object of given type from prefs
*
* @param key String
* @param typeOfC Type of Collection Object
* @param <C> Generic for Collection Object
* @return Collection Object which can be casted
*/
public <C> C getCollection(String key, Type typeOfC) {
String jsonData = getPrefs().getString(key, null);
if (null != jsonData) {
try {
Gson gson = new Gson();
C arrFromPrefs = gson.fromJson(jsonData, typeOfC);
return arrFromPrefs;
} catch (ClassCastException cce) {
Log.d(TAG, "Cannot convert string obtained from prefs into collection of type " +
typeOfC.toString() + "\n" + cce.getMessage());
}
}
return null;
}
public void registerPrefsListener(SharedPreferences.OnSharedPreferenceChangeListener listener) {
getPrefs().registerOnSharedPreferenceChangeListener(listener);
}
public void unregisterPrefsListener(
SharedPreferences.OnSharedPreferenceChangeListener listener) {
getPrefs().unregisterOnSharedPreferenceChangeListener(listener);
}
public SharedPreferences.Editor getEditor() {
return getPrefs().edit();
}
private static String createJSONStringFromObject(Object object) {
Gson gson = new Gson();
return gson.toJson(object);
}
}
Model
interface
die von Klassen implementiert wird, die zu Gson
, um eine Verschleierung durch Gson
zu vermeiden.
public interface Model {
}
Proguard-Regeln für die Model
Schnittstelle:
-keep interface com.example.app.Model
-keep class * implements com.example.app.Model { *;}
Verschiedene Möglichkeiten, ein Objekt von SharedPreferences zu instantiieren
Sie können auf SharedPreferences auf verschiedene Arten zugreifen:
Rufen Sie die standardmäßige SharedPreferences-Datei ab:
import android.preference.PreferenceManager;
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
Holen Sie sich eine bestimmte SharedPreferences-Datei:
public static final String PREF_FILE_NAME = "PrefFile";
SharedPreferences prefs = getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);
Holen Sie sich SharedPreferences von einer anderen App:
// Note that the other app must declare prefs as MODE_WORLD_WRITEABLE
final ArrayList<HashMap<String,String>> LIST = new ArrayList<HashMap<String,String>>();
Context contextOtherApp = createPackageContext("com.otherapp", Context.MODE_WORLD_WRITEABLE);
SharedPreferences prefs = contextOtherApp.getSharedPreferences("pref_file_name", Context.MODE_WORLD_READABLE);
getPreferences (int) VS getSharedPreferences (String, int)
getPreferences(int)
gibt die Einstellungen zurück, die unter Activity's class name
von Activity's class name
gespeichert wurden, wie in den Dokumenten beschrieben :
Rufen Sie ein SharedPreferences-Objekt ab, um auf Einstellungen zuzugreifen, die für diese Aktivität privat sind. Dadurch wird einfach die zugrunde liegende Methode getSharedPreferences (String, int) aufgerufen, indem der Klassenname dieser Aktivität als Präferenzname übergeben wird.
Bei Verwendung der getSharedPreferences-Methode (String-Name, int-Modus) gibt die Methode die unter dem angegebenen name
gespeicherten Präferenzen zurück. Wie in den Dokumenten:
Rufen Sie den Inhalt der Voreinstellungsdatei 'name' ab und geben Sie diese ein, und geben Sie SharedPreferences zurück, über die Sie die Werte abrufen und ändern können.
Wenn der Wert, der in den SharedPreferences
gespeichert wird, in der App verwendet werden muss, sollte getSharedPreferences (String name, int mode)
mit einem festen Namen verwendet werden. Mit getPreferences(int)
die Voreinstellungen der Activity
die sie anruft, zurückgegeben / getPreferences(int)
.
Commit vs. Apply
Die editor.apply()
-Methode ist asynchron , während editor.commit()
synchron ist .
Natürlich sollten Sie entweder apply()
oder commit()
aufrufen.
SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will asynchronously save the shared preferences without holding the current thread.
editor.apply();
SharedPreferences settings = getSharedPreferences(PREFS_FILE, MODE_PRIVATE);
SharedPreferences.Editor editor = settings.edit();
editor.putBoolean(PREF_CONST, true);
// This will synchronously save the shared preferences while holding the current thread until done and returning a success flag.
boolean result = editor.commit();
apply()
wurde in 2.3 (API 9) hinzugefügt. Es wird ein Commit ausgeführt, ohne dass ein boolescher Wert zurückgegeben wird, der den Erfolg oder Misserfolg angibt.
commit()
gibt true zurück, wenn das Speichern funktioniert, andernfalls false.
apply()
wurde hinzugefügt, da das Android-Entwicklerteam feststellte, dass fast niemand den Rückgabewert zur Kenntnis genommen hat. Daher ist apply schneller, da es asynchron ist.
Im Gegensatz zu commit()
, das seine Voreinstellungen synchron in den permanenten Speicher schreibt, werden die Änderungen durch apply()
sofort in den SharedPreferences
im Arbeitsspeicher SharedPreferences
jedoch ein asynchroner Commit auf die Festplatte SharedPreferences
, und es werden keine Fehler gemeldet. Wenn ein anderer Editor für diese SharedPreferences
ein reguläres commit()
SharedPreferences
commit()
während ein apply()
noch aussteht, wird das commit()
so lange blockiert, bis alle asynchronen Commits (apply) abgeschlossen sind, sowie alle anderen ausstehenden Sync-Commits.
Unterstützte Datentypen in SharedPreferences
SharedPreferences
können Sie nur primitive Datentypen speichern ( boolean
, float
, long
, int
, String
und string set
). Sie können keine komplexeren Objekte in SharedPreferences
, und als solche ist wirklich ein Ort zum Speichern von Benutzereinstellungen oder Ähnlichem gedacht. Es ist nicht als Datenbank gedacht, in der Benutzerdaten gespeichert werden (z. B. Speichern einer Aufgabenliste, die ein Benutzer erstellt hat).
Um etwas in SharedPreferences
zu speichern, SharedPreferences
Sie einen Schlüssel und einen Wert. Mit dem Schlüssel können Sie nachschlagen, was Sie später gespeichert haben, und auf die Wertdaten, die Sie speichern möchten.
String keyToUseToFindLater = "High Score";
int newHighScore = 12938;
//getting SharedPreferences & Editor objects
SharedPreferences sharedPref = getActivity().getPreferences(Context.MODE_PRIVATE);
SharedPreferences.Editor editor = sharedPref.edit();
//saving an int in the SharedPreferences file
editor.putInt(keyToUseToFindLater, newHighScore);
editor.commit();
Speichern, Abrufen, Entfernen und Löschen von Daten aus SharedPreferences
Erstellen Sie SharedPreferences BuyyaPref
SharedPreferences pref = getApplicationContext().getSharedPreferences("BuyyaPref", MODE_PRIVATE);
Editor editor = pref.edit();
Speichern von Daten als KEY / VALUE-Paar
editor.putBoolean("key_name1", true); // Saving boolean - true/false
editor.putInt("key_name2", 10); // Saving integer
editor.putFloat("key_name3", 10.1f); // Saving float
editor.putLong("key_name4", 1000); // Saving long
editor.putString("key_name5", "MyString"); // Saving string
// Save the changes in SharedPreferences
editor.commit(); // commit changes
Holen Sie sich SharedPreferences-Daten
Wenn der Wert für den Schlüssel nicht vorhanden ist, geben Sie den zweiten Parameterwert zurück.
pref.getBoolean("key_name1", null); // getting boolean
pref.getInt("key_name2", null); // getting Integer
pref.getFloat("key_name3", null); // getting Float
pref.getLong("key_name4", null); // getting Long
pref.getString("key_name5", null); // getting String
Schlüsselwert aus SharedPreferences löschen
editor.remove("key_name3"); // will delete key key_name3
editor.remove("key_name4"); // will delete key key_name4
// Save the changes in SharedPreferences
editor.commit(); // commit changes
Löschen Sie alle Daten aus SharedPreferences
editor.clear();
editor.commit(); // commit changes
Unterstützt Pre-Honeycomb mit StringSet
Hier ist die Utility-Klasse:
public class SharedPreferencesCompat {
public static void putStringSet(SharedPreferences.Editor editor, String key, Set<String> values) {
if (Build.VERSION.SDK_INT >= 11) {
while (true) {
try {
editor.putStringSet(key, values).apply();
break;
} catch (ClassCastException ex) {
// Clear stale JSON string from before system upgrade
editor.remove(key);
}
}
} else putStringSetToJson(editor, key, values);
}
public static Set<String> getStringSet(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
if (Build.VERSION.SDK_INT >= 11) {
try {
return prefs.getStringSet(key, defaultReturnValue);
} catch (ClassCastException ex) {
// If user upgraded from Gingerbread to something higher read the stale JSON string
return getStringSetFromJson(prefs, key, defaultReturnValue);
}
} else return getStringSetFromJson(prefs, key, defaultReturnValue);
}
private static Set<String> getStringSetFromJson(SharedPreferences prefs, String key, Set<String> defaultReturnValue) {
final String input = prefs.getString(key, null);
if (input == null) return defaultReturnValue;
try {
HashSet<String> set = new HashSet<>();
JSONArray json = new JSONArray(input);
for (int i = 0, size = json.length(); i < size; i++) {
String value = json.getString(i);
set.add(value);
}
return set;
} catch (JSONException e) {
e.printStackTrace();
return defaultReturnValue;
}
}
private static void putStringSetToJson(SharedPreferences.Editor editor, String key, Set<String> values) {
JSONArray json = new JSONArray(values);
if (Build.VERSION.SDK_INT >= 9)
editor.putString(key, json.toString()).apply();
else
editor.putString(key, json.toString()).commit();
}
private SharedPreferencesCompat() {}
}
Ein Beispiel zum Speichern von Einstellungen als StringSet-Datentyp ist:
Set<String> sets = new HashSet<>();
sets.add("John");
sets.add("Nicko");
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferencesCompat.putStringSet(preferences.edit(), "pref_people", sets);
Um sie zurückzuholen:
Set<String> people = SharedPreferencesCompat.getStringSet(preferences, "pref_people", new HashSet<String>());
Referenz: Android Support-Voreinstellung
Fügen Sie einen Filter für EditTextPreference hinzu
Diese Klasse erstellen:
public class InputFilterMinMax implements InputFilter {
private int min, max;
public InputFilterMinMax(int min, int max) {
this.min = min;
this.max = max;
}
public InputFilterMinMax(String min, String max) {
this.min = Integer.parseInt(min);
this.max = Integer.parseInt(max);
}
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
try {
int input = Integer.parseInt(dest.toString() + source.toString());
if (isInRange(min, max, input))
return null;
} catch (NumberFormatException nfe) { }
return "";
}
private boolean isInRange(int a, int b, int c) {
return b > a ? c >= a && c <= b : c >= b && c <= a;
}
}
Benutzen :
EditText compressPic = ((EditTextPreference) findPreference(getString("pref_key_compress_pic"))).getEditText();
compressPic.setFilters(new InputFilter[]{ new InputFilterMinMax(1, 100) });