parcelable android example
Android: ¿Diferencia entre Parcelable y Serializable? (12)
Si desea ser un buen ciudadano, tómese el tiempo adicional para implementar Parcelable, ya que se desempeñará 10 veces más rápido y utilizará menos recursos.
Sin embargo, en la mayoría de los casos, la lentitud de Serializable no se notará. 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 tome más de un segundo. Puede hacer que las transiciones o la rotación de retrato a paisaje se sientan muy lentas.
Fuente a este punto: http://www.developerphil.com/parcelable-vs-serializable/
¿Por qué Android proporciona 2 interfaces para serializar objetos? ¿Los objetos serializables se interoperan con los archivos de Android Binder y AIDL?
1. Serializable
@ver http://docs.oracle.com/javase/7/docs/api/java/io/Serializable.html
¿Interfaz de qué?
- es una interfaz estándar de Java
Velocidad
- mas lento que el Parcelable
2. Parcelable
@ver 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 su uso en el desarrollo de Android)
> En conclusión
Tenga en cuenta que Serializable es una interfaz estándar de Java y que Parcelable es para el desarrollo de Android
De hecho, voy a ser el único que abogará 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 existen otras diferencias más sutiles. Ver mi blog en el tema para más información.
En Android sabemos que no podemos simplemente pasar objetos a actividades. Los objetos deben ser implementados como interfaz Serializable o Parcelable para hacer esto.
Serializable
Serializable es una interfaz estándar de Java. 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 un poco de 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<String> address;
public MyObjects(String name, int age, ArrayList<String> address) {
super();
this.name = name;
this.age = age;
this.address = address;
}
public ArrayList<String> getAddress() {
if (!(address == null))
return address;
else
return new ArrayList<String>();
}
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 parcelable es mucho más rápido que serializable. Una de las razones de esto es que estamos siendo explícitos sobre el proceso de serialización en lugar de utilizar la reflexión para inferirlo. También es lógico pensar que el código ha sido fuertemente optimizado para este propósito.
Mira el siguiente ejemplo (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<String> address;
public MyObjects(String name, int age, ArrayList<String> 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<String> getAddress() {
if (!(address == null))
return address;
else
return new ArrayList<String>();
}
public static final Creator<MyObjects> CREATOR = new Creator<MyObjects>() {
@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<MyObjects> 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<MyObjects> mUsers = mIntent.getParcelableArrayList("UniqueKey");
Conclusión.
- Parcelable es más rápido que la interfaz serializable
- La interfaz parcelable toma más tiempo para la implementación en comparación con la interfaz serializable
- La interfaz serializable es más fácil de implementar
- La interfaz serializable crea una gran cantidad de objetos temporales y causa un poco de recolección de basura
- La matriz parcelable se puede pasar a través de Intent en Android
En Parcelable, los desarrolladores escriben código personalizado para calcular y desatascar, lo que crea menos objetos de basura en comparación con la serialización. El rendimiento de Parcelable sobre Serialización mejora dramáticamente (aproximadamente 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 calcular los datos de acuerdo con sus requisitos. En la serialización, una operación de cálculo de referencias se realiza en una Máquina Virtual Java (JVM) utilizando la API de reflexión de Java. Esto ayuda a identificar el miembro y el comportamiento del objeto Java, pero también termina creando una gran cantidad de objetos basura. Debido a esto, el proceso de serialización es lento en comparación con Parcelable.
Editar: ¿Cuál es el significado de ordenando y poco riguroso?
En pocas palabras, "ordenamiento" se refiere al proceso de convertir los datos o los objetos en un byte-stream, y "no desagradable" es el proceso inverso de convertir el beack de byte-stream a su objeto u datos originales. La conversión se logra a través de "serialización".
Hay algún problema de rendimiento en relación con el cálculo de referencias y la desvinculació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/parcelable-vs-java-serialization-in-android-app-development
La implementación de parcelable puede ser más rápida si usa un complemento paracelable en Android Studio. búsqueda de generador de código parcelable de Android
La interfaz Serializable se puede usar de la misma manera que la Parcelable, lo que resulta en (no mucho) mejores rendimientos. Simplemente sobrescriba esos dos métodos para manejar el proceso de ordenación manual y el proceso no riguroso:
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 cuando se desarrolla Android nativo, usar la API de Android es el camino a seguir.
Ver :
Se puede parcelar mucho más rápido que el serializable con Binder, porque el serializable usa la reflexión y causa muchos GC. Parcelable es un diseño para optimizar pasar un objeto.
Aquí hay un enlace a la referencia. http://www.developerphil.com/parcelable-vs-serializable/
puede usar los objetos serializables en los intentos, pero al momento de realizar la serialización de un objeto Parcelable puede dar una excepción seria como NotSerializableException. ¿No se recomienda usar serializable con Parcelable? Por lo tanto, es mejor extender Parcelable con el objeto que desea usar con el paquete y los intentos. Como Parcelable es específico de Android, no tiene efectos secundarios. :)
Parcelable vs http://www.developerphil.com/parcelable-vs-serializable/ me refiero a estos dos.
Serializable, la simplicidad
¿Qué es serializable?
Serializable es una interfaz estándar de Java. No es una parte del SDK de Android. Su simplicidad es su belleza. Simplemente implementando 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 ser serializable es que solo necesita implementar la interfaz Serializable en una clase y sus hijos. Es una interfaz de marcador, lo que significa que no hay un método para implementar, Java simplemente hará su mejor esfuerzo para serializarlo de manera eficiente.
El problema con este enfoque es que se utiliza la reflexión y es un proceso lento. Este mecanismo también tiende a crear una gran cantidad de objetos temporales y causa un poco de 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 diseñado específicamente de tal manera que no hay reflejo cuando se usa. 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<TestModel> CREATOR = new Parcelable.Creator<TestModel>() {
@Override
public TestModel createFromParcel(Parcel source) {
return new TestModel(source);
}
@Override
public TestModel[] newArray(int size) {
return new TestModel[size];
}
};
}
Ahora, el ganador es
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 afirmación también.
Según ellos, el enfoque predeterminado de Serializable 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 en realidad 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 en absoluto personalizado y genera mucha basura! Así, 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 Serializable Parcelable y personalizado parece justa! ¡Los resultados pueden ser sorprendentes! El enfoque personalizado de Serializable 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.
Serializable es una interfaz estándar de Java. 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 en la que implementa la serialización usted mismo. Fue creado para ser mucho más eficiente que Serializable y para solucionar algunos problemas con el esquema de serialización Java predeterminado.
Creo que Binder y AIDL funcionan con objetos Parcelable.
Sin embargo, puedes usar objetos serializables en Intentos.