android 五种存储

ゝ一纸荒年。 2021-09-10 09:02 409阅读 0赞

Android数据的五种存储方式

**SharePreferences**

**SQLite**

**Contert Provider**

**File**

**网络存储**

作为一个完整的应用程序，数据存储的操作是必不可少的。

Android系统提供了四种存储数据方式。分别为：SharePreference、SQLite、Content Provider和File。但由于Android系统中，数据基本是私有的，都是存放于”data/data”程序包名目录下，所以要实现数据共享，正确方式是使用Content Provider。

SQLite：SQLite是一个轻量级的数据库，支持基本的SQL语法，是常被采用的一种数据存储方式。

Android为此数据库提供了一个名为SQLiteDatabase的类，封装了一些操作数据库的API。

SharedPreference： 除SQLite数据库外，另一种常用的数据存储方式，其本质就是一个xml文件，常用于存储较简单的参数设置。

File： 即常说的文件（I/O）存储方法，常用语存储大数量的数据，但是缺点是更新数据将是一件困难的事情。

ContentProvider：Android系统中能实现所有应用程序共享的一种数据存储方式，由于数据通常在各应用间的是互相私密的，所以此存储方式较少使用，但是其又是必不可少的一种存储方式。例如音频，视频，图片和通讯录，一般都可以采用此种方式进行存储。每个Content Provider都会对外提供一个公共的URI（包装成Uri对象），如果应用程序有数据需要共享时，就需要使用Content Provider为这些数据定义一个URI，然后其他的应用程序就通过Content Provider传入这个URI来对数据进行操作。

URI由3个部分组成:"content://"、数据的路径、标识ID(可选)。

======================================================================

**（1）SQLite数据存储**

======================================================================

SQLite是一种转为嵌入式设备设计的轻型数据库，其只有五种数据类型，分别为：

**NULL**:空值

**INTEGER**:整数

**REAL**:浮点数

**TEXT**:字符串

**BLOB**:大数据

在SQLite中，并没有专门设计BOOLEAN和DATE类型，因为BOOLEAN型可以用INTEGER的0和1代替true和false，而DATE类型则可以拥有特定格式的TEXT、REAL和INTEGER的值来代替显示，为了能方便的操作DATE类型，SQLite提供了一组函数，详见：[http://www.sqlite.org/lang\_datefunc.html][http_www.sqlite.org_lang_datefunc.html]。这样简单的数据类型设计更加符合嵌入式设备的要求。关于SQLite的更多资料，请参看：[http://www.sqlite.org/][http_www.sqlite.org]。

在Android系统中提供了anroid.database.sqlite包，用于进行SQLite数据库的增，删，改，查工作，其主要方法如下：

beginTransaction(): 开始一个事务。

close(): 关闭连接，释放资源。

delete(String table, String whereClause, String\[\] whereArgs): 根据给定条件，删除符合条件的记录。

endTransaction(): 结束一个事务。

execSQL(String sql): 执行给定SQL语句。

insert(String table, String nullColumnHack, ContentValues values): 根据给定条件，插入一条记录。

openOrCreateDatabase(String path, SQLiteDatabase.CursorFactory factory): 根据给定条件连接数据库，如果此数据库不存在，则创建。

query(String table, String\[\] columns, String selection, String\[\] selectionArgs, String groupBy, String having, String orderBy): 执行查询。

rawQuery(String sql, String\[\] selectionArgs): 根据给定SQL，执行查询。

update(String table, ContentValues values, String whereClause, String\[\] whereArgs): 根据给定条件，修改符合条件的记录。

除了上诉主要方法外，Android还提供了诸多实用的方法，总之一句话：其实Android访问数据库是一件很方便的事儿。

![Center][]

![Center 1][]

![Center 2][]

![Center 3][]

可以清晰的在查询结果中，红线上下的数据是完全一致的，也就是说query和rawQuery方法在的不同仅仅在于所需参数的不同。rawQuery方法需要开发者手动写出查询SQL，而query方法是由目标表名、where子句、order by子句、having子句等诸多子句由系统组成SQL语句。两方法同返回Cursor对象，所以两方在使用时孰优孰劣，就看具体情况了。本人更喜欢rawQuery的方式，因为此方式更接近传统Java开发，也可以由专业DBA来书写SQL语句，这样更符合MVC的思想，而且这样的代码可读性更高。（query方法里面参数实在太多，有点记不住谁是order by子句，谁是having子句了）。

Cursor对象可以理解为游标对象，凡是对数据有所了解的人，相信对此对象都不会陌生，在这里不再累述。只提醒一点，在第一次读取Cursor对象中的数据时，一定要先移动游标，否则此游标的位置在第一条记录之前，会引发异常。

![Center 4][]

2.案例：

[http://blog.csdn.net/developer\_jiangqq/article/details/7043487][http_blog.csdn.net_developer_jiangqq_article_details_7043487]

======================================================================

**（2）SharedPreference数据存储**

======================================================================

除了SQLite数据库外，SharedPreferences也是一种轻型的数据存储方式，它的本质是基于XML文件存储key-value键值对数据，通常用来存储一些简单的配置信息。其存储位置在/data/data/<包名>/shared\_prefs目录下。SharedPreferences对象本身只能获取数据而不支持存储和修改，存储修改是通过Editor对象实现。实现SharedPreferences存储的步骤如下：

一、根据Context获取SharedPreferences对象

二、利用edit()方法获取Editor对象。

三、通过Editor对象存储key-value键值对数据。

四、通过commit()方法提交数据。

1.getSharedPreferences（String name, int mode）

得到名为‘name’的偏好文件。同时你可以更改和返回他的值。任何调用者在调用同样名字的偏好文件时只有一个实例返回，这就意味着这些调用者都可以看到其他调用者做出的更改。

name为本组件的配置文件名( 自己定义，也就是一个文件名)，当这个文件不存在时，直接创建，如果已经存在，则直接使用，

mode为操作模式，默认的模式为0或MODE\_PRIVATE，还可以使用MODE\_WORLD\_READABLE和MODE\_WORLD\_WRITEABLE

mode指定为MODE\_PRIVATE，则该配置文件只能被自己的应用程序访问。

mode指定为MODE\_WORLD\_READABLE，则该配置文件除了自己访问外还可以被其它应该程序读取。

mode指定为MODE\_WORLD\_WRITEABLE，则该配置文件除了自己访问外还可以被其它应该程序读取和写入

2，PreferenceManager的方法getSharedPreferences（）

这个方法是一个普通的方法，必须有PreferenceManager的实例调用才行

3.getDefaultSharedPreferences方法

这个方法是静态的，因此可以直接调用，同时它与我们调用getSharedPreferences()方法得到的返回值是一样的，只是调用的方式不同罢了。

因为SharedPreferences背后是使用xml文件保存数据，getSharedPreferences(name, mode)方法的第一个参数用于指定该文件的名称，名称不用带后缀，后缀会由Android自动加上。方法的第二个参数指定文件的操作模式，共有四种操作模式，这四种模式前面介绍使用文件方式保存数据时已经讲解过。如果希望SharedPreferences背后使用的xml文件能被其他应用读和写，可以指定Context.MODE\_WORLD\_READABLE和Context.MODE\_WORLD\_WRITEABLE权限。另外Activity还提供了另一个getPreferences(mode)方法操作SharedPreferences，这个方法默认使用当前类不带包名的类名作为文件的名称。

如果访问其他应用中的Preference，前提条件是：该preference创建时指定了Context.MODE\_WORLD\_READABLE或Context.MODE\_WORLD\_WRITEABLE权限。如：有个<package name>为cn.yang.action的应用使用下面语句创建了preference。

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  getSharedPreferences("TEST", Context.MODE\_WORLD\_READABLE);

其他应用要访问上面应用的preference，首先需要创建上面应用的Context，然后通过Context 访问preference ，访问preference时会在应用所在包下的shared\_prefs目录找到preference ：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  Context otherAppsContext = createPackageContext("cn.wsl.action", Context.CONTEXT\_IGNORE\_SECURITY);  
2.  SharedPreferences sharedPreferences = otherAppsContext.getSharedPreferences("TEST", Context.MODE\_WORLD\_READABLE);  
3.  String name = sharedPreferences.getString("name", "");  
4.  **int** age = sharedPreferences.getInt("sex", "");

如果不通过创建Context访问其他应用的preference，也可以以读取xml文件方式直接访问其他应用preference对应的xml文件，如：

File xmlFile = new File(“/data/data/<package name>/shared\_prefs/itcast.xml”);//<package name>应替换成应用的包名。

具体实现代码如下：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** MainActivity **extends** Activity \{  
2.      @Override  
3.      **public** **void** onCreate(Bundle savedInstanceState) \{  
4.          **super**.onCreate(savedInstanceState);  
5.          setContentView(R.layout.main);  
6.            
7.          // 获取SharedPreferences对象  
8.          Context ctx = MainActivity.**this**;         
9.          SharedPreferences sp = ctx.getSharedPreferences("SI", MODE\_PRIVATE);  
10.         // 存入数据  
11.         Editor editor = sp.edit();//获取编辑器  
12.         editor.putString("STRING\_KEY", "string1");  
13.         editor.putInt("INT\_KEY", 0);  
14.         editor.putBoolean("BOOLEAN\_KEY", **true**);  
15.         editor.commit();  
16.           
17.         // 返回STRING\_KEY的值  
18.         Log.d("SP", sp.getString("STRING\_KEY", "none"));  
19.         //如果NOT\_EXIST不存在，则返回值为"none"  
20.         Log.d("SP", sp.getString("NOT\_EXIST", "none"));  
21.     \}  
22. \}

这段代码执行过后，即在/data/data/com.test/shared\_prefs目录下生成了一个SI.xml文件，一个应用可以创建多个这样的xml文件。如图所示：

![Center 5][]

SP.xml文件的具体内容如下：

**\[html\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **<?****xml** version='1.0' encoding='utf-8' standalone='yes' **?>**  
2.  **<****map****>**  
3.      **<****string** name="STRING\_KEY"**>**string**</****string****>**  
4.      **<****int** name="INT\_KEY" value="0" **/>**  
5.      **<****boolean** name="BOOLEAN\_KEY" value="true" **/>**  
6.  **</****map****>**

在程序代码中，通过 getXXX 方法，可以方便的获得对应 Key 的 Value 值，如果 key 值错误或者此 key 无对应 value 值， SharedPreferences 提供了一个赋予默认值的机会，以此保证程序的健壮性。如下图运行结果中因为并无值为 "NOT\_EXIST" 的 Key ，所以 Log 打印出的是其默认值：“ none ”。在访问一个不存在 key 值这个过程中，并无任何异常抛出。

![Center 6][]

SharedPreferences对象与SQLite数据库相比，免去了创建数据库，创建表，写SQL语句等诸多操作，相对而言更加方便，简洁。但是SharedPreferences也有其自身缺陷，比如其职能存储boolean，int，float，long和String五种简单的数据类型，比如其无法进行条件查询等。所以不论SharedPreferences的数据存储操作是如何简单，它也只能是存储方式的一种补充，而无法完全替代如SQLite数据库这样的其他数据存储方式。

2.案例说明：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **private** **void** saveflag(**int** flag) \{  
2.      SharedPreferences sp = **this**.getSharedPreferences("scrolltag", Context.MODE\_PRIVATE);  
3.      Editor editor = sp.edit();  
4.      editor.putInt("flagtag", flag);  
5.      editor.commit();  
6.  \}  
7.  **private** **int** getflag() \{  
8.      SharedPreferences sharedPreferences = getSharedPreferences("scrolltag", Context.MODE\_PRIVATE);  
9.      **int** flag = sharedPreferences.getInt("flagtag", 0);  
10.     **return** flag;  
11. \}  
12.   
13. // 此方法可以在任何程序中添加该段代码，来获取cn.com.shine.hotel应用中的数据了，前提是在该应用生成xml文件的时候的权限应该是 Context.MODE\_WORLD\_READABLE，或者是：读写  
14. **private** String getScrollTextOther() \{  
15.     String str = **null**;  
16.     Context otherAppsContext = **null**;  
17.     **try** \{  
18.         otherAppsContext = createPackageContext("cn.com.shine.hotel", Context.CONTEXT\_IGNORE\_SECURITY);  
19.         SharedPreferences sp = otherAppsContext.getSharedPreferences("scrolltext", Context.MODE\_WORLD\_READABLE);  
20.         str = sp.getString("scrolltext", "");  
21.     \} **catch** (NameNotFoundException e) \{  
22.         // TODO Auto-generated catch block  
23.         e.printStackTrace();  
24.     \}  
25.     **return** str;  
26. \}

======================================================================

**（3）ContentProvider数据存储**

======================================================================

ContentProvider是在Android平台中不同应用程序之间实现数据共享的一种机制。一个应用程序如果需要让别的程序可以操作自己的数据，即可采用这种机制。并且此种方式忽略了底层的数据存储实现，ContentProvider提供了一种统一的通过Uri实现数据操作的方式。其步骤为：

1. 在当前应用程序中定义一个ContentProvider。

2. 在当前应用程序的AndroidManifest.xml中注册此ContentProvider

3. 其他应用程序通过ContentResolver和Uri来获取此ContentProvider的数据。

ContentResolver提供了诸如insert(), delete(), query()和update()之类的方法。用于实现对ContentProvider中数据的存取操作。

Uri是一个通用资源标志符，将其分为A，B，C，D 4个部分：

A：无法改变的标准前缀，包括；"content://"、"tel://"等。当前缀是"content://"时，说明通过一个Content Provider控制这些数据

B：URI的标识，它通过authorities属性声明，用于定义了是哪个ContentProvider提供这些数据。对于第三方应用程序，为了保证URI标识的唯一性，它必须是一个完整的、小写的   类名。例如;"content://com.test.data.myprovider"

C：路径，可以近似的理解为需要操作的数据库中表的名字，如："content://hx.android.text.myprovider/name"中的name

D：如果URI中包含表示需要获取的记录的ID；则就返回该id对应的数据，如果没有ID，就表示返回全部；

下面进行案展示：演示一下如何在应用程序之间相互获取数据：

在应用程序A中，继承ContentProvider类，并重写其中方法：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** MyProvider **extends** ContentProvider \{  
2.      @Override  
3.      **public** **int** delete(Uri uri, String selection, String\[\] selectionArgs) \{  
4.          // TODO Auto-generated method stub  
5.          **return** 0;  
6.      \}  
7.     
8.      @Override  
9.      **public** String getType(Uri uri) \{  
10.         // TODO Auto-generated method stub  
11.         **return** **null**;  
12.     \}  
13.    
14.     @Override  
15.     **public** Uri insert(Uri uri, ContentValues values) \{  
16.         **return** **null**;  
17.     \}  
18.    
19.     //在Create中初始化一个数据库  
20.     @Override  
21.     **public** **boolean** onCreate() \{  
22.         SQLiteDatabase db = **this**.getContext().openOrCreateDatabase("test\_db.db3", Context.MODE\_PRIVATE, **null**);  
23.         db.execSQL("create table tab(\_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL)");  
24.         ContentValues values = **new** ContentValues();  
25.         values.put("name", "test");  
26.         db.insert("tab", "\_id", values);  
27.         db.close();  
28.         **return** **true**;  
29.     \}  
30.    
31.     //实现query方法  
32.     @Override  
33.     **public** Cursor query(Uri uri, String\[\] projection, String selection, String\[\] selectionArgs, String sortOrder) \{  
34.         SQLiteDatabase db = **this**.getContext().openOrCreateDatabase("test\_db.db3", Context.MODE\_PRIVATE, **null**);  
35.         Cursor c = db.query("tab", **null**, **null**, **null**, **null**, **null**,**null**);  
36.         **return** c;  
37.     \}  
38.    
39.     @Override  
40.     **public** **int** update(Uri uri, ContentValues values, String selection, String\[\] selectionArgs) \{  
41.         // TODO Auto-generated method stub  
42.         **return** 0;  
43.     \}  
44. \}

在其AndroidManifest.xml中声明此ContentProvider，其中authorities属性定义了此ContentProvider的Uri标识

<provider android:name=".MyProvider" android:authorities="com.test.MyProvider"/>

在应用程序B中，通过ContentResolver获取程序A的ContentProvider中的数据。

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **class** MainActivity **extends** Activity \{  
2.      @Override  
3.      **public** **void** onCreate(Bundle savedInstanceState) \{  
4.          **super**.onCreate(savedInstanceState);  
5.          setContentView(R.layout.main);  
6.            
7.          // 获取上下文  
8.          Context ctx = MainActivity.**this**;  
9.          // 获取ContentResolver对象  
10.         ContentResolver resolver = ctx.getContentResolver();  
11.         // 获取Uri对象  
12.         Uri uri = Uri.parse("content://com.test.MyProvider");  
13.         // 获取数据  
14.         Cursor c = resolver.query(uri, **null**, **null**, **null**, **null**);  
15.         c.moveToFirst();  
16.         **for** (**int** i = 0; i < c.getCount(); i++) \{  
17.             **int** index = c.getColumnIndexOrThrow("name");  
18.             String src = c.getString(index);  
19.             Log.d("", src);  
20.             c.moveToNext();  
21.         \}  
22.     \}  
23. \}

应用程序B的运行结果如下，从此图可以发现我们在程序B中成功的获取到了程序A中的数据：

![Center 7][]

再观察两个应用程序的结构，如下图，其中红框是应用程序A的程序结构，可以清楚看到其有一个名为“test\_db.db3”的数据库，蓝框是应用程序B的程序结构，其并没有任何数据库用于存储数据。由此图，可以确定应用程序B中查询出来的数据结果是来自于应用程序A。

[http://www.cnblogs.com/dyllove98/archive/2013/07/17/3196821.html][http_www.cnblogs.com_dyllove98_archive_2013_07_17_3196821.html]

[http://blog.csdn.net/biaozhiyuan/article/details/7298095][http_blog.csdn.net_biaozhiyuan_article_details_7298095]

![Center 8][]

以上就是ContentProvider的使用方式，这种存储方式相比SQLite和SharedPreferences，其复杂性是显而易见的，但是在处处可见“云”的今天，程序间的数据交互需求令ContentProvider存储机制变成必不可少的一部分。

======================================================================

**（4）File数据存储**

======================================================================

使用File进行存储 我们有时候可以将数据直接以文件的形式保存在设备中，

例如：文本文件，图片文件等等

使用File进行存储操作主要使用到以下的

（1）:public abstract FileInputStream openFileInput (String name)

这个主要是打开文件，返回FileInputStream

（2）:public abstract FileOutputStream openFileOutput (String name, int mode)

这个主要是写入文件，如果该文件不存在，直接进行创建，返回FileOutputStream

Mode(主要有以下的四种的模式)

MODE\_APPEND  //在尾部追加

MODE\_PRIVATE //私有

MODE\_WORLD\_READABLE //可读

MODE\_WORLD\_WRITEABLE //可写

（3）:FileInputStream(获取文件输入流)与FileOutputStream （获取文件输出流）这两类在JavaIO 操作中很常见

接下来进行操作 保存成功之后讲文件保存在当前应该程序的包名下的files/（可以改变存储的其他路径）

![Center 9][]

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.jiangqq.file;    
2.    
3.  **import** java.io.FileInputStream;    
4.  **import** java.io.FileOutputStream;    
5.      
6.  **import** android.app.Activity;    
7.  **import** android.os.Bundle;    
8.  **import** android.view.View;    
9.  **import** android.view.View.OnClickListener;    
10. **import** android.widget.Button;    
11. **import** android.widget.EditText;    
12. **import** android.widget.Toast;    
13.   
14. **public** **class** FileAcitivy **extends** Activity \{  
15.     **private** Button bt1, bt2;  
16.     **private** EditText et1, et2;  
17.     **private** **static** **final** String FILENAME = "temp\_file.txt";  
18.       
19.     @Override  
20.     **public** **void** onCreate(Bundle savedInstanceState) \{  
21.         **super**.onCreate(savedInstanceState);    
22.         setContentView(R.layout.main);    
23.         bt1 = (Button) **this**.findViewById(R.id.bt1);  
24.         bt2 = (Button) **this**.findViewById(R.id.bt2);    
25.         et1 = (EditText) **this**.findViewById(R.id.et1);    
26.         et2 = (EditText) **this**.findViewById(R.id.et2);    
27.         bt1.setOnClickListener(**new** OnClickListener() \{  
28.             @Override    
29.             **public** **void** onClick(View v) \{    
30.                 write(et1.getText().toString());    
31.                 Toast.makeText(FileAcitivy.**this**, "文件写入成功", Toast.LENGTH\_LONG).show();  
32.             \}    
33.         \});    
34.         bt2.setOnClickListener(**new** OnClickListener() \{  
35.             @Override    
36.             **public** **void** onClick(View v) \{    
37.                 et2.setText(read());    
38.                 Toast.makeText(FileAcitivy.**this**, "文件读出成功", Toast.LENGTH\_LONG).show();  
39.             \}    
40.         \});  
41.     \}  
42.       
43.     // 读文件方法  
44.     **private** String read() \{  
45.         **try** \{  
46.             FileInputStream inputStream = openFileInput(FILENAME);  
47.             **byte**\[\] b = **new** **byte**\[inputStream.available()\];  
48.             inputStream.read(b);  
49.             **return** **new** String(b);  
50.         \} **catch** (Exception e) \{  
51.         \}  
52.         **return** **null**;  
53.     \}  
54.     
55.     // 写文件  
56.     **private** **void** write(String content) \{  
57.         **try** \{  
58.             FileOutputStream fos = openFileOutput(FILENAME, MODE\_APPEND);  
59.             fos.write(content.getBytes());    
60.             fos.close();    
61.         \} **catch** (Exception e) \{    
62.         \}    
63.     \}  
64. \}

2.文件存储，Activity提供了openFileOutput()方法可以用于把数据输出到文件中，具体的实现过程与在J2SE环境中保存数据到文件中是一样的。

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **void** save() \{  
2.      **try** \{  
3.          FileOutputStream outStream = **this**.openFileOutput("a.txt", Context.MODE\_WORLD\_READABLE);  
4.          outStream.write(text.getText().toString().getBytes());  
5.          outStream.close();  
6.          Toast.makeText(MyActivity.**this**, "Saved", Toast.LENGTH\_LONG).show();  
7.      \} **catch** (FileNotFoundException e) \{  
8.          **return**;  
9.      \}  
10.     **catch** (IOException e)\{  
11.         **return** ;  
12.     \}  
13. \}

openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。创建的文件保存在/data/data/<package name>/files目录，如： /data/data/cn.itcast.action/files/itcast.txt ，通过点击Eclipse菜单“Window”\-“Show View”\-“Other”，在对话窗口中展开android文件夹，选择下面的File Explorer视图，然后在File Explorer视图中展开/data/data/<package name>/files目录就可以看到该文件。

openFileOutput()方法的第二参数用于指定操作模式，有四种模式，分别为： Context.MODE\_PRIVATE    =  0

Context.MODE\_APPEND    =  32768

Context.MODE\_WORLD\_READABLE =  1

Context.MODE\_WORLD\_WRITEABLE =  2

Context.MODE\_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容，如果想把新写入的内容追加到原文件中。可以使用Context.MODE\_APPEND

Context.MODE\_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

Context.MODE\_WORLD\_READABLE和Context.MODE\_WORLD\_WRITEABLE用来控制其他应用是否有权限读写该文件。

MODE\_WORLD\_READABLE：表示当前文件可以被其他应用读取；MODE\_WORLD\_WRITEABLE：表示当前文件可以被其他应用写入。

如果希望文件被其他应用读和写，可以传入：

openFileOutput("itcast.txt", Context.MODE\_WORLD\_READABLE + Context.MODE\_WORLD\_WRITEABLE);

android有一套自己的安全模型，当应用程序(.apk)在安装时系统就会分配给他一个userid，当该应用要去访问其他资源比如文件的时候，就需要userid匹配。默认情况下，任何应用创建的文件，sharedpreferences，数据库都应该是私有的（位于/data/data/<package name>/files），其他程序无法访问。除非在创建时指定了Context.MODE\_WORLD\_READABLE或者Context.MODE\_WORLD\_WRITEABLE ，只有这样其他程序才能正确访问。

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **public** **void** load() \{  
2.      **try** \{  
3.          FileInputStream inStream = **this**.openFileInput("a.txt");  
4.          ByteArrayOutputStream stream = **new** ByteArrayOutputStream();  
5.          **byte**\[\] buffer = **new** **byte**\[1024\];  
6.          **int** length = -1;  
7.          **while** ((length = inStream.read(buffer)) != -1) \{  
8.              stream.write(buffer, 0, length);  
9.          \}  
10.         stream.close();  
11.         inStream.close();  
12.         text.setText(stream.toString());  
13.         Toast.makeText(MyActivity.**this**, "Loaded", Toast.LENGTH\_LONG).show();  
14.     \} **catch** (FileNotFoundException e) \{  
15.         e.printStackTrace();  
16.     \} **catch** (IOException e) \{  
17.         **return**;  
18.     \}  
19. \}

对于私有文件只能被创建该文件的应用访问，如果希望文件能被其他应用读和写，可以在创建文件时，指定Context.MODE\_WORLD\_READABLE和Context.MODE\_WORLD\_WRITEABLE权限。

Activity还提供了getCacheDir()和getFilesDir()方法：

getCacheDir()方法用于获取/data/data/<package name>/cache目录

getFilesDir()方法用于获取/data/data/<package name>/files目录

使用Activity的openFileOutput()方法保存文件，文件是存放在手机空间上，一般手机的存储空间不是很大，存放些小文件还行，如果要存放像视频这样的大文件，是不可行的。对于像视频这样的大文件，我们可以把它存放在SDCard。 SDCard是干什么的？你可以把它看作是移动硬盘或U盘。

在模拟器中使用SDCard，你需要先创建一张SDCard卡（当然不是真的SDCard，只是镜像文件）。创建SDCard可以在Eclipse创建模拟器时随同创建，也可以使用DOS命令进行创建，如下：

在Dos窗口中进入android SDK安装路径的tools目录，输入以下命令创建一张容量为2G的SDCard，文件后缀可以随便取，建议使用.img：

mksdcard 2048M D:\\AndroidTool\\sdcard.img

在程序中访问SDCard，你需要申请访问SDCard的权限。

在AndroidManifest.xml中加入访问SDCard的权限如下:

<uses-permission android:name="android.permission.MOUNT\_UNMOUNT\_FILESYSTEMS"/>

<uses-permission android:name="android.permission.WRITE\_EXTERNAL\_STORAGE"/>

要往SDCard存放文件，程序必须先判断手机是否装有SDCard，并且可以进行读写。

注意：访问SDCard必须在AndroidManifest.xml中加入访问SDCard的权限

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **if** (Environment.getExternalStorageState().equals(Environment.MEDIA\_MOUNTED))\{   
2.      File sdCardDir = Environment.getExternalStorageDirectory();//获取SDCard目录   
3.      File saveFile = **new** File(sdCardDir, “a.txt”);   
4.      FileOutputStream outStream = **new** FileOutputStream(saveFile);  
5.      outStream.write("test".getBytes());   
6.      outStream.close();   
7.  \}

Environment.getExternalStorageState()方法用于获取SDCard的状态，如果手机装有SDCard，并且可以进行读写，那么方法返回的状态等于Environment.MEDIA\_MOUNTED。

Environment.getExternalStorageDirectory()方法用于获取SDCard的目录，当然要获取SDCard的目录，你也可以这样写：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  File sdCardDir = **new** File("/sdcard"); //获取SDCard目录   
2.  File saveFile = **new** File(sdCardDir, "itcast.txt");    
3.  //上面两句代码可以合成一句： File saveFile = new File("/sdcard/a.txt");   
4.  FileOutputStream outStream = **new** FileOutputStream(saveFile);   
5.  outStream.write("test".getBytes());   
6.  outStream.close();

======================================================================

**（5）网络存储**

======================================================================

Android提供了通过网络来实现数据的存储和获取的方法。

我们可以调用WebService返回的数据或是解析HTTP协议实现网络数据交互。

具体需要熟悉java.net.\*，Android.net.\*这两个包的内容，详细的类与方法的说明，请参考ＳＤＫ。

下面是一个通过地区名称查询该地区的天气预报，以POST发送的方式发送请求到webservicex.net站点，访问WebService.webservicex.net站点上提供查询天气预报的服务。

代码如下：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  **package** com.android.weather;   
2.  **import** java.util.ArrayList;  
3.  **import** java.util.List;  
4.  **import** org.apache.http.HttpResponse;  
5.  **import** org.apache.http.NameValuePair;  
6.  **import** org.apache.http.client.entity.UrlEncodedFormEntity;  
7.  **import** org.apache.http.client.methods.HttpPost;  
8.  **import** org.apache.http.impl.client.DefaultHttpClient;  
9.  **import** org.apache.http.message.BasicNameValuePair;  
10. **import** org.apache.http.protocol.HTTP;  
11. **import** org.apache.http.util.EntityUtils;  
12. **import** android.app.Activity;  
13. **import** android.os.Bundle;  
14.   
15. **public** **class** MyAndroidWeatherActivity **extends** Activity \{  
16.       
17.     // 定义需要获取的内容来源地址  
18.     **private** **static** **final** String SERVER\_URL =   
19.             "http://www.webservicex.net/WeatherForecast.asmx/GetWeatherByPlaceName";  
20.       
21.     @Override  
22.     **public** **void** onCreate(Bundle savedInstanceState) \{  
23.         **super**.onCreate(savedInstanceState);  
24.         setContentView(R.layout.main);  
25.           
26.         HttpPost request = **new** HttpPost(SERVER\_URL); // 根据内容来源地址创建一个Http请求  
27.         List<NameValuePair> params = **new** ArrayList<NameValuePair>(); // 添加一个变量   
28.           
29.         // 设置一个地区名称  
30.         params.add(**new** BasicNameValuePair("PlaceName", "NewYork"));  // 添加必须的参数  
31.           
32.         **try** \{   
33.             request.setEntity(**new** UrlEncodedFormEntity(params, HTTP.UTF\_8)); // 设置参数的编码  
34.             HttpResponse httpResponse = **new** DefaultHttpClient().execute(request); // 发送请求并获取反馈  
35.             **if** (httpResponse.getStatusLine().getStatusCode() != 404) \{ // 解析返回的内容  
36.                String result = EntityUtils.toString(httpResponse.getEntity());   
37.                System.out.println(result);  
38.             \}  
39.         \} **catch** (Exception e) \{  
40.             e.printStackTrace();  
41.        \}   
42.     \}  
43. \}

别忘记了在配置文件中设置访问网络权限：

<uses-permission android:name="android.permission.INTERNET" />

=============

以上就是Android常用的五种数据存储方式，在此总结，有那些不明白的地方，可以留言讨论，谢谢

参考博客：

http://www.cnblogs.com/hanyonglu/archive/2012/03/01/2374894.html

转自：http://blog.csdn.net/appandroid/article/details/11895277

[http_www.sqlite.org_lang_datefunc.html]: http://www.sqlite.org/lang_datefunc.html
[http_www.sqlite.org]: http://www.sqlite.org/
[Center]: /images/20210511/17c700ff62bd440788624579b55124bc.png
[Center 1]: /images/20210511/b0e2b43b3acb413d840a65d95524f236.png
[Center 2]: /images/20210511/3cb80322e2574b8d9d09772fbee4d6b3.png
[Center 3]: /images/20210511/efafda031aa7468686f11787705bdeaf.png
[Center 4]: /images/20210511/fe181c02c4364c70a86697702c2bccb8.png
[http_blog.csdn.net_developer_jiangqq_article_details_7043487]: http://blog.csdn.net/developer_jiangqq/article/details/7043487
[view plain]: http://blog.csdn.net/habbyge/article/details/20412911#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/216074
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/216074/fork
[Center 5]: /images/20210511/9121b2defa12401699822e2c0e52af72.png
[Center 6]: /images/20210511/8538d0415e3a4d43979b0a02a56f7637.png
[Center 7]: /images/20210511/0b694a57955b4ef5b8c7da3b1987574f.png
[http_www.cnblogs.com_dyllove98_archive_2013_07_17_3196821.html]: http://www.cnblogs.com/dyllove98/archive/2013/07/17/3196821.html
[http_blog.csdn.net_biaozhiyuan_article_details_7298095]: http://blog.csdn.net/biaozhiyuan/article/details/7298095
[Center 8]: /images/20210511/d0d98c1accff4b5ab2aa4a91a019bb88.png
[Center 9]: /images/20210511/1a891d3159f043ae901ad9fbdff54040.png