我正在尝试从一个“活动”发送客户类的对象，并在另一个“”中显示它。
客户类别的代码：
public class Customer {
private String firstName, lastName, address;
int age;
public Customer(String fname, String lname, int age, String address) {
firstName = fname;
lastName = lname;
age = age;
address = address;
}
public String printValues() {
String data = null;
data = "First Name :" + firstName + " Last Name :" + lastName
+ " Age : " + age + " Address : " + address;
return data;
}
}
我想将其对象从一个“活动”发送到另一个“，然后在另一个活动”上显示数据。
我怎样才能做到这一点？
创建自己的类Customer，如下所示：
import import java.io.Serializable;
public class Customer implements Serializable
{
private String name;
private String city;
public Customer()
{
}
public Customer(String name, String city)
{
this.name= name;
this.city=city;
}
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public String getCity()
{
return city;
}
public void setCity(String city)
{
this.city= city;
}
}
在onCreate（）方法中
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_top);
Customer cust=new Customer();
cust.setName("abc");
cust.setCity("xyz");
Intent intent=new Intent(abc.this,xyz.class);
intent.putExtra("bundle",cust);
startActivity(intent);
}
在xyz活动类中，您需要使用以下代码：
Intent intent=getIntent();
Customer cust=(Customer)intent.getSerializableExtra("bundle");
textViewName.setText(cust.getName());
textViewCity.setText(cust.getCity());
这个问题也在另一个堆栈溢出问题中讨论。请查看使用Serializable通过意向传递数据的解决方案。重点是使用Bundle对象，它在Intent中存储必要的数据。
Bundle bundle = new Bundle();
bundle.putSerializable(key1, value1);
bundle.putSerializable(key2, value2);
bundle.putSerializable(key3, value3);
intent.putExtras(bundle);
要提取值，请执行以下操作：
Bundle bundle = new Bundle();
for (String key : bundle.keySet()) {
value = bundle.getSerializable(key));
}
Serializable的优点是简单。然而，如果需要传输许多数据，您应该考虑使用Parcelable方法，因为Parcelable是专门为Android设计的，它比Serializable更高效。可以使用以下命令创建Parcelable类：
在线工具parcelablerAndroid Studio插件-Android Parcelable代码生成器
在Android中，有许多方法可以将对象从一个活动传递到另一个活动。但它们中没有一个可以直接选择通过Intents或Bundles传递对象。您需要做的就是解码对象，作为字符串传递，在NextActivity中编码。示例如下：
Intent i = new Intent(this, nextActivity.class);
i.putExtra("fname", customer.getFirstName());
i.putExtra("lname", customer.getLastName());
i.putExtra("address", customer.getAddress());
startActivity(i);
第二种方法非常简单，使用可以从所有活动轻松访问的静态对象。
第三，最后但并非最不重要的是，您可以将Object存储到某个常量Java文件中，然后从任何活动中读取该Object值。
你可以尝试使用该类。限制是它不能在一个过程之外使用。
一项活动：
final Object obj1 = new Object();
final Intent in = new Intent();
in.putExtra(EXTRA_TEST, new Sharable(obj1));
其他活动：
final Sharable s = in.getExtras().getParcelable(EXTRA_TEST);
final Object obj2 = s.obj();
public final class Sharable implements Parcelable {
private Object mObject;
public static final Parcelable.Creator < Sharable > CREATOR = new Parcelable.Creator < Sharable > () {
public Sharable createFromParcel(Parcel in ) {
return new Sharable( in );
}
@Override
public Sharable[] newArray(int size) {
return new Sharable[size];
}
};
public Sharable(final Object obj) {
mObject = obj;
}
public Sharable(Parcel in ) {
readFromParcel( in );
}
Object obj() {
return mObject;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(final Parcel out, int flags) {
final long val = SystemClock.elapsedRealtime();
out.writeLong(val);
put(val, mObject);
}
private void readFromParcel(final Parcel in ) {
final long val = in .readLong();
mObject = get(val);
}
/////
private static final HashMap < Long, Object > sSharableMap = new HashMap < Long, Object > (3);
synchronized private static void put(long key, final Object obj) {
sSharableMap.put(key, obj);
}
synchronized private static Object get(long key) {
return sSharableMap.remove(key);
}
}
不可能序列化任何类型的对象。例如，不能序列化携带代码而不是数据的委托方法或接口。因此，我编写了一个“Box”类，您可以使用它来传递任何类型的数据，而无需序列化。
1-将数据用于预期用途：
Intent I = new Intent(this, YourActivity.class);
CustomClass Date = new CustomClass();
Box.Add(I, "Name", Data);
2-用于从意向检索数据：
CustomClass Data = Box.Get(getIntent(), "Name");
3-要在使用后删除数据，请将此方法添加到活动中：
@Override
protected void onDestroy() {
Box.Remove(getIntent());
super.onDestroy();
}
4-并将此代码添加到项目中：
package ir.namirasoft.Utility;
import android.content.Intent;
import java.util.HashMap;
import java.util.Vector;
public class Box {
// Number
private static int Number = 1;
public static int NextNumber() {
return Number++;
}
//
private static String _Intent_Identifier = "_Intent_Identifier";
private static HashMap<Integer, Vector<Integer>> DeleteList = new HashMap<Integer, Vector<Integer>>();
private static HashMap<Integer, HashMap<String, Object>> ObjectList = new HashMap<Integer, HashMap<String, Object>>();
public static int GetIntent_Identifier(Intent I) {
int Intent_Identifier = I.getIntExtra(_Intent_Identifier, 0);
if (Intent_Identifier == 0)
I.putExtra(_Intent_Identifier, Intent_Identifier = NextNumber());
return Intent_Identifier;
}
public static void Add(Intent I, String Name, Object O) {
int Intent_Identifier = GetIntent_Identifier(I);
synchronized (ObjectList) {
if (!ObjectList.containsKey(Intent_Identifier))
ObjectList.put(Intent_Identifier, new HashMap<String, Object>());
ObjectList.get(Intent_Identifier).put(Name, O);
}
}
public static <T> T Get(Intent I, String Name) {
int Intent_Identifier = GetIntent_Identifier(I);
synchronized (DeleteList) {
DeleteList.remove(Intent_Identifier);
}
return (T) ObjectList.get(Intent_Identifier).get(Name);
}
public static void Remove(final Intent I) {
final int Intent_Identifier = GetIntent_Identifier(I);
final int ThreadID = NextNumber();
synchronized (DeleteList) {
if (!DeleteList.containsKey(Intent_Identifier))
DeleteList.put(Intent_Identifier, new Vector<Integer>());
DeleteList.get(Intent_Identifier).add(ThreadID);
}
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(60 * 1000);
} catch (InterruptedException e) {
}
synchronized (DeleteList) {
if (DeleteList.containsKey(Intent_Identifier))
if (DeleteList.get(Intent_Identifier).contains(ThreadID))
synchronized (ObjectList) {
ObjectList.remove(Intent_Identifier);
}
}
}
}).start();
}
}
**Box类是线程安全的。
