如何在Android中使用SharedPreferences来存储，获取和编辑值


How to use SharedPreferences in Android to store, fetch and edit values

我想存储一个时间值，需要检索和编辑它。 如何使用SharedPreferences执行此操作？

相关讨论

要获取共享首选项，请使用以下方法
在您的活动中：

1
2
SharedPreferences prefs = this.getSharedPreferences(
     "com.example.app", Context.MODE_PRIVATE);

要阅读首选项：

1
2
3
4
String dateTimeKey ="com.example.app.datetime";

// use a default value using new Date()
long l = prefs.getLong(dateTimeKey, new Date().getTime());

编辑和保存首选项

1
2
Date dt = getSomeDate();
prefs.edit().putLong(dateTimeKey, dt.getTime()).apply();

android sdk的示例目录包含检索和存储共享首选项的示例。它位于：

1
/samples/android-<platformversion>/ApiDemos directory

编辑==>

我注意到，在这里写出commit()和apply()之间的差异也很重要。

commit()如果值成功保存则返回true，否则false。它同步将值保存到SharedPreferences。

2.3中添加了apply()，并且在成功或失败时都不返回任何值。它会立即将值保存到SharedPreferences，但会启动异步提交。
更多细节在这里。

相关讨论

要在共享首选项中存储值：

1
2
3
4
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Name","Harneet");
editor.apply();

要从共享首选项中检索值：

1
2
3
4
5
6
SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(this);
String name = preferences.getString("Name","");
if(!name.equalsIgnoreCase(""))
{
    name = name +"  Sethi";  /* Edit the value here*/
}
相关讨论

编辑sharedpreference中的数据

1
2
3
4
5
 SharedPreferences.Editor editor = getPreferences(MODE_PRIVATE).edit();
 editor.putString("text", mSaved.getText().toString());
 editor.putInt("selection-start", mSaved.getSelectionStart());
 editor.putInt("selection-end", mSaved.getSelectionEnd());
 editor.apply();

从sharedpreference检索数据

1
2
3
4
5
6
7
8
9
10
11
12
SharedPreferences prefs = getPreferences(MODE_PRIVATE);
String restoredText = prefs.getString("text", null);
if (restoredText != null)
{
  //mSaved.setText(restoredText, TextView.BufferType.EDITABLE);
  int selectionStart = prefs.getInt("selection-start", -1);
  int selectionEnd = prefs.getInt("selection-end", -1);
  /*if (selectionStart != -1 && selectionEnd != -1)
  {
     mSaved.setSelection(selectionStart, selectionEnd);
  }*/
}

编辑

我从API Demo示例中获取了这个片段。那里有一个EditText盒子。在这个context中它不是必需的。我正在评论相同的。

相关讨论

来写 ：

1
2
3
4
5
6
SharedPreferences preferences = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_WORLD_WRITEABLE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("Authentication_Id",userid.getText().toString());
editor.putString("Authentication_Password",password.getText().toString());
editor.putString("Authentication_Status","true");
editor.apply();

阅读 ：

1
2
SharedPreferences prfs = getSharedPreferences("AUTHENTICATION_FILE_NAME", Context.MODE_PRIVATE);
String Astatus = prfs.getString("Authentication_Status","");
相关讨论

最简单的方法：

要保存：

1
getPreferences(MODE_PRIVATE).edit().putString("Name of variable",value).commit();

要检索：

1
your_variable = getPreferences(MODE_PRIVATE).getString("Name of variable",default value);
相关讨论

在偏好中设置值：

1
2
3
4
5
6
// MY_PREFS_NAME - a static String variable like:
//public static final String MY_PREFS_NAME ="MyPrefsFile";
SharedPreferences.Editor editor = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE).edit();
 editor.putString("name","Elena");
 editor.putInt("idName", 12);
 editor.commit();

从首选项中检索数据：

1
2
3
4
5
6
SharedPreferences prefs = getSharedPreferences(MY_PREFS_NAME, MODE_PRIVATE);
String restoredText = prefs.getString("text", null);
if (restoredText != null) {
  String name = prefs.getString("name","No name defined");//"No name defined" is the default value.
  int idName = prefs.getInt("idName", 0); //0 is the default value.
}

更多信息：

使用共享首选项

共享首选项

相关讨论

存储信息

1
2
3
4
5
6
SharedPreferences preferences = getSharedPreferences(PREFS_NAME,Context.MODE_PRIVATE);
SharedPreferences.Editor editor = preferences.edit();
editor.putString("username", username.getText().toString());
editor.putString("password", password.getText().toString());
editor.putString("logged","logged");
editor.commit();

重置您的偏好

1
2
3
SharedPreferences.Editor editor = preferences.edit();
editor.clear();
editor.commit();

单身共享首选项类。它可能在将来对其他人有所帮助。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
import android.app.Activity;
import android.content.Context;
import android.content.SharedPreferences;

public class SharedPref
{
    private static SharedPreferences mSharedPref;
    public static final String NAME ="NAME";
    public static final String AGE ="AGE";
    public static final String IS_SELECT ="IS_SELECT";

    private SharedPref()
    {

    }

    public static void init(Context context)
    {
        if(mSharedPref == null)
            mSharedPref = context.getSharedPreferences(context.getPackageName(), Activity.MODE_PRIVATE);
    }

    public static String read(String key, String defValue) {
        return mSharedPref.getString(key, defValue);
    }

    public static void write(String key, String value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putString(key, value);
        prefsEditor.commit();
    }

    public static boolean read(String key, boolean defValue) {
        return mSharedPref.getBoolean(key, defValue);
    }

    public static void write(String key, boolean value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putBoolean(key, value);
        prefsEditor.commit();
    }

    public static Integer read(String key, int defValue) {
        return mSharedPref.getInt(key, defValue);
    }

    public static void write(String key, Integer value) {
        SharedPreferences.Editor prefsEditor = mSharedPref.edit();
        prefsEditor.putInt(key, value).commit();
    }
}

只需在MainActivity上调用SharedPref.init()一次

1
SharedPref.init(getApplicationContext());

写数据

1
2
3
SharedPref.write(SharedPref.NAME,"XXXX");//save string in shared preference.
SharedPref.write(SharedPref.AGE, 25);//save int in shared preference.
SharedPref.write(SharedPref.IS_SELECT, true);//save boolean in shared preference.

阅读数据

1
2
3
String name = SharedPref.read(SharedPref.NAME, null);//read string in shared preference.
int age = SharedPref.read(SharedPref.AGE, 0);//read int in shared preference.
boolean isSelect = SharedPref.read(SharedPref.IS_SELECT, false);//read boolean in shared preference.

在任何应用程序中，都可以通过PreferenceManager实例及其相关方法getDefaultSharedPreferences(Context)访问默认首选项。

使用sharedpreference实例，可以使用getInt(String key，int defVal)检索任何首选项的int值。我们对这种情况感兴趣的偏好是反制的。

在我们的例子中，我们可以使用edit()在我们的案例中修改sharedpreference实例并使用putInt(String key, int newVal)我们增加了应用程序的计数，该应用程序在应用程序之外预先存在并相应地显示。

要进一步演示此操作，重新启动并重新启动应用程序，您会注意到每次重新启动应用程序时计数都会增加。

PreferencesDemo.java

码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
package org.example.preferences;
import android.app.Activity;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.widget.TextView;

public class PreferencesDemo extends Activity {
   /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Get the app's shared preferences
        SharedPreferences app_preferences =
        PreferenceManager.getDefaultSharedPreferences(this);

        // Get the value for the run counter
        int counter = app_preferences.getInt("counter", 0);

        // Update the TextView
        TextView text = (TextView) findViewById(R.id.text);
        text.setText("This app has been started" + counter +" times.");

        // Increment the counter
        SharedPreferences.Editor editor = app_preferences.edit();
        editor.putInt("counter", ++counter);
        editor.commit(); // Very important
    }
}

main.xml中

码：

1
2
3
4
5
6
7
8
9
10
11
12
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
      android:orientation="vertical"
      android:layout_width="fill_parent"
      android:layout_height="fill_parent">

        <TextView
            android:id="@+id/text"  
            android:layout_width="fill_parent"
            android:layout_height="wrap_content"
            android:text="@string/hello" />
</LinearLayout>

如果您正在与团队中的其他开发人员一起制作大型应用程序，并且打算在没有分散代码或不同SharedPreferences实例的情况下完成所有组织，那么您可以执行以下操作：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
//SharedPreferences manager class
public class SharedPrefs {

    //SharedPreferences file name
    private static String SHARED_PREFS_FILE_NAME ="my_app_shared_prefs";

    //here you can centralize all your shared prefs keys
    public static String KEY_MY_SHARED_BOOLEAN ="my_shared_boolean";
    public static String KEY_MY_SHARED_FOO ="my_shared_foo";

    //get the SharedPreferences object instance
    //create SharedPreferences file if not present


    private static SharedPreferences getPrefs(Context context) {
        return context.getSharedPreferences(SHARED_PREFS_FILE_NAME, Context.MODE_PRIVATE);
    }

    //Save Booleans
    public static void savePref(Context context, String key, boolean value) {
        getPrefs(context).edit().putBoolean(key, value).commit();      
    }

    //Get Booleans
    public static boolean getBoolean(Context context, String key) {
        return getPrefs(context).getBoolean(key, false);
    }

    //Get Booleans if not found return a predefined default value
    public static boolean getBoolean(Context context, String key, boolean defaultValue) {
        return getPrefs(context).getBoolean(key, defaultValue);
    }

    //Strings
    public static void save(Context context, String key, String value) {
        getPrefs(context).edit().putString(key, value).commit();
    }

    public static String getString(Context context, String key) {
        return getPrefs(context).getString(key,"");
    }

    public static String getString(Context context, String key, String defaultValue) {
        return getPrefs(context).getString(key, defaultValue);
    }

    //Integers
    public static void save(Context context, String key, int value) {
        getPrefs(context).edit().putInt(key, value).commit();
    }

    public static int getInt(Context context, String key) {
        return getPrefs(context).getInt(key, 0);
    }

    public static int getInt(Context context, String key, int defaultValue) {
        return getPrefs(context).getInt(key, defaultValue);
    }

    //Floats
    public static void save(Context context, String key, float value) {
        getPrefs(context).edit().putFloat(key, value).commit();
    }

    public static float getFloat(Context context, String key) {
        return getPrefs(context).getFloat(key, 0);
    }

    public static float getFloat(Context context, String key, float defaultValue) {
        return getPrefs(context).getFloat(key, defaultValue);
    }

    //Longs
    public static void save(Context context, String key, long value) {
        getPrefs(context).edit().putLong(key, value).commit();
    }

    public static long getLong(Context context, String key) {
        return getPrefs(context).getLong(key, 0);
    }

    public static long getLong(Context context, String key, long defaultValue) {
        return getPrefs(context).getLong(key, defaultValue);
    }

    //StringSets
    public static void save(Context context, String key, Set<String> value) {
        getPrefs(context).edit().putStringSet(key, value).commit();
    }

    public static Set<String> getStringSet(Context context, String key) {
        return getPrefs(context).getStringSet(key, null);
    }

    public static Set<String> getStringSet(Context context, String key, Set<String> defaultValue) {
        return getPrefs(context).getStringSet(key, defaultValue);
    }
}

在您的活动中，您可以通过这种方式保存SharedPreferences

1
2
//saving a boolean into prefs
SharedPrefs.savePref(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN, booleanVar);

并且您可以通过这种方式检索您的SharedPreferences

1
2
//getting a boolean from prefs
booleanVar = SharedPrefs.getBoolean(this, SharedPrefs.KEY_MY_SHARED_BOOLEAN);

存储在SharedPreferences中

1
2
3
4
SharedPreferences preferences = getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
Editor editor = preferences.edit();
editor.putString("name", name);
editor.commit();

获取SharedPreferences

1
2
SharedPreferences preferences=getSharedPreferences("temp", getApplicationContext().MODE_PRIVATE);
String name=preferences.getString("name",null);

注意："temp"是sharedpreferences名称，"name"是输入值。如果值没有退出则返回null

相关讨论

如何通过SharedPreferences存储登录值的简单解决方案。

您可以扩展MainActivity类或其他类，您将在其中存储"您想要保留的值的值"。把它放入作家和读者类：

1
public static final String GAME_PREFERENCES_LOGIN ="Login";

这里输入InputClass，OutputClass分别是输出类。

1
2
3
4
5
6
7
8
9
10
11
12
// This is a storage, put this in a class which you can extend or in both classes:
//(input and output)
public static final String GAME_PREFERENCES_LOGIN ="Login";

// String from the text input (can be from anywhere)
String login = inputLogin.getText().toString();

// then to add a value in InputCalss"SAVE",
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
Editor editor = example.edit();
editor.putString("value", login);
editor.commit();

现在你可以像其他类一样在其他地方使用它。以下是OutputClass。

1
2
3
4
5
SharedPreferences example = getSharedPreferences(GAME_PREFERENCES_LOGIN, 0);
String userString = example.getString("value","defValue");

// the following will print it out in console
Logger.getLogger("Name of a OutputClass".class.getName()).log(Level.INFO, userString);

编辑

1
2
3
4
SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
SharedPreferences.Editor editor = pref.edit();
editor.putString("yourValue", value);
editor.commit();

读

1
2
SharedPreferences pref = getSharedPreferences("YourPref", MODE_PRIVATE);
value= pref.getString("yourValue","");
1
editor.putString("text", mSaved.getText().toString());

这里，mSaved可以是任何TextView或EditText，我们可以从中提取字符串。你可以简单地指定一个字符串。这里的文本将是保存从mSaved(TextView或EditText)获得的值的键。

1
SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

此外，不需要使用包名称保存首选项文件，即"com.example.app"。您可以提及自己的首选名称。希望这可以帮助 ！

SharedPreferences的基本思想是将事物存储在XML文件中。

  • 声明您的xml文件路径。(如果您没有此文件，Android将创建它。如果您有此文件，Android将访问它。)

    1
    SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);

  • 将值写入共享首选项

    1
    prefs.edit().putLong("preference_file_key", 1010101).apply();

    preference_file_key是共享首选项文件的名称。 1010101是您需要存储的值。

    apply()最后是保存更改。如果从apply()收到错误，请将其更改为commit()。所以这个替代句子是

    1
    prefs.edit().putLong("preference_file_key", 1010101).commit();

  • 从共享首选项中读取

    1
    2
    SharedPreferences sp = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);
    long lsp = sp.getLong("preference_file_key", -1);

    如果preference_file_key没有值，lsp将是-1。如果'preference_file_key'有值，它将返回this的值。

    • 整个编写代码是

    1
    2
        SharedPreferences prefs = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
        prefs.edit().putLong("preference_file_key", 1010101).apply();    // Write the value to key.

    阅读代码是

    1
    2
        SharedPreferences sf = this.getSharedPreferences("com.example.app", Context.MODE_PRIVATE);    // Declare xml file
        long lsp = sp.getLong("preference_file_key", -1);    // Read the key and store in lsp
    相关讨论

    您可以使用此方法保存值：

    1
    2
    3
    4
    5
    6
    7
    8
    public void savePreferencesForReasonCode(Context context,
        String key, String value) {
        SharedPreferences sharedPreferences = PreferenceManager
        .getDefaultSharedPreferences(context);
        SharedPreferences.Editor editor = sharedPreferences.edit();
        editor.putString(key, value);
        editor.commit();
        }

    使用此方法，您可以从SharedPreferences获取值：

    1
    2
    3
    4
    5
    public String getPreferences(Context context, String prefKey) {
      SharedPreferences sharedPreferences = PreferenceManager
     .getDefaultSharedPreferences(context);
     return sharedPreferences.getString(prefKey,"");
    }

    这里prefKey是您用来保存特定值的键。谢谢。

    相关讨论

    最好的做法

    创建使用PreferenceManager命名的接口：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    // Interface to save values in shared preferences and also for retrieve values from shared preferences
    public interface PreferenceManager {

        SharedPreferences getPreferences();
        Editor editPreferences();

        void setString(String key, String value);
        String getString(String key);

        void setBoolean(String key, boolean value);
        boolean getBoolean(String key);

        void setInteger(String key, int value);
        int getInteger(String key);

        void setFloat(String key, float value);
        float getFloat(String key);

    }

    如何使用Activity / Fragment：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    public class HomeActivity extends AppCompatActivity implements PreferenceManager{

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout_activity_home);
        }

        @Override
        public SharedPreferences getPreferences(){
            return getSharedPreferences("SP_TITLE", Context.MODE_PRIVATE);
        }

        @Override
        public SharedPreferences.Editor editPreferences(){
            return getPreferences().edit();
        }

        @Override
        public void setString(String key, String value) {
            editPreferences().putString(key, value).commit();
        }

        @Override
        public String getString(String key) {
            return getPreferences().getString(key,"");
        }

        @Override
        public void setBoolean(String key, boolean value) {
            editPreferences().putBoolean(key, value).commit();
        }

        @Override
        public boolean getBoolean(String key) {
            return  getPreferences().getBoolean(key, false);
        }

        @Override
        public void setInteger(String key, int value) {
            editPreferences().putInt(key, value).commit();
        }

        @Override
        public int getInteger(String key) {
            return getPreferences().getInt(key, 0);
        }

        @Override
        public void setFloat(String key, float value) {
            editPreferences().putFloat(key, value).commit();
        }

        @Override
        public float getFloat(String key) {
            return getPreferences().getFloat(key, 0);
        }
    }

    注意：将您的SharedPreference密钥替换为SP_TITLE。

    例子：

    在shareperence中存储字符串：

    1
    setString("my_key","my_value");

    从shareperence获取字符串：

    1
    String strValue = getString("my_key");

    希望这会帮助你。

    相关讨论

    要在共享首选项中存储值：

    1
    2
    3
    4
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString("Name","Jayesh");
    editor.commit();

    要从共享首选项中检索值：

    1
    2
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    String name = sp.getString("Name",""); // Second parameter is the default value.

    人们建议如何使用SharedPreferences有很多方法。我在这里做了一个演示项目。样本的关键点是使用ApplicationContext＆amp;单个共享首选项对象。这演示了如何使用具有以下功能的SharedPreferences： -

    • 使用singelton类访问/更新SharedPreferences
    • 无需为读/写SharedPreferences总是传递上下文
    • 它使用apply()而不是commit()
    • apply()是异步保存，不返回任何内容，它首先更新内存中的值＆amp;更改将在以后写入磁盘
      asynchronusly。
    • commit()是同步保存，它根据结果返回true / false。更改将同步写入磁盘
    • 适用于android 2.3+版本

    用法示例如下： -

    1
    2
    MyAppPreference.getInstance().setSampleStringKey("some_value");
    String value= MyAppPreference.getInstance().getSampleStringKey();

    获取源代码
    ＆安培;详细的API可以在developer.android.com上找到

    相关讨论

    保存

    1
    PreferenceManager.getDefaultSharedPreferences(this).edit().putString("VarName","your value").apply();

    撤退：

    1
    String name = PreferenceManager.getDefaultSharedPreferences(this).getString("VarName","defaultValue");

    default value is : Values to return if this preference does not exist.

    you can change"this" with getActivity() or getApplicationContext() in
    some cases

    相关讨论

    使用此示例简单明了并检查

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    <?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="com.example.sairamkrishna.myapplication">

       <application
          android:allowBackup="true"
          android:icon="@mipmap/ic_launcher"
          android:label="@string/app_name"
          android:theme="@style/AppTheme">

          <activity
             android:name=".MainActivity"
             android:label="@string/app_name">

             <intent-filter>
               
                <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>

          </activity>

       </application>
    </manifest>
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    public class MainActivity extends AppCompatActivity {
       EditText ed1,ed2,ed3;
       Button b1;

       public static final String MyPREFERENCES ="MyPrefs" ;
       public static final String Name ="nameKey";
       public static final String Phone ="phoneKey";
       public static final String Email ="emailKey";

       SharedPreferences sharedpreferences;

       @Override
       protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);

          ed1=(EditText)findViewById(R.id.editText);
          ed2=(EditText)findViewById(R.id.editText2);
          ed3=(EditText)findViewById(R.id.editText3);

          b1=(Button)findViewById(R.id.button);
          sharedpreferences = getSharedPreferences(MyPREFERENCES, Context.MODE_PRIVATE);

          b1.setOnClickListener(new View.OnClickListener() {
             @Override
             public void onClick(View v) {
                String n  = ed1.getText().toString();
                String ph  = ed2.getText().toString();
                String e  = ed3.getText().toString();

                SharedPreferences.Editor editor = sharedpreferences.edit();

                editor.putString(Name, n);
                editor.putString(Phone, ph);
                editor.putString(Email, e);
                editor.commit();
                Toast.makeText(MainActivity.this,"Thanks",Toast.LENGTH_LONG).show();
             }
          });
       }

    }

    我为sharedpreferences写了一个帮助类：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    import android.content.Context;
    import android.content.SharedPreferences;

    /**
     * Created by mete_ on 23.12.2016.
     */
    public class HelperSharedPref {

    Context mContext;

    public HelperSharedPref(Context mContext) {
        this.mContext = mContext;
    }

    /**
     *
     * @param key Constant RC
     * @param value Only String, Integer, Long, Float, Boolean types
     */
    public void saveToSharedPref(String key, Object value) throws Exception {
        SharedPreferences.Editor editor = mContext.getSharedPreferences(key, Context.MODE_PRIVATE).edit();
        if (value instanceof String) {
            editor.putString(key, (String) value);
        } else if (value instanceof Integer) {
            editor.putInt(key, (Integer) value);
        } else if (value instanceof Long) {
            editor.putLong(key, (Long) value);
        } else if (value instanceof Float) {
            editor.putFloat(key, (Float) value);
        } else if (value instanceof Boolean) {
            editor.putBoolean(key, (Boolean) value);
        } else {
            throw new Exception("Unacceptable object type");
        }

        editor.commit();
    }

    /**
     * Return String
     * @param key
     * @return null default is null
     */
    public String loadStringFromSharedPref(String key) throws Exception {
        SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
        String restoredText = prefs.getString(key, null);

        return restoredText;
    }

    /**
     * Return int
     * @param key
     * @return null default is -1
     */
    public Integer loadIntegerFromSharedPref(String key) throws Exception {
        SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
        Integer restoredText = prefs.getInt(key, -1);

        return restoredText;
    }

    /**
     * Return float
     * @param key
     * @return null default is -1
     */
    public Float loadFloatFromSharedPref(String key) throws Exception {
        SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
        Float restoredText = prefs.getFloat(key, -1);

        return restoredText;
    }

    /**
     * Return long
     * @param key
     * @return null default is -1
     */
    public Long loadLongFromSharedPref(String key) throws Exception {
        SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
        Long restoredText = prefs.getLong(key, -1);

        return restoredText;
    }

    /**
     * Return boolean
     * @param key
     * @return null default is false
     */
    public Boolean loadBooleanFromSharedPref(String key) throws Exception {
        SharedPreferences prefs = mContext.getSharedPreferences(key, Context.MODE_PRIVATE);
        Boolean restoredText = prefs.getBoolean(key, false);

        return restoredText;
    }

    }

    2.存储在共享的prefrence

    1
    2
    3
    4
    SharedPreferences.Editor editor =
    getSharedPreferences("DeviceToken",MODE_PRIVATE).edit();
                        editor.putString("DeviceTokenkey","ABABABABABABABB12345");
    editor.apply();

    2.检索相同的用途

    1
    2
    3
        SharedPreferences prefs = getSharedPreferences("DeviceToken",
     MODE_PRIVATE);
      String deviceToken = prefs.getString("DeviceTokenkey", null);

    我想在此处添加这个问题的大多数代码段在使用SharedPreferences时会有类似MODE_PRIVATE的内容。好吧，MODE_PRIVATE意味着您写入此共享首选项的任何内容只能由您的应用程序读取。

    无论你传递给getSharedPreferences()方法的密钥是什么，android都会创建一个具有该名称的文件，并将偏好数据存储到其中。
    还要记住，当您打算为应用程序提供多个首选项文件时，应该使用getSharedPreferences()。如果您打算使用单个首选项文件并将所有键值对存储到其中，则使用getSharedPreference()方法。很奇怪为什么每个人(包括我自己)都只使用getSharedPreferences()风味，甚至没有理解上面两者之间的区别。

    以下视频教程应该有所帮助
    https://www.youtube.com/watch?v=2PcAQ1NBy98

    简单而轻松的::"Android-SharedPreferences-Helper"库

    迟到总比没有好：我创建了"Android-SharedPreferences-Helper"库，以帮助降低使用SharedPreferences的复杂性和工作量。它还提供了一些扩展功能。它提供的几件事情如下：

    • One line initialization and setup
    • Easily selecting whether to use default preferences or a custom preference file
    • Predefined (data type defaults) and customizable (what you may choose) default values for each datatype
    • Ability to set different default value for single use with just an additional param
    • You can register and unregister OnSharedPreferenceChangeListener as you do for default class
    1
    2
    3
    4
    5
    dependencies {
        ...
        ...
        compile(group: 'com.viralypatel.sharedpreferenceshelper', name: 'library', version: '1.1.0', ext: 'aar')
    }

    Declaration of SharedPreferencesHelper object: (recommended at class
    level)

    1
    SharedPreferencesHelper sph;

    Instantiation of the SharedPreferencesHelper object: (recommended in
    onCreate() method)

    1
    2
    3
    4
    // use one of the following ways to instantiate
    sph = new SharedPreferencesHelper(this); //this will use default shared preferences
    sph = new SharedPreferencesHelper(this,"myappprefs"); // this will create a named shared preference file
    sph = new SharedPreferencesHelper(this,"myappprefs", 0); // this will allow you to specify a mode

    Putting values into shared preferences

    相当简单！与默认方式(使用SharedPreferences类时)不同，您不需要一直调用.edit()和.commit()。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    sph.putBoolean("boolKey", true);
    sph.putInt("intKey", 123);
    sph.putString("stringKey","string value");
    sph.putLong("longKey", 456876451);
    sph.putFloat("floatKey", 1.51f);

    // putStringSet is supported only for android versions above HONEYCOMB
    Set name = new HashSet();
    name.add("Viral");
    name.add("Patel");
    sph.putStringSet("name", name);

    而已！您的值存储在共享首选项中。

    Getting values from shared preferences

    同样，只需一个简单的方法调用键名称。

    1
    2
    3
    4
    5
    6
    7
    8
    sph.getBoolean("boolKey");
    sph.getInt("intKey");
    sph.getString("stringKey");
    sph.getLong("longKey");
    sph.getFloat("floatKey");

    // getStringSet is supported only for android versions above HONEYCOMB
    sph.getStringSet("name");

    It has a lot of other extended functionality

    在GitHub存储库页面上查看扩展功能，使用和安装说明等的详细信息。

    相关讨论

    使用这个简单的库，您可以通过以下方式调用SharedPreferences。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    TinyDB tinydb = new TinyDB(context);

    tinydb.putInt("clickCount", 2);

    tinydb.putString("userName","john");
    tinydb.putBoolean("isUserMale", true);

    tinydb.putList("MyUsers", mUsersArray);
    tinydb.putImagePNG("DropBox/WorkImages","MeAtlunch.png", lunchBitmap);

    //These plus the corresponding get methods are all Included
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    SharedPreferences.Editor editor = getSharedPreferences("identifier",
    MODE_PRIVATE).edit();
    //identifier is the unique to fetch data from your SharedPreference.


    editor.putInt("keyword", 0);
    // saved value place with 0.
    //use this"keyword" to fetch saved value again.
    editor.commit();//important line without this line your value is not stored in preference  

    // fetch the stored data using ....

    SharedPreferences prefs = getSharedPreferences("identifier", MODE_PRIVATE);
    // here both identifier will same

    int fetchvalue = prefs.getInt("keyword", 0);
    // here keyword will same as used above.
    // 0 is default value when you nothing save in preference that time fetch value is 0.

    你需要在AdapterClass或任何其他使用SharedPreferences。
    那个时候只是使用这个声明并使用上面的相同屁股。

    1
    2
    3
    4
    5
    SharedPreferences.Editor editor = context.getSharedPreferences("idetifier",
    Context.MODE_PRIVATE).edit();
    SharedPreferences prefs = context.getSharedPreferences("identifier", Context.MODE_PRIVATE);

    //here context is your application context

    用于字符串或布尔值

    1
    2
    3
    editor.putString("stringkeyword","your string");
    editor.putBoolean("booleankeyword","your boolean value");
    editor.commit();

    获取与上面相同的数据

    1
    2
    String fetchvalue = prefs.getString("keyword","");
    Boolean fetchvalue = prefs.getBoolean("keyword","");

    要在共享首选项中存储值：

    1
    2
    3
    4
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    SharedPreferences.Editor editor = sp.edit();
    editor.putString("Name","Jayesh");
    editor.commit();

    要从共享首选项中检索值：

    1
    2
    SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(this);
    String name = sp.getString("Name","");

    我创建了一个助手课程，让我的生活变得轻松。这是一个通用类，并且有许多常用于共享首选项，电子邮件有效期，日期时间格式等应用程序的方法。在您的代码中复制此类，并在您需要的任何地方访问它的方法。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    156
    157
    158
    159
    160
    161
    162
    163
    164
    165
    166
    167
    168
    169
    170
    171
    172
    173
    174
    175
    176
    177
    178
    179
    180
    181
    182
    183
    184
    185
    186
    187
    188
    189
    190
    191
    192
    193
    194
    195
    196
    197
    198
    199
    200
    201
    202
    203
    204
    205
    206
    207
    208
    209
    210
    211
    212
    213
    214
    215
    216
    217
    218
    219
    220
    221
    222
    223
    224
    225
    226
    227
    228
    229
    230
    231
    232
    233
    234
    235
    236
    237
    238
    239
    240
    241
    242
    243
    244
    245
    246
    247
    248
    249
    250
    251
    252
    253
    254
    255
    256
    257
    258
    259
    260
    261
    262
    263
    264
    265
    266
    267
    268
    269
    270
    271
    272
    273
    274
    275
    276
    277
    278
    279
    280
    281
    282
    283
    284
    285
    286
    287
    288
    289
    290
    291
    292
    293
    294
    295
    296
    297
    298
    299
    300
    301
    302
    303
     import android.app.AlertDialog;
     import android.app.ProgressDialog;
     import android.content.Context;
     import android.content.DialogInterface;
     import android.content.SharedPreferences;
     import android.support.v4.app.FragmentActivity;
     import android.view.inputmethod.InputMethodManager;
     import android.widget.EditText;
     import android.widget.Toast;

     import java.text.ParseException;
     import java.text.SimpleDateFormat;
     import java.util.Date;
     import java.util.Random;
     import java.util.regex.Matcher;
     import java.util.regex.Pattern;
     import java.util.regex.PatternSyntaxException;

    /**
    * Created by Zohaib Hassan on 3/4/2016.
    */
     public class Helper {

    private static ProgressDialog pd;

    public static void saveData(String key, String value, Context context) {
        SharedPreferences sp = context.getApplicationContext()
                .getSharedPreferences("appData", 0);
        SharedPreferences.Editor editor;
        editor = sp.edit();
        editor.putString(key, value);
        editor.commit();
    }

    public static void deleteData(String key, Context context){
        SharedPreferences sp = context.getApplicationContext()
                .getSharedPreferences("appData", 0);
        SharedPreferences.Editor editor;
        editor = sp.edit();
        editor.remove(key);
        editor.commit();

    }

    public static String getSaveData(String key, Context context) {
        SharedPreferences sp = context.getApplicationContext()
                .getSharedPreferences("appData", 0);
        String data = sp.getString(key,"");
        return data;

    }




    public static long dateToUnix(String dt, String format) {
        SimpleDateFormat formatter;
        Date date = null;
        long unixtime;
        formatter = new SimpleDateFormat(format);
        try {
            date = formatter.parse(dt);
        } catch (Exception ex) {

            ex.printStackTrace();
        }
        unixtime = date.getTime();
        return unixtime;

    }

    public static String getData(long unixTime, String formate) {

        long unixSeconds = unixTime;
        Date date = new Date(unixSeconds);
        SimpleDateFormat sdf = new SimpleDateFormat(formate);
        String formattedDate = sdf.format(date);
        return formattedDate;
    }

    public static String getFormattedDate(String date, String currentFormat,
                                          String desiredFormat) {
        return getData(dateToUnix(date, currentFormat), desiredFormat);
    }




    public static double distance(double lat1, double lon1, double lat2,
                                  double lon2, char unit) {
        double theta = lon1 - lon2;
        double dist = Math.sin(deg2rad(lat1)) * Math.sin(deg2rad(lat2))
                + Math.cos(deg2rad(lat1)) * Math.cos(deg2rad(lat2))
                * Math.cos(deg2rad(theta));
        dist = Math.acos(dist);
        dist = rad2deg(dist);
        dist = dist * 60 * 1.1515;
        if (unit == 'K') {
            dist = dist * 1.609344;
        } else if (unit == 'N') {
            dist = dist * 0.8684;
        }
        return (dist);
    }

    /* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
    /* :: This function converts decimal degrees to radians : */
    /* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
    private static double deg2rad(double deg) {
        return (deg * Math.PI / 180.0);
    }

    /* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
    /* :: This function converts radians to decimal degrees : */
    /* ::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: */
    private static double rad2deg(double rad) {
        return (rad * 180.0 / Math.PI);
    }

    public static int getRendNumber() {
        Random r = new Random();
        return r.nextInt(360);
    }

    public static void hideKeyboard(Context context, EditText editText) {
        InputMethodManager imm = (InputMethodManager) context
                .getSystemService(Context.INPUT_METHOD_SERVICE);
        imm.hideSoftInputFromWindow(editText.getWindowToken(), 0);
    }

    public static void showLoder(Context context, String message) {
        pd = new ProgressDialog(context);

        pd.setCancelable(false);
        pd.setMessage(message);
        pd.show();
    }

    public static void showLoderImage(Context context, String message) {
        pd = new ProgressDialog(context);
        pd.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
        pd.setCancelable(false);
        pd.setMessage(message);
        pd.show();
    }

    public static void dismissLoder() {
        pd.dismiss();
    }

    public static void toast(Context context, String text) {

        Toast.makeText(context, text, Toast.LENGTH_LONG).show();
    }
    /*
         public static Boolean connection(Context context) {
        ConnectionDetector connection = new ConnectionDetector(context);
        if (!connection.isConnectingToInternet()) {

            Helper.showAlert(context,"No Internet access...!");
            //Helper.toast(context,"No internet access..!");
            return false;
        } else
            return true;
    }*/

    public static void removeMapFrgment(FragmentActivity fa, int id) {

        android.support.v4.app.Fragment fragment;
        android.support.v4.app.FragmentManager fm;
        android.support.v4.app.FragmentTransaction ft;
        fm = fa.getSupportFragmentManager();
        fragment = fm.findFragmentById(id);
        ft = fa.getSupportFragmentManager().beginTransaction();
        ft.remove(fragment);
        ft.commit();

    }

    public static AlertDialog showDialog(Context context, String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        builder.setMessage(message);

        builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int id) {
                // TODO Auto-generated method stub

            }
        });

        return builder.create();
    }

    public static void showAlert(Context context, String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        builder.setTitle("Alert");
        builder.setMessage(message)
                .setPositiveButton("Ok", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {
                        dialog.dismiss();
                    }
                }).show();
    }

    public static boolean isURL(String url) {
        if (url == null)
            return false;

        boolean foundMatch = false;
        try {
            Pattern regex = Pattern
                    .compile(
                           "\\b(?:(https?|ftp|file)://|www\\.)?[-A-Z0-9+&#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]\\.[-A-Z0-9+&@#/%?=~_|$!:,.;]*[A-Z0-9+&@#/%=~_|$]",
                            Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
            Matcher regexMatcher = regex.matcher(url);
            foundMatch = regexMatcher.matches();
            return foundMatch;
        } catch (PatternSyntaxException ex) {
            // Syntax error in the regular expression
            return false;
        }
    }

    public static boolean atLeastOneChr(String string) {
        if (string == null)
            return false;

        boolean foundMatch = false;
        try {
            Pattern regex = Pattern.compile("[a-zA-Z0-9]",
                    Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
            Matcher regexMatcher = regex.matcher(string);
            foundMatch = regexMatcher.matches();
            return foundMatch;
        } catch (PatternSyntaxException ex) {
            // Syntax error in the regular expression
            return false;
        }
    }

    public static boolean isValidEmail(String email, Context context) {
        String expression ="^[\\w\\.-]+@([\\w\\-]+\\.)+[A-Z]{2,4}$";
        CharSequence inputStr = email;
        Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(inputStr);
        if (matcher.matches()) {
            return true;
        } else {
            // Helper.toast(context,"Email is not valid..!");

            return false;
        }
    }

    public static boolean isValidUserName(String email, Context context) {
        String expression ="^[0-9a-zA-Z]+$";
        CharSequence inputStr = email;
        Pattern pattern = Pattern.compile(expression, Pattern.CASE_INSENSITIVE);
        Matcher matcher = pattern.matcher(inputStr);
        if (matcher.matches()) {
            return true;
        } else {
            Helper.toast(context,"Username is not valid..!");
            return false;
        }
    }

    public static boolean isValidDateSlash(String inDate) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd/mm/yyyy");
        dateFormat.setLenient(false);
        try {
            dateFormat.parse(inDate.trim());
        } catch (ParseException pe) {
            return false;
        }
        return true;
    }

    public static boolean isValidDateDash(String inDate) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd-mm-yyyy");
        dateFormat.setLenient(false);
        try {
            dateFormat.parse(inDate.trim());
        } catch (ParseException pe) {
            return false;
        }
        return true;
    }

    public static boolean isValidDateDot(String inDate) {
        SimpleDateFormat dateFormat = new SimpleDateFormat("dd.mm.yyyy");
        dateFormat.setLenient(false);
        try {
            dateFormat.parse(inDate.trim());
        } catch (ParseException pe) {
            return false;
        }
        return true;
    }

    }

    在这里，我创建了一个Helper类来在android中使用首选项。

    这是助手类：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    public class PrefsUtil {

    public static SharedPreferences getPreference() {
        return PreferenceManager.getDefaultSharedPreferences(Applicatoin.getAppContext());
    }

    public static void putBoolean(String key, boolean value) {
        getPreference().edit().putBoolean(key, value)
                .apply();
    }

    public static boolean getBoolean(String key) {
        return getPreference().getBoolean(key, false);
    }

    public static void putInt(String key, int value) {

        getPreference().edit().putInt(key, value).apply();

    }

    public static void delKey(String key) {

        getPreference().edit().remove(key).apply();

    }

    }

    以函数方式存储和检索全局变量。
    要进行测试，请确保页面上有Textview项，取消注释代码中的两行并运行。然后再次注释这两行，然后运行。
    这里TextView的id是用户名和密码。

    在要使用它的每个类中，最后添加这两个例程。
    我希望这个例程是全局惯例，但不知道如何。这有效。

    变量随处可见。
    它将变量存储在"MyFile"中。你可以按照自己的方式改变它。

    你用它来调用它

    1
    2
     storeSession("username","frans");
     storeSession("password","!2#4%");***

    变量用户名将填入"frans"，密码填写"！2＃4％"。即使重启后它们也可用。

    然后你使用它来检索它

    1
    2
     password.setText(getSession(("password")));
     usernames.setText(getSession(("username")));

    在我的grid.java的整个代码下面

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
        package nl.yentel.yenteldb2;
        import android.content.SharedPreferences;
        import android.os.Bundle;
        import android.support.design.widget.FloatingActionButton;
        import android.support.design.widget.Snackbar;
        import android.support.v7.app.AppCompatActivity;
        import android.support.v7.widget.Toolbar;
        import android.view.View;
        import android.widget.EditText;
        import android.widget.TextView;

        public class Grid extends AppCompatActivity {
        private TextView usernames;
        private TextView password;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
           setContentView(R.layout.activity_grid);
            Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
            setSupportActionBar(toolbar);

            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    Snackbar.make(view,"Replace with your own action", Snackbar.LENGTH_LONG)
                            .setAction("Action", null).show();
                }
            });
            getSupportActionBar().setDisplayHomeAsUpEnabled(true);

          ***//  storeSession("username","[email protected]");
            //storeSession("password","mijn wachtwoord");***
            password = (TextView) findViewById(R.id.password);
            password.setText(getSession(("password")));
            usernames=(TextView) findViewById(R.id.username);
            usernames.setText(getSession(("username")));
        }

        public void storeSession(String key, String waarde) {
            SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
            SharedPreferences.Editor editor = pref.edit();
            editor.putString(key, waarde);
            editor.commit();
        }

        public String getSession(String key) {
    //http://androidexample.com/Android_SharedPreferences_Basics/index.php?view=article_discription&aid=126&aaid=146
            SharedPreferences pref = getApplicationContext().getSharedPreferences("MyFile", MODE_PRIVATE);
            SharedPreferences.Editor editor = pref.edit();
            String output = pref.getString(key, null);
            return output;
        }

        }

    在下面你找到textview项目

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="usernames"
        android:id="@+id/username"
        android:layout_below="@+id/textView"
        android:layout_alignParentStart="true"
        android:layout_marginTop="39dp"
        android:hint="hier komt de username" />

     <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="password"
        android:id="@+id/password"
        android:layout_below="@+id/user"
        android:layout_alignParentStart="true"
        android:hint="hier komt het wachtwoord" />