Android
Des préférences partagées

Introduction

Syntaxe

• Méthode de contexte

  • public SharedPreferences getSharedPreferences (nom de chaîne, mode int)

• Méthode d'activité

  • public SharedPreferences getPreferences ()

• Méthodes SharedPreferences

  • public SharedPreferences.Editor edit ()
  • booléen public contient ()
  • carte publique <String,?> getAll ()
  • boolean public getBoolean (clé de chaîne, booléen defValue)
  • float public getFloat (clé String, float defValue)
  • public int getInt (clé de chaîne, int defValue)
  • public long getLong (clé de chaîne, long defValue)
  • public String getString (clé de chaîne, String defValue)
  • public Set getStringSet (clé de chaîne, Set defValues)
  • public void registerOnSharedPreferenceChangeListener (auditeur SharedPreferences.OnSharedPreferenceChangeListener)
  • void public unregisterOnSharedPreferenceChangeListener (auditeur SharedPreferences.OnSharedPreferenceChangeListener)

• Méthodes SharedPreferences.Editor

  • annulation publique appliquer ()
  • commit booléen public ()
  • public SharedPreferences.Editor clear ()
  • public SharedPreferences.Editor putBoolean (clé de chaîne, valeur booléenne)
  • public SharedPreferences.Editor putFloat (clé de chaîne, valeur flottante)
  • public SharedPreferences.Editor putInt (clé de chaîne, valeur int)
  • public SharedPreferences.Editor putLong (clé de chaîne, valeur longue)
  • public SharedPreferences.Editor putString (clé de chaîne, valeur de chaîne)
  • public SharedPreferences.Editor putStringSet (clé de chaîne, valeurs définies)
  • public SharedPreferences.Editor remove (Clé de chaîne)

Paramètres

Remarques

Lire et écrire des valeurs dans 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() est une méthode de la classe Context - dont l' Activity s'étend. Si vous devez accéder à la méthode getSharedPreferences() partir d'autres classes, vous pouvez utiliser context.getSharedPreferences() avec une référence d'objet de Context partir d'une Activity , d'une View ou d'une Application .

Enlever les clés

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

Après le apply() , prefs contient "key" -> "value", en plus de ce qu'il contient déjà. Même s'il semble que j'ai ajouté "clé" et que je l'ai ensuite retiré, la suppression se produit en premier. Les modifications dans l' Editor sont toutes appliquées en une seule fois, et non dans l'ordre dans lequel vous les avez ajoutées. Toutes les suppressions ont lieu avant toutes les mises.

Implémentation d'un écran Paramètres en utilisant SharedPreferences

Une utilisation de SharedPreferences consiste à implémenter un écran "Settings" dans votre application, où l'utilisateur peut définir ses préférences / options. Comme ça:

Un SharedPreferences préférence enregistre les préférences de l'utilisateur dans les préférences SharedPreferences . Pour créer un écran de préférence, vous avez besoin de quelques éléments:

Un fichier XML pour définir les options disponibles:

Cela va dans /res/xml/preferences.xml , et pour l'écran de paramètres ci-dessus, cela ressemble à ceci:

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

Ceci définit les options disponibles dans l'écran des paramètres. Il existe de nombreux autres types de Preference répertoriés dans la documentation des développeurs Android sur la classe de préférence .

Ensuite, nous avons besoin d' une activité pour héberger notre interface utilisateur de préférences . Dans ce cas, c'est assez court et ressemble à ceci:

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

Il étend PreferenceActivity et fournit l'interface utilisateur pour l'écran des préférences. Il peut être lancé comme une activité normale, dans ce cas, avec quelque chose comme:

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

N'oubliez pas d'ajouter PreferencesActivity à votre AndroidManifest.xml .

Obtenir les valeurs des préférences dans votre application est assez simple, appelez simplement setDefaultValues() pour définir les valeurs par défaut définies dans votre XML, puis obtenez les SharedPreferences par défaut. Un exemple:

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

Récupérer toutes les entrées stockées d'un fichier SharedPreferences particulier

La méthode getAll() récupère toutes les valeurs des préférences. Nous pouvons l'utiliser, par exemple, pour enregistrer le contenu actuel des 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 documentation vous avertit de la modification de la Collection retournée par getAll :

Notez que vous ne devez pas modifier la collection renvoyée par cette méthode ou modifier son contenu. La cohérence de vos données stockées n'est pas garantie si vous le faites.

Écoute des modifications de SharedPreferences

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


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

Notez s'il vous plaît:

• L'auditeur ne se déclenche que si la valeur a été ajoutée ou modifiée, le réglage de la même valeur ne l'appelera pas;
• Le programme d'écoute doit être enregistré dans une variable membre et non avec une classe anonyme, car registerOnSharedPreferenceChangeListener stocke avec une référence faible, de sorte qu'il soit récupéré.
• Au lieu d'utiliser une variable membre, elle peut également être directement implémentée par la classe, puis appeler registerOnSharedPreferenceChangeListener(this);
• N'oubliez pas de désenregistrer l'écouteur lorsqu'il n'est plus nécessaire d'utiliser unregisterOnSharedPreferenceChangeListener .

Lecture et écriture de données dans SharedPreferences with Singleton

Classe SharedPreferences Manager (Singleton) pour lire et écrire tous les types de données.

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 qui est implémentée par les classes allant à Gson pour éviter le brouillage de proguard.

public interface Model {
    
}

Règles de progression pour l'interface du Model :

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

Différentes manières d'instancier un objet de SharedPreferences

Vous pouvez accéder à SharedPreferences de plusieurs manières:

Récupère le fichier SharedPreferences par défaut:

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

Obtenez un fichier SharedPreferences spécifique:

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

Obtenir des préférences partagées à partir d'une autre application:

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

renvoie les préférences enregistrées par Activity's class name comme décrit dans la documentation :

Récupérer un objet SharedPreferences pour accéder aux préférences privées de cette activité. Cela appelle simplement la méthode getSharedPreferences (String, int) sous-jacente en transmettant le nom de classe de cette activité comme nom de préférences.

Lors de l'utilisation de la méthode getSharedPreferences (nom de chaîne, mode int) renvoie les préférences enregistrées sous le name donné. Comme dans les docs:

Récupérez et conservez le contenu du fichier de préférences "nom", en renvoyant une valeur de SharedPreferences à travers laquelle vous pouvez récupérer et modifier ses valeurs.

Donc, si la valeur enregistrée dans les SharedPreferences doit être utilisée dans l’application, il faut utiliser getSharedPreferences (String name, int mode) avec un nom fixe. Comme, l'utilisation de getPreferences(int) renvoie / enregistre les préférences appartenant à l' Activity appelle.

Commit vs. Apply

La méthode editor.apply() est asynchrone , alors que editor.commit() est synchrone .

De toute évidence, vous devriez appeler apply() ou 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() été ajouté dans 2.3 (API 9), il valide sans retourner un booléen indiquant le succès ou l'échec.

commit() renvoie true si la sauvegarde fonctionne, false sinon.

apply() été ajouté, car l'équipe de développement Android a remarqué que presque personne ne prenait note de la valeur de retour, donc, appliquer est plus rapide car elle est asynchrone.

Contrairement à commit() , qui écrit ses préférences dans le stockage persistant de manière synchrone, apply() SharedPreferences immédiatement les modifications apportées à la SharedPreferences mémoire, mais lance une validation asynchrone sur le disque. Si un autre éditeur de cette SharedPreferences effectue un commit() normal commit() alors qu'un apply() est toujours en attente, le commit() bloquera jusqu'à ce que tous les commits asynchrones (s'appliquent) ainsi que tous les autres commits de synchronisation en attente.

Types de données pris en charge dans SharedPreferences

SharedPreferences vous permet de stocker uniquement les types de données primitifs ( boolean , float , long , int , String et string set ). Vous ne pouvez pas stocker des objets plus complexes dans SharedPreferences et, en tant que tel, vous souhaitez stocker des paramètres utilisateur ou similaires, ce n'est pas une base de données pour conserver les données utilisateur (par exemple enregistrer une liste de SharedPreferences par exemple).

Pour stocker quelque chose dans SharedPreferences vous utilisez une clé et une valeur. La clé est la manière dont vous pouvez référencer ce que vous avez enregistré plus tard et les données de valeur que vous souhaitez stocker.

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

Stocker, récupérer, supprimer et effacer les données des préférences partagées

Créer des préférences partagées BuyyaPref

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

Stockage des données sous forme de paire 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

Obtenir des données SharedPreferences

Si la valeur de la clé n'existe pas, renvoyer la deuxième valeur de paramètre (dans ce cas, null, c'est comme la valeur par défaut)

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

Supprimer la valeur de clé de 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

Effacer toutes les données de SharedPreferences

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

Pré-Honeycomb avec StringSet

Voici la classe d'utilitaire:

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 exemple pour enregistrer les préférences en tant que type de données StringSet est:

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

Pour les récupérer:

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

Référence: Préférence de support Android

Ajouter un filtre pour EditTextPreference

Créez cette 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;
    }
}

Utilisation :

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