android intent 传递对象 Serializable android intent传递数组

 

关于 android Intent 传对象和对象数组的一些操作

androidintent传递对象传递对象数组

直接开正题，Intent传递值就是平常那些很简单的，接下来介绍传递 对象，和 对象数组

 

1 .intent 传递自定义的 对象 -

实体类继承  Serializable

1. public class AA implements Serializable{  
2.   
3. public String  a;  
4. public String  aa;  
5. public String  aaa;  
6.       
7.       
8. }

intent塞入数据端

1. AA a = new AA();  
2. a.a="a";  
3. a.aa ="aa";  
4. a.aaa = "aaa";  
5.   
6. Intent in = new Intent().setClass(MainActivity.this, MainActivity1.class);  
7. Bundle bu = new Bundle();  
8. bu.putSerializable("enty", a);  
9. in.putExtras(bu);  
10. startActivity(in);

intent 接收数据端

1. AA a =(AA)this.getIntent().getExtras().getSerializable("enty");  
2. "a.a ="+  app.a);  
3. "a.aa ="+  app.aa);  
4. "a.aaa ="+  app.aaa);

 

 

实体类类继承  Parcelable（简单介绍一下：

 

1.什么是Parcelable ？

     Parcelable,定义了将数据写入Parcel，和从Parcel中读出的接口。一个实体（用类来表示），如果需要封装到消息中去，就必须实现这一接口，实现了这一接口，该实体就成为“可打包的”了。

2.Parcelable 传递对象

     Android序列化对象主要有两种方法：

    1.1实现Serializable接口是JavaSE本身就支持的;

    1.2实现Parcelable接口,Parcelable是Android特有的功能，效率比实现Serializable接口高，像用于Intent数据传递也都支持，而且还可以用在进程间通信(IPC)，

      除了基本类型外，只有实现了Parcelable接口的类才能被放入Parcel中。

）

Parcelable的接口的定义：

1. public interface Parcelable {  
2. //内容描述接口  
3. public int describeContents();  
4. //写入接口函数，打包  
5. public void writeToParcel(Parcel dest, int flags);  
6. //1.读取接口，目的是要从Parcel中构造一个实现了Parcelable的类的实例处理。因为实现类在这里还是不可知的，所以需要用到模板的方式，继承类名通过模板参数传入。  
7. //2.为了能够实现模板参数的传入，这里才定义CREATOR嵌入接口,有两个接口函数分别返回单个和多个继承类实例。  
8. public interface Creator<T> {  
9. public T createFromParcel(Parcel source);  
10. public T[] newArray(int size);  
11.            }

 

1. public class AA implements Parcelable{  
2.   
3. public String  a;  
4. public String  aa;  
5. public String  aaa;  
6.   
7. @Override  
8. public int describeContents() {  
9. return 0;  
10.     }  
11.   
12. @Override  
13. public void writeToParcel(Parcel parcel, int flags) {  
14. //序列化对象，必须按照声明顺序  
15.         parcel.writeString(a);  
16.         parcel.writeString(aa);  
17.         parcel.writeString(aaa);  
18.           
19.     }  
20. //必须实现这个接口，它的作用是从 percel中读出来数据，顺序必须按照声明顺序  
21. public static final Parcelable.Creator<AA> CREATOR  = new Creator<AA>(){  
22. @Override  
23. public AA createFromParcel(Parcel source) {  
24. new AA();  
25.             app.a = source.readString();  
26.             app.aa = source.readString();  
27.             app.aaa = source.readString();  
28. return app;  
29.         }  
30. @Override  
31. public AA[] newArray(int size) {  
32. return new AA[size];  
33.         }  
34.           
35.     };  
36. }

intent塞入数据端

 

1. new AA();  
2. a.a="a";  
3. a.aa ="aa";  
4. a.aaa = "aaa";  
5.   
6. Intent in = new Intent().setClass(MainActivity.this, MainActivity1.class);  
7. Bundle bu = new Bundle();  
8. bu.putParcelable("enty", a);  
9. in.putExtras(bu);  
10. startActivity(in);

接收数据端

 

 

1. // 可以这样app =(AA)this.getIntent().getParcelableExtra("enty");  
2. //也可以这样写，上面的也是  
3. this.getIntent().getExtras().getParcelable("enty");  
4. "a.a ="+  app.a);  
5. "a.aa ="+  app.aa);  
6. "a.aaa ="+  app.aaa);

2。 下来是 自定义对象 数组传递

 

实体类类继承  Parcelable

intent塞入数据端

1. new ArrayList<AA>();  
2. AA a = new AA();  
3. a.a="a";  
4. a.aa ="aa";  
5. a.aaa = "aaa";  
6.   
7. new AA();  
8. a1.a="a1";  
9. a1.aa ="aa1";  
10. a1.aaa = "aaa1";  
11.   
12. list_aa.add(a);  
13. list_aa.add(a1);  
14.   
15. Intent in = new Intent().setClass(MainActivity.this, MainActivity1.class);  
16. Bundle bu = new Bundle();  
17. bu.putParcelableArrayList("list", (ArrayList<? extends Parcelable>) list_aa);  //---  
18. in.putExtras(bu);  
19. startActivity(in);

接收list数据端

1. List<AA> aa =this.getIntent().getExtras().getParcelableArrayList("list");  
2.               
3. for (AA aa2 : aa) {  
4. "list_a.a = "+ aa2.a);  
5. "list_a.aa = "+ aa2.aa);  
6. "list_a.aaa = "+ aa2.aaa);  
7. "=================================");  
8.                   
9.             }