MODE_WORLD_WRITEABLE现在（since API 17）已经被标记为deprecated）。
换句话说，它们不是共享的，如果需要在不同的应用之间共享数据，需要建立content provider，本文对这部分内容不作介绍。
本文基本是官方文档翻译，原文请见文后链接。
本文目录
一.利用shared preferences存储键值对
1.获得SharedPreferences的Handle
2.向Shared Preferences写数据
3.从Shared Preferences读取数据
二.存储文件
选择内部或外部存储
获取外部存储设备的权限
向内部存储存文件
向外部存储存储文件
查询剩余空间
删除文件
三.在SQL数据库中存储文件
定义一个构架和契约Define a Schema and Contract
用SQL Helper创建一个数据库
向数据库中存入数据
从数据库中读取数据
删除数据库中的信息
更新数据库
利用shared preferences存储键值对
SharedPreferences 提供了一种存储键值对的方法，可以用于存储原生数据类型（boolean, float, int, long, String）。
这些数据在用户工作阶段一直被保持，即便应用被关闭也还是保持。
所以可以用来保存一些数据，比如用户设定的字体，背景，用户名等，在下一次打开应用时，不用重新设定这些数据。
1. 获得SharedPreferences的Handle
获得SharedPreferences对象可以使用下面两种方法：
getSharedPreferences()这是 Context 中的方法，可以通过第一个参数指定你需要获得的文件名。
getPreferences()这是 Activity 中的方法，获取Activity中默认的shared preference文件，这个文件是Activity私有的，所以不需要指定名字。
2.向Shared Preferences写数据
向Shared Preferences写数据，首先需要调用edit()方法创建一个 SharedPreferences.Editor对象，然后调用这个对象的putXXX()方法存储键值对，键都是String类型，值是XXX所对应的数据类型（boolean, float, int, long, String, String集合）。
最后需要调用commit() 方法把改变从Editor对象转移到SharedPreferences对象。
3.从Shared Preferences读取数据
读取数据时需要调用SharedPreferences对象的getXXX()方法，来获得给定键（第一个参数）对应的值，如果给定键不存在，则会返回给定的默认值（第二个参数）。
存储文件
Android文件系统和其他平台上的类似，使用File APIs可以读写文件。
这部分内容需要你已经了解了Linux文件系统的基础，并且也了解了java.io包中的标准文件输入输出APIs。
选择内部或外部存储
所有的Android设备都有两块文件存储区域：内部和外部存储。
内部存贮一般指设备自带的非易失性存储器，外部存储指可拆卸的存储介质，比如微型的SD卡。
一些设备把永久的存储区域分为"internal"和"external"的分区，所以即便没有可拆卸的存储介质，这些设备永远都有两种存储区域，并且不管外部存储区到底是可拆卸的还是内置的，APIs的行为是一致的。
内部存储：
永远可用。
存储在内部存储区域的数据默认情况下只对你的app可用。无论是用户或者是其他app都不能访问你的数据。
当用户卸载你的app时，系统会自动移除app在内部存储上的所有文件。
外部存储：
不一定一直可以访问，因为用户可以拆卸外部存储设备。
存储在外部存储的文件是全局可读的，没有访问限制，不受你的控制。可以和其他apps分享数据，用户使用电脑也可以访问在外部存储中的文件。
当用户卸载你的app时，只有当你把文件存储在以 getExternalFilesDir().获得的路径下时，系统才会帮你自动移除。
注意：默认情况下app是安装在内存上的，可以通过在manifest中指定android:installLocation 属性来安排app的安装位置。具体见App Install Location.
获取外部存储设备的权限
为了向外部存储中写入数据，需要在manifest中指定权限 WRITE_EXTERNAL_STORAGE ：
<manifest ...>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
...
</manifest>
注意：现在所有的app都可以读取外部存储中的数据，而不需要特殊的权限说明。
但是，这点在新版本的更新中有可能会改变，如果你的应用需要读取外部存储中的数据而不需要写数据，应该声明READ_EXTERNAL_STORAGE 权限。
为了保证应用能够持续工作，应该现在开始就加入读取权限：
<manifest ...>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
...
</manifest>
然而，如果你的应用包含了WRITE_EXTERNAL_STORAGE 权限，它隐式地包含了读取权限。
向内部存储存文件
向内部存储存文件时，可以通过下面两个方法获取合适的路径，返回值是一个File对象。
getFilesDir()返回一个File，表示的是app的应用文件在内部存储的绝对路径。
getCacheDir()返回一个File，表示的是app的缓存文件在内部存储的绝对路径。
在如上路径中创建一个新文件，可以利用File() 的构造方法。将上面两个方法获得的File对象作为参数传入，如：
File file = new File(context.getFilesDir(), filename);
另外，也可以调用 openFileOutput()来获取FileOutputStream ，然后向你的内部目录写入数据，如下：
String filename = "myfile";
String string = "Hello world!";
FileOutputStream outputStream;
try {
outputStream = openFileOutput(filename, Context.MODE_PRIVATE);
outputStream.write(string.getBytes());
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
或者，如果你需要缓存一些文件，你应该使用createTempFile().
比如，下面的例子从一个URL中提取了文件名，然后利用该文件名创建了一个文件存储在应用的内部缓存路径下：
public File getTempFile(Context context, String url) {
File file;
try {
String fileName = Uri.parse(url).getLastPathSegment();
file = File.createTempFile(fileName, null, context.getCacheDir());
catch (IOException e) {
// Error while creating file
}
return file;
}
注意：
你应用的内部存储路径是由应用的包名指定的，在Android文件系统上的一个特定位置。
技术上来说，如果你把文件的模式设置为可读的，其他应用是可以读取你的内部文件的，但是，另外的应用需要知道你的应用的包名和文件的名字。
如果不明确指明，其他应用是不可浏览你的内部文件路径的，也不拥有读取和写入的权限。
所以，只要你对内部存储上的文件使用MODE_PRIVATE，它们对其他应用来说就是不可用的。
向外部存储存储文件
因为外部存储很有可能不可用，所以每次使用前都需要检查可用性。
通过getExternalStorageState()方法可以查询外部存储状态，如果返回状态为MEDIA_MOUNTED, 你可以继续对文件进行读写操作。
比如下面的方法：
/* Checks if external storage is available for read and write */
public boolean isExternalStorageWritable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {
return true;
}
return false;
}
/* Checks if external storage is available to at least read */
public boolean isExternalStorageReadable() {
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state) ||
Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {
return true;
}
return false;
}
尽管外部存储可以被用户和其他app修改，仍然有两种类型的文件你可以选择：
Public files：
这些文件对用户和其他应用都是可用的。当用户卸载应用时，这些文件对用户仍然是可用的。比如，应用拍摄的照片文件或者是下载的文件。
Private files：
属于你应用的文件，应当在应用被卸载的时候同时被删除。
尽管从技术上来说，这些文件可以被用户和其他文件访问，因为它们是存储在外部存储介质上的，但是它们在你的应用外部并不提供什么实际价值。当用户卸载应用时，系统会删除外部存储上应用私有路径下的所有文件。
比如，应用下载的一些额外的资源或者临时的媒体文件。
存储公有文件，首先用getExternalStoragePublicDirectory()获得路径，这个方法需要一个参数指明文件类型，比如 DIRECTORY_MUSIC 或 DIRECTORY_PICTURES. 如：
public File getAlbumStorageDir(String albumName) {
// Get the directory for the user's public pictures directory.
File file = new File(Environment.getExternalStoragePublicDirectory(
Environment.DIRECTORY_PICTURES), albumName);
if (!file.mkdirs()) {
Log.e(LOG_TAG, "Directory not created");
}
return file;
}
如果想要创建私有文件，利用getExternalFilesDir() 方法获得路径，并且传递给它一个名字指明路径类型。
每一个用这种方法创建的路径都会被加在一个父目录中，这个目录包装了你的应用的所有外部文件，当你卸载应用时，系统会删除它们。
比如，下面的方法为相册创建了一个路径：
public File getAlbumStorageDir(Context context, String albumName) {
// Get the directory for the app's private pictures directory.
File file = new File(context.getExternalFilesDir(
Environment.DIRECTORY_PICTURES), albumName);
if (!file.mkdirs()) {
Log.e(LOG_TAG, "Directory not created");
}
return file;
}
如果所有预定义的子目录都不适合于你的文件，你可以调用getExternalFilesDir()并且传入null。这样会返回你的应用在外部存储上私有路径的根目录。
要记住getExternalFilesDir()在一个卸载应用时系统要删除的目录中创建目录。如果你的文件在应用删除之后仍需要保存，你应该使用getExternalStoragePublicDirectory()。
无论使用哪种方法，比较重要的一点是，要使用API提供的路径名常量，如DIRECTORY_PICTURES等。这些路径名保证了文件会被系统正确处理。
查询剩余空间
如果你提前知道你要存储多少数据，你可以实现查询是否有足够的存储空间，而不必引起一个IOException 。
通过调用 getFreeSpace() 和getTotalSpace()方法，你可以获取当前的空闲空间和当前卷的总空间。
但是，系统并不保证你可以存储的容量和getFreeSpace() 方法获取的字节数一样多，如果该方法返回的容量要比你实际存储的数据大小多几个MB，或者存储后系统的填满程度小于90%，那么很可能是可以安全处理的。否则，可能就存储不下了。
并没有要求你必须先检查剩余空间再存储文件，你可以把存储的语句写入一个try块中，然后catch IOException。在你并不知道文件多大时你需要这么做。
删除文件
在你不需要文件时你需要将其删除。
最直接的方法：获得文件引用然后调用delete() 方法：
myFile.delete();
如果文件存储在内部存储上，可以请求 Context 去定位和删除文件，通过调用deleteFile():
myContext.deleteFile(fileName);
注意，当用户卸载你的app时，Android系统删除如下：
所有在内部存储上的文件。
所有用getExternalFilesDir()存储在外部存储上的文件。
然而，你需要定期手工地删除利用getCacheDir() 创建的所有缓存文件。并且，需要定期清除所有不再需要的文件。
在SQL数据库中存储文件
对于重复或结构性强的数据来说，把它们存储在数据库中是一种理想的做法。
Android系统上你将会用到的数据库相关的APIs都在这个包中：android.database.sqlite 。
定义一个构架和契约Define a Schema and Contract
SQL数据库中的主要原则之一就是构架（schema）：一个关于这个数据库是如何组织的一个正式的声明。
构架反映在创建SQL数据库的语句中。
你可能会发现创建一个同伴类（companion class）很有用，同伴类同时被称作合约类（contract class），其中明确规定了你的构架的布局，以一种系统且自说明的方式。
一个合约类（contract class）是一个常量的容器，这些常量定义了URI，表的名字，列的名字。
合约类允许你在同一个包的其他类中使用这些名字常量。
这就允许了你在一个地方改变列名，而同时把它传播到代码的其他地方去。
组织合约类的一个好方法是：把对于你的整个数据库来说是全局的那些定义放在类的根级上；然后对于每一个表（table）创建一个内部类，列举其列。
注意：通过实现BaseColumns 接口，你的内部类要继承一个基本的关键字域叫做_ID，一些Android的类比如cursor adaptors将需要它。
它不是必须的，但是它能帮助你的数据库更和谐地和Android framework工作。
比如，下面这个代码段定义了表名和列名：
public static abstract class FeedEntry implements BaseColumns {
public static final String TABLE_NAME = "entry";
public static final String COLUMN_NAME_ENTRY_ID = "entryid";
public static final String COLUMN_NAME_TITLE = "title";
public static final String COLUMN_NAME_SUBTITLE = "subtitle";
...
}
为了阻止不小心实例化合约类，给它一个私有的空构造函数：
// Prevents the FeedReaderContract class from being instantiated.
private FeedReaderContract() {}
用SQL Helper创建一个数据库
一旦你定义好了你的数据库看起来什么样，你就应该实现一些方法，用来创建和维护数据库和数据表。
下面是创建和删除表的一些典型的语句：
private static final String TEXT_TYPE = " TEXT";
private static final String COMMA_SEP = ",";
private static final String SQL_CREATE_ENTRIES =
"CREATE TABLE " + FeedReaderContract.FeedEntry.TABLE_NAME + " (" +
FeedReaderContract.FeedEntry._ID + " INTEGER PRIMARY KEY," +
FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + TEXT_TYPE + COMMA_SEP +
FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE + TEXT_TYPE + COMMA_SEP +
... // Any other options for the CREATE command
" )";
private static final String SQL_DELETE_ENTRIES =
"DROP TABLE IF EXISTS " + TABLE_NAME_ENTRIES;
就好像你存储文件到设备的内部存储上一样，Android在你应用相关的私有磁盘空间上存储你的数据库数据。
你的数据是安全的，因为默认情况下其他应用无法访问这块区域。
SQLiteOpenHelper 类提供了一些有用的APIs，当你使用这个类来获取数据库的引用时，系统仅在需要时执行可能长时间的操作：创建和更新数据库，而不是在应用启动的时候执行。
你需要做的仅仅是调用 getWritableDatabase()或getReadableDatabase()方法。
注意：因为它们是长时间运行的，所以请确保你在背景线程中调用：
getWritableDatabase()或getReadableDatabase()。
比如用 AsyncTask 或 IntentService。
为了使用SQLiteOpenHelper，创建一个子类，然后覆盖这三个回调函数：
onCreate(), onUpgrade() 和 onOpen()。
你也可以实现 onDowngrade()，但这并不是必须的。
如下是一个对SQLiteOpenHelper的实现例子：
public class FeedReaderDbHelper extends SQLiteOpenHelper {
// If you change the database schema, you must increment the database version.
public static final int DATABASE_VERSION = 1;
public static final String DATABASE_NAME = "FeedReader.db";
public FeedReaderDbHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
public void onCreate(SQLiteDatabase db) {
db.execSQL(SQL_CREATE_ENTRIES);
}
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// This database is only a cache for online data, so its upgrade policy is
// to simply to discard the data and start over
db.execSQL(SQL_DELETE_ENTRIES);
onCreate(db);
}
public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
onUpgrade(db, oldVersion, newVersion);
}
}
要访问你的数据库，需要先实例化你的SQLiteOpenHelper的子类。
FeedReaderDbHelper mDbHelper = new FeedReaderDbHelper(getContext());
向数据库中存入数据
想数据库中插入数据：通过向 insert()方法中传入一个 ContentValues对象实现。
// Gets the data repository in write mode
SQLiteDatabase db = mDbHelper.getWritableDatabase();
// Create a new map of values, where column names are the keys
ContentValues values = new ContentValues();
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID, id);
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE, title);
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_CONTENT, content);
// Insert the new row, returning the primary key value of the new row
long newRowId;
newRowId = db.insert(
FeedReaderContract.FeedEntry.TABLE_NAME,
FeedReaderContract.FeedEntry.COLUMN_NAME_NULLABLE,
values);
insert()方法接收的第一个参数是表的名字，第二个参数是列的名字：可以通过这个参数设定一个列名，如果ContentValues是空值，这样这个列就会插入NULL；如果第二个参数是null，那么如果ContentValues是空值将不会被插入表中。
从数据库中读取数据
从数据库中读取，是通过query()方法，向它传递你的选择标准和你想要的列。
这个方法结合了insert()和update()方法的元素，只不过它的列的表指定了你想取出的数据，而不是插入的数据。
查询结果是由一个Cursor对象的形式返回给你的。
例如：
SQLiteDatabase db = mDbHelper.getReadableDatabase();
// Define a projection that specifies which columns from the database
// you will actually use after this query.
String[] projection = {
FeedReaderContract.FeedEntry._ID,
FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE,
FeedReaderContract.FeedEntry.COLUMN_NAME_UPDATED,
...
};
// How you want the results sorted in the resulting Cursor
String sortOrder =
FeedReaderContract.FeedEntry.COLUMN_NAME_UPDATED + " DESC";
Cursor c = db.query(
FeedReaderContract.FeedEntry.TABLE_NAME, // The table to query
projection, // The columns to return
selection, // The columns for the WHERE clause
selectionArgs, // The values for the WHERE clause
null, // don't group the rows
null, // don't filter by row groups
sortOrder // The sort order
);
想要看一个Cursor中的一行，可以使用 Cursor 类中的各种move方法中的一个，当你开始读取值时你必须先调用它。
一般情况下，你应该先调用moveToFirst()方法，它将把读取位置指向结果中的第一项。
对每一行，你可以通过Cursor类的get方法读取各列内容，比如 getString()或 getLong()。
对每一个get方法，你必须指定你想要的列的索引，你可以通过 getColumnIndex() 或 getColumnIndexOrThrow()方法来获得索引。
比如：
cursor.moveToFirst();
long itemId = cursor.getLong(
cursor.getColumnIndexOrThrow(FeedReaderContract.FeedEntry._ID)
);
删除数据库中的信息
要删除表中的行，你需要提供一定的选择标准来确定要删除的行。
数据库API提供了一种机制，用于创建选择标准，防止SQL注入。
该机制将选择标准分为一个选择从句和一些选择参数。这个从句定义了需要查看的列，也允许你结合列的测试。这些参数是和从句绑定的需要测试的值。
因为结果不像常规的SQL语句那样处理，所以它是防SQL注入的。
// Define 'where' part of query.
String selection = FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
// Specify arguments in placeholder order.
String[] selelectionArgs = { String.valueOf(rowId) };
// Issue SQL statement.
db.delete(table_name, selection, selectionArgs);
更新数据库
当你需要修改你的数据库中值的一个子集时，运用update()方法。
更新数据表结合了insert()方法中的content values语义和 delete()方法中的where语义。
SQLiteDatabase db = mDbHelper.getReadableDatabase();
// New value for one column
ContentValues values = new ContentValues();
values.put(FeedReaderContract.FeedEntry.COLUMN_NAME_TITLE, title);
// Which row to update, based on the ID
String selection = FeedReaderContract.FeedEntry.COLUMN_NAME_ENTRY_ID + " LIKE ?";
String[] selectionArgs = { String.valueOf(rowId) };
int count = db.update(
FeedReaderDbHelper.FeedEntry.TABLE_NAME,
values,
selection,
selectionArgs);