วิธีที่ดีที่สุดในการแบ่งปันข้อมูลระหว่างกิจกรรมคืออะไร


239

ฉันมีกิจกรรมหนึ่งกิจกรรมซึ่งเป็นกิจกรรมหลักที่ใช้ทั่วทั้งแอพและมีตัวแปรจำนวนมาก ฉันมีสองกิจกรรมอื่น ๆ ที่ฉันต้องการใช้ข้อมูลจากกิจกรรมแรก ตอนนี้ฉันรู้ว่าฉันสามารถทำสิ่งนี้:

GlobalState gs = (GlobalState) getApplication();
String s = gs.getTestMe();

อย่างไรก็ตามฉันต้องการแบ่งปันตัวแปรจำนวนมากและบางคนอาจค่อนข้างใหญ่ดังนั้นฉันไม่ต้องการสร้างสำเนาของพวกเขาเหมือนด้านบน

มีวิธีรับและเปลี่ยนแปลงตัวแปรโดยตรงโดยไม่ต้องใช้วิธีรับและตั้งค่าหรือไม่ ฉันจำได้ว่าอ่านบทความบนเว็บไซต์ Google dev โดยบอกว่านี่ไม่เหมาะสำหรับการทำงานบน Android


2
ตั้งแต่ Android 2.3 (Gingerbread) การเพิ่มประสิทธิภาพของการรับ / การตั้งค่าจะดำเนินการโดยอัตโนมัติโดย Dalvik; สิ่งนี้เกี่ยวข้องเฉพาะเมื่อคุณกำหนดเป้าหมายเป็น Android เวอร์ชันเก่า
StellarVortex

โปรดทราบว่าตัวอย่างนี้ไม่ได้คัดลอกข้อมูลสตริง ค่อนข้างจะสร้างการอ้างอิงไปยังวัตถุสตริงเดียวกัน
โค้ด - ฝึกงาน

มันยากที่จะเชื่อว่าทำไมจึงไม่มีความเป็นไปได้ที่จะเริ่มกิจกรรมจากกิจกรรมอื่นและส่งผ่านวัตถุที่ซับซ้อนใด ๆ จากที่หนึ่งไปที่สอง โดยไม่มีการทำให้เป็นอนุกรมบันทึกวัตถุและความพยายามทั้งหมดที่ นี่เป็นช่องโหว่หรือไม่หรือมีเหตุผลอื่นใดที่ต่อต้านการส่งผ่านการอ้างอิงวัตถุหากทั้งสองกิจกรรมอยู่ในแอปเดียวกันหรือไม่ (ฉันเข้าใจว่ามันแตกต่างกันหากพวกเขาอยู่ในแอพที่แตกต่างกัน)
Droidum


LiveData เป็นทางออกที่ดีที่สุดและล่าสุด ตรวจสอบคำตอบของฉันด้านล่าง
Amir Uval

คำตอบ:


476

นี่คือการรวบรวมวิธีการทั่วไปในการบรรลุสิ่งนี้ :

  • ส่งข้อมูลภายในเจตนา
  • ฟิลด์คงที่
  • HashMap ของ WeakReferences
  • วัตถุที่มีอยู่ (sqlite, การตั้งค่าการแชร์, ไฟล์, ฯลฯ )

TL; DR : มีสองวิธีในการแบ่งปันข้อมูล: การส่งข้อมูลในความพิเศษของเจตนาหรือบันทึกไว้ที่อื่น หากข้อมูลเป็นข้อมูลพื้นฐานสตริงหรือวัตถุที่ผู้ใช้กำหนด: ส่งเป็นส่วนหนึ่งของความตั้งใจพิเศษ (วัตถุที่ผู้ใช้กำหนดเองต้องนำมาใช้Parcelable) หากผ่านวัตถุที่ซับซ้อนให้บันทึกอินสแตนซ์ในซิงเกิลตันที่อื่นและเข้าถึงจากกิจกรรมที่เรียกใช้

ตัวอย่างบางส่วนของวิธีการและเหตุผลที่จะใช้แต่ละวิธี:

ส่งข้อมูลภายในเจตนา

Intent intent = new Intent(FirstActivity.this, SecondActivity.class);
intent.putExtra("some_key", value);
intent.putExtra("some_other_key", "a value");
startActivity(intent);

ในกิจกรรมที่สอง:

Bundle bundle = getIntent().getExtras();
int value = bundle.getInt("some_key");
String value2 = bundle.getString("some_other_key");

ใช้วิธีนี้ถ้าคุณจะผ่านข้อมูลแบบดั้งเดิมหรือสตริง คุณยังสามารถส่งผ่านวัตถุที่ใช้งานSerializableได้

แม้ว่าจะดึงดูดคุณควรคิดให้รอบคอบก่อนใช้Serializable: มันเกิดข้อผิดพลาดได้ง่ายและช้ามาก ดังนั้นโดยทั่วไป: อยู่ให้ห่างจากSerializableถ้าเป็นไปได้ หากคุณต้องการที่จะผ่านวัตถุที่ผู้ใช้กำหนดซับซ้อนใช้เวลาดูที่Parcelableอินเตอร์เฟซ มันยากที่จะดำเนินการ Serializableแต่ก็มีกำไรความเร็วมากเมื่อเทียบกับ

แบ่งปันข้อมูลโดยไม่ต้องต่อกับดิสก์

เป็นไปได้ที่จะแบ่งปันข้อมูลระหว่างกิจกรรมโดยบันทึกไว้ในหน่วยความจำเนื่องจากส่วนใหญ่กิจกรรมทั้งสองจะทำงานในกระบวนการเดียวกัน

หมายเหตุ:บางครั้งเมื่อผู้ใช้ออกจากกิจกรรมของคุณ (โดยไม่เลิก) Android อาจตัดสินใจฆ่าแอปพลิเคชันของคุณ ในสถานการณ์เช่นนี้ฉันมีกรณีที่ Android พยายามเปิดกิจกรรมล่าสุดโดยใช้เจตนาที่มีให้ก่อนที่แอปจะถูกฆ่า ในกรณีนี้ข้อมูลที่เก็บไว้ในซิงเกิลตัน (ของคุณหรือApplication) จะหายไปและสิ่งเลวร้ายอาจเกิดขึ้นได้ เพื่อหลีกเลี่ยงกรณีดังกล่าวคุณคงอยู่วัตถุไปยังดิสก์หรือตรวจสอบข้อมูลก่อนที่จะใช้เพื่อให้แน่ใจว่าถูกต้อง

ใช้คลาสเดี่ยว

มีคลาสสำหรับเก็บข้อมูล:

public class DataHolder {
  private String data;
  public String getData() {return data;}
  public void setData(String data) {this.data = data;}

  private static final DataHolder holder = new DataHolder();
  public static DataHolder getInstance() {return holder;}
}

จากกิจกรรมที่เปิดตัว:

String data = DataHolder.getInstance().getData();

ใช้แอปพลิเคชันเดี่ยว

แอปพลิเคชันซิงเกิลตันเป็นอินสแตนซ์android.app.Applicationที่สร้างขึ้นเมื่อเปิดตัวแอพ คุณสามารถกำหนดเองได้โดยขยายApplication:

import android.app.Application;
public class MyApplication extends Application {
  private String data;
  public String getData() {return data;}
  public void setData(String data) {this.data = data;}
}

ก่อนเริ่มกิจกรรม:

MyApplication app = (MyApplication) getApplicationContext();
app.setData(someData);

จากนั้นจากกิจกรรมที่เปิดตัว:

MyApplication app = (MyApplication) getApplicationContext();
String data = app.getData();

ฟิลด์คงที่

ความคิดนั้นเหมือนกับซิงเกิล แต่ในกรณีนี้คุณให้การเข้าถึงข้อมูลแบบคงที่:

public class DataHolder {
  private static String data;
  public static String getData() {return data;}
  public static void setData(String data) {DataHolder.data = data;}
}

จากกิจกรรมที่เปิดตัว:

String data = DataHolder.getData();

HashMap ของ WeakReferences

แนวคิดเดียวกัน แต่อนุญาตให้ตัวรวบรวมขยะลบวัตถุที่ไม่อ้างอิง (เช่นเมื่อผู้ใช้ออกจากกิจกรรม):

public class DataHolder {
  Map<String, WeakReference<Object>> data = new HashMap<String, WeakReference<Object>>();

  void save(String id, Object object) {
    data.put(id, new WeakReference<Object>(object));
  }

  Object retrieve(String id) {
    WeakReference<Object> objectWeakReference = data.get(id);
    return objectWeakReference.get();
  }
}

ก่อนเริ่มกิจกรรม:

DataHolder.getInstance().save(someId, someObject);

จากกิจกรรมที่เปิดตัว:

DataHolder.getInstance().retrieve(someId);

คุณอาจจะหรืออาจไม่จำเป็นต้องผ่าน ID วัตถุโดยใช้ความพิเศษของเจตนา ทุกอย่างขึ้นอยู่กับปัญหาเฉพาะของคุณ

คงวัตถุไว้ในดิสก์

แนวคิดคือการบันทึกข้อมูลลงในดิสก์ก่อนที่จะเปิดกิจกรรมอื่น ๆ

ข้อดี:คุณสามารถเริ่มกิจกรรมจากที่อื่นได้และหากข้อมูลยังคงอยู่มันควรจะทำงานได้ดี

ข้อเสีย:มันยุ่งยากและใช้เวลาในการดำเนินการมากขึ้น ต้องใช้รหัสมากขึ้นและมีโอกาสมากขึ้นในการแนะนำข้อบกพร่อง มันจะช้ากว่ามาก

วิธีในการคงอยู่ของวัตถุมีดังนี้:


11
ฉันจะยืนยันว่านั่นไม่ใช่วิธี "ปกติ" สำหรับข้อมูลที่มีขนาดใหญ่ / ซับซ้อนกว่า มันง่ายกว่าที่จะใช้ singleton static หรือ Application object และใช้งานได้ดี ตอนนี้ที่กล่าวว่า OP ได้ใช้สตริงในตัวอย่างสำหรับจุดประสงค์นั้นสมบูรณ์แบบและเป็นที่ต้องการ
Charlie Collins

10
พบว่า Serializable มีปัญหาประสิทธิภาพการทำงานที่ร้ายแรงในรูปแบบกระบวนการ Android นั่นเป็นเหตุผลที่พวกเขาแนะนำ Parcelable อ่านพัสดุแทนSerializableในคำตอบข้างต้น
Subin Sebastian

3
ทำได้โดยsetResultวิธีการ นอกจากนี้ในกรณีนั้นกิจกรรมรองจะต้องเรียกใช้โดยใช้startActivityForResultวิธีการ
Cristian

2
สรุปยอดเยี่ยม! เกี่ยวกับปัญหาของการถูกทำลาย singletons มีวิธีแก้ปัญหาง่าย ๆ สำหรับแอพที่มีกิจกรรมและวัตถุมากมาย: ใช้คลาสย่อยของActivityทั้งหมดและonCreate()ตรวจสอบฟิลด์คงที่ของซิงเกิลที่คุณกรอกเมื่อเริ่มต้นแอป หากฟิลด์นั้นว่างให้ย้อนกลับไปที่กิจกรรมเริ่มโดยใช้FLAG_ACTIVITY_CLEAR_TASKหรือ a BroadcastReceiverเพื่อฆ่ากิจกรรมอื่น ๆ
Janosch

1
ฉันจะไม่แนะนำให้บันทึกข้อมูลในคลาสแอปพลิเคชัน อ่านเพิ่มเติมได้ที่นี่: developerphil.com/dont-store-data-in-the-application-object
Shayan_Aryan

22

สิ่งที่คุณสามารถใช้:

  1. ส่งผ่านข้อมูลระหว่างกิจกรรม (เช่น Cristian กล่าว)
  2. ใช้คลาสที่มีตัวแปรสแตติกจำนวนมาก (เพื่อให้คุณสามารถเรียกพวกมันได้โดยไม่มีตัวอย่างของคลาสและโดยไม่ต้องใช้ getter / setter)
  3. การใช้ฐานข้อมูล
  4. การตั้งค่าที่ใช้ร่วมกัน

สิ่งที่คุณเลือกขึ้นอยู่กับความต้องการของคุณ อาจเป็นไปได้ว่าคุณจะใช้มากกว่าหนึ่งวิธีเมื่อคุณมี "มาก"


1
โปรดทราบว่าสถิตยศาสตร์จะถูกล้างเมื่อกระบวนการตาย
EpicPandaForce

@EpicPandaForce แน่นอนและเมื่ออุปกรณ์ถูกปิด
WarrenFaith

1
แต่หากปิดอุปกรณ์ไว้แอปจะเริ่มต้นใหม่จากการMAINทำงาน หลังจากกระบวนการตายคุณเริ่มต้นใหม่ในกิจกรรมใดก็ตามที่เปิดครั้งสุดท้ายซึ่งอาจเป็นหน้ารายละเอียดที่บางส่วนในแอพ
EpicPandaForce

@EpicPandaForce ดูเหมือนว่าคุณพลาดประชดของฉันแม้ในขณะที่คุณเป็น Cpt ชัดเจน
WarrenFaith

16

ทำในสิ่งที่ google สั่งให้คุณทำ! ที่นี่: http://developer.android.com/resources/faq/framework.html#3

  • ชนิดข้อมูลดั้งเดิม
  • วัตถุที่ไม่ขัดข้อง
  • คลาสซิงเกิล - ที่ชื่นชอบ: D
  • ฟิลด์ / เมธอดสแตติกสาธารณะ
  • HashMap ของจุดอ่อนไปยังวัตถุ
  • วัตถุถาวร (การตั้งค่าแอปพลิเคชัน, ไฟล์, contentProviders, SQLite DB)

1
ลิงก์ของ Google สำหรับวัตถุที่คงอยู่: developer.android.com/guide/topics/data/data-storage.html
NicoMinsk

เฉพาะ antipatterns คลาส Singleton เป็นรูปแบบการออกแบบครั้งแรกคลาสที่มีฟิลด์แบบคงที่ / วิธีการทำงานเป็นจำนวนมากเช่น singletons และการสร้างฐานข้อมูลสำหรับวัตถุ busniss ที่ยังคงมีอยู่ในบางครั้งไม่ใช่สิ่งที่ดีแน่นอนว่าไม่ใช่ความผิดของคุณ วิธีที่จะทำให้สำเร็จ แต่ฉันสงสัยว่าทำไม Google มีความซับซ้อนเช่นสิ่งที่โง่มากปัญหาประสิทธิภาพหรืออะไร ?? !!!! หรือฉันไม่เข้าใจวิธี Android ?? !!!!
La VloZ Merrill

ลิงก์ใช้งานไม่ได้ :(
Shayan_Aryan

14

"อย่างไรก็ตามฉันต้องการแบ่งปันตัวแปรจำนวนมากและบางคนอาจค่อนข้างใหญ่ดังนั้นฉันไม่ต้องการสร้างสำเนาของพวกเขาเหมือนด้านบน"

ที่ไม่ได้คัดลอก (โดยเฉพาะกับStringแต่แม้วัตถุจะผ่านค่าอ้างอิงไม่วัตถุและ getter ของที่ชอบใช้ดี - arguably ดีกว่าการใช้วิธีอื่นเพราะพวกเขาเป็นเรื่องธรรมดาและ เข้าใจกันดี) "ตำนานประสิทธิภาพ" ที่เก่ากว่าเช่นไม่ใช้ getters และ setters ยังคงมีค่าอยู่บ้าง แต่ยังได้รับการอัปเดตในเอกสารด้วย

แต่ถ้าคุณไม่ต้องการทำเช่นนั้นคุณสามารถทำให้ตัวแปรเป็นแบบสาธารณะหรือได้รับการปกป้องในGlobalStateและเข้าถึงตัวแปรโดยตรง และคุณสามารถสร้าง singleton คงที่ตามที่Application Object JavaDoc บ่งชี้ :

ตามปกติแล้วไม่จำเป็นต้องใช้คลาสย่อย ในสถานการณ์ส่วนใหญ่ Singletons แบบคงที่สามารถให้ฟังก์ชั่นเดียวกันในทางโมดูลาร์มากขึ้น หากซิงเกิลของคุณต้องการบริบทส่วนกลาง (ตัวอย่างเช่นการลงทะเบียนรีซีฟเวอร์รีซีฟเวอร์) ฟังก์ชั่นเพื่อดึงข้อมูลสามารถรับบริบทซึ่งใช้ Context.getApplicationContext () ภายในเมื่อสร้างซิงเกิลครั้งแรก

การใช้ข้อมูลเจตนาเช่นเดียวกับคำตอบอื่น ๆ ที่นี่หมายเหตุเป็นอีกวิธีหนึ่งในการส่งผ่านข้อมูล แต่โดยทั่วไปจะใช้สำหรับข้อมูลขนาดเล็กลงและประเภทที่เรียบง่าย คุณสามารถส่งผ่านข้อมูลที่มีขนาดใหญ่ / ซับซ้อนได้ แต่มันมีส่วนร่วมมากกว่าเพียงแค่ใช้สแตติกเดี่ยว ประยุกต์ใช้วัตถุที่ยังคงเป็นที่ชื่นชอบส่วนตัวของฉันสำหรับการแบ่งปันข้อมูล / ถาวรที่ไม่ซับซ้อนมากขึ้นขนาดใหญ่ระหว่าง Android คอมโพเนนต์ของโปรแกรมประยุกต์แม้ว่า (เพราะมีวงจรชีวิตที่กำหนดไว้ในแอป Android)

นอกจากนี้ตามที่คนอื่น ๆ ระบุไว้หากข้อมูลมีความซับซ้อนมากและจำเป็นต้องคงอยู่คุณสามารถใช้ SQLite หรือระบบไฟล์ได้เช่นกัน


1
อันที่จริงผมก็สะดุดกับเรื่องนี้ในเอกสารเมื่อเร็ว ๆ นี้: developer.android.com/guide/appendix/faq/framework.html#3 สำหรับ "ออบเจ็กต์ไม่ซับซ้อน" ขอแนะนำให้ใช้คลาสแอพพลิเคชั่นในการสร้างและกำจัด singleton static! ด้วยวิธีนี้คุณจะได้รับแอปพลิเคชันวงจรชีวิตที่กำหนดไว้อย่างดีและความสะดวกในการใช้งานของสแตติกเดี่ยว
Charlie Collins

2
ดูเหมือนว่าส่วนของคำถามที่พบบ่อยจะถูกลบออกในตอนนี้ (ฉันเห็น "วัตถุที่ไม่ถาวร" เท่านั้นและไม่ได้กล่าวถึงคลาสแอปพลิเคชัน) อย่างไรก็ตามคุณสามารถทำอย่างละเอียด?
Tony Chan

1
ปัจจุบันอยู่ที่developer.android.com/guide/faq/framework.html#3 "ฉันจะส่งผ่านข้อมูลระหว่างกิจกรรม / บริการภายในแอปพลิเคชันเดียวได้อย่างไร" และไม่มีการกล่าวถึงคลาสแอปพลิเคชัน
Jerry101

ฉันชอบที่จะใช้แอปพลิเคชันวัตถุตามก่อนหน้านี้ที่คุณตั้งไว้ใน "Android in Action" แต่นายจ้างที่คาดหวังจำนวนมากไม่ชอบเมื่อพวกเขาเห็นสิ่งนี้ในการท้าทายรหัส พวกเขาอาจจะผิด แต่พวกเขาโยนน้ำหนักของพวกเขา BTW: ลิงก์ 'framework.html # 3 ไม่ทำงานอีกต่อไป
แมตต์เจ

7

คุณสามารถขยายคลาสแอปพลิเคชันและแท็กบนวัตถุใด ๆ ที่คุณต้องการจากนั้นพวกเขาจะสามารถใช้ได้ทุกที่ในแอปพลิเคชันของคุณ


ฉันจะไม่แนะนำให้บันทึกข้อมูลในคลาสแอปพลิเคชัน อ่านเพิ่มเติมได้ที่นี่: developerphil.com/dont-store-data-in-the-application-object
Shayan_Aryan

4

มีวิธีการใหม่และดีกว่าที่จะใช้ข้อมูลร่วมกันระหว่างกิจกรรมและมันเป็นLiveData แจ้งให้ทราบล่วงหน้าโดยเฉพาะข้อความนี้จากหน้าของนักพัฒนา Android:

ความจริงที่ว่าวัตถุ LiveData เป็นวงจรชีวิตที่รับรู้ถึงวิธีการที่คุณสามารถแบ่งปันระหว่างกิจกรรมหลายชิ้นส่วนและบริการ เพื่อให้ตัวอย่างง่ายคุณสามารถใช้คลาส LiveData เป็นซิงเกิล

ความหมายของสิ่งนี้มีขนาดใหญ่มาก - ข้อมูลโมเดลใด ๆ สามารถใช้ร่วมกันในคลาสซิงเกิลตันทั่วไปภายในLiveDatawrapper มันสามารถฉีดจากกิจกรรมต่าง ๆ ของพวกเขาViewModelเพื่อประโยชน์ในการทดสอบ และคุณไม่จำเป็นต้องกังวลเกี่ยวกับการอ้างอิงที่อ่อนแอเพื่อป้องกันการรั่วไหลของหน่วยความจำ


2

การใช้ hashmap ของวิธีการอ้างอิงอ่อนอธิบายไว้ข้างต้นและในhttp://developer.android.com/guide/faq/framework.htmlดูเหมือนว่าจะเป็นปัญหาสำหรับฉัน รายการทั้งหมดถูกเรียกคืนอย่างไรไม่ใช่เพียงแค่ค่าแผนที่ คุณจัดสรรในขอบเขตใด เนื่องจากเฟรมเวิร์กอยู่ในการควบคุมวงจรชีวิตของกิจกรรมการมีหนึ่งในกิจกรรมที่เข้าร่วมเป็นของตัวเองจึงมีความเสี่ยงข้อผิดพลาดรันไทม์เมื่อเจ้าของถูกทำลายก่อนลูกค้า หากแอปพลิเคชันเป็นเจ้าของกิจกรรมบางอย่างจะต้องลบรายการอย่างชัดเจนเพื่อหลีกเลี่ยง hashmap จากการเก็บไว้ในรายการด้วยคีย์ที่ถูกต้องและการอ้างอิงที่อ่อนแออาจเก็บรวบรวมไว้ นอกจากนี้ลูกค้าควรทำอย่างไรเมื่อค่าที่ส่งคืนสำหรับคีย์เป็นโมฆะ

สำหรับฉันแล้วดูเหมือนว่า WeakHashMap ที่เป็นเจ้าของโดยแอปพลิเคชันหรือภายในซิงเกิลนั้นเป็นตัวเลือกที่ดีกว่า ค่าในแผนที่สามารถเข้าถึงได้ผ่านวัตถุสำคัญและเมื่อไม่มีการอ้างอิงที่สำคัญไปยังคีย์ (เช่นกิจกรรมทั้งหมดจะทำกับคีย์และสิ่งที่มันแมปไป) GC สามารถเรียกคืนรายการแผนที่


2

มีหลายวิธีในการแชร์ข้อมูลระหว่างกิจกรรม

1: การส่งผ่านข้อมูลระหว่างกิจกรรมโดยใช้เจตนา

Intent intent=new Intent(this, desirableActivity.class);
intent.putExtra("KEY", "Value");
startActivity(intent)

2: การใช้คำหลักคงที่กำหนดตัวแปรเป็นสาธารณะคงที่และใช้ใด ๆ ในโครงการ

      public static int sInitialValue=0;

ใช้ที่ใดก็ได้ในโครงการโดยใช้ classname.variableName;

3: การใช้ฐานข้อมูล

แต่กระบวนการที่มีความยาวบิตคุณต้องใช้แบบสอบถามเพื่อแทรกข้อมูลและวนซ้ำข้อมูลโดยใช้เคอร์เซอร์เมื่อต้องการ แต่ไม่มีโอกาสที่จะสูญเสียข้อมูลโดยไม่ต้องล้างแคช

4: การใช้การตั้งค่าที่ใช้ร่วมกัน

ง่ายกว่าฐานข้อมูล แต่มีข้อ จำกัด บางประการที่คุณไม่สามารถบันทึกวัตถุ ArrayList, List และ custome

5: สร้างตัวตั้งค่า getter ในคลาส Aplication และเข้าถึงที่ใด ๆ ในโครงการ

      private String data;
      public String getData() {
          return data;
      }

      public void setData(String data) {
          this.data = data;
      }

ที่นี่ตั้งและรับจากกิจกรรม

         ((YourApplicationClass)getApplicationContext()).setData("abc"); 

         String data=((YourApplicationClass)getApplicationContext()).getData();  

1

ฉันมีความคิดเล็กน้อย แต่ฉันไม่รู้ว่ามันเป็นสิ่งที่คุณต้องการหรือไม่

คุณสามารถใช้บริการที่เก็บข้อมูลทั้งหมดแล้วผูกกิจกรรมของคุณเข้ากับบริการเพื่อดึงข้อมูลกลับคืน

หรือจัดแพคเกจข้อมูลของคุณเป็นแบบอนุกรมหรือพัสดุไปรษณีย์และแนบกับบันเดิลและส่งบันเดิลระหว่างกิจกรรม

อันนี้อาจไม่ใช่สิ่งที่คุณกำลังมองหา แต่คุณสามารถลองใช้ SharedPreferences หรือค่ากำหนดทั่วไป

ให้ฉันรู้ว่าคุณตัดสินใจอย่างไร


1

สมมติว่าคุณกำลังเรียกกิจกรรมที่สองจากกิจกรรมหนึ่งโดยใช้เจตนา
คุณสามารถส่งผ่านข้อมูลด้วย intent.putExtra ()

ใช้สิ่งนี้สำหรับการอ้างอิงของคุณ กำลังส่งอาร์เรย์ด้วย Intent.putExtra

หวังว่าเป็นสิ่งที่คุณต้องการ


1

ถ้าความตั้งใจของคุณคือการเรียกกิจกรรมอื่น ๆ จากกิจกรรมปัจจุบันคุณควรใช้Intent ของ คุณให้ความสำคัญกับข้อมูลที่มีอยู่น้อยกว่าการแบ่งปันข้อมูลตามความต้องการ

อย่างไรก็ตามถ้าคุณต้องการยืนยันค่าเหล่านี้คุณสามารถคงอยู่ในไฟล์ข้อความที่มีโครงสร้างหรือฐานข้อมูลในที่เก็บข้อมูลภายใน ไฟล์คุณสมบัติไฟล์ XML หรือไฟล์ JSON สามารถจัดเก็บข้อมูลของคุณและแยกวิเคราะห์ได้ง่ายระหว่างการสร้างกิจกรรม อย่าลืมว่าคุณมี SQLite บนอุปกรณ์ Android ทั้งหมดดังนั้นคุณสามารถเก็บไว้ในตารางฐานข้อมูล คุณยังสามารถใช้แผนที่เพื่อจัดเก็บคู่ค่าคีย์และทำให้แผนที่เป็นอนุกรมในที่จัดเก็บในตัวเครื่อง แต่สิ่งนี้อาจยุ่งยากเกินไปที่จะเป็นประโยชน์สำหรับโครงสร้างข้อมูลอย่างง่าย


1

คำตอบทั้งหมดข้างต้นนั้นยอดเยี่ยมมาก ... ฉันแค่เพิ่มชื่อที่ยังไม่มีใครพูดถึงเกี่ยวกับการเก็บข้อมูลผ่านกิจกรรมและนั่นคือการใช้ฐานข้อมูล SQLite สำหรับ Android เพื่อยืนยันข้อมูลที่เกี่ยวข้อง ... ในความเป็นจริงคุณสามารถวาง databaseHelper ในสถานะแอปพลิเคชันและเรียกมันได้ตามต้องการตลอดการเปิดใช้งาน .. หรือเพียงแค่สร้างคลาสผู้ช่วยและทำการโทร DB เมื่อจำเป็น ... เพียงแค่เพิ่มเลเยอร์อื่นให้คุณพิจารณา ... แต่คำตอบอื่น ๆ ทั้งหมดจะพอเพียง เช่นกัน .. ความชอบจริง ๆ


1

การแชร์ข้อมูลระหว่างกิจกรรมตัวอย่างส่งอีเมลหลังจากเข้าสู่ระบบ

"email" เป็นชื่อที่สามารถใช้เพื่ออ้างอิงค่ากิจกรรมที่ร้องขอ

1 รหัสในหน้าเข้าสู่ระบบ

Intent openLoginActivity = new Intent(getBaseContext(), Home.class);
    openLoginActivity.putExtra("email", getEmail);

2 รหัสในหน้าแรก

Bundle extras = getIntent().getExtras();
    accountEmail = extras.getString("email");

1

และถ้าคุณต้องการทำงานกับวัตถุข้อมูลสองสิ่งนี้สำคัญมาก:

ต่อเนื่องกันได้กับพัสดุ

  • Serializable เป็นอินเทอร์เฟซของตัวทำเครื่องหมายซึ่งหมายความว่าผู้ใช้ไม่สามารถรวบรวมข้อมูลตามความต้องการของพวกเขา ดังนั้นเมื่อวัตถุดำเนินการ Serializable Java จะเป็นอันดับโดยอัตโนมัติ
  • พัสดุเป็นโปรโตคอลการทำให้เป็นอันดับของ Android ใน Parcelable นักพัฒนาเขียนโค้ดที่กำหนดเองสำหรับการทำมาร์ชชิ่งและ unmarshaling ดังนั้นจึงสร้างวัตถุขยะน้อยลงเมื่อเปรียบเทียบกับการทำให้เป็นอนุกรม
  • ประสิทธิภาพของ Parcelable นั้นสูงมากเมื่อเปรียบเทียบกับ Serializable เนื่องจากการใช้งานที่กำหนดเองขอแนะนำอย่างยิ่งให้ใช้การฝัง Parcelable เมื่อซีเรียลไลซ์วัตถุใน Android

public class User implements Parcelable

ตรวจสอบเพิ่มเติมได้ที่นี่

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.