Android
SharedPreferences

소개

통사론

• 컨텍스트 메서드

  • 공용 SharedPreferences getSharedPreferences (문자열 이름, int 모드)

• 활동 방식

  • public SharedPreferences getPreferences ()

• SharedPreferences 메서드

  • public SharedPreferences.Editor edit ()
  • public boolean contains ()
  • public Map <String,?> getAll ()
  • public boolean getBoolean (String key, boolean defValue) 지정된 키를 돌려줍니다.
  • public float getFloat (String key, float defValue)
  • public int getInt (String key, int defValue) 지정된 캐릭터 라인을 돌려줍니다.
  • 공용 long getLong (String key, long defValue)
  • 공개 스트링 getString (String key, String defValue)
  • public Set getStringSet (String key, defValues를 설정한다)
  • 공개 무효의 registerOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener listener)
  • 공개 무효화 unregisterOnSharedPreferenceChangeListener (SharedPreferences.OnSharedPreferenceChangeListener listener)

• SharedPreferences.Editor 메서드

  • public void apply ()
  • public boolean commit ()
  • public SharedPreferences.Editor clear ()
  • 공용 SharedPreferences.Editor putBoolean (String key, boolean value)
  • 공개 SharedPreferences.Editor putFloat (문자열 키, 부동 값)
  • 공용 SharedPreferences.Editor putInt (String key, int value)
  • 공용 SharedPreferences.Editor putLong (String key, long value)
  • 공개 SharedPreferences.Editor putString (문자열 키, 문자열 값)
  • 공개 SharedPreferences.Editor putStringSet (문자열 키, 값 설정)
  • 공용 SharedPreferences.Editor 제거 (문자열 키)

매개 변수

비고

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() 는 Activity 확장하는 Context 클래스의 메서드입니다. 다른 클래스에서 getSharedPreferences() 메소드에 액세스해야하는 경우 Activity , View 또는 Application 의 Context 오브젝트 참조와 함께 context.getSharedPreferences() 를 사용할 수 있습니다.

키 제거

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

apply() 후에, prefs 는 이미 포함 된 것 이외에 "key"-> "value"를 포함한다. "키"를 추가 한 다음 제거한 것처럼 보이더라도 실제로 제거가 먼저 발생합니다. Editor 의 변경 사항은 모두 추가 된 순서가 아니라 한 번에 적용됩니다. 모든 제거는 모든 넣기 전에 발생합니다.

SharedPreferences를 사용하여 설정 화면 구현

SharedPreferences 한 가지 용도는 사용자가 자신의 환경 설정 / 옵션을 설정할 수있는 "설정"화면을 앱에 구현하는 것입니다. 이렇게 :

PreferenceScreen은 SharedPreferences 사용자 기본 설정을 저장합니다. PreferenceScreen을 만들려면 다음과 같은 것들이 필요합니다.

사용 가능한 옵션을 정의하는 XML 파일 :

이것은 /res/xml/preferences.xml 에 있으며, 위의 설정 화면에서는 다음과 같습니다.

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

설정 화면에서 사용할 수있는 옵션을 정의합니다. Preference 클래스 의 Android Developers 문서에는 많은 다른 유형의 Preference 나열되어 있습니다.

다음으로 Preferences 사용자 인터페이스 를 호스팅 할 Activity 가 필요 합니다 . 이 경우 상당히 짧으며 다음과 같이 보입니다.

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

PreferenceActivity 확장하고 환경 설정 화면에 대한 사용자 인터페이스를 제공합니다. 이 경우 일반적인 활동처럼 시작할 수 있습니다.

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

AndroidManifest.xml 에 PreferencesActivity 를 추가하는 것을 잊지 마십시오.

앱 내에서 환경 설정의 값을 얻는 것은 매우 간단합니다. XML에 정의 된 기본값을 설정하고 기본 SharedPreferences 를 얻으려면 먼저 setDefaultValues() 호출하십시오. 예 :

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

특정 SharedPreferences 파일에서 저장된 모든 항목 검색

getAll() 메소드는 환경 설정에서 모든 값을 검색합니다. 예를 들어 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);
    } 
}

getAll 의해 반환 된 Collection 수정하는 방법에 대한 설명서가 있습니다.

이 메소드가 돌려주는 콜렉션을 변경하거나 그 내용을 변경해서는 안된다. 저장된 데이터의 일관성은 보장되지 않습니다.

SharedPreferences 변경 사항 수신 대기 중

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


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

참고 사항 :

• 청취자는 값이 추가되거나 변경된 경우에만 실행되며, 동일한 값을 설정하면 호출되지 않습니다.
• registerOnSharedPreferenceChangeListener 는 약한 참조를 저장하므로 가비지 수집되므로 리스너를 익명 클래스가 아닌 멤버 변수에 저장해야합니다.
• 멤버 변수를 사용하는 대신 클래스에 의해 직접 구현 된 다음 registerOnSharedPreferenceChangeListener(this); 를 호출 할 수도 있습니다 registerOnSharedPreferenceChangeListener(this);
• 그것은 더 이상 필요 사용하지 않을 때 리스너의 등록을 취소하는 것을 잊지 마십시오 unregisterOnSharedPreferenceChangeListener .

Singleton을 사용하여 SharedPreferences에 데이터 읽기 및 쓰기

SharedPreferences 모든 유형의 데이터를 읽고 쓰는 관리자 (싱글 톤) 클래스입니다.

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

Proguard 난독 화를 피하기 위해 Gson 으로가는 클래스에 의해 구현되는 Model interface .

public interface Model {
    
}

Model 인터페이스에 대한 Proguard 규칙 :

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

SharedPreferences의 객체를 인스턴스화하는 다양한 방법

여러 가지 방법으로 SharedPreferences에 액세스 할 수 있습니다.

기본 SharedPreferences 파일 가져 오기 :

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

특정 SharedPreferences 파일 가져 오기 :

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

다른 앱에서 SharedPreferences 받기 :

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

문서에 설명 된대로 Activity's class name 으로 저장 한 환경 설정을 반환합니다.

이 활동에 비공개 인 환경 설정에 액세스하기위한 SharedPreferences 객체를 가져옵니다. 이것은,이 액티 버티의 클래스 명을 설정 명으로서 건네주는 것에 의해, 기본이되는 getSharedPreferences (String, int) 메소드를 간단하게 호출합니다.

getSharedPreferences (String name, int mode) 메서드를 사용하면 (자) , 지정된 name 보존 된 prefs가 돌려 주어집니다. 문서에서와 같이 :

'name'환경 설정 파일의 내용을 검색하여 보유하고 값을 검색하고 수정할 수있는 SharedPreferences를 반환합니다.

따라서 SharedPreferences 에 저장된 값을 앱에서 사용해야하는 경우 고정 된 이름으로 getSharedPreferences (String name, int mode) 를 사용해야합니다. As getPreferences(int) 는, 그것을 호출하는 Activity 속하는 환경 설정을 리턴하거나 저장합니다.

커밋 대 적용

editor.apply() 중에있어서, 비동기 editor.commit() 동기된다.

분명히 apply() 또는 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() 가 2.3 (API 9 apply() 에 추가되면 성공 또는 실패를 나타내는 부울을 반환하지 않고 커밋합니다.

commit() 은 save가 작동하면 true를 반환하고 그렇지 않으면 false를 반환합니다.

apply() 가 추가되었습니다. Android 개발자 팀은 거의 아무도 반환 값을 알지 못했음을 알았으므로 비동기이므로 적용 속도가 빨라졌습니다.

환경 설정을 영구 저장소에 동 기적으로 쓰는 commit() 과 달리 apply() 는 메모리 내 SharedPreferences 에 대한 변경 사항을 즉시 커밋하지만 디스크에 대한 비동기 커밋을 시작하므로 아무런 오류 메시지도 표시되지 않습니다. 이 SharedPreferences 다른 편집기가 apply() 가 아직 처리되지 않은 상태에서 일반 commit() 을 수행하면 commit() 은 모든 비동기 커밋 (적용)이 완료 될 때까지 대기하고있을 수있는 다른 모든 동기화 커밋을 차단합니다.

SharedPreferences의 지원되는 데이터 형식

SharedPreferences 사용하면 기본 데이터 유형 ( boolean , float , long , int , String 및 string set ) 만 저장할 수 있습니다. 더 복잡한 객체를 SharedPreferences 저장할 수는 없으므로 사용자 설정 또는 유사한 것을 저장하는 장소이기 때문에 사용자 데이터를 보관할 데이터베이스는 아닙니다 (예 : 사용자가 만든 todo 목록 저장).

SharedPreferences 항목을 저장하려면 키와 값을 사용합니다. 키는 나중에 저장 한 내용과 저장하려는 값 데이터를 참조하는 방법입니다.

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

SharedPreferences에서 데이터 저장, 검색, 제거 및 지우기

SharedPreferences 만들기 BuyyaPref

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

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

SharedPreferences 데이터 가져 오기

key 값이 존재하지 않으면 두 번째 param 값을 반환합니다 (이 경우 null, 기본값과 같습니다)

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

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

SharedPreferences의 모든 데이터 지우기

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

StringSet으로 pre-Honeycomb 지원

다음은 유틸리티 클래스입니다.

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

환경 설정을 StringSet 데이터 형식으로 저장하는 예제는 다음과 같습니다.

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

다시 검색하려면 다음을 수행하십시오.

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

참조 : Android 지원 환경 설정

EditTextPreference에 대한 필터 추가

이 클래스를 만듭니다.

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

사용 :

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