[关闭]
@coder-pig 2015-08-24T02:19:59.000000Z 字数 6880 阅读 1078

Android基础入门教程——4.5.2 Intent之复杂数据的传递

Android基础入门教程


本节引言:

上一节中我们学习了Intent的一些基本使用,知道了Intent的七个属性,显式Intent以及
隐式Intent,以及如何自定义隐式Intent,最后还给大家提供了一些常用的系统Intent!
而本节跟大家讲解的是Intent传递数据的问题~好的,开始本节内容~


1.Intent传递简单数据

还记得我们在Activity那里学过如何在两个Activity中互相传递简单数据的方法吗?

就是可以直接通过调用Intent的putExtra()方法存入数据,然后在获得Intent后调用getXxxExtra获得
对应类型的数据;传递多个的话,可以使用Bundle对象作为容器,通过调用Bundle的putXxx先将数据
存储到Bundle中,然后调用Intent的putExtras()方法将Bundle存入Intent中,然后获得Intent以后,
调用getExtras()获得Bundle容器,然后调用其getXXX获取对应的数据!
另外数据存储有点类似于Map的<键,值>!


2.Intent传递数组

嘿嘿,普通类型倒没问题,但是如果是数组咧?解决方法如下:

写入数组

  1. bd.putStringArray("StringArray", new String[]{"呵呵","哈哈"});
  2. 可把StringArray换成其他数据类型,比如int,float等等...

读取数组

  1. String[] str = bd.getStringArray("StringArray")

3.Intent传递集合

嗯,数组很简单吧,那我们再来传下集合~这个就稍微复杂点了,分情况处理:


1)List<基本数据类型或String>

写入集合:

  1. intent.putStringArrayListExtra(name, value)
  2. intent.putIntegerArrayListExtra(name, value)

读取集合:

  1. intent.getStringArrayListExtra(name)
  2. intent.getIntegerArrayListExtra(name)

2)List< Object>

将list强转成Serializable类型,然后传入(可用Bundle做媒介)

写入集合:

  1. putExtras(key, (Serializable)list)

读取集合:

  1. (List<Object>) getIntent().getSerializable(key)

PS:Object类需要实现Serializable接口


3)Map,或更复杂的

解决方法是:外层套个List

  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. Intent intent = new Intent();
  8. intent.setClass(MainActivity.this,ComplexActivity.class);
  9. Bundle bundle = new Bundle();
  10. //须定义一个list用于在budnle中传递需要传递的ArrayList<Object>,这个是必须要的
  11. ArrayList bundlelist = new ArrayList();
  12. bundlelist.add(list);
  13. bundle.putParcelableArrayList("list",bundlelist);
  14. intent.putExtras(bundle);
  15. startActivity(intent);

4.Intent传递对象

传递对象的方式有两种:将对象转换为Json字符串或者通过Serializable,Parcelable序列化
不建议使用Android内置的抠脚Json解析器,可使用fastjson或者Gson第三方库!


1)将对象转换为Json字符串

Gson解析的例子:

Model:

  1. public class Author{
  2. private int id;
  3. private String name;
  4. //...
  5. }
  6. public class Author{
  7. private int id;
  8. private String name;
  9. //...
  10. }

写入数据:

  1. Book book=new Book();
  2. book.setTitle("Java编程思想");
  3. Author author=new Author();
  4. author.setId(1);
  5. author.setName("Bruce Eckel");
  6. book.setAuthor(author);
  7. Intent intent=new Intent(this,SecondActivity.class);
  8. intent.putExtra("book",new Gson().toJson(book));
  9. startActivity(intent);

读取数据:

  1. String bookJson=getIntent().getStringExtra("book");
  2. Book book=new Gson().fromJson(bookJson,Book.class);
  3. Log.d(TAG,"book title->"+book.getTitle());
  4. Log.d(TAG,"book author name->"+book.getAuthor().getName());

2)使用Serializable,Parcelable序列化对象


1.Serializable实现:

①业务Bean实现:Serializable接口,写上getter和setter方法
②Intent通过调用putExtra(String name, Serializable value)传入对象实例
当然对象有多个的话多个的话,我们也可以先Bundle.putSerializable(x,x);
③新Activity调用getSerializableExtra()方法获得对象实例:
eg:Product pd = (Product) getIntent().getSerializableExtra("Product");
④调用对象get方法获得相应参数


2.Parcelable实现:

一般流程:

①业务Bean继承Parcelable接口,重写writeToParcel方法,将你的对象序列化为一个Parcel对象;
②重写describeContents方法,内容接口描述,默认返回0就可以
③实例化静态内部对象CREATOR实现接口Parcelable.Creator
④同样式通过Intent的putExtra()方法传入对象实例,当然多个对象的话,我们可以先
放到Bundle里Bundle.putParcelable(x,x),再Intent.putExtras()即可

一些解释:

通过writeToParcel将你的对象映射成Parcel对象,再通过createFromParcel将Parcel对象映射
成你的对象。也可以将Parcel看成是一个流,通过writeToParcel把对象写到流里面,
在通过createFromParcel从流里读取对象,只不过这个过程需要你来实现,因此写的
顺序和读的顺序必须一致。

实现Parcelable接口的代码示例:

  1. //Internal Description Interface,You do not need to manage
  2. @Override
  3. public int describeContents() {
  4. return 0;
  5. }
  6. @Override
  7. public void writeToParcel(Parcel parcel, int flags){
  8. parcel.writeString(bookName);
  9. parcel.writeString(author);
  10. parcel.writeInt(publishTime);
  11. }
  12. public static final Parcelable.Creator<Book> CREATOR = new Creator<Book>() {
  13. @Override
  14. public Book[] newArray(int size) {
  15. return new Book[size];
  16. }
  17. @Override
  18. public Book createFromParcel(Parcel source) {
  19. Book mBook = new Book();
  20. mBook.bookName = source.readString();
  21. mBook.author = source.readString();
  22. mBook.publishTime = source.readInt();
  23. return mBook;
  24. }
  25. };

Android Studio生成Parcleable插件

Intellij/Andriod Studio插件android-parcelable-intellij-plugin
只要ALT+Insert,即可直接生成Parcleable接口代码
另外:Android中大量用到Parcelable对象,实现Parcable接口又是非常繁琐的,可以用到
第三方的开源框架:Parceler,因为Maven的问题,暂时还没试
参考地址:Android的Parcelable自动生成

3.两种序列化方式的比较:

两者的比较:
1)在使用内存的时候,Parcelable比Serializable性能高,所以推荐使用Parcelable。
2)Serializable在序列化的时候会产生大量的临时变量,从而引起频繁的GC。
3)Parcelable不能使用在要将数据存储在磁盘上的情况,因为Parcelable不能很好的保证数据的
持续性在外界有变化的情况下。尽管Serializable效率低点,但此时还是建议使用Serializable。


5.Intent传递Bitmap

bitmap默认实现Parcelable接口,直接传递即可

实现代码:

  1. Bitmap bitmap = null;
  2. Intent intent = new Intent();
  3. Bundle bundle = new Bundle();
  4. bundle.putParcelable("bitmap", bitmap);
  5. intent.putExtra("bundle", bundle);

6.传来传去不方便,直接定义全局数据

如果是传递简单的数据,有这样的需求,Activity1 -> Activity2 -> Activity3 -> Activity4,
你想在Activity中传递某个数据到Activity4中,怎么破,一个个页面传么?
显然不科学是吧,如果你想某个数据可以在任何地方都能获取到,你就可以考虑使用
Application全局对象了!
Android系统在每个程序运行的时候创建一个Application对象,而且只会创建一个,所以Application
是单例(singleton)模式的一个类,而且Application对象的生命周期是整个程序中最长的,他的生命
周期等于这个程序的生命周期。如果想存储一些比静态的值(固定不改变的,也可以变),如果你想使用
Application就需要自定义类实现Application类,并且告诉系统实例化的是我们自定义的Application
而非系统默认的,而这一步,就是在AndroidManifest.xml中卫我们的application标签添加:name属性

关键部分代码:

1)自定义Application类:

  1. class MyApp extends Application {
  2. private String myState;
  3. public String getState(){
  4. return myState;
  5. }
  6. public void setState(String s){
  7. myState = s;
  8. }
  9. }

2)AndroidManifest.xml中声明:

  1. <application android:name=".MyApp" android:icon="@drawable/icon"
  2. android:label="@string/app_name">

3)在需要的地方调用:

  1. class Blah extends Activity {
  2. @Override
  3. public void onCreate(Bundle b){
  4. ...
  5. MyApp appState = ((MyApp)getApplicationContext());
  6. String state = appState.getState();
  7. ...
  8. }
  9. }

高逼格写法:在任何位置都能获取到Application全局对象
Applicaiton是系统的一个组件,他也有自己的一个生命周期,我们可以在onCraete里获得这个
Application对象。贴下修改后的代码吧!

  1. class MyApp extends Application {
  2. private String myState;
  3. private static MyApp instance;
  4. public static MyApp getInstance(){
  5. return instance;
  6. }
  7. public String getState(){
  8. return myState;
  9. }
  10. public void setState(String s){
  11. myState = s;
  12. }
  13. @Override
  14. public void onCreate(){
  15. onCreate();
  16. instance = this;
  17. }
  18. }

然后在任意地方我们就可以直接调用:MyApp.getInstance()来获得Application的全局对象!


注意事项:

Application对象是存在于内存中的,也就有它可能会被系统杀死,比如这样的场景:
我们在Activity1中往application中存储了用户账号,然后在Activity2中获取到用户账号,并且显示!
如果我们点击home键,然后过了N久候,系统为了回收内存kill掉了我们的app。这个时候,我们重新
打开这个app,这个时候很神奇的,回到了Activity2的页面,但是如果这个时候你再去获取Application
里的用户账号,程序就会报NullPointerException,然后crash掉~
之所以会发生上述crash,是因为这个Application对象是全新创建的,可能你以为App是重新启动的,
其实并不是,仅仅是创建一个新的Application,然后启动上次用户离开时的Activity,从而创造App
并没有被杀死的假象!所以如果是比较重要的数据的话,建议你还是进行本地化,另外在使用数据的时候
要对变量的值进行非空检查!还有一点就是:不止是Application变量会这样,单例对象以及公共静态变量
也会这样~


7.单例模式传参

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

范例代码:(代码来自于网上~)

①定义一个单例类

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

②设置参数:

  1. XclSingleton.getInstance().put("key1", "value1");
  2. XclSingleton.getInstance().put("key2", "value2");

③获取参数:

  1. HashMap<String,Object> map = XclSingleton.getInstance().mMap;

本节小结:

好的,关于Intent复杂数据传输就到这里,本节除了讲述使用Intent来传递复杂数据外,还教了大家
使用Application和单例模式来传递参数!相信会对大家在数据传递方面带来方便,谢谢~

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注