Beneficio de usar Parcelable en lugar de serializar el objeto

Según tengo entendido, Bundle and Parcelable pertenece a la forma en que Android realiza la serialización. Se usa, por ejemplo, para pasar datos entre actividades. Pero me pregunto si hay ventajas en el uso de serialización Parcelable lugar de clásica en caso de que se guarde el estado de mis objetos comerciales en la memoria interna, por ejemplo. ¿Será más simple o más rápido que el modo clásico? ¿Dónde debería usar la serialización clásica y dónde mejor utilizar los paquetes?

De “Pro Android 2”

NOTA: Ver Parcelable podría haber desencadenado la pregunta, ¿por qué Android no está utilizando el mecanismo de serialización de Java incorporado? Resulta que el equipo de Android llegó a la conclusión de que la serialización en Java es demasiado lenta para satisfacer los requisitos de comunicación entre procesos de Android. Entonces el equipo construyó la solución Parcelable. El enfoque Parcelable requiere que serialice explícitamente a los miembros de su clase, pero al final obtendrá una serialización mucho más rápida de sus objetos.

También tenga en cuenta que Android proporciona dos mecanismos que le permiten pasar datos a otro proceso. El primero es pasar un paquete a una actividad usando un bash, y el segundo es pasar un Paquete a un servicio. Estos dos mecanismos no son intercambiables y no deben confundirse. Es decir, Parcelable no se debe pasar a una actividad. Si desea iniciar una actividad y pasarle algunos datos, use un paquete. Parcelable está destinado a ser utilizado solo como parte de una definición AIDL.

Serializable es cómicamente lento en Android. Borderline inútil en muchos casos, de hecho.

Parcel y Parcelable son fantásticamente rápidos, pero su documentación dice que no debe usarlo para la serialización de uso general para el almacenamiento, ya que la implementación varía con las diferentes versiones de Android (es decir, una actualización del sistema operativo podría romper una aplicación que dependía de ella).

La mejor solución para el problema de la serialización de datos para el almacenamiento a una velocidad razonable es tirar la suya. Yo personalmente uso una de mis propias clases de utilidad que tiene una interfaz similar a Parcel y que puede serializar todos los tipos estándar de manera muy eficiente (a expensas de la seguridad del tipo). Aquí hay una versión resumida de esto:

 public interface Packageable { public void readFromPackage(PackageInputStream in) throws IOException ; public void writeToPackage(PackageOutputStream out) throws IOException ; } public final class PackageInputStream { private DataInputStream input; public PackageInputStream(InputStream in) { input = new DataInputStream(new BufferedInputStream(in)); } public void close() throws IOException { if (input != null) { input.close(); input = null; } } // Primitives public final int readInt() throws IOException { return input.readInt(); } public final long readLong() throws IOException { return input.readLong(); } public final long[] readLongArray() throws IOException { int c = input.readInt(); if (c == -1) { return null; } long[] a = new long[c]; for (int i=0 ; i ArrayList readPackageableList(Class clazz) throws IOException { int N = readInt(); if (N == -1) { return null; } ArrayList list = new ArrayList(); while (N>0) { try { T item = (T) clazz.newInstance(); item.readFromPackage(this); list.add(item); } catch (InstantiationException e) { e.printStackTrace(); } catch (IllegalAccessException e) { e.printStackTrace(); } N--; } return list; } } public final class PackageOutputStream { private DataOutputStream output; public PackageOutputStream(OutputStream out) { output = new DataOutputStream(new BufferedOutputStream(out)); } public void close() throws IOException { if (output != null) { output.close(); output = null; } } // Primitives public final void writeInt(int val) throws IOException { output.writeInt(val); } public final void writeLong(long val) throws IOException { output.writeLong(val); } public final void writeLongArray(long[] val) throws IOException { if (val == null) { writeInt(-1); return; } writeInt(val.length); for (int i=0 ; i void writePackageableList(ArrayList val) throws IOException { if (val == null) { writeInt(-1); return; } int N = val.size(); int i=0; writeInt(N); while (i < N) { Packageable item = val.get(i); item.writeToPackage(this); i++; } } } 

Vea qué tan rápido Parcelable es que Serializable.


enter image description here

de POR QUÉ AMAMOS PARCELABLE


enter image description here

de Parcelable vs Serializable

Si necesita serialización para fines de almacenamiento, pero desea evitar la penalización de velocidad de reflexión incurrida por la interfaz Serializable , debe crear explícitamente su propio protocolo de serialización con la interfaz Externalizable .

Cuando se implementa correctamente, coincide con la velocidad de Parcelable y también da cuenta de la compatibilidad entre las diferentes versiones de Android y / o la plataforma Java.

Este artículo podría aclarar las cosas también:

¿Cuál es la diferencia entre Serializable y Externalizable en Java?

En una nota al margen, también es la técnica de serialización más rápida en muchos puntos de referencia, superando a Kryo, Avro, Protocol Buffers y Jackson (json):

http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking

Parece que hoy en día la diferencia no es tan notable, al menos no cuando la ejecutas entre tus propias actividades.

Según las pruebas que se muestran en este sitio web , Parcelable es aproximadamente 10 veces más rápido en los dispositivos más nuevos (como nexus 10), y es aproximadamente 17 más rápido en los antiguos (como deseo Z)

por lo tanto, depende de usted decidir si vale la pena.

tal vez para clases relativamente pequeñas y simples, Serializable está bien, y para el rest, debe usar Parcelable

Parcelable se relaciona principalmente con IPC que usa la infraestructura de Binder , donde los datos se pasan como Parcelas .

Dado que Android depende mucho de Binder para la mayoría, si no para todas las tareas de IPC, tiene sentido implementar Parcelable en la mayoría de los lugares, y especialmente en el marco, porque permite pasar un objeto a otro proceso si lo necesita. Hace que los objetos sean “transportables”.

Pero si tiene una capa de negocio no específica de Android que usa serializables para guardar estados de objeto, y solo necesita almacenarlos en el sistema de archivos, entonces creo que serializable está bien. Permite evitar el código de placa de caldera plotble.

Basado en este artículo http://www.mooproductions.org/node/6?page=5 Parcelable debe ser más rápido.

No mencionado en el artículo, es que no creo que los objetos serializables funcionen en AIDL para servicios remotos.

Solo uso GSON -> Serialise a JSON String -> Restore Object from JSON String.

También Parcelable ofrece una implementación personalizada donde el usuario tiene la posibilidad de plotr cada uno de sus objetos anulando el writeToParcel (). Sin embargo, la serialización no hace esta implementación personalizada ya que su forma de pasar los datos implica la API JAVA reflection.