Android: ¿diferencia entre plotble y serializable?

¿Por qué Android proporciona 2 interfaces para serializar objetos? ¿Los objetos serializables se pueden interconectar con archivos de Binder y AIDL de Android?

En Android sabemos que no podemos simplemente pasar objetos a actividades. Los objetos deben ser implementados interfaz Serializable o Parcelable para hacer esto.

Serializable

Serializable es una interfaz Java estándar. Simplemente puede implementar la interfaz Serializable y agregar métodos de anulación. El problema con este enfoque es que se utiliza la reflexión y es un proceso lento. Este método crea una gran cantidad de objetos temporales y causa bastante recolección de basura. La interfaz serializable es más fácil de implementar.

Mira el siguiente ejemplo (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

El proceso plotble es mucho más rápido que serializable. Una de las razones para esto es que estamos siendo explícitos sobre el proceso de serialización en lugar de usar la reflexión para inferirlo. También es lógico pensar que el código ha sido muy optimizado para este propósito.

Mira el ejemplo a continuación (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"); 

Conclusión.

  1. Parcelable es más rápido que la interfaz serializable
  2. La interfaz plotble toma más tiempo para la implementación en comparación con la interfaz serializable
  3. La interfaz serializable es más fácil de implementar
  4. Interfaz serializable crea una gran cantidad de objetos temporales y causa un poco de recolección de basura
  5. La matriz plotble se puede pasar a través de Intent en android

Serializable es una interfaz Java estándar. Simplemente marque una clase Serializable implementando la interfaz, y Java la serializará automáticamente en ciertas situaciones.

Parcelable es una interfaz específica de Android donde usted mismo implementa la serialización. Fue creado para ser mucho más eficiente que Serializable, y para solucionar algunos problemas con el esquema de serialización predeterminado de Java.

Creo que Binder y AIDL funcionan con objetos Parcelable.

Sin embargo, puede usar objetos Serializables en Intents.

Si quieres ser un buen ciudadano, tómate el tiempo extra para implementar Parcelable ya que funcionará 10 veces más rápido y usará menos recursos.

Sin embargo, en la mayoría de los casos, la lentitud de Serializable no será notable. Siéntase libre de usarlo, pero recuerde que la serialización es una operación costosa, así que manténgala al mínimo.

Si está intentando pasar una lista con miles de objetos serializados, es posible que todo el proceso tarde más de un segundo. Puede hacer que las transiciones o la rotación desde el retrato hasta el paisaje se sientan muy lentas.

Fuente a este punto: http://www.developerphil.com/plotble-vs-serializable/

En Parcelable, los desarrolladores escriben código personalizado para calcular y desasignar, por lo que crea menos objetos basura en comparación con la serialización. El rendimiento de Parcelable sobre Serialización mejora drásticamente (alrededor de dos veces más rápido), debido a esta implementación personalizada.

La serialización es una interfaz de marcador, lo que implica que el usuario no puede ordenar los datos de acuerdo con sus requisitos. En la serialización, se realiza una operación de cálculo de referencias en una máquina virtual Java (JVM) utilizando la API de reflection de Java. Esto ayuda a identificar el miembro y el comportamiento del objeto Java, pero también termina creando muchos objetos basura. Debido a esto, el proceso de serialización es lento en comparación con Parcelable.

Editar: ¿Cuál es el significado de reunir y descalificar?

En pocas palabras, “marshalling” se refiere al proceso de convertir los datos o los objetos en una secuencia de bytes, y “unmarshalling” es el proceso inverso de conversión de la transmisión por bytes a sus datos u objetos originales. La conversión se logra a través de “serialización”.

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

De hecho, voy a ser el único que aboga por Serializable. La diferencia de velocidad ya no es tan drástica ya que los dispositivos son mucho mejores que hace varios años y también hay otras diferencias más sutiles. Ver mi publicación en el blog sobre el tema para más información.

1. Serializable

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

Interfaz de qué?

  • es una interfaz estándar de Java

Velocidad

  • más lento que Parcelable

2. Parcelable

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

Interfaz de qué?

  • es la interfaz de android.os
    • lo que significa que Google desarrolló Parcelable para un mejor rendimiento en Android

Velocidad

  • más rápido (porque está optimizado para el uso en el desarrollo de Android)

> En Conclusión

Tenga en cuenta que Serializable es una interfaz estándar de Java, y Parcelable es para Android.

Parcelable vs Serializable Remito a estos dos.

Serializable, la Simplicidad

¿Qué es Serializable?

Serializable es una interfaz Java estándar. No es parte del SDK de Android. Su simplicidad es su belleza. Simplemente al implementar esta interfaz su POJO estará listo para saltar de una Actividad a otra.

 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; } } 
  • La belleza de serializable es que solo necesitas implementar la interfaz Serializable en una clase y sus hijos. Es una interfaz de marcador, lo que significa que no hay ningún método para implementar, Java simplemente hará su mejor esfuerzo para serializarlo de manera eficiente.

  • El problema con este enfoque es que se usa reflexión y es un proceso lento. Este mecanismo también tiende a crear una gran cantidad de objetos temporales y causar bastante recolección de basura.

Parcelable, La velocidad

¿Qué es Parcelable?

Parcelable es otra interfaz. A pesar de su rival (Serializable en caso de que lo hayas olvidado), es parte del SDK de Android. Ahora, Parcelable fue específicamente diseñado de tal manera que no hay reflection al usarlo. Eso es porque estamos siendo realmente explícitos para el proceso de serialización.

 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]; } }; } 

Ahora, el ganador es

enter image description here

Los resultados de las pruebas realizadas por Philippe Breault muestran que Parcelable es más de 10 veces más rápido que Serializable. Algunos otros ingenieros de Google respaldan esta statement también.

Según ellos, el enfoque Serializable predeterminado es más lento que Parcelable. ¡Y aquí tenemos un acuerdo entre las dos partes! PERO, ¡es injusto comparar estos dos en absoluto! Porque con Parcelable estamos escribiendo código personalizado. Código creado específicamente para ese POJO. Por lo tanto, no se crea basura y los resultados son mejores. Pero con el enfoque Serializable predeterminado, confiamos en el proceso de serialización automática de Java. ¡Aparentemente el proceso no es personalizado y crea mucha basura! Por lo tanto, los peores resultados.

Stop Stop !!!!, antes de tomar una decisión

Ahora, hay otro enfoque . Todo el proceso automático detrás de Serializable se puede reemplazar por un código personalizado que utiliza los métodos writeObject () y readObject (). Estos métodos son específicos. Si queremos confiar en el enfoque Serializable en combinación con el comportamiento de serialización personalizado, entonces debemos incluir estos dos métodos con la misma firma exacta que la siguiente:

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

¡Y ahora una comparación entre Parcelable y Serializable personalizado parece justo! ¡Los resultados pueden ser sorprendentes! El enfoque Serializable personalizado es más de 3 veces más rápido para las escrituras y 1.6 veces más rápido para las lecturas que Parcelable.

Existe un problema de rendimiento con respecto a la clasificación y la eliminación. Parcelable es dos veces más rápido que Serializable.

Por favor, vaya a través del siguiente enlace:

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

La implementación de plotble puede ser más rápida si usa el complemento paracelable en el estudio de Android. buscar generador de código de Android Parcelable

La interfaz de Serializable se puede usar de la misma manera que la de Parcelable, lo que resulta en (no mucho) mejor rendimiento. Simplemente sobrescriba esos dos métodos para manejar el proceso manual de ordenar y desmaterializar:

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

Aún así, me parece que al desarrollar Android nativo, usar la API de Android es el camino a seguir.

Ver :

puede usar los objetos serializables en los bashs, pero al momento de serializar un objeto Parcelable puede dar una excepción seria como NotSerializableException. No es recomendable usar serializable con Parcelable. Por lo tanto, es mejor extender Parcelable con el objeto que desea usar con bundle e intents. Como este plotble es específico de Android, no tiene ningún efecto secundario. 🙂

Parcelable mucho más rápido que serializable con Binder, porque la reflexión de uso serializable y causa muchos GC. Parcelable está diseñado para optimizar al pasar el objeto.

Aquí hay un enlace para referencia. http://www.developerphil.com/plotble-vs-serializable/