Android五种数据传递方法汇总

最新推荐文章于 2023-09-14 17:05:48 发布

Y X L

最新推荐文章于 2023-09-14 17:05:48 发布

阅读量1.9w

点赞数 14

分类专栏： Android

Android 专栏收录该内容

68 篇文章 0 订阅

订阅专栏

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

效果图:
这里写图片描述

Demo地址:https://download.csdn.net/download/rely_on_yourself/10595099

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

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

1.1 设置参数

            //传递些简单的参数
             Intent intent1 = new Intent();
             intent1.setClass(MainActivity.this,SimpleActivity.class);

             //intent1.putExtra("usr", "lyx");
             //intent1.putExtra("pwd", "123456");
             //startActivity(intent1);

             Bundle bundleSimple = new Bundle();
             bundleSimple.putString("usr", "lyx");
             bundleSimple.putString("pwd", "123456");
             intent1.putExtras(bundleSimple);

             startActivity(intent1);

1.2接收参数

          //接收参数

           //Intent intent = getIntent();
           //String eml = intent.getStringExtra("usr");
           //String pwd = intent.getStringExtra("pwd");

           Bundle bundle = this.getIntent().getExtras();
           String eml = bundle.getString("usr");
           String pwd = bundle.getString("pwd");

在这种情况下 , 有些童鞋喜欢直接用intent传递数据 , 不经过bundle来传递数据 . 其实这两种方式没有区别的 , 查看Intent 的源码就会发现 , 其实intent1.putExtra也是通过bundle来传递 . 具体的讲解可以参考这位童鞋的分享 , 我觉得挺清晰的 , 地址:https://www.cnblogs.com/jeffen/p/6835622.html

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

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

2.1 设置参数

        //传递复杂些的参数
        Map<String, Object> map = new HashMap<>();
        map.put("key1", "value1");
        map.put("key2", "value2");
        List<Map<String, Object>> list = new ArrayList<>();
        list.add(map);

        Intent intent = new Intent();
        intent.setClass(MainActivity.this,ComplexActivity.class);
        Bundle bundle = new Bundle();
        //须定义一个list用于在budnle中传递需要传递的ArrayList<Object>,这个是必须要的
        ArrayList bundlelist = new ArrayList();
        bundlelist.add(list);
        bundle.putParcelableArrayList("list",bundlelist);
        intent.putExtras(bundle);
        startActivity(intent);

2.2 接收参数

    this.setTitle("复杂参数传递例子");

    //接收参数
     Bundle bundle = getIntent().getExtras();
     ArrayList list = bundle.getParcelableArrayList("list");
    //从List中将参数转回 List<Map<String, Object>>
     List<Map<String, Object>> lists= (List<Map<String, Object>>)list.get(0);

     String sResult = "";
       for (Map<String, Object> m : lists) {
           for (String k : m.keySet()) {
               sResult += "\r\n" + k + " : " + m.get(k);
           }
       }

    TextView  tv = findViewById(R.id.tv);
    tv.setText(sResult);

3. 通过实现Serializable接口

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

实体类:

public class Person implements Serializable {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

3.1设置参数

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

        //2.通过Serializable接口传递实体类
        Person person = new Person();
        person.setAge(25);
        person.setName("lyx");
        Intent intent2 = new Intent(MainActivity.this, SerializableActivity.class);
        intent2.putExtra("serializable", person);
        startActivity(intent2);

3.2 接收参数

this.setTitle("Serializable例子");

  //接收参数

  //1.接收集合
// Bundle bundle = this.getIntent().getExtras();
//如果传 LinkedHashMap，则bundle.getSerializable转换时会报ClassCastException，不知道什么原因
//传HashMap倒没有问题。
//HashMap<String, String> map = (HashMap<String, String>) bundle.getSerializable("serializable");
//
//String sResult = "map.size() =" + map.size();
//
//Iterator iter = map.entrySet().iterator();
//  while (iter.hasNext()) {
//  Map.Entry entry = (Map.Entry) iter.next();
//   Object key = entry.getKey();
//  Object value = entry.getValue();
//  //System.out.println("key---->"+ (String)key);
//  //System.out.println("value---->"+ (String)value);
//
//  sResult += "\r\n key----> " + (String) key;
//  sResult += "\r\n value----> " + (String) value;
//    }

  //2.接收实体类
  Person person = (Person) getIntent().getSerializableExtra("serializable");
  String sResult = "姓名:" + person.getName() + "--年龄:" + person.getAge();

  TextView tv = findViewById(R.id.tv);
  tv.setText(sResult);

4. 通过实现Parcelable接口
这个是通过实现Parcelable接口，把要传的数据打包在里面，然后在接收端自己分解出来。这个是Android独有的，在其本身的源码中也用得很多，效率要比Serializable相对要好。
Parcelable方式实现的原理是将一个完整的对象进行分解 , 而分解后的每一部分都是Intent所支持的数据类型 , 这样也就实现传递对象的功能了 .

Parcelable的实现方式 :

public class Student implements Parcelable {

    private String name;
    private int age;

    public Student() {
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    protected Student(Parcel in) {
        name = in.readString();
        age = in.readInt();
    }

    public static final Creator<Student> CREATOR = new Creator<Student>() {
        @Override
        public Student createFromParcel(Parcel in) {
            return new Student(in);
        }

        @Override
        public Student[] newArray(int size) {
            return new Student[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(name);
        dest.writeInt(age);
    }
}

Parcelable的实现方式要稍微复杂一些 , 首先让Student类去实现了Parcelable接口 , 这样就必须重写describeContents()和writeToParcel()这两个方法 . 其中describeContents()方法可以直接返回0就可以了 , 而writeToParcel()方法中需要调用Parcel的writeXxx()方法 , 将Student类中的字段一一写出 . 注意 , 字符串数据就调用writeString()方法 , 整数数据就调用writeInt()方法 , 一次类推 .
除此之外 , 我们还必须在Student类中提供一个名为CREATOR的常量 , 这里创建了Parcelable.Creator接口的一个实现 , 并将泛型指定为Student . 接着需要重写createFromParcel()和newArray()这两个方法 . 在createFromParcel()方法中我们要去创建一个Student对象 , .而newArray()方法只需要new出一个Student数组 , 并传入size()作为数据的大小就可以了 .

4.1 设置参数

Student student = new Student();
student.setAge(25);
student.setName("lyx");
Intent intent4 = new Intent(MainActivity.this, ParcelableActivity.class);
intent4.putExtra("parcelable", student);
startActivity(intent4);

4.2 接收参数

   this.setTitle("Parcelable例子");

   //接收参数
   Intent i = getIntent();
   Student student = i.getParcelableExtra("parcelable");

   TextView tv = findViewById(R.id.tv);
   tv.setText("姓名:" + student.getName() + "--年龄:" + student.getAge());

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

5.1 定义一个单实例的类

//单例模式
public class XclSingleton {

    //单例模式实例
    private static XclSingleton instance = null;

    //synchronized 用于线程安全，防止多线程同时创建实例
    public synchronized static XclSingleton getInstance() {
        if (instance == null) {
            instance = new XclSingleton();
        }
        return instance;
    }

    final HashMap<String, Object> mMap;

    public XclSingleton() {
        mMap = new HashMap<>();
    }

    public void put(String key, Object value) {
        mMap.put(key, value);
    }

    public Object get(String key) {
        return mMap.get(key);
    }

}

5.2 设置参数

//通过单例模式传参数的例子
 XclSingleton.getInstance().put("key1", "value1");
 XclSingleton.getInstance().put("key2", "value2");

 Intent intentSingleton = new Intent();
 intentSingleton.setClass(MainActivity.this,
         SingletonActivity.class);
 startActivity(intentSingleton);

5.3 接收参数

  this.setTitle("单例模式例子");

        //接收参数
  HashMap<String, Object> map = XclSingleton.getInstance().mMap;
    String sResult = "map.size() =" + map.size();

    //遍历参数
    Iterator iter = map.entrySet().iterator();
    while (iter.hasNext()) {
        Map.Entry entry = (Map.Entry) iter.next();
        Object key = entry.getKey();
        Object value = entry.getValue();
        sResult += "\r\n key----> " + (String) key;
        sResult += "\r\n value----> " + (String) value;
    }

    TextView tv = findViewById(R.id.tv);
    tv.setText(sResult);

转自:https://blog.csdn.net/xcl168/article/details/14436539

Y X L

关注

14
点赞
踩
68

收藏

觉得还不错? 一键收藏
1
评论
Android五种数据传递方法汇总

1. 利用Intent对象携带简单数据利用Intent的Extra部分来存储我们想要传递的数据，可以传送String , int, long, char等一些基础类型,对复杂的对象就无能为力了。1.1 设置参数 //传递些简单的参数 Intent intent1 = new Intent(); intent1.s...
复制链接

扫一扫