Android: Разница между Parcelable и Serializable?

Почему Android предоставляет 2 интерфейса для сериализации объектов? Связаны ли объекты Serializable с Android Binder и AIDL-файлами?

    В Android мы знаем, что мы не можем просто передавать объекты на действия. Для этого объекты должны либо реализовывать интерфейс Serializable, либо Parcelable.

    Сериализуемый

    Serializable – это стандартный интерфейс Java. Вы можете просто реализовать интерфейс Serializable и добавить методы переопределения. Проблема с этим подходом заключается в том, что используется reflection, и это медленный процесс. Этот метод создает много временных объектов и вызывает немало сбора мусора. Интерфейс Serializable проще реализовать.

    Посмотрите пример ниже (Serializable)

     //MyObjects Serializable class import java.io.Serializable; import java.util.ArrayList; import java.util.TreeMap; import android.os.Parcel; import android.os.Parcelable; public class MyObjects implements Serializable { private String name; private int age; public ArrayList address; public MyObjects(String name, int age, ArrayList address) { super(); this.name = name; this.age = age; this.address = address; } public ArrayList getAddress() { if (!(address == null)) return address; else return new ArrayList(); } public String getName() { return name; } public String getAge() { return age; } } //MyObjects instance MyObjects mObjects = new MyObjects("name","age","Address array here"); //Passing MyObjects instance via intent Intent mIntent = new Intent(FromActivity.this, ToActivity.class); mIntent.putExtra("UniqueKey", mObjects); startActivity(mIntent); //Getting MyObjects instance Intent mIntent = getIntent(); MyObjects workorder = (MyObjects) mIntent.getSerializableExtra("UniqueKey"); 

    Parcelable

    Существенный процесс намного быстрее, чем сериализуемый. Одной из причин этого является то, что мы говорим о процессе сериализации вместо использования рефлексии для его вывода. Также понятно, что для этой цели код был сильно оптимизирован.

    Посмотрите пример ниже (Parcelable)

     //MyObjects Parcelable class import java.util.ArrayList; import android.os.Parcel; import android.os.Parcelable; public class MyObjects implements Parcelable { private int age; private String name; private ArrayList address; public MyObjects(String name, int age, ArrayList address) { this.name = name; this.age = age; this.address = address; } public MyObjects(Parcel source) { age = source.readInt(); name = source.readString(); address = source.createStringArrayList(); } @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(age); dest.writeString(name); dest.writeStringList(address); } public int getAge() { return age; } public String getName() { return name; } public ArrayList getAddress() { if (!(address == null)) return address; else return new ArrayList(); } public static final Creator CREATOR = new Creator() { @Override public MyObjects[] newArray(int size) { return new MyObjects[size]; } @Override public MyObjects createFromParcel(Parcel source) { return new MyObjects(source); } }; } MyObjects mObjects = new MyObjects("name","age","Address array here"); //Passing MyOjects instance Intent mIntent = new Intent(FromActivity.this, ToActivity.class); mIntent.putExtra("UniqueKey", mObjects); startActivity(mIntent); //Getting MyObjects instance Intent mIntent = getIntent(); MyObjects workorder = (MyObjects) mIntent.getParcelableExtra("UniqueKey"); //You can pass Arraylist of Parceble obect as below //Array of MyObjects ArrayList mUsers; //Passing MyOjects instance Intent mIntent = new Intent(FromActivity.this, ToActivity.class); mIntent.putParcelableArrayListExtra("UniqueKey", mUsers); startActivity(mIntent); //Getting MyObjects instance Intent mIntent = getIntent(); ArrayList mUsers = mIntent.getParcelableArrayList("UniqueKey"); 

    Вывод.

    1. Parcelable быстрее, чем сериализуемый интерфейс
    2. Интерфейс Parcelable занимает больше времени для реализации по сравнению с сериализуемым интерфейсом
    3. Интерфейс Serializable проще реализовать
    4. Интерфейс Serializable создает много временных объектов и выдает довольно много мусора
    5. Parcelable array может проходить через Intent в android

    Serializable – это стандартный интерфейс Java. Вы просто отмечаете class Serializable, реализуя интерфейс, и Java будет автоматически сериализовать его в определенных ситуациях.

    Parcelable – это специфический для Android интерфейс, где вы сами реализуете сериализацию. Он был создан гораздо эффективнее, чем Serializable, и чтобы обойти некоторые проблемы со схемой сериализации Java по умолчанию.

    Я считаю, что Binder и AIDL работают с объектами Parcelable.

    Однако вы можете использовать объекты Serializable в Intents.

    Если вы хотите быть хорошим гражданином, возьмите дополнительное время для реализации Parcelable, поскольку оно будет работать в 10 раз быстрее и использовать меньше ресурсов.

    Однако в большинстве случаев медленность Serializable не будет заметна. Не стесняйтесь использовать его, но помните, что сериализация является дорогостоящей операцией, поэтому свести ее к минимуму.

    Если вы пытаетесь передать список с тысячами сериализованных объектов, возможно, что весь процесс займет больше секунды. Это может привести к тому, что переходы или поворот от портрета к lanscape будут очень медлительными.

    Источник по этому вопросу: http://www.developerphil.com/parcelable-vs-serializable/

    В Parcelable разработчики пишут собственный код для маршалинга и размаширования, поэтому он создает меньше мусорных объектов по сравнению с сериализацией. Из-за этой пользовательской реализации производительность Parcelable over Serialization значительно улучшается (примерно в два раза быстрее).

    Сериализация – это интерфейс маркера, который подразумевает, что пользователь не может маршировать данные в соответствии с их требованиями. В Сериализации операция маршалинга выполняется на виртуальной машине Java (JVM) с использованием API отражения Java. Это помогает идентифицировать элемент и поведение объекта Java, но также приводит к созданию большого количества объектов мусора. В связи с этим процесс сериализации медленный по сравнению с Parcelable.

    Изменить: В чем смысл маршаллинга и parsingки?

    В нескольких словах «маршаллинг» относится к процессу преобразования данных или объектов в байтовый stream, а «unmarshalling» – это обратный процесс преобразования байтового streamа в исходные данные или объект. Преобразование осуществляется посредством «сериализации».

    http://www.jguru.com/faq/view.jsp?EID=560072

    Я на самом деле буду тем, кто выступает за Serializable. Разница в скорости не настолько резка, потому что устройства намного лучше, чем несколько лет назад, а также есть другие, более тонкие отличия. Для получения дополнительной информации см. Мою статью в блоге .

    1. Сериализуемый

    @see http://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html

    Интерфейс чего?

    • является стандартным интерфейсом Java

    скорость

    • медленнее, чем у Parcelable

    2. Возможная

    @see http://developer.android.com/reference/android/os/Parcelable.html

    Интерфейс чего?

    • есть интерфейс android.os
      • что означает, что Google разработал Parcelable для лучшей производительности на Android

    скорость

    • быстрее (потому что он оптимизирован для использования в разработке Android)

    > В заключение

    Имейте в виду, что Serializable – это стандартный Java-интерфейс, а Parcelable – для Android Development

    Parcelable vs Serializable Я отношу эти два.

    Сериализуемый, простота

    Что такое Serializable?

    Serializable – это стандартный интерфейс Java. Он не является частью Android SDK. Его простота – его красота. Просто реализуя этот интерфейс, ваш POJO будет готов перейти от одного действия к другому.

     public class TestModel implements Serializable { String name; public TestModel(String name) { this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } } 
    • Красота сериализуемого заключается в том, что вам нужно только реализовать интерфейс Serializable для classа и его дочерних элементов. Это интерфейс-маркер, а это означает, что нет никакого способа реализовать, Java просто сделает все возможное для его сериализации.

    • Проблема с этим подходом заключается в том, что используется reflection, и это медленный процесс. Этот механизм также имеет тенденцию создавать много временных объектов и вызывать немало сбора мусора.

    Исправлено, скорость

    Что является возможным?

    Parcelable – это еще один интерфейс. Несмотря на свою конкуренцию (Serializable на случай, если вы забыли), это часть Android SDK. Теперь Parcelable был специально разработан таким образом, что при его использовании нет никакого отражения. Это потому, что мы действительно являемся явным для процесса сериализации.

     public class TestModel implements Parcelable { String name; public TestModel(String name, String id) { this.name = name; } protected TestModel(Parcel in) { this.name = in.readString(); } 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) { dest.writeString(this.name); } public static final Parcelable.Creator CREATOR = new Parcelable.Creator() { @Override public TestModel createFromParcel(Parcel source) { return new TestModel(source); } @Override public TestModel[] newArray(int size) { return new TestModel[size]; } }; } 

    Теперь победитель

    введите описание изображения здесь

    Результаты тестов, проведенных Philippe Breault, показывают, что Parcelable более чем в 10 раз быстрее, чем Serializable. За этим утверждением стоят и другие инженеры Google.

    По их словам, стандартный метод Serializable медленнее, чем Parcelable. И здесь у нас есть соглашение между двумя сторонами! НО, несправедливо сравнивать эти два! Потому что с Parcelable мы на самом деле пишем собственный код. Код, специально созданный для этого POJO. Таким образом, никакой мусор не создается, и результаты лучше. Но с использованием стандартного подхода Serializable мы полагаемся на процесс автоматической сериализации Java. Этот процесс, по-видимому, не является обычным явлением и создает много мусора! Таким образом, худшие результаты.

    Stop Stop !!!!, Прежде чем принимать решение

    Теперь есть другой подход . Весь автоматический процесс Serializable можно заменить специальным кодом, который использует методы writeObject () и readObject (). Эти методы специфичны. Если мы хотим полагаться на подход Serializable в сочетании с пользовательским поведением сериализации, тогда мы должны включить эти два метода с той же точной подписями, что и ниже:

      private void writeObject(java.io.ObjectOutputStream out) throws IOException; private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException; private void readObjectNoData() throws ObjectStreamException; 

    И теперь сравнение между Parcelable и пользовательским Serializable кажется справедливым! Результаты могут быть неожиданными! Пользовательский подход Serializable более чем в 3 раза быстрее для записи и на 1,6 раза быстрее для чтения, чем для Parcelable.

    Существует некоторая проблема с производительностью, связанная с маршалингом и демонтажем. Parcelable в два раза быстрее, чем Serializable.

    Перейдите по следующей ссылке:

    http://www.3pillarglobal.com/insights/parcelable-vs-java-serialization-in-android-app-development

    Внедрение parcelable может быть более быстрым, если вы используете paracelable plugin в android studio. поиск Android Parcelable code generator

    Интерфейс Serializable можно использовать так же, как и Parcelable, что приводит к (не намного) лучшим характеристикам. Просто перепишите эти два метода для обработки ручного сортировки и отмены процесса:

     private void writeObject(java.io.ObjectOutputStream out) throws IOException private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException 

    Тем не менее, мне кажется, что при разработке собственного Android, использование Android api – это путь.

    Видеть :

    вы можете использовать сериализуемые объекты в намерениях, но во время создания сериализации объекта Parcelable это может привести к серьезному исключению, например NotSerializableException. Не рекомендуется ли использовать сериализуемое соединение с Parcelable. Поэтому лучше расширять Parcelable с помощью объекта, который вы хотите использовать с пакетом и намерениями. Поскольку этот Parcelable является специфичным для Android, он не имеет побочных эффектов. 🙂

    Устанавливается гораздо быстрее, чем сериализуемое с помощью Binder, поскольку сериализуемое использование отражает и вызывает много GC. Parcelable – это дизайн для оптимизации прохождения объекта.

    Вот ссылка на ссылку. http://www.developerphil.com/parcelable-vs-serializable/

    Давайте будем гением компьютера.