Android中SharePreference的使用

合集下载

Android文件存储与SharedPreferences存储方式详解用法

Android⽂件存储与SharedPreferences存储⽅式详解⽤法⽬录持久化技术简介⽂件存储1. 将数据存储到⽂件中2. 从⽂件中读取数据SharedPreferences 存储1. 将数据存储到 SharedPreferences 中2. 从 SharedPreferences 中读取数据持久化技术简介数据持久化就是指将那些内存中的瞬时数据保存到存储设备中，保证即使在⼿机或计算机关机的情况下，这些数据也不会丢失。

保存在内存中的数据是处于瞬时状态的，⽽保存在存储设备的数据是处于持久状态的。

持久化技术提供了⼀种机制，可以让数据在瞬时状态和持久状态之间进⾏切换⽂件存储1. 将数据存储到⽂件中⽂件存储是 Android 中最基本的数据存储⽅式，它不对存储的内容进⾏格式化处理，所有数据都是原封不动的保存到⽂件当中，适合存储⼀些简单的⽂本数据或⼆进制数据Context类提供了⼀个openFileOutput()⽅法，可以将数据存储到指定的⽂件中fun save(inputText: String) {try {val output = openFileOutput("data", Context.MODE_PRIVATE)val writer = BufferedWriter(OutputStreamWriter(output))e {it.write(inputText)}} catch (e: IOException) {e.printStackTrace()}}openFileOutput()⽅法接收两个参数：第⼀个参数是⽂件名，在⽂件创建的时候使⽤。

指定的⽂件名可以不包含路径，因为所有的⽂件都默认存储到/data/data/<package name>/files/ ⽬录下第⼆个参数是⽂件的操作模式，主要有MODE_PRIVATE和MODE_APPEND两种模式可选，默认是MODE_PRIVATE，表⽰当指定相同⽂件名时，所写⼊的内容将会覆盖原⽂件的内容。

黑马程序员安卓教程：SharedPreferences 的使用

SharedPreferences 的使用SharedPreferences 简称sp，是Android 平台上一个轻量级的存储类，一般应用程序都会提供“设置”或者“首选项”等这样的界面，那么这些设置就可以通过sp来保存。

在Android系统中该文件保存在：/data/data/包名/shared_prefs目录下。

在本节中依然使用1.3中的需求，只不过将数据的存储方式改为sp。

因此需求和布局就不再赘述。

1.6.1 编写代码【文件1-9】MainActivity.java1.package com.itheima.android.save.data;2.3.import com.itheima.android.save.sp.R;4.import android.os.Bundle;5.import android.app.Activity;6.import android.content.SharedPreferences;7.import android.content.SharedPreferences.Editor;8.import android.text.TextUtils;9.import android.view.View;10.import android.widget.CheckBox;11.import android.widget.EditText;12.import android.widget.Toast;13.14./**15.*16.* @author wzy2015-10-2317.* 将数据存储到SharedPreferences中18.*/19.public class MainActivity extends Activity{20.21.private EditText et_name;22.private EditText et_pwd;23.private CheckBox cb;24.private SharedPreferences sp;25.26.@Override27.protected void onCreate(Bundle savedInstanceState){28.super.onCreate(savedInstanceState);29.setContentView(yout.activity_main);30.// 获取控件31.et_name = (EditText) findViewById(R.id.et_name);32.et_pwd=(EditText) findViewById(R.id.et_pwd);33.cb = (CheckBox) findViewById(R.id.cb);34./*35.* 调用父类的方法获取sp对象36.* 第一个参数：sp文件的名字，没有则创建37.* 第二个参数：文件权限38.*/39.sp = getSharedPreferences("info", MODE_PRIVATE);40.41.// 数据的回显42.// 从sp中获取数据43.String name=sp.getString("name","");44.String pwd= sp.getString("pwd", "");45.// 给EditText设置数据46.et_name.setText(name);47.et_pwd.setText(pwd);48.}49.50./*51.* 给登录按钮绑定的点击事件52.*/53.public void login(View view) {54.// 获取EditText中的数据55.String name=et_name.getEditableText().toString().trim();56.String pwd= et_pwd.getText().toString().trim();57.// 校验数据58.if (TextUtils.isEmpty(name) ||TextUtils.isEmpty(pwd)){59.Toast.makeText(this, _txt,Toast.LENGTH_SHORT).show();60.return;61.}62.// 获取CheckBox的选中状态63.boolean checked = cb.isChecked();64.// 保存数据name##pwd65.if (checked) {66.try{67./*68.* 如果想往sp中添加、修改、删除数据则需要通过sp获取到Editor69.*/70.Editor editor = sp.edit();71.// 设置数据72.editor.putString("name",name);73.editor.putString("pwd", pwd);74.// 一定要记得执行提交方法，不然前面保存的数据没有任何效果mit();76.77.}catch (Exception e){78. e.printStackTrace();79.}80.}else{81.// 删除数据82.Editor edit=sp.edit();83.edit.clear();mit();85.}86.}87.}注意：将数据保存到sp中后通过DDMS观测data/data/包名/目录结构如图1-9。

sharepreferences 排序规则

"SharePreferences" 是Android 中用于存储小量数据的一种轻量级持久性存储机制。

通常，`SharedPreferences` 存储的数据是键值对形式的。

在`SharedPreferences` 中，键（keys）是唯一的，而值（values）可以是不同的数据类型，如整数、字符串、布尔值等。

`SharedPreferences` 中的数据是按照键（keys）的字母顺序来排序的。

这意味着如果您使用相同的`SharedPreferences` 文件来存储多个键值对，那么您可以期望这些键值对按字母顺序排列。

这通常是有助于组织和检索数据的。

以下是一个示例，演示如何使用`SharedPreferences` 存储和检索数据：```java// 获取SharedPreferences 对象SharedPreferences sharedPreferences =getSharedPreferences("mySharedPreferences", Context.MODE_PRIVATE);// 编辑SharedPreferencesSharedPreferences.Editor editor = sharedPreferences.edit();editor.putString("key1", "value1");editor.putString("key3", "value3");editor.putString("key2", "value2");editor.apply();// 从SharedPreferences 检索数据String value1 = sharedPreferences.getString("key1", "");String value2 = sharedPreferences.getString("key2", "");String value3 = sharedPreferences.getString("key3", "");```在上述示例中，键"key1"、"key2" 和"key3" 的数据会按照字母顺序排列。

android SharedPreferences详解

1.概述。

SharePreferences是用来存储一些简单配置信息的一种机制，使用Map数据结构来存储数据，以键值对的方式存储，采用了XML格式将数据存储到设备中。

例如保存登录用户的用户名和密码。

只能在同一个包内使用，不能在不同的包之间使用，其实也就是说只能在创建它的应用中使用，其他应用无法使用。

创建的存储文件保存在/data/data/<package name>/shares_prefs文件夹下。

2.使用。

通过Context.getSharedPreferences方法获取SharedPreferences对象，参数分别为存储的文件名和存储模式。

[java]view plaincopyprint?1.// 获取SharedPreferences对象2.SharedPreferences sp = getSharedPreferences(DATABASE, Activity.MODE_PRIVATE);3.// 获取Editor对象4.Editor editor = sp.edit();3.操作。

SharePreferences存储数据是通过获取Editor编辑器对象来操作的。

插入数据：调用Editor.putxxxx方法，两个参数分别为键和值。

获取数据：调用Editor.getxxxx方法，两个参数分别为键和不存在指定键时的默认值。

删除数据：调用Editor.remove方法，参数为指定的键。

清空所有数据：调用Editor.clear方法上述所有方法调用都要执行mit方法来提交。

下面通过对数据的增删改查来演示下SharePreferences的使用。

完整程序下载地址：android_sharedpreferences.rar[java]view plain copyprint?1./**2. * MainActivity3. *4. * @author zuolongsnail5. */6.public class MainActivity extends Activity {7. private EditText keyET;8. private EditText valueET;9. private Button insertBtn;10. private Button deleteBtn;11. private Button modifyBtn;12. private Button queryBtn;13. private Button clearBtn;14. private TextView textView;15. /** 存储的文件名 */16. public static final String DATABASE = "Database";17. /** 存储后的文件路径：/data/data/<package name>/shares_prefs + 文件名.xml */18. public static final String PATH = "/data/data/code.sharedpreferences/shared_prefs/Database.xml";19.20.@Override21. public void onCreate(Bundle savedInstanceState) {22. super.onCreate(savedInstanceState);23. setContentView(yout.main);24. keyET = (EditText) findViewById(R.id.key);25. valueET = (EditText) findViewById(R.id.value);26. insertBtn = (Button) findViewById(R.id.insert);27. deleteBtn = (Button) findViewById(R.id.delete);28. modifyBtn = (Button) findViewById(R.id.modify);29. queryBtn = (Button) findViewById(R.id.query);30. clearBtn = (Button) findViewById(R.id.clear);31. // 用于显示存储文件中数据32. textView = (TextView) findViewById(R.id.content);33. insertBtn.setOnClickListener(new OperateOnClickListener());34. deleteBtn.setOnClickListener(new OperateOnClickListener());35. modifyBtn.setOnClickListener(new OperateOnClickListener());36. queryBtn.setOnClickListener(new OperateOnClickListener());37. clearBtn.setOnClickListener(new OperateOnClickListener());38. }39.40. class OperateOnClickListener implements OnClickListener {41.@Override42. public void onClick(View v) {43. // 获取SharedPreferences对象44. SharedPreferences sp = getSharedPreferences(DATABASE,45. Activity.MODE_PRIVATE);46. // 获取Editor对象47. Editor editor = sp.edit();48. // 获取界面中的信息49. String key = keyET.getText().toString();50. String value = valueET.getText().toString();51. switch (v.getId()) {52. // 插入数据53. case R.id.insert:54. editor.putString(key, value);55. mit();56. textView.setText(MainActivity.this.print());57. break;58. // 删除数据59. case R.id.delete:60. editor.remove(key);61. mit();62. textView.setText(MainActivity.this.print());63. break;64. // 修改数据65. case R.id.modify:66. editor.putString(key, value);67. mit();68. textView.setText(MainActivity.this.print());69. break;70. // 查询数据71. case R.id.query:72. String result = sp.getString(key, "");73. textView.setText("key=" + key + ",value=" + result);74. break;75. // 清空所有数据76. case R.id.clear:77. editor.clear();78. mit();79. textView.setText(MainActivity.this.print());80. break;81. }82.83. }84. }85.86. /** 获取存储文件的数据 */87. private String print() {88. StringBuffer buff = new StringBuffer();89. try {90. BufferedReader reader = new BufferedReader(new InputStreamReader(91. new FileInputStream(PATH)));92. String str;93. while ((str = reader.readLine()) != null) {94. buff.append(str + "/n");95. }96. } catch (Exception e) {97. e.printStackTrace();98. }99. return buff.toString();100. }101.}下面提供一个SharedPreferences工具类，在开发中直接调用即可。

Android中SharedPreferences与文件操作

打开一个与应用程序联系的私有文件输入流 6. ByteArrayOutputStream baos = new ByteArrayOutpu tStream(); 当文件不存在时抛出FileNotFoundException 7. byte[] buffer = new byte[1024]; FileInputStream in = 8. int len = 0; 9. this.openFileInput("test.txt");// while ((len = fis.read(buffer)) != -1) { 打开文件 "test.txt" 10. baos.write(buffer, 0, len); …… 11. } 12. content = baos.toString(); in.close();// 关闭输入流 13. fis.close(); 14. baos.close(); 15. } catch (Exception e) { 16. e.printStackTrace(); 17. } 18. return content; 19. }

SharedPreferences sharedPreferences = getSharedPreferences("lxt008", Context.MODE_PRIVATE); Editor editor = sharedPreferences.edit();//获取编辑器 editor.putString("name", "lxt"); editor.putInt("age", 35); mit();//提交修改生成的lxt008.xml文件内容如下： <?xml version=“1.0” encoding=“utf-8” standalone=“yes” ?> <map> <string name="name">lxt</string> <int name="age" value=“30" /> </map>

安卓sharedpreferences的用法

安卓sharedpreferences的用法安卓中的SharedPreferences是一种轻量级的数据存储方式，用于存储和读取应用程序的简单键值对数据。

SharedPreferences旨在存储应用程序的配置信息、用户首选项和其他简单的数据类型，以便在应用程序下次启动时可以快速读取。

SharedPreferences的使用非常简便，接下来我会一步一步回答你关于它的问题，帮助你更好地理解和运用。

第一步：创建SharedPreferences对象在安卓中，我们可以通过Context类的getSharedPreferences()方法来创建SharedPreferences对象。

这个方法接受两个参数，第一个参数是SharedPreferences的名称，第二个参数是指定访问模式（MODE_PRIVATE表示只有当前应用程序可以访问）。

SharedPreferences sharedPreferences = getSharedPreferences("MyData", Context.MODE_PRIVATE);第二步：保存数据要保存数据到SharedPreferences中，我们需要使用SharedPreferences对象的edit()方法获取一个Editor对象，然后使用Editor对象的putXxx()方法将数据存入。

SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putString("username", "John");editor.putInt("age", 25);editor.putBoolean("isMarried", false);editor.apply();在上面的例子中，我们使用putString()方法将用户名存储为"John"，putInt()方法将年龄存储为25，putBoolean()方法将婚姻状态存储为false。

android sharedpreferences原理

android sharedpreferences原理Android SharedPreferences原理解析什么是SharedPreferencesSharedPreferences是Android中的一种轻量级的数据存储方式，用于存储简单的键值对数据。

它基于XML文件存储，并提供了简单的接口来读取和写入数据。

SharedPreferences的工作原理SharedPreferences的实现是通过XML文件进行数据的存储和读取。

每个应用程序都有自己的SharedPreferences文件，可以在应用程序中使用默认的SharedPreferences对象，也可以自定义名称的SharedPreferences对象。

SharedPreferences的创建和获取创建SharedPreferences对象可以通过以下方式创建SharedPreferences对象： 1. 使用默认的SharedPreferences文件：SharedPreferences sharedPreferences = (Context);2.使用自定义名称的SharedPreferences文件：SharedPreferences sharedPreferences = (name, _PRIVA TE);可以通过以下方式获取SharedPreferences中的值：String value = (key, defaultValue);其中，key为要获取的值对应的键，defaultValue为默认值，在SharedPreferences中找不到对应的键时将返回默认值。

SharedPreferences的操作方法写入SharedPreferences可以通过以下方式写入SharedPreferences中的值：editor = ();(key, value);();其中，key为要保存的值对应的键，value为要保存的值。

sharedpreferences的作用和使用方法

SharedPreferences是Android平台上一个轻量级的存储类，主要用于保存应用的一些常用配置，如Activity状态等。

当Activity暂停时，可以将此Activity的状态保存到SharedPreferences中，当Activity重载时，系统回调方法onSaveInstanceState会从SharedPreferences中取出之前保存的值。

SharedPreferences提供了Java常规的Long、Int、String等类型数据的保存接口，其存储的数据以XML格式保存在本地文件中。

使用SharedPreferences存储数据相对简单，主要通过以下步骤进行：获取SharedPreferences对象：可以通过调用Context类的getSharedPreferences()方法来获取SharedPreferences对象，第一个参数为文件名，第二个参数为操作模式，通常使用MODE_PRIVATE。

获取SharedPreferences.Editor对象：通过调用SharedPreferences 对象的edit()方法来获取SharedPreferences.Editor对象，用于添加、删除、修改数据。

添加、删除、修改数据：使用SharedPreferences.Editor对象提供的putXxx()或remove()方法来添加或删除数据，其中Xxx表示具体的类型，如String、Int等。

提交数据：完成数据的添加、删除、修改后，需要调用commit()方法来提交数据。

需要注意的是，SharedPreferences的读写操作是线程不安全的，如果在多线程环境下使用SharedPreferences，可能会导致数据读写不一致的问题。

因此，如果需要在多线程环境下读写SharedPreferences，需要进行相应的同步处理。

android之sharePreferences的存储数据流程（十七）

android之sharePreferences的存储数据流程（⼗七）sharedPreferences是通过xml⽂件来做数据存储的。

⼀般⽤来存放⼀些标记性的数据，⼀些设置信息。

*********使⽤sharedPreferences存储数据的步骤1.通过Context对象创建⼀个SharedPreference对象//name:sharedpreference⽂件的名称 mode:⽂件的操作模式SharedPreferences sharedPreferences = context.getSharedPreferences("userinfo.txt", Context.MODE_PRIVATE); 2.通过sharedPreferences对象获取⼀个Editor对象Editor editor = sharedPreferences.edit();3.往Editor中添加数据editor.putString("username", username);editor.putString("password", password);4.提交Editor对象mit();*********使⽤sharedPreferences读取数据1.通过Context对象创建⼀个SharedPreference对象SharedPreferences sharedPreferences = context.getSharedPreferences("userinfo.txt", Context.MODE_PRIVATE); 2.通过sharedPreference获取存放的数据//key:存放数据时的key defValue: 默认值,根据业务需求来写String username = sharedPreferences.getString("username", "");String password = sharedPreferences.getString("password", "");通过PreferenceManager可以获取⼀个默认的sharepreferences对象SharedPreferences sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);。

安卓preference的用法

安卓preference的用法安卓Preference是一种用户界面元素，用于显示和修改应用程序的设置。

使用Preference，可以方便地管理应用程序的各种配置选项，并提供了一些内置的界面元素，如复选框、单选按钮、编辑框等。

以下是Preference的用法：1. 在res文件夹下的xml文件夹中创建一个preference.xml文件，用于定义Preference的布局和属性。

2. 在布局文件中使用PreferenceScreen标签作为Preference 的容器，并在其中定义各种Preference元素。

3. 在Activity中使用PreferenceFragment或PreferenceActivity来显示和管理Preference。

- 如果使用PreferenceFragment，需要创建一个继承自PreferenceFragment的子类，并在其中加载preference.xml文件。

- 如果使用PreferenceActivity，可以直接在Activity的布局文件中嵌入PreferenceScreen标签，或者通过setPreferenceScreen 方法将preference.xml文件加载到Activity中。

4. 在Manifest文件中声明Activity，并设置其主题为Theme.AppCompat或Theme.Holo等兼容主题。

5. 在Activity中，可以使用SharedPreferences来读取和写入Preference的值。

- 使用Preference的getKey方法获取Preference的键，然后使用SharedPreferences的get方法获取对应的值。

- 使用SharedPreferences的edit方法获取Editor对象，然后使用put方法设置Preference的值，并使用commit方法提交修改。

6. 可以通过Preference的setOnPreferenceChangeListener方法为Preference设置监听器，以便在值发生变化时进行相应的操作。

sharedpreferences 类

在Android开发中，SharedPreference类是一种轻量级的数据存储方式，它可以用来保存小段的数据，如用户设置、游戏进度等。

在本文中，我将深入探讨SharedPreference类的使用方式、优缺点以及个人观点。

1. SharedPreference类的基本概念SharedPreference是Android提供的一种数据存储方式，它以键值对的形式存储数据，并且可以跨进程使用。

使用SharedPreference 类可以方便地存储和读取各种数据类型，如int、long、float、String 等。

2. SharedPreference类的使用方法在Android开发中，要使用SharedPreference类，首先需要通过Context对象获取SharedPreferences实例，然后通过实例的edit()方法获取SharedPreferences.Editor对象，再通过Editor对象的putXXX()方法存储数据，最后调mit()或apply()方法提交数据。

在读取数据时，只需通过SharedPreferences实例的getXXX()方法即可获取相应的数据。

3. SharedPreference类的优缺点优点：SharedPreference类使用简单方便，适用于存储小量的数据；可以跨进程使用，非常适合用来保存应用的配置信息；数据存储在xml文件中，不会影响应用的性能。

缺点：不适合存储大量的数据，因为数据存储在xml文件中，可能会导致文件过大，影响读写性能；数据存储在手机内部，无法直接被其他应用读取，可能存在安全性问题。

4. 我对SharedPreference类的个人观点和理解在实际开发中，我认为SharedPreference类是一种非常方便的数据存储方式，特别适合用来保存应用的配置信息，如用户设置、游戏进度等。

但是，在存储大量数据时，建议使用其他存储方式，如数据库或文件存储，以免影响应用的性能和用户体验。

sharepreference使用方法

sharepreference使用方法sharepreference是Android中用于存储小量数据的一种轻量级数据存储方式，本文将介绍sharepreference的使用方法。

1. 获取SharePreference实例对象可以使用getSharedPreferences()或getPreferences()方法获取SharePreference实例对象，其中getSharedPreferences()方法需要指定文件名和模式，而getPreferences()方法则将当前Activity的类名作为文件名。

// 获取文件名为'my_data'的SharePreference实例对象SharedPreferences sp = getSharedPreferences('my_data', MODE_PRIVATE);// 获取当前Activity的SharePreference实例对象SharedPreferences sp = getPreferences(MODE_PRIVATE);2. 存储数据存储数据需要使用Editor对象，调用Editor对象的putXxx()方法存储数据，其中Xxx表示不同的数据类型，例如putInt()、putString()等。

SharedPreferences.Editor editor = sp.edit();editor.putString('name', '张三');editor.putInt('age', 18);editor.putBoolean('isMarried', false);mit();3. 读取数据读取数据需要使用getXXX()方法，其中XXX表示不同的数据类型，例如getInt()、getString()等。

String name = sp.getString('name', '');int age = sp.getInt('age', 0);boolean isMarried = sp.getBoolean('isMarried', false);4. 删除数据删除某个键值对的数据可以使用remove()方法，删除所有数据可以使用clear()方法。

Android中SharedPreference详解及简单实例

Android中SharedPreference详解及简单实例Android中SharedPreference详解SharedPreference是Android提供的⼀种轻量级的数据存储⽅式，主要⽤来存储⼀些简单的配置信息，例如，默认欢迎语，登录⽤户名和密码等。

其以键值对的⽅式存储,使得我们能很⽅便进⾏读取和存⼊。

SharedPreference ⽂件保存在/data/data/<package name>/shared_prefs 路径下(如/data/data/com.android.alarmclock/shared_prefs/com.android.text_preferences.xml)，通过cat命令可以查看⽂件，如：通过Activity⾃带的getSharedPreferences⽅法，可以得到SharedPreferences对象。

public abstract SharedPreferences getSharedPreferences (String name, int mode);name：表⽰保存后 xml ⽂件的名称mode：表⽰ xml ⽂档的操作权限模式(私有,可读,可写)，使⽤0或者MODE_PRIVATE作为默认的操作权限模式。

1.数据读取：通过SharedPreferences对象的键key可以获取到对应key的键值。

对于不同类型的键值有不同的函数：getBoolean,getInt,getFloat,getLong.public abstract String getString (String key, String defValue);2.数据存⼊：数据的存⼊是通过SharedPreferences对象的编辑器对象Editor来实现的。

通过编辑器函数设置键值，然后调⽤commit()提交设置，写⼊xml⽂件。

public abstract SharedPreferences.Editor edit ();public abstract SharedPreferences.Editor putString (String key, String value);public abstract boolean commit ();下⾯⼀个实例显⽰⼀个TextView，上⾯显⽰⽤户使⽤该应⽤的次数。

sharedpreference 简单使用

sharedpreference 简单使用SharedPreference是Android中一种轻量级的数据存储方式，可以用来保存一些简单的应用程序配置信息或者是用户个性化设置等数据。

接下来就为大家分享一下在Android开发过程中如何进行SharedPreference的简单使用。

1. SharedPreference的简单介绍SharedPreference是Android系统提供的一种轻型的数据存储方式，通过键值对的形式存储数据，在应用程序退出后数据仍然会保留。

SharedPreference在本地以xml文件的形式存在，数据存取速度快，适用于存储小量数据。

2. SharedPreference的获取获取SharedPreference的实例对象方式有两种：（1）Context.getSharedPreferences()方法可以通过Context类的getSharedPreferences()方法获取SharedPreference实例对象。

例如：获取名为myPreferences的SharedPreference对象SharedPreferences sharedPreferences =getSharedPreferences("myPreferences", Context.MODE_PRIVATE);（2）Activity.getPreferences()方法Activity.getPreferences可以直接获取Activity本身的SharedPreference对象。

例如：获取当前Activity的SharedPreference实例对象SharedPreferences sharedPreferences =getPreferences(Context.MODE_PRIVATE);3. SharedPreference的读写操作（1）写入数据SharedPreferences.Editor对象可以实现SharedPreference的写入操作，具体代码如下：SharedPreferences sharedPreferences =getSharedPreferences("myPreferences", Context.MODE_PRIVATE); SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putString("name", "Jack");//写入一个String类型的数据editor.putInt("age", 12);//写入一个int类型的数据editor.putBoolean("isBoy", true);//写入一个Boolean类型的数据editor.apply();//提交数据（2）读取数据读取数据同样使用SharedPreferences的实例对象，具体代码如下：SharedPreferences sharedPreferences =getSharedPreferences("myPreferences", Context.MODE_PRIVATE); String name = sharedPreferences.getString("name", "");int age = sharedPreferences.getInt("age", 0);boolean isBoy = sharedPreferences.getBoolean("isBoy", false);4. SharedPreference数据的删除SharedPreference的删除操作可以使用remove()方法，也可以使用clear()方法删除所有数据。

android sharedpreferences用法

android sharedpreferences用法Android中的SharedPreferences是一种轻量级的数据存储方式，可以用来保存和获取简单的键值对数据。

SharedPreferences提供了一种简单的方式，允许我们存储和检索数据，这些数据在应用程序退出后也会保留。

在本文中，我们将一步一步地介绍SharedPreferences的使用方法。

首先，我们需要明确一下什么是SharedPreferences。

SharedPreferences 是一种存储数据的机制，允许我们存储和检索数据，这些数据以键值对的形式存在。

SharedPreferences存储的数据是以XML文件的形式保存在设备的存储目录下。

在Android中，我们可以通过调用getSharedPreferences()方法来获取SharedPreferences对象。

这个方法需要两个参数：第一个参数是SharedPreferences对象的名称，第二个参数是访问模式。

访问模式有两种：MODE_PRIVATE和MODE_MULTI_PROCESS。

MODE_PRIVATE是默认的访问模式，表示只有当前应用程序可以访问这个SharedPreferences对象；MODE_MULTI_PROCESS表示允许其他应用程序来共享这个SharedPreferences对象。

获取了SharedPreferences对象后，我们可以使用putXXX()方法来存储数据。

其中，XXX是数据类型的名称，比如putInt()用于存储整数，putString()用于存储字符串。

这些方法需要两个参数：第一个参数是键，用于标识这个数据；第二个参数是值，表示要存储的具体数据。

例如，我们可以使用以下代码来存储一个整数和一个字符串到SharedPreferences中：SharedPreferences sharedPreferences = getSharedPreferences("MyData", Context.MODE_PRIVATE); SharedPreferences.Editor editor = sharedPreferences.edit(); editor.putInt("age", 25);editor.putString("name", "Tom");editor.apply();上述代码中，我们首先通过`getSharedPreferences()`方法获取了一个名为“MyData”的SharedPreferences对象，并指定了访问模式为MODE_PRIVATE。

Android开发之 SharedPreferences 使用总结

1.SharedPreferences简介Sharedpreferences是Android平台上一个轻量级的存储类，可以用于保存应用程序的各种配置信息，如应用设置里面的各种开关、是否打开音效、是否使用震动效果、小游戏的玩家积分等，其本质是以“键-值”对的方式保存数据到本地的 xmxxxxl 文件中，其文件保存在/data/data/<package name>/shared_prefs 目录下。

&emsp;&emsp;核心原理：以“键-值”对的方式保存数据到本地的 xmxxxxl 文件中，具体实现是在 SharedPreferencesImpl 里面使用Map来管理，xmxxxxl 文件的具体保存路径是在/data/data/<package name>/shared_prefs 目录下。

SharedPreferences对象本身只能获取数据而不支持存储和修改，存储修改是通过SharedPreferences.edit()获取的内部接口Editor对象实现。

SharedPreferences本身是一个接口，程序无法直接创建SharedPreferences实例，只能通过Context提供的getSharedPreferences(String name int mode)方法来获取SharedPreferences实例，该方法中name表示要操作的xmxxxxl文件名，第二个参数具体如下：Context.MODE_APPEND: 追加方式存储Context.MODE_PRIVATE: 指定该SharedPreferences数据只能被本应用程序读、写。

Context.MODE_WORLD_READABLE: 指定该SharedPreferences数据能被其他应用程序读，但不能写。

Context.MODE_WORLD_WRITEABLE: 指定该SharedPreferences数据能被其他应用程序读，写Context.MODE_MULTI_PROCESS: 适用于多进程访问(目前已被废弃，google官方推荐使用ContentProvider来实现进程间共享访问)Editor有如下主要重要方法：SharedPreferences.Editor clear():清空SharedPreferences里所有数据SharedPreferences.Editor putXxx(String key xxx value): 向SharedPreferences存入指定key 对应的数据，其中xxx 可以是booleanfloatint等各种基本类型据SharedPreferences.Editor remove(): 删除SharedPreferences中指定key对应的数据项boolean commit(): 当Editor编辑完成后，使用该方法提交修改首次创建SharedPreferences对象（即SharedPreferences初始化时），会根据文件名将文件下内容一次性加载到mMap容器中，每当我们edit都会创建一个新的EditorImpl对象，当修改或者添加数据时会将数据添加到mModifiled容器中，然后commit或者apply操作比较mMap与mModifiled数据修正mMap中最后一次提交数据然后写入到文件中。

Android SharedPreferences的使用

SharedPreferences的使用SharedPreferences是Android平台上一个轻量级的存储类，主要是保存一些常用的配置比如窗口状态，一般在Activity中重载窗口状态onSaveInstanceState保存一般使用SharedPreferences完成，它提供了Android平台常规的Long长整形、Int整形、String 字符串型的保存，它是什么样的处理方式呢?SharedPreferences类似过去Windows系统上的ini配置文件，但是它分为多种权限，可以全局共享访问，android123提示最终是以xml 方式来保存，整体效率来看不是特别的高，对于常规的轻量级而言比SQLite要好不少，如果真的存储量不大可以考虑自己定义文件格式。

xml 处理时Dalvik会通过自带底层的本地XML Parser解析，比如XMLpull方式，这样对于内存资源占用比较好。

这种方式应该是用起来最简单的Android读写外部数据的方法了。

他的用法基本上和J2SE(java.util.prefs.Preferences)中的用法一样，以一种简单、透明的方式来保存一些用户个性化设置的字体、颜色、位置等参数信息。

一般的应用程序都会提供“设置”或者“首选项”的这样的界面，那么这些设置最后就可以通过Preferences来保存，而程序员不需要知道它到底以什么形式保存的，保存在了什么地方。

当然，如果你愿意保存其他的东西，也没有什么限制。

只是在性能上不知道会有什么问题。

在Android系统中，这些信息以XML文件的形式保存在/data/data/PACKAGE_NAME /shared_prefs 目录下。

下面是程序代码：[java]view plaincopy1.package com.cloay;2.3.import android.app.Activity;4.import android.content.SharedPreferences;5.import android.os.Bundle;6.import android.view.MotionEvent;7.import android.view.View;8.import android.view.View.OnTouchListener;9.import android.widget.EditText;10.import android.widget.ImageButton;11./**12. *13. * MySharedPreferencesActivity.java14. * @author cloay15. * 2011-10-1816. */17.public class MySharedPreferencesActivity extends Activity {18.private EditText user = null;19.private EditText password = null;20.21.private ImageButton loginBtn = null;22.@Override23.public void onCreate(Bundle savedInstanceState) {24.super.onCreate(savedInstanceState);25. setContentView(yout.main);26. user = (EditText)findViewById(er);27. password = (EditText)findViewById(R.id.pass);28. loginBtn = (ImageButton)findViewById(R.id.loginButton);29. initView();30. loginBtn.setOnTouchListener(new OnTouchListener(){31.32.@Override33.public boolean onTouch(View v, MotionEvent event) {34.if(event.getAction()==MotionEvent.ACTION_DOWN){35. v.setBackgroundResource(R.drawable.dengluxitong1);36. SharedPreferences userInfo = getSharedPreferences("user_info", 0);37. userInfo.edit().putString("name", user.getText().toString()).commit();38. userInfo.edit().putString("pass", password.getText().toString()).commit();39. }40.else if(event.getAction()==MotionEvent.ACTION_UP){41. v.setBackgroundResource(R.drawable.dengluxitong);42. }43.return false;44. }45.46. });47. }48.private void initView() {49. SharedPreferences userInfo = getSharedPreferences("user_info", 0);50. String username = userInfo.getString("name", "");51. String pass = userInfo.getString("pass", "");52. user.setText(username);53. password.setText(pass);54. }55.}SharedPreferences settings = getSharedPreferences(PREFS_NAME, 0);通过名称，得到一个SharedPreferences，顾名思义，这个Preferences是共享的，共享的范围据现在同一个Package中，这里面说所的Package和Java里面的那个Package不同，貌似这里面的Package是指在AndroidManifest.xml文件中的[html]view plaincopy1.<?xml version="1.0"encoding="utf-8"?>2.<manifest xmlns:android="/apk/res/android"3.package="com.cloay"4.android:versionCode="1"5.android:versionName="1.0">6.<uses-sdk android:minSdkVersion="8"/>7.8.<application android:icon="@drawable/icon"android:label="@string/app_name">9.<activity android:name=".MySharedPreferencesActivity"10.android:label="@string/app_name">11.<intent-filter>12.<action android:name="android.intent.action.MAIN"/>13.<category android:name="UNCHER"/>14.</intent-filter>15.</activity>16.17.</application>18.</manifest>布局文件如下：<?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:android="/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent"android:layout_height="fill_parent"><EditText android:layout_width="185dp" android:id="@+id/user"android:layout_height="40dp" android:hint="请输入用户名"android:singleLine="true" android:layout_alignParentTop="true"android:layout_alignLeft="@+id/pass" android:layout_marginTop="66dp"><requestFocus></requestFocus></EditText><EditText android:inputType="textPassword"android:layout_width="185dp" android:id="@+id/pass"android:layout_height="40dp" android:hint="请输入密码" android:singleLine="true"android:layout_below="@+id/user" android:layout_centerHorizontal="true" android:layout_marginTop="44dp"></EditText><ImageButton android:layout_height="40dp"android:layout_width="80dp" android:id="@+id/loginButton"android:background="@drawable/dengluxitong"android:layout_centerVertical="true" android:layout_alignRight="@+id/pass" android:layout_marginRight="17dp"></ImageButton></RelativeLayout>运行结果如下，首次显示的时空白，第二次运行时如下：。

sharedpreferences 用法

sharedpreferences 用法SharedPreferences是Android中一种轻量级的数据存储方式，用于存储少量的键值对数据。

它是基于XML文件存储的，可以用于存储应用程序的配置信息、用户偏好设置等。

SharedPreferences的使用非常简单，下面将详细介绍SharedPreferences的用法。

1. 创建SharedPreferences对象要使用SharedPreferences，首先需要获取一个SharedPreferences对象。

可以通过Context的getSharedPreferences()方法或者PreferenceManager的getDefaultSharedPreferences()方法来获取SharedPreferences对象。

- 使用getSharedPreferences()方法：javaSharedPreferences sharedPreferences =getSharedPreferences("my_preferences", Context.MODE_PRIVATE);这里的"my_preferences"是SharedPreferences的名称，Context.MODE_PRIVATE表示只有当前应用程序可以访问该SharedPreferences。

- 使用getDefaultSharedPreferences()方法：javaSharedPreferences sharedPreferences =PreferenceManager.getDefaultSharedPreferences(context);getDefaultSharedPreferences()方法会自动使用当前应用程序的包名作为SharedPreferences的名称，并且使用Context.MODE_PRIVATE模式。

SharedPreferences,安卓

SharedPreferences,安卓1、SharedPreferences一般的应用程序都会提供“设置”或者“首选项”的这样的界面，那么这些设置最终就可以通过Preferences来保存，而程序员不需要知道它到底以什么形式保存的，保存在了什么地方。

写入数据的步骤：1.使用以上方法获得一个SharedPreferences类型的对象getSharedPreferences(Stringname,intmode)参数1：指定文件名参数2：操作模式。

Use0orMODE_PRIVATEforthedefaultoperation2.使用SharedPreferences类型对象调用edit方法获得一个SharedPreferences.Editor.3.使用pu2、tBoolean()或者putString()等方法保存数据。

4.使用commit()方法提交数据。

完好代码如下：publicstaticfinalStringPREFS_NAME=MyPrefsFile;SharedPrefere ncessettings=getSharedPreferences(PREFS_NAME,0);SharedPrefe rences.Editoreditor=settings.edit();editor.putBoolean(silen tMode,mSilentMode);mit();提取数据：1.使用以上方法获得一个SharedPreferences类型的对象2.使用3、getBoolean()或者getString()等方法获取数据。

完好代码如下：SharedPreferencessettings=getSharedPreferences(PREFS_NAME,0 );booleansilent=settings.getBoolean(silentMode,false);例子：在界面里放置一个EditText和一个Button，界面第一次启动时，EditText里默认为null。