Android
SharedPreferences

introduzione

Sintassi

• Metodo di contesto

  • public SharedPreferences getSharedPreferences (Nome stringa, modalità int)

• Metodo di attività

  • public SharedPreferences getPreferences ()

• Metodi SharedPreferences

  • public SharedPreferences.Editor edit ()
  • contiene booleano pubblico ()
  • Mappa pubblica <String,?> getAll ()
  • public boolean getBoolean (String key, boolean defValue)
  • public float getFloat (String key, float defValue)
  • public int getInt (String key, int defValue)
  • public long getLong (String key, long defValue)
  • public String getString (String key, String defValue)
  • public Set getStringSet (String key, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener listener)
  • public void unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener listener)

• SharedPreferences.Editor Methods

  • public public apply ()
  • commit booleano pubblico ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (Chiave stringa, valore booleano)
  • public SharedPreferences.Editor putFloat (Chiave stringa, valore float)
  • public SharedPreferences.Editor putInt (Chiave stringa, valore int)
  • public SharedPreferences.Editor putLong (Chiave stringa, valore lungo)
  • public SharedPreferences.Editor putString (Chiave stringa, Valore stringa)
  • public SharedPreferences.Editor putStringSet (Chiave stringa, Imposta valori)
  • public SharedPreferences.Editor remove (Chiave stringa)

Parametri

Osservazioni

Leggere e scrivere valori su 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() è un metodo della classe Context , che Activity estende. Se avete bisogno di accedere alle getSharedPreferences() metodo dal altre classi, è possibile utilizzare context.getSharedPreferences() con un Context di riferimento oggetto da un Activity , View , o Application .

Rimozione delle chiavi

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

Dopo apply() , prefs contiene "chiave" -> "valore", oltre a qualsiasi cosa contenesse già. Anche se sembra che ho aggiunto "chiave" e poi rimosso, la rimozione avviene effettivamente prima. Le modifiche Editor vengono applicate tutte in una volta, non nell'ordine in cui sono state aggiunte. Tutte le rimosse accadono prima di tutte le put.

Implementazione di una schermata delle impostazioni usando SharedPreferences

Un uso di SharedPreferences consiste nell'implementare una schermata "Impostazioni" nella tua app, in cui l'utente può impostare le proprie preferenze / opzioni. Come questo:

A PreferenceScreen salva le preferenze dell'utente in SharedPreferences . Per creare un PreferenceScreen, hai bisogno di alcune cose:

Un file XML per definire le opzioni disponibili:

Questo va in /res/xml/preferences.xml , e per la schermata delle impostazioni sopra, appare come questo:

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

Definisce le opzioni disponibili nella schermata delle impostazioni. Esistono molti altri tipi di Preference elencati nella documentazione degli sviluppatori Android sulla classe di preferenza .

Successivamente, abbiamo bisogno di un'attività per ospitare la nostra interfaccia utente delle preferenze . In questo caso, è piuttosto breve e assomiglia a questo:

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

Estende PreferenceActivity e fornisce l'interfaccia utente per la schermata delle preferenze. Può essere avviato come un'attività normale, in questo caso, con qualcosa di simile:

Intent i = new Intent(this, PreferencesActivity.class);
startActivity(i);

Non dimenticare di aggiungere PreferencesActivity al tuo AndroidManifest.xml .

Ottenere i valori delle preferenze all'interno della tua app è abbastanza semplice, basta chiamare setDefaultValues() per impostare i valori predefiniti definiti nel tuo XML e quindi ottenere le SharedPreferences predefinite. Un esempio:

//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", "");

Recupera tutte le voci memorizzate da un particolare file SharedPreferences

Il metodo getAll() recupera tutti i valori dalle preferenze. Possiamo usarlo, ad esempio, per registrare il contenuto corrente di 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);
    } 
}

La documentazione ti avverte della modifica della Collection restituita da getAll :

Si noti che non è necessario modificare la raccolta restituita da questo metodo o alterarne il contenuto. La coerenza dei dati memorizzati non è garantita se lo fai.

Ascolto delle modifiche di SharedPreferences

SharedPreferences sharedPreferences = ...;
sharedPreferences.registerOnSharedPreferenceChangeListener(mOnSharedPreferenceChangeListener);


private final SharedPreferences.OnSharedPreferenceChangeListener mOnSharedPreferenceChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
    @Override
    public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
        //TODO
    }
}

Notare che:

• Il listener scatterà solo se il valore è stato aggiunto o modificato, l'impostazione dello stesso valore non la chiamerà;
• Il listener deve essere salvato in una variabile membro e NON con una classe anonima, perché registerOnSharedPreferenceChangeListener memorizza con un riferimento debole, quindi sarebbe garbage collection;
• Invece di utilizzare una variabile membro, può anche essere implementata direttamente dalla classe e quindi chiamare registerOnSharedPreferenceChangeListener(this);
• Ricordarsi di annullare la registrazione del listener quando non è più necessario utilizzare unregisterOnSharedPreferenceChangeListener .

Lettura e scrittura di dati su SharedPreferences con Singleton

Classe SharedPreferences Manager (Singleton) per leggere e scrivere tutti i tipi di dati.

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

interface Model che viene implementata dalle classi che vanno a Gson per evitare l'offuscamento proguard.

public interface Model {
    
}

Regole Proguard per l'interfaccia Model :

-keep interface com.example.app.Model
-keep class * implements com.example.app.Model { *;}

Diversi modi di creare un'istanza di un oggetto di SharedPreferences

È possibile accedere a SharedPreferences in diversi modi:

Ottieni il file SharedPreferences predefinito:

import android.preference.PreferenceManager;
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);

Ottieni un file SharedPreferences specifico:

public static final String PREF_FILE_NAME = "PrefFile";
SharedPreferences prefs = getSharedPreferences(PREF_FILE_NAME, MODE_PRIVATE);

Ottieni SharedPreferences da un'altra 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)

restituisce le preferenze salvate dal Activity's class name come descritto nei documenti :

Recupera un oggetto SharedPreferences per accedere alle preferenze private di questa attività. Questo semplicemente chiama il metodo getSharedPreferences (String, int) sottostante passando il nome della classe di questa attività come nome delle preferenze.

Durante l'utilizzo del metodo getSharedPreferences (nome String, modalità int) vengono restituiti i prefs salvati con il name . Come nei documenti:

Recupera e mantieni il contenuto del file delle preferenze 'nome', restituendo un oggetto SharedPreferences attraverso il quale è possibile recuperare e modificare i suoi valori.

Pertanto, se il valore da salvare in SharedPreferences deve essere utilizzato nell'app, è necessario utilizzare getSharedPreferences (String name, int mode) con un nome fisso. Come, usando getPreferences(int) ritorna / salva le preferenze che appartengono Activity chiamandola.

Commit vs. Applica

Il metodo editor.apply() è asincrono , mentre editor.commit() è sincrono .

Ovviamente, dovresti chiamare apply() o commit() .

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() stato aggiunto in 2.3 (API 9), esegue il commit senza restituire un valore booleano che indica il successo o il fallimento.

commit() restituisce true se il salvataggio funziona, false altrimenti.

apply() stato aggiunto mentre il team di sviluppo Android ha notato che quasi nessuno ha preso nota del valore restituito, quindi applicare è più veloce in quanto è asincrono.

A differenza di commit() , che scrive le sue preferenze in memoria permanente in modo sincrono, apply() SharedPreferences immediatamente le sue modifiche alle SharedPreferences memoria ma avvia un commit asincrono su disco e non viene notificato alcun errore. Se un altro editor su questo SharedPreferences esegue un commit() regolare mentre un apply() è ancora in sospeso, il commit() si bloccherà fino a quando non saranno completati tutti i commit asincroni (apply) e tutti gli altri commit di sincronizzazione che potrebbero essere in sospeso.

Tipi di dati supportati in SharedPreferences

SharedPreferences consente di memorizzare solo tipi di dati primitivi ( boolean , float , long , int , String e string set ). Non è possibile archiviare oggetti più complessi in SharedPreferences e, in quanto tale, è pensato per essere un luogo in cui archiviare le impostazioni dell'utente o simili, non è pensato per essere un database per conservare i dati dell'utente (ad esempio il salvataggio di un elenco di attività effettuato dall'utente, ad esempio).

Per memorizzare qualcosa in SharedPreferences usi una chiave e un valore. La chiave è come puoi fare riferimento a ciò che hai archiviato in seguito e ai dati del valore che desideri memorizzare.

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

Archivia, recupera, rimuove e cancella i dati da SharedPreferences

Crea SharedPreferences BuyyaPref

SharedPreferences pref = getApplicationContext().getSharedPreferences("BuyyaPref", MODE_PRIVATE); 
Editor editor = pref.edit();

Memorizzazione dei dati come coppia KEY / VALUE

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

Ottieni dati SharedPreferences

Se il valore per la chiave non esiste, restituisce il valore del secondo parametro (in questo caso null, questo è come il valore predefinito)

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

Eliminazione del valore chiave da SharedPreferences

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

Cancella tutti i dati da SharedPreferences

 editor.clear();
 editor.commit(); // commit changes

Supporta pre-Honeycomb con StringSet

Ecco la classe di utilità:

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

Un esempio per salvare le preferenze come tipo di dati StringSet è:

Set<String> sets = new HashSet<>();
sets.add("John");
sets.add("Nicko");
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferencesCompat.putStringSet(preferences.edit(), "pref_people", sets);

Per recuperarli di nuovo:

Set<String> people = SharedPreferencesCompat.getStringSet(preferences, "pref_people", new HashSet<String>());

Riferimento: preferenza di supporto Android

Aggiungi filtro per EditTextPreference

Crea questa classe:

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

Uso :

EditText compressPic = ((EditTextPreference) findPreference(getString("pref_key_compress_pic"))).getEditText();
compressPic.setFilters(new InputFilter[]{ new InputFilterMinMax(1, 100) });