Android
SharedPreferences

前書き

構文

• コンテキストメソッド

  • public 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）指定された文字列を返します。
  • 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メソッド

  • public void apply（）
  • public boolean commit（）
  • public SharedPreferences.Editor clear（）
  • public SharedPreferences.Editor putBoolean（String key、boolean value）
  • パブリックSharedPreferences.Editor putFloat（String key、float value）
  • パブリックSharedPreferences.Editor putInt（String key、int value）
  • パブリックSharedPreferences.Editor putLong（String key、long value）
  • パブリックSharedPreferences.Editor putString（String key、String value）
  • public SharedPreferences.Editor putStringSet（文字列キー、値の設定）
  • パブリックSharedPreferences.Editor remove（String key）

パラメーター

備考

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()他のクラスからメソッドを、あなたが使用することができますcontext.getSharedPreferences()でContextからのオブジェクト参照Activity 、 View 、またはApplication 。

キーを削除する

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 1つの用途は、ユーザーが自分の設定/オプションを設定できる「設定」画面をアプリケーションに実装することです。このような：

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開発者のドキュメントに記載されているプリファレンスクラス 。

次に、 Preferencesのユーザーインターフェイスをホストするアクティビティが必要です。この場合、かなり短く、次のようになります。

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を追加することを忘れないでください。

あなたのアプリケーション内の設定の値を取得することは非常に簡単です setDefaultValues()まず呼び出して、XMLで定義されているデフォルト値を設定し、デフォルトのSharedPreferences取得してください。例：

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

ご注意ください：

• リスナーは、valueが追加または変更された場合にのみ起動されます。同じ値を設定すると、それが呼び出されません。
• ので、リスナーは、匿名のクラスでメンバ変数とNOTに保存する必要がregisterOnSharedPreferenceChangeListener弱参照して格納するので、ごみを収集することができるであろう。
• メンバ変数を使用する代わりに、クラスによって直接実装され、 registerOnSharedPreferenceChangeListener(this);呼び出すこともできregisterOnSharedPreferenceChangeListener(this);
• それはもう必要と使用しないときに、リスナーの登録を解除することを忘れないでくださいunregisterOnSharedPreferenceChangeListener 。

シングルトンを使って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);
    } 
}

プロガードの難読化を避けるために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()は、保存が機能する場合はtrueを返し、そうでない場合はfalseを返します。

Androidデベロッパーチームがほとんど誰も戻り値に気づいていないことに気付いたのでapply()が追加されたので、適用は非同期であるため速くなります。

apply()は、その設定を永続的なストレージに同期的に書き出すcommit()とは異なり、その変更をメモリ内SharedPreferencesただちにコミットしますが、ディスクへの非同期コミットを開始します。このSharedPreferences別のエディタがapply()が未解決である間に通常のcommit()をcommit()と、すべての非同期コミット（適用）が完了し、保留中の他の同期コミットが完了するまでcommit()がブロックされます。

SharedPreferencesでサポートされるデータ型

SharedPreferences使用すると、基本データ型（ boolean 、 float 、 long 、 int 、 String 、およびstring set ）のみを格納できます。より複雑なオブジェクトをSharedPreferences格納することはできません。実際にはユーザー設定などを格納する場所であるため、ユーザーデータを保持するデータベースではありません（ユーザーが作成したToDoリストの保存など）。

SharedPreferences何かを格納するには、KeyとValueを使用します。キーは、後で保存したものと保存する値データを参照する方法です。

    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の値が存在しない場合は、2番目の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) });