Android 五中数据传递方式汇总

   Android开发中，在不同模块(如Activity)间经常会有各种各样的数据需要相互传递，我把常用的几种
方法都收集到了一起。它们各有利弊，有各自的应用场景。
我现在把它们集中到一个例子中展示,在例子中每一个按纽代表了一种实现方法。

1. 利用Intent对象携带简单数据

利用Intent的Extra部分来存储我们想要传递的数据，可以传送int, long, char等一些基础类型,对复杂的对象就无能为力了。

        1.1 设置参数

[java]  view plain copy

1.        //传递些简单的参数  
2. Intent intentSimple = new Intent();  
3. intentSimple.setClass(MainActivity.this,SimpleActivity.class);  
4.   
5. Bundle bundleSimple = new Bundle();  
6. bundleSimple.putString("usr", "xcl");  
7. bundleSimple.putString("pwd", "zj");  
8. intentSimple.putExtras(bundleSimple);  
9.                
10. startActivity(intentSimple);  

1. 2   接收 参数

[java]  view plain copy

1.        this.setTitle("简单的参数传递例子");  
2.   
3. //接收参数  
4. Bundle bunde = this.getIntent().getExtras();  
5. String eml = bunde.getString("usr");  
6. String pwd = bunde.getString("pwd");   

2. 利用Intent对象携带如ArrayList之类复杂些的数据

这种原理是和上面一种是一样的，只是要注意下。 在传参数前，要用新增加一个List将对象包起来。

2.1 设置参数

[java]  view plain copy

1. //传递复杂些的参数  
2. Map<String, Object> map1 = new HashMap<String, Object>();  
3. map1.put("key1", "value1");  
4. map1.put("key2", "value2");  
5. List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();  
6. list.add(map1);  
7.                        
8. Intent intent = new Intent();  
9. intent.setClass(MainActivity.this,ComplexActivity.class);  
10. Bundle bundle = new Bundle();  
11. //须定义一个list用于在budnle中传递需要传递的ArrayList<Object>,这个是必须要的  
12. ArrayList bundlelist = new ArrayList();   
13. bundlelist.add(list);   
14. bundle.putParcelableArrayList("list",bundlelist);  
15. intent.putExtras(bundle);                
16. startActivity(intent);  

2 .1 接收参数

[java]  view plain copy

1. <span style="white-space:pre">  </span>   this.setTitle("复杂参数传递例子");  
2.           
3.         //接收参数  
4.          Bundle bundle = getIntent().getExtras();   
5.          ArrayList list = bundle.getParcelableArrayList("list");  
6.         //从List中将参数转回 List<Map<String, Object>>  
7.          List<Map<String, Object>> lists= (List<Map<String, Object>>)list.get(0);  
8.          
9.          String sResult = "";  
10.          for (Map<String, Object> m : lists)    
11.          {    
12.              for (String k : m.keySet())    
13.              {    
14.                   sResult += "\r\n"+k + " : " + m.get(k);    
15.              }            
16.          }    

3. 通过实现Serializable接口

3.1 设置参数

利用Java语言本身的特性，通过将数据序列化后，再将其传递出去。

[java]  view plain copy

1. //通过Serializable接口传参数的例子  
2. HashMap<String,String> map2 = new HashMap<String,String>();  
3. map2.put("key1", "value1");  
4. map2.put("key2", "value2");  
5.   
6. Bundle bundleSerializable = new Bundle();  
7. bundleSerializable.putSerializable("serializable", map2);  
8. Intent intentSerializable = new Intent();     
9. intentSerializable.putExtras(bundleSerializable);  
10. intentSerializable.setClass(MainActivity.this,   
11.                             SerializableActivity.class);                      
12. startActivity(intentSerializable);    

3.2 接收参数

[java]  view plain copy

1.           this.setTitle("Serializable例子");  
2.   
3.   //接收参数  
4.    Bundle bundle = this.getIntent().getExtras();      
5.    //如果传 LinkedHashMap，则bundle.getSerializable转换时会报ClassCastException，不知道什么原因  
6.    //传HashMap倒没有问题。        
7.    HashMap<String,String> map =  (HashMap<String,String>)bundle.getSerializable("serializable");  
8.                               
9. String sResult = "map.size() ="+map.size();  
10.   
11. Iterator iter = map.entrySet().iterator();  
12. while(iter.hasNext())  
13. {  
14.     Map.Entry entry = (Map.Entry)iter.next();  
15.     Object key = entry.getKey();  
16.     Object value = entry.getValue();  
17.     sResult +="\r\n key----> "+(String)key;  
18.     sResult +="\r\n value----> "+(String)value;            
19. }  

4. 通过实现Parcelable接口

这个是通过实现Parcelable接口，把要传的数据打包在里面，然后在接收端自己分解出来。这个是Android独有的，在其本身的源码中也用得很多，

效率要比Serializable相对要好。

4.1 首先要定义一个类，用于 实现Parcelable接口

因为其本质也是序列化数据，所以这里要注意定义顺序要与解析顺序要一致噢。

[java]  view plain copy

1. public class XclParcelable implements Parcelable {  
2.       
3.     //定义要被传输的数据  
4.     public int mInt;  
5.     public String mStr;  
6.     public HashMap<String,String> mMap = new HashMap<String,String>();  
7.       
8.     //Describe the kinds of special objects contained in this Parcelable's marshalled representation.  
9.     public int describeContents() {  
10.         return 0;  
11.     }  
12.   
13.     //Flatten this object in to a Parcel.  
14.     public void writeToParcel(Parcel out, int flags) {  
15.         //等于将数据映射到Parcel中去  
16.         out.writeInt(mInt);          
17.         out.writeString(mStr);  
18.         out.writeMap(mMap);  
19.     }  
20.   
21.     //Interface that must be implemented and provided as a public CREATOR field   
22.     //that generates instances of your Parcelable class from a Parcel.   
23.     public static final Parcelable.Creator<XclParcelable> CREATOR  
24.             = new Parcelable.Creator<XclParcelable>() {  
25.         public XclParcelable createFromParcel(Parcel in) {  
26.             return new XclParcelable(in);  
27.         }  
28.   
29.         public XclParcelable[] newArray(int size) {  
30.             return new XclParcelable[size];  
31.         }  
32.     };  
33.       
34.     private XclParcelable(Parcel in) {  
35.         //将映射在Parcel对象中的数据还原回来  
36.         //警告，这里顺序一定要和writeToParcel中定义的顺序一致才行!!!  
37.         mInt = in.readInt();          
38.         mStr  = in.readString();  
39.         mMap  = in.readHashMap(HashMap.class.getClassLoader());  
40.     }  
41.   
42.     public XclParcelable() {  
43.         // TODO Auto-generated constructor stub  
44.     }  
45. }  

4.2  设置参数

[java]  view plain copy

1. //通过实现Parcelable接口传参的例子  
2.                     Intent intentParcelable = new Intent();                   
3.                     XclParcelable xp = new XclParcelable();               
4.                     xp.mInt = 1;  
5.                     xp.mStr = "字符串";  
6.                     xp.mMap = new HashMap<String,String>();  
7.                     xp.mMap.put("key", "value");                      
8.                     intentParcelable.putExtra("Parcelable", xp);                      
9.                     intentParcelable.setClass(MainActivity.this,   
10.                                               ParcelableActivity.class);     
11.                     startActivity(intentParcelable);     

4.3 接收参数

[java]  view plain copy

1. <span style="white-space:pre">      </span>this.setTitle("Parcelable例子");  
2.           
3.         //接收参数  
4.         Intent i = getIntent();     
5.         XclParcelable xp = i.getParcelableExtra("Parcelable");     
6.   
7.         TextView  tv = (TextView)findViewById(R.id.tv);  
8.         tv.setText(  " mInt ="+xp.mInt   
9.                     +"\r\n mStr"+xp.mStr  
10.                     +"\r\n size()="+xp.mMap.size());  

5. 通过单例模式实现参数传递

       单例模式的特点就是可以保证系统中一个类有且只有一个实例。这样很容易就能实现，
在A中设置参数，在B中直接访问了。这是几种方法中效率最高的。

5.1  定义一个单实例的类

[java]  view plain copy

1. //单例模式  
2. public class XclSingleton  
3. {  
4.     //单例模式实例  
5.     private static XclSingleton instance = null;  
6.       
7.     //synchronized 用于线程安全，防止多线程同时创建实例  
8.     public synchronized static XclSingleton getInstance(){  
9.         if(instance == null){  
10.             instance = new XclSingleton();  
11.         }     
12.         return instance;  
13.     }     
14.       
15.     final HashMap<String, Object> mMap;  
16.     public XclSingleton()  
17.     {  
18.         mMap = new HashMap<String,Object>();  
19.     }  
20.       
21.     public void put(String key,Object value){  
22.         mMap.put(key,value);  
23.     }  
24.       
25.     public Object get(String key)  
26.     {  
27.         return mMap.get(key);  
28.     }  
29.       
30. }  

 5.2 设置参数

[java]  view plain copy

1. //通过单例模式传参数的例子  
2. XclSingleton.getInstance().put("key1", "value1");  
3. XclSingleton.getInstance().put("key2", "value2");  
4.   
5. Intent intentSingleton = new Intent();                
6. intentSingleton.setClass(MainActivity.this,   
7.                         SingletonActivity.class);                     
8. startActivity(intentSingleton);   

5.3 接收参数

[java]  view plain copy

1. <span style="white-space:pre">      </span>this.setTitle("单例模式例子");  
2.           
3.         //接收参数  
4.         HashMap<String,Object> map = XclSingleton.getInstance().mMap;                           
5.         String sResult = "map.size() ="+map.size();       
6.           
7.         //遍历参数  
8.         Iterator iter = map.entrySet().iterator();  
9.         while(iter.hasNext())  
10.         {  
11.             Map.Entry entry = (Map.Entry)iter.next();  
12.             Object key = entry.getKey();  
13.             Object value = entry.getValue();  
14.             sResult +="\r\n key----> "+(String)key;  
15.             sResult +="\r\n value----> "+(String)value;                
16.         }