露天矿钻机:【Android游戏开发十二】（保存游戏数据 [上文]）详解SharedPreference 与 FIleInputStream/FileOutputStream将数据存储到SD卡中!

Himi  原创， 欢迎转载，转载请在明显处注明！ 谢谢。

原文地址: http://blog.csdn.net/xiaominghimi/archive/2011/01/02/6113019.aspx

     对于游戏中的数据进行保存方式，在Android中常用的有四种保存方式，这里我先给大家统一先简单的介绍下：

1.  SharedPreference

此保存方式试用于简单数据的保存，文如其名属于配置性质的保存，不适合数据比较大的保存方式；

2. 文件存储 (FIleInputStream/FileOutputStream)

此保存方式比较适合游戏的保存和使用，可以保存较大的数据，因为相对于SQLite来说更容易让童鞋们接受，此方式不仅能把数据存储在系统中也能将数据保存到SDcard中;

3.SQLite 

此保存方式比较适合游戏的保存和使用，可以保存较大的数据，并且可以将自己的数据存储到文件系统或者数据库当中，也可以将自己的数据存储到SQLite数据库当中,也能将数据保存到SDcard中;

4.ContentProvider (不推荐用于游戏保存)

此保存方式不推荐用于游戏保存，因为此方式不仅能存储较大数据，还支持多个程序之间就的数据进行交换！！！ 但是由于游戏中基本就不可能去访问外部应用的数据,所以对于此方式我不予讲解， 有兴趣的可以去自行百度 google 学习;

以上简单的对几种常用的保存方式进行的概述，那么，下面会详细的去分析每个的优缺点以及每种保存的实现和需要注意的地方！

下面我首先向大家介绍第一种保存方式： 

             保存方式之：  《SharedPreference》

           优点： 简单、方便、适合简单数据的快速保存

           缺点：1.存数的文件只能在同一包内使用，不能在不同包之间使用!

            2.默认将数据存放在系统路径下 /data/data/com.himi/  ，没有找到放SD卡上的方法。

           总结：其实本保存方式如同它的名字一样是个配置保存，虽然方便，但只适合存储比较简单的数据!

main.xml  ：

1.   
3.     android:orientation="vertical" android:layout_width="fill_parent"  
4.     android:layout_height="fill_parent">  
5.     
6.         android:layout_height="wrap_content" android:text="保存数据练习!"  
7.         android:textSize="20sp" android:textColor="#ff0000" android:id="@+id/tv_title" />  
8.     
9.         android:layout_height="wrap_content" android:text="请输入帐号" />  
10.     
11.         android:layout_height="wrap_content" android:id="@+id/editText_Login"  
12.         android:text="">  
13.     
14.         android:layout_height="wrap_content" android:text="请输入密码" />  
15.     
16.         android:layout_height="wrap_content" android:id="@+id/editText_Password"  
17.         android:text="">  
18.     
19.         android:layout_height="wrap_content" android:text="保存">  
20.     
21.         android:layout_height="wrap_content" android:text="取出数据"  
22.         android:visibility="invisible">  
23.   

先把xml文件放上来的原因是因为我在此篇中介绍的 SharedPreference 和 文件存储 (FIleInputStream/FileOutputStream),都共用此xml,很简单，两个textview 两个 editview 以及两个button,这里就不多说了;

下面是SharedPreference 的代码实现和详细讲解:

1. /**  
2.  * @author Himi  
3.  * @保存方式：SharedPreference  
4.  * @注意：SharedPreference 可以跨程序包使用，多谢二楼童鞋提醒！ 
5.  * @操作模式: Context.MODE_PRIVATE：新内容覆盖原内容  
6.  *            Context.MODE_APPEND：新内容追加到原内容后  
7.  *            Context.MODE_WORLD_READABLE：允许其他应用程序读取  
8.  *            Context.MODE_WORLD_WRITEABLE：允许其他应用程序写入，会覆盖原数据。  
9.  */    
10. public class MainActivity extends Activity implements OnClickListener {    
11.     private EditText et_login, et_password;    
12.     private Button btn_save;    
13.     private TextView tv_title;    
14.     private SharedPreferences sp;    
15.     @Override    
16.     public void onCreate(Bundle savedInstanceState) {    
17.         super.onCreate(savedInstanceState);    
18.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,    
19.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);    
20.         this.requestWindowFeature(Window.FEATURE_NO_TITLE);    
21.         setContentView(R.layout.main);    
22.         btn_save = (Button) findViewById(R.id.button_save);    
23.         btn_save.setOnClickListener(this);    
24.         et_login = (EditText) findViewById(R.id.editText_Login);    
25.         et_password = (EditText) findViewById(R.id.editText_Password);    
26.         tv_title = (TextView) findViewById(R.id.tv_title);    
27.         // 这里我们先调用 getSharedPreferences()来实例化一个SharedPreferences,     
28.         // 第二个参数是指：操作模式(上面对各种操作模式已有解释)     
29.         sp = getSharedPreferences("Setting_himi", MODE_PRIVATE);    
30.         /*  
31.          * 下面代码是我们要在程序刚启动的时候我们来读取之前的数据,   
32.          * 当然我们还没有保存任何数据所以肯定找不到！！  
33.          * 如果找不到也没关系会默认返回一个参数值，看下面的方法含义便知！  
34.          */    
35.         sp.getString("login", "");    
36.         // getString()类似哈希表，一个key 一个volue ,     
37.         // 这个方法如果找不到对应的第一个参数(key),那么将以第二个参数作为此key的返回值     
38.         et_login.setText(sp.getString("login", ""));    
39.         et_password.setText(sp.getString("password", ""));    
40.     }    
41.     @Override    
42.     public void onClick(View v) {    
43.         if (v == btn_save) {    
44.             if (et_login.getText().toString().equals(""))    
45.                 tv_title.setText("请输入帐号!");    
46.             else if (et_password.getText().toString().equals(""))    
47.                 tv_title.setText("请输入密码!");    
48.             else {    
49.                 sp.edit()    
50.                   .putString("login", et_login.getText().toString())    
51.                   .putString("password", et_password.getText().toString())    
52.                   .commit();    
53.                 // 从sp.edit()开始进入编辑状态，直到commit()提交！     
54.                 tv_title.setText("保存成功!可重新打开此程序,测试是否已经保存数据!" +    
55.                     "/n(或者在'File Explorer'窗口下-data-data-com.himi路径下" +    
56.                     "是否存在" +"了'Setting_himi.xml')");    
57.             }    
58.         }    
59.     }    
60. }    

代码中的注释的很清楚了，比较简单,不多说了。

             保存方式之：  《文件存储 OutputStream/InputStream》

           优点： 1.适合游戏存储，能存储较大数据；

                     2.不仅能存储到系统中，也能存储到SD卡中！

           总结：如果童鞋们对SQL不太熟习的话那么选择此种方式最为合适的啦、嘿嘿

1. /** 
2.  * @author Himi 
3.  * @保存方式：Stream 数据流方式 
4.  * @注意1：默认情况下，使用openFileOutput 方法创建的文件只能被其调用的应用使用， 
5.  *         其他应用无法读取这个文件，如果需要在不同的应用中共享数据； 
6.  *          
7.  * @注意2：因为android  os内部闪存有限，所以适合保存较少的数据，当然我们也有解决的方法， 
8.  *         就是把数据保存在SD开中，这样就可以了，后面我也会向大家讲解   ! 
9.  *          
10.  * @提醒1 调用FileOutputStream 时指定的文件不存在，Android 会自动创建它。 
11.  *        另外，在默认情况下，写入的时候会覆盖原 文件内容，如果想把新写入的内 
12.  *        容附加到原文件内容后，则可以指定其mode为Context.MODE_APPEND。 
13.  *         
14.  * @提醒2 启动程序就初始化的时候一定要注意处理！代码中有注释！一定要仔细看！ 
15.  *  
16.  * @提醒3 这里我给大家讲两种方式，一种是原生态file流来写入/读入, 
17.  *        另外一种是用Data流包装file流进行写入/读入 其实用data流来包装进行操作; 
18.  *        原因是：包装后支持了更多的写入/读入操作，比如：file流写入不支持 
19.  *        writeUTF(String str); 但是用Data包装后就会支持。 
20.  *         
21.  * @操作模式: Context.MODE_PRIVATE：新内容覆盖原内容 
22.  *            Context.MODE_APPEND：新内容追加到原内容后 
23.  *            Context.MODE_WORLD_READABLE：允许其他应用程序读取 
24.  *            Context.MODE_WORLD_WRITEABLE：允许其他应用程序写入，会覆盖原数据。 
25.  */  
26. public class MainActivity extends Activity implements OnClickListener {  
27.     private EditText et_login, et_password;  
28.     private Button btn_save;  
29.     private TextView tv_title;  
30.     private FileOutputStream fos;  
31.     private FileInputStream fis;  
32.     private DataOutputStream dos;  
33.     private DataInputStream dis;  
34.     @Override  
35.     public void onCreate(Bundle savedInstanceState) {  
36.         String temp = null;  
37.         super.onCreate(savedInstanceState);  
38.         getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,  
39.                 WindowManager.LayoutParams.FLAG_FULLSCREEN);  
40.         this.requestWindowFeature(Window.FEATURE_NO_TITLE);  
41.         setContentView(R.layout.main);  
42.         btn_save = (Button) findViewById(R.id.button_save);  
43.         btn_save.setOnClickListener(this);  
44.         et_login = (EditText) findViewById(R.id.editText_Login);  
45.         et_password = (EditText) findViewById(R.id.editText_Password);  
46.         tv_title = (TextView) findViewById(R.id.tv_title);  
47.         try {  
48.             // openFileInput 不像 sharedPreference 中   
49.             // getSharedPreferences的方法那样找不到会返回默认值,   
50.             // 这里找不到数据文件就会报异常,所以finally里关闭流尤为重要!!!   
51.             if (this.openFileInput("save.himi") != null) {    
52.                 // --------------单纯用file来读入的方式-----------------   
53.                 // fis = this.openFileInput("save.himi");   
54.                 // ByteArrayOutputStream byteArray = new   
55.                 // ByteArrayOutputStream();   
56.                 // byte[] buffer = new byte[1024];   
57.                 // int len = 0;   
58.                 // while ((len = fis.read(buffer)) > 0) {   
59.                 // byteArray.write(buffer, 0, len);   
60.                 // }   
61.                 // temp = byteArray.toString();   
62.                 // -------------- 用data流包装后的读入的方式------------   
63.                 fis = this.openFileInput("save.himi");//备注1    
64.                 dis = new DataInputStream(fis);  
65.                 et_login.setText(dis.readUTF());  
66.                 et_password.setText(dis.readUTF());  
67.                 // 这里也是在刚启动程序的时候去读入存储的数据   
68.                 // 读的时候要注意顺序; 例如我们写入数据的时候   
69.                 //先写的字符串类型,我们也要先读取字符串类型,一一对应！   
70.             }  
71.         } catch (FileNotFoundException e) {  
72.             // TODO Auto-generated catch block   
73.             e.printStackTrace();  
74.         } catch (IOException e) {  
75.             // TODO Auto-generated catch block   
76.             e.printStackTrace();  
77.         } finally {  
78.             // 在finally中关闭流!因为如果找不到数据就会异常我们也能对其进行关闭操作 ;   
79.             try {  
80.                 if (this.openFileInput("save.himi") != null) {  
81.                     // 这里也要判断，因为找不到的情况下，两种流也不会实例化。   
82.                     // 既然没有实例化，还去调用close关闭它,肯定"空指针"异常！！！   
83.                     fis.close();  
84.                 }  
85.             } catch (FileNotFoundException e) {  
86.                 // TODO Auto-generated catch block   
87.                 e.printStackTrace();  
88.             } catch (IOException e) {  
89.                 // TODO Auto-generated catch block   
90.                 e.printStackTrace();  
91.             }  
92.         }  
93.     }  
94.     @Override  
95.     public void onClick(View v) {  
96.         if (Environment.getExternalStorageState() != null) {  
97.             // 这个方法在试探终端是否有sdcard!   
98.             Log.v("Himi", "有SD卡");  
99.         }  
100.         if (v == btn_save) {  
101.             if (et_login.getText().toString().equals(""))  
102.                 tv_title.setText("请输入帐号!");  
103.             else if (et_password.getText().toString().equals(""))  
104.                 tv_title.setText("请输入密码!");  
105.             else {  
106.                 try {   
107.                     // ------单纯用file来写入的方式--------------   
108.                     //fos = new FileOutputStream(f);   
109.                     // fos.write(et_login.getText().toString().getBytes());   
110.                     // fos.write(et_password.getText().toString().getBytes());   
111.                     // ------data包装后来写入的方式--------------   
112.                     fos = this.openFileOutput("save.himi", MODE_PRIVATE);//备注2   
113.                     dos = new DataOutputStream(fos);  
114.                     dos.writeUTF(et_login.getText().toString());  
115.                     dos.writeUTF(et_password.getText().toString());  
116.                     tv_title.setText("保存成功!可重新打开此程序,测试是" +  
117.                             "否已经保存数据!/n(或者在'File Explorer'" +  
118.                             "窗口下-data-data-com.himi-files路径下" +  
119.                             "是否存在了'save.himi')");  
120.                 } catch (FileNotFoundException e) {  
121.                     // TODO Auto-generated catch block   
122.                     e.printStackTrace();  
123.                 } catch (IOException e) {  
124.                     // TODO Auto-generated catch block   
125.                     e.printStackTrace();  
126.                 } finally {  
127.                     // 在finally中关闭流 这样即使try中有异常我们也能对其进行关闭操作 ;   
128.                     try {  
129.                         dos.close();  
130.                         fos.close();  
131.                     } catch (IOException e) {  
132.                         // TODO Auto-generated catch block   
133.                         e.printStackTrace();  
134.                     }  
135.                 }  
136.             }  
137.         }  
138.     }  
139. }  

以上代码中实现了两种流形式来完成写入和读入，这里我们为什么要使用Data流来包装，其实不光是获得更多的操作方式，最主要的是方便快捷，你比如用file来读入的时候，明显的复杂了一些不说，它还一次性把所有数据都取出来了，不便于对数据的处理！

强调的有几点：

1： 在一开始对数据的访问再次提醒童鞋们，这个跟sharedPreference的获取方式不一样，sharedPreference 的获取方式可以得到一个默认的值，但是你用咱们获取的是个文件 而且直接就去open这个文件，一旦不存在必定异常，所以这一块的异常处理，以及finally的处理一定要处理得当。

2.其实在一开始用data包装的时候发现写入的字符串在读入的时候发现字符乱码了，查了api才发现，api规定当写入字符串的时候必须写入UTF-8格式的编码，但是后来不知道怎么了就没事了。 - -、所以这里如果童鞋们遇到此问题，我给出大家一个解决方法，就是在写入的时候我们不要去DataOutputStream 来包装而是用，OutputStreamWriter ,因为在构造的可以设定编码！

                                 OutputStreamWriter osw = new OutputStreamWriter(fis,"UTF-8");

 String  content = EncodingUtils.getString(buffer, "UTF-8");  这个也能把字符数组转码制！

这样写入的就肯定是UTF-8编码的字符啦、

下面介绍如何把我们的数据通过 OutputStream/InputStream 存入SD卡中!

   其实将我们的数据放入SD卡中，无疑就需要对代码进行两处的修改：

注意：一定要有SD卡！对于如何创建SD卡在前一篇文章中已经说了两种方式，不会的童鞋可以去看下；

第一：检查是否装有SD卡；  

第二： 修改读入的地方(备注1)

         fis = this.openFileInput("save.himi"); //这里没有路径，路径是默认的 data-data-com.himi-files下 

      替换成我们的SD卡的路径就可以了：

          File path = new File("/sdcard/himi/save.himi");//这里新建一个File目录路径

          fis = new FileInputStream(path);传入路径

第三 : 修改写入的地方(备注2)

        fos = this.openFileOutput("save.himi", MODE_PRIVATE);这里也是默认路径,需要对其修改,

       注意：这里修改了，那么在finally中的判定大家也要对应的适当修改；

注意：如果是系统路径,当没有此文件的时候,android 会默认创建一个！但是我们放入SD卡的时候要自己创建目录路径和文件！

1. if (Environment.getExternalStorageState() != null) {// 这个方法在试探终端是否有sdcard!   
2.                 Log.v("Himi", "有SD卡");  
3.                 File path = new File("/sdcard/himi");// 创建目录   
4.                 File f = new File("/sdcard/himi/save.himi");// 创建文件   
5.                 if (!path.exists()) {// 目录不存在返回false   
6.                     path.mkdirs();// 创建一个目录   
7.                 }  
8.                 if (!f.exists()) {// 文件不存在返回false   
9.                     f.createNewFile();// 创建一个文件   
10.                 }  
11.                 fos = new FileOutputStream(f);// 将数据存入sd卡中   
12.             }  

第四： 因为我们要在SD卡中进行写入的操作，所以要在配置文件中声明权限！

AndroidMainfest.xml

view plaincopy to clipboardprint?·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

1.   
3.       package="com.himi"  
4.       android:versionCode="1"  
5.       android:versionName="1.0">  
6.       
7.         
8.                   android:label="@string/app_name">  
9.               
10.                   
11.                   
12.               
13.            
14.       
15.        
16.       
17.    

 这一句就是啦~

为了让大家看到所放的位置，所以把整个xml放出来供参考；

那么当创建路径和文件的时候，我们对其检查SD卡中是否已经存在exists（）方法 ，如果已经存在就不去创建，这样避免下次再次写入数据的时候又新建了文件和路径、

其实我们在可以在启动程序的时候判断如果没有此文件，我们可以直接紧接着创建一个文件，这些都属于优化上的了，我主要是让大家引入，学会，那么其他的简化啦，优化啦，其他方式去实现啦都留给各位同学自己了、

OK、今天就先介绍到这里，后面会单独剖析SQLite如何存入数据，以及对数据操作的！ 希望大家继续关注！

(推荐大家订阅本博客，因为咱的更新速度可是很快的~娃哈哈)

本篇源码：http://download.csdn.net/source/2959100