Android 의 데이터 전달 Parcelable 인터페이스

안 드 로 이 드 의 경우 복잡 한 유형 을 전달 하 는 것 은 주로 자신의 클래스 를 기반 으로 하 는 바이트 배열 로,액 티 비 티 간 전달 데 이 터 는 인 텐트 를 통 해 이 뤄 진다.Android 직렬 화 대상 은 주로 Serializable 인 터 페 이 스 를 실현 하거나 Parcelable 인 터 페 이 스 를 실현 하 는 두 가지 방법 이 있 습 니 다.Serializable 인 터 페 이 스 를 실현 하 는 것 은 자바 입 니 다. SE 자체 가 지원 하 는 반면 Parcelable 은 Serializable 인 터 페 이 스 를 실현 하 는 것 보다 효율 적 이 고 프로 세 스 간 통신(IPC)에 도 사용 할 수 있 는 안 드 로 이 드 특유 의 기능 이다.Serializable 인 터 페 이 스 를 실현 하 는 것 은 매우 간단 합 니 다.성명 만 하면 됩 니 다.Parcelable 인 터 페 이 스 를 실현 하 는 것 은 다소 복잡 하지만 효율 이 높 아 성능 을 향상 시 키 는 것 을 추천 합 니 다.Parcelable 인터페이스의 역할:Parcelable 인터페이스의 인 스 턴 스 를 실현 하면 자신의 상태 정보(상태 정 보 는 일반적으로 각 구성원 변수의 값 을 말 합 니 다)를 Parcel 에 기록 할 수도 있 고 Parcel 에서 상 태 를 회복 할 수도 있 습 니 다.Parcel 은 데이터 의 직렬 화 전달 을 완성 하 는 데 사용 된다.Parcelable 인 터 페 이 스 를 실현 하 는 방법 을 소개 한다.Parcelable 인터페이스 직렬 화 대상 을 실현 하 는 절차:
1.Parcelable 인 터 페 이 스 를 실현 합 니 다.
2.또한 Parcelable 인 터 페 이 스 를 실현 하 는 Public      void writeToParcel(Parcel dest,int flags)방법
3.사용자 정의 형식 에는 CREATOR 라 는 정적 구성원 이 있어 야 합 니 다.이 구성원 대상 은 Parcelable.Creator 인터페이스 와 방법 을 요구 합 니 다.      한 마디 로 writeToParcel 을 통 해 대상 을 Parcel 대상 으로 표시 한 다음 createFromParcel 을 통 해 Parcel 대상 을 대상 으로 표시 합 니 다.Parcel             하나의 흐름 으로 간주 되 며,writeToParcel 을 통 해 대상 을 흐름 에 기록 합 니 다.createFromParcel 을 통 해 흐름 에서 대상 을 읽 습 니 다.다만 이 과정 은 당신 이 이 루어 져 야 하기 때문에 쓴 순서 와 읽 는 순서 가 일치 해 야 합 니 다.
new Array(int size)는 T,길이 가 size 인 배열 을 만 들 고 한 마디(return new T[size])만 하면 됩 니 다.
예제 코드:

import android.os.Parcel; import android.os.Parcelable; public class Person implements Parcelable { //                      private Integer id; private String name; public Person() { } public Person(Integer id, String name) { this.id = id; this.name = name; } public Integer getId() { return id; } public void setId(Integer id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { //  javanbean      Parcel。  id   name dest.writeInt(this.id); dest.writeString(this.name); } //         ,  CREATOR,      Parcelable.Creator   public static final Parcelable.Creator<Person> CREATOR = new Parcelable.Creator<Person>() { @Override public Person createFromParcel(Parcel source) { //  Parcel     ，  person   return new Person(source.readInt(), source.readString()); } @Override public Person[] newArray(int size) { return new Person[size]; } }; } 

 1: public class Student implements Parcelable{ 2: private String id; 3: private String name; 4: private String grade; 5: 6: // Constructor 7: public Student(String id, String name, String grade){ 8: this.id = id; 9: this.name = name; 10: this.grade = grade; 11: } 12: // Getter and setter methods 13: ......... 14: ......... 15: 16: // Parcelling part 17: public Student(Parcel in){ 18: String[] data = new String[3]; 19: 20: in.readStringArray(data); 21: this.id = data[0]; 22: this.name = data[1]; 23: this.grade = data[2]; 24: } 25: 26: @override 27: public int describeContents(){ 28: return 0; 29: } 30: 31: @Override 32: public void writeToParcel(Parcel dest, int flags) { 33: dest.writeStringArray(new String[] {this.id, 34: this.name, 35: this.grade}); 36: } 37: public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { 38: public Student createFromParcel(Parcel in) { 39: return new Student(in); 40: } 41: 42: public Student[] newArray(int size) { 43: return new Student[size]; 44: } 45: }; 46: } 

import java.util.HashMap; import android.os.Parcel; import android.os.Parcelable; public class ParcelTest implements Parcelable { private HashMap map; public ParcelTest() { map = new HashMap(); } public ParcelTest(Parcel in) { map = new HashMap(); readFromParcel(in); } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { public ParcelTest createFromParcel(Parcel in) { return new ParcelTest(in); } public ParcelTest[] newArray(int size) { return new ParcelTest[size]; } }; @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(map.size()); for (String s: map.keySet()) { dest.writeString(s); dest.writeString(map.get(s)); } } public void readFromParcel(Parcel in) { int count = in.readInt(); for (int i = 0; i < count; i++) { map.put(in.readString(), in.readString()); } } public String get(String key) { return map.get(key); } public void put(String key, String value) { map.put(key, value); } }

안 드 로 이 드 에서 사용자 정의 대상 의 직렬 화 문 제 는 두 가지 선택 이 있 습 니 다.하 나 는 Parcelable 이 고 다른 하 나 는 Serializable 입 니 다.직렬 화 원인:1.대상 을 영구적 으로 저장 하고 대상 의 바이트 순 서 를 로 컬 파일 에 저장 합 니 다.2.직렬 화 대상 을 통 해 네트워크 에서 대상 을 전달한다.3.프로 세 스 간 전달 대상 을 직렬 화 합 니 다.  둘째,다음 원칙 을 참고 할 수 있 는 것 을 선택 하 십시오.1.메모 리 를 사용 할 때 Parcelable 클래스 는 Serializable 보다 성능 이 높 기 때문에 Parcelable 클래스 를 사용 하 는 것 을 추천 합 니 다.2.Serializable 은 직렬 화 할 때 대량의 임시 변 수 를 발생 시 켜 빈번 한 GC 를 일으킨다.3.Parcelable 은 데 이 터 를 디스크 에 저장 할 때 사용 할 수 없습니다.왜냐하면 Parcelable 은 데이터 의 지속 성 이 외부 에서 변화 하 는 상황 에서 잘 보장 되 지 않 기 때 문 입 니 다.비록 Serializable 은 효율 이 낮 고 사용 을 권장 하지 않 지만 이런 상황 에서 Serializable 을 사용 하 는 것 을 권장 합 니 다.