android - type - intent用法




如何使用Intents将对象从一个Android活动发送到另一个? (20)

我如何使用类IntentputExtra()方法将自定义类型的对象从一个Activity传递到另一个Activity


By far the easiest way IMHO to parcel objects. You just add an annotation tag above the object you wish to make parcelable.

An example from the library is below https://github.com/johncarl81/parceler

@Parcel
public class Example {
    String name;
    int age;

    public Example(){ /*Required empty bean constructor*/ }

    public Example(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public String getName() { return name; }

    public int getAge() { return age; }
}

First implement Parcelable in your class. Then pass object like this.

SendActivity.java

ObjectA obj = new ObjectA();

// Set values etc.

Intent i = new Intent(this, MyActivity.class);
i.putExtra("com.package.ObjectA", obj);

startActivity(i);

ReceiveActivity.java

Bundle b = getIntent().getExtras();
ObjectA obj = b.getParcelable("com.package.ObjectA");

The package string isn't necessary, just the string needs to be the same in both Activities

http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/


If you have a singleton class (fx Service) acting as gateway to your model layer anyway, it can be solved by having a variable in that class with getters and setters for it.

In Activity 1:

Intent intent = new Intent(getApplicationContext(), Activity2.class);
service.setSavedOrder(order);
startActivity(intent);

In Activity 2:

private Service service;
private Order order;

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_quality);

    service = Service.getInstance();
    order = service.getSavedOrder();
    service.setSavedOrder(null) //If you don't want to save it for the entire session of the app.
}

In Service:

private static Service instance;

private Service()
{
    //Constructor content
}

public static Service getInstance()
{
    if(instance == null)
    {
        instance = new Service();
    }
    return instance;
}
private Order savedOrder;

public Order getSavedOrder()
{
    return savedOrder;
}

public void setSavedOrder(Order order)
{
    this.savedOrder = order;
}

This solution does not require any serialization or other "packaging" of the object in question. But it will only be beneficial if you are using this kind of architecture anyway.


POJO class "Post " (Note that it is implemented Serializable)

package com.example.booklib;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

import android.graphics.Bitmap;

public class Post implements Serializable{
    public String message;
    public String bitmap;
    List<Comment> commentList = new ArrayList<Comment>();
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String getBitmap() {
        return bitmap;
    }
    public void setBitmap(String bitmap) {
        this.bitmap = bitmap;
    }
    public List<Comment> getCommentList() {
        return commentList;
    }
    public void setCommentList(List<Comment> commentList) {
        this.commentList = commentList;
    }

}

POJO类“评论”(由于是Post类的成员,所以还需要实现Serializable)

    package com.example.booklib;

    import java.io.Serializable;

    public class Comment implements Serializable{
        public String message;
        public String fromName;
        public String getMessage() {
            return message;
        }
        public void setMessage(String message) {
            this.message = message;
        }
        public String getFromName() {
            return fromName;
        }
        public void setFromName(String fromName) {
            this.fromName = fromName;
        }

    }

然后在您的活动课中,您可以按照以下步骤将对象传递给其他活动。

ListView listview = (ListView) findViewById(R.id.post_list);
listview.setOnItemClickListener(new OnItemClickListener(){
        @Override
        public void onItemClick(AdapterView<?> parent, View view,
                int position, long id) {
            Post item = (Post)parent.getItemAtPosition(position);
            Intent intent = new Intent(MainActivity.this,CommentsActivity.class);
            intent.putExtra("post",item);
            startActivity(intent);

        }
    });

在您的收件人类“CommentsActivity”中,您可以获取如下所示的数据

Post post =(Post)getIntent().getSerializableExtra("post");

The simplest would be to just use the following where the item is a string:

intent.putextra("selected_item",item)

For receiving:

String name = data.getStringExtra("selected_item");

你可以使用android BUNDLE来做到这一点。

从你的班级创建一个Bundle,如:

public Bundle toBundle() {
    Bundle b = new Bundle();
    b.putString("SomeKey", "SomeValue");

    return b;
}

然后通过这个捆绑INTENT。 现在你可以通过传递bundle来重新创建类对象

public CustomClass(Context _context, Bundle b) {
    context = _context;
    classMember = b.getString("SomeKey");
}

在你的Custom类中声明并使用它。


你的类应该实现Serializable或Parcelable。

public class MY_CLASS implements Serializable

完成后,您可以在putExtra上发送一个对象

intent.putExtra("KEY", MY_CLASS_instance);

startActivity(intent);

要获得临时演员,你只需要做

Intent intent = getIntent();
MY_CLASS class = (MY_CLASS) intent.getExtras().getSerializable("KEY");

如果你的类实现了Parcelable下一个使用

MY_CLASS class = (MY_CLASS) intent.getExtras().getParcelable("KEY");

我希望这有助于:D


使用谷歌的Gson库,您可以将对象传递给另一个活动。实际上,我们将以json字符串的形式转换对象,并在传递给其他活动之后,我们将再次将对象重新转换为此类对象

考虑一个像这样的bean类

 public class Example {
    private int id;
    private String name;

    public Example(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

我们需要传递Example类的对象

Example exampleObject=new Example(1,"hello");
String jsonString = new Gson().toJson(exampleObject);
Intent nextIntent=new Intent(this,NextActivity.class);
nextIntent.putExtra("example",jsonString );
startActivity(nextIntent);

为了阅读,我们需要在NextActivity中执行相反的操作

 Example defObject=new Example(-1,null);
    //default value to return when example is not available
    String defValue= new Gson().toJson(defObject);
    String jsonString=getIntent().getExtras().getString("example",defValue);
    //passed example object
    Example exampleObject=new Gson().fromJson(jsonString,Example .class);

Add this dependancy in gradle

compile 'com.google.code.gson:gson:2.6.2'

另一种方法是使用Application对象(android.app.Application)。 您在AndroidManifest.xml文件中将其定义为:

<application
    android:name=".MyApplication"
    ...

然后,您可以从任何活动中调用该对象,并将该对象保存到Application类。

在FirstActivity中:

MyObject myObject = new MyObject();
MyApplication app = (MyApplication) getApplication();
app.setMyObject(myObject);

在SecondActivity中,执行:

MyApplication app = (MyApplication) getApplication();
MyObject retrievedObject = app.getMyObject(myObject);

如果您的对象具有应用程序级别的范围,即它们必须在整个应用程序中使用,则这很方便。 如果您希望显式控制对象范围或范围有限,则Parcelable方法仍然更好。

尽管如此,这完全避免了Intents的使用。 我不知道他们是否适合你。 我使用这种方法的另一种方法是通过intent发送对象的int标识符,并检索我在Application对象中的Maps中的对象。


在你的类模型(Object)中实现Serializable,例如:

public class MensajesProveedor implements Serializable {

    private int idProveedor;


    public MensajesProveedor() {
    }

    public int getIdProveedor() {
        return idProveedor;
    }

    public void setIdProveedor(int idProveedor) {
        this.idProveedor = idProveedor;
    }


}

和你的第一个活动

MensajeProveedor mp = new MensajeProveedor();
Intent i = new Intent(getApplicationContext(), NewActivity.class);
                i.putExtra("mensajes",mp);
                startActivity(i);

和你的第二个活动(NewActivity)

        MensajesProveedor  mensajes = (MensajesProveedor)getIntent().getExtras().getSerializable("mensajes");

祝你好运!!


在您的第一个活动中:

intent.putExtra("myTag", yourObject);

在你的第二个:

myCustomObject myObject = (myCustomObject) getIntent().getSerializableExtra("myTag");

不要忘记让你的自定义对象可串行化:

public class myCustomObject implements Serializable {
...
}

如果你只是传递物体, Parcelable就是为此而设计的。 与使用Java的本地序列化相比,它需要更多的努力来使用,但它的速度更快(我的意思是说, WAY更快)。

从文档中,如何实现的一个简单示例是:

// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;

    /* everything below here is for implementing Parcelable */

    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    }

    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    }

    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        }

        public MyParcelable[] newArray(int size) {
            return new MyParcelable[size];
        }
    };

    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
    }
}

请注意,如果您从给定的包裹中检索多个字段,则必须按照您放入的顺序执行此操作(即采用FIFO方法)。

一旦你的对象实现了putExtra()putExtra()把它们放到你的Intents

Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);

然后你可以用getParcelableExtra()把它们拉出来:

Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");

如果你的对象类实现了Parcelable和Serializable,那么确保你投射到下列其中一个:

i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);

对于你知道你将在应用程序中传递数据的情况,使用“globals”(比如静态类)

HereDianne Hackborn(hackbod--谷歌Android软件工程师)在这件事上必须说的话:

对于您知道活动在同一过程中运行的情况,您可以通过全局分享数据。 例如,你可以有一个全局的HashMap<String, WeakReference<MyInterpreterState>> ,当你为一个新的MyInterpreterState提供一个唯一的名字并把它放在哈希映射中; 要将该状态发送给另一个活动,只需将唯一名称放入哈希映射中,并在第二个活动启动时,它可以使用收到的名称从哈希映射中检索MyInterpreterState。


快速需要的简短答案

1.实现你的类来实现Serializable。

如果你有任何内部类别不要忘记将它们实现为可序列化!

public class SportsData implements  Serializable
public class Sport implements  Serializable

List<Sport> clickedObj;

2.将你的对象放在意图

 Intent intent = new Intent(SportsAct.this, SportSubAct.class);
            intent.putExtra("sport", clickedObj);
            startActivity(intent);

3.在另一个Activity类中接收你的对象

Intent intent = getIntent();
    Sport cust = (Sport) intent.getSerializableExtra("sport");

您需要将您的对象序列化为某种字符串表示形式。 一种可能的字符串表示形式是JSON,如果您问我,可以通过Google GSON在Android中序列化JSON的最简单方法之一

在这种情况下,你可以从(new Gson()).toJson(myObject); 并检索字符串值并使用fromJson将其转换回您的对象。

但是,如果你的对象不是很复杂,它可能不值得花费,你可以考虑传递对象的单独值。


感谢提供帮助,但我找到了更多的可选解决方案

 public class getsetclass implements Serializable {
        private int dt = 10;
    //pass any object, drwabale 
        public int getDt() {
            return dt;
        }

        public void setDt(int dt) {
            this.dt = dt;
        }
    }

活动一

getsetclass d = new getsetclass ();
                d.setDt(50);
                LinkedHashMap<String, Object> obj = new LinkedHashMap<String, Object>();
                obj.put("hashmapkey", d);
            Intent inew = new Intent(SgParceLableSampelActivity.this,
                    ActivityNext.class);
            Bundle b = new Bundle();
            b.putSerializable("bundleobj", obj);
            inew.putExtras(b);
            startActivity(inew);

在活动中获取数据2

 try {  setContentView(R.layout.main);
            Bundle bn = new Bundle();
            bn = getIntent().getExtras();
            HashMap<String, Object> getobj = new HashMap<String, Object>();
            getobj = (HashMap<String, Object>) bn.getSerializable("bundleobj");
            getsetclass  d = (getsetclass) getobj.get("hashmapkey");
        } catch (Exception e) {
            Log.e("Err", e.getMessage());
        }

我使用Gson以其强大而简单的API来在活动之间发送对象,

// This is the object to be sent, can be any object
public class AndroidPacket {

    public String CustomerName;

   //constructor
   public AndroidPacket(String cName){
       CustomerName = cName;
   }   
   // other fields ....


    // You can add those functions as LiveTemplate !
    public String toJson() {
        Gson gson = new Gson();
        return gson.toJson(this);
    }

    public static AndroidPacket fromJson(String json) {
        Gson gson = new Gson();
        return gson.fromJson(json, AndroidPacket.class);
    }
}

2函数将它们添加到要发送的对象

用法

将对象从A发送到B

    // Convert the object to string using Gson
    AndroidPacket androidPacket = new AndroidPacket("Ahmad");
    String objAsJson = androidPacket.toJson();

    Intent intent = new Intent(A.this, B.class);
    intent.putExtra("my_obj", objAsJson);
    startActivity(intent);

在B接收

@Override
protected void onCreate(Bundle savedInstanceState) {        
    Bundle bundle = getIntent().getExtras();
    String objAsJson = bundle.getString("my_obj");
    AndroidPacket androidPacket = AndroidPacket.fromJson(objAsJson);

    // Here you can use your Object
    Log.d("Gson", androidPacket.CustomerName);
}

我几乎在每个项目中都使用它,而且我没有任何性能问题。


我发现的最简单的解决方案是...用静态数据成员创建一个具有getter setter的类。

从一个活动中设置并从另一个活动中获取该对象。

活动A

mytestclass.staticfunctionSet("","",""..etc.);

活动b

mytestclass obj= mytestclass.staticfunctionGet();

有几种方法可以访问其他类或Activity中的变量或对象。

A.数据库

B.共享偏好。

C.对象序列化。

D.一个能容纳普通数据的类可以命名为Common Utilities,它取决于你。

E.通过Intents和Parcelable接口传递数据。

这取决于您的项目需求。

A. 数据库

SQLite是嵌入到Android中的开源数据库。 SQLite支持标准的关系数据库功能,如SQL语法,事务和预处理语句。

教程 - http://www.vogella.com/articles/AndroidSQLite/article.html

B. 共享首选项

假设你想存储用户名。 所以现在有两件事是关键用户名, 值的价值。

如何存储

 // Create object of SharedPreferences.
 SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
 //now get Editor
 SharedPreferences.Editor editor = sharedPref.edit();
 //put your value
 editor.putString("userName", "stackoverlow");

 //commits your edits
 editor.commit();

使用putString(),putBoolean(),putInt(),putFloat(),putLong()可以保存所需的dtatype。

如何获取

SharedPreferences sharedPref = PreferenceManager.getDefaultSharedPreferences(this);
String userName = sharedPref.getString("userName", "Not Available");

http://developer.android.com/reference/android/content/SharedPreferences.html

C. 对象序列化

如果我们想要保存一个对象状态以通过网络发送它,或者您也可以将它用于您的目的,则使用对象serlization。

使用java bean并将其作为他的一个领域存储,并使用getter和setter来实现

JavaBeans是具有属性的Java类。 将属性视为私有实例变量。 由于他们是私人的,所以他们可以从课外访问的唯一途径就是通过课堂中的方法。 更改属性值的方法称为setter方法,并且检索属性值的方法称为getter方法。

public class VariableStorage implements Serializable  {

    private String inString ;

    public String getInString() {
        return inString;
    }

    public void setInString(String inString) {
        this.inString = inString;
    }


}

通过使用在邮件方法中设置变量

VariableStorage variableStorage = new VariableStorage();
variableStorage.setInString(inString);

然后使用对象Serialzation序列化这个对象,并在你的其他类中反序列化这个对象。

在序列化过程中,对象可以表示为包含对象数据的字节序列,以及有关对象类型和存储在对象中的数据类型的信息。

序列化对象写入文件后,可以从文件中读取并反序列化,即可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

如果你想要这个教程,请参考这个链接

http://javawithswaranga.blogspot.in/2011/08/serialization-in-java.html

在其他类中获取变量

D.共同事业

你可以通过自己创建一个能够包含你的项目中经常需要的常用数据的课程。

样品

public class CommonUtilities {

    public static String className = "CommonUtilities";

}

E. 通过意图传递数据

请参阅本教程以获取传递数据的选项。

http://shri.blog.kraya.co.uk/2010/04/26/android-parcel-data-to-pass-between-activities-using-parcelable-classes/


Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
startACtivity(i);




android-activity