Android: Différence entre colis et sérialisable?
Pourquoi Android fournit-il 2 interfaces pour la sérialisation d'objets? Les objets sérialisables interagissent-ils avec les fichiers Android Binder et AIDL?
Dans Android, nous ne pouvons pas simplement transmettre des objets à des activités. Pour ce faire, les objets doivent implémenter l'interface Serializable ou Parcelable.
Sérialisable
Serializable est une interface standard Java. Vous pouvez simplement implémenter l'interface Serializable et ajouter des méthodes de remplacement. Le problème avec cette approche est que la réflexion est utilisée et que le processus est lent. Cette méthode crée un grand nombre d'objets temporaires et provoque un peu de garbage collection. Cependant, l'interface Serializable est plus facile à implémenter.
Regardez l'exemple ci-dessous (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");
colis
Le processus Parcelable est beaucoup plus rapide que Serializable. Une des raisons est que nous parlons explicitement du processus de sérialisation au lieu d’utiliser la réflexion pour l’inférer. Il va sans dire que le code a été fortement optimisé à cette fin.
Regardez l'exemple ci-dessous (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 instance
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");
Vous pouvez passer ArrayList des objets pouvant être parcellés comme ci-dessous:
// 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");
Conclusion
Parcelableest plus rapide queSerializableinterface- La mise en oeuvre de l'interface
Parcelableprend plus de temps que celle de l'interfaceSerializable Serializablel'interface est plus facile à implémenterSerializableinterface crée beaucoup d'objets temporaires et cause un peu de garbage collection- Le tableau
Parcelablepeut être transmis via Intent dans Android
Serializable est une interface standard Java. Vous marquez simplement une classe Serializable en implémentant l'interface. Java la sérialisera automatiquement dans certaines situations.
Parcelable est une interface spécifique à Android où vous implémentez vous-même la sérialisation. Il a été créé pour être beaucoup plus efficace que Serializable et pour résoudre certains problèmes liés au schéma de sérialisation Java par défaut.
Je crois que Binder et AIDL fonctionnent avec des objets parcellables.
Toutefois, vous pouvez utiliser des objets Serializable dans Intents.
Si vous voulez être un bon citoyen, prenez le temps supplémentaire nécessaire pour implémenter Parcelable, qui fonctionnera 10 fois plus vite et nécessitera moins de ressources.
Cependant, dans la plupart des cas, la lenteur de Serializable ne sera pas perceptible. N'hésitez pas à l'utiliser, mais rappelez-vous que la sérialisation est une opération coûteuse, alors gardez-la au minimum.
Si vous essayez de transmettre une liste avec des milliers d'objets sérialisés, il est possible que l'ensemble du processus prenne plus d'une seconde. Cela peut rendre les transitions ou les rotations de portrait en paysage très lentes.
Source à ce point: http://www.developerphil.com/parcelable-vs-serializable/
colis vs sérialisable Je renvoie ces deux.
Sérialisable, la simplicité
Qu'est-ce que Serializable?
Serializable est une interface standard Java. Il ne fait pas partie du Android SDK. Sa simplicité est sa beauté. En mettant en place cette interface, votre POJO sera prêt à passer d’une activité à une autre.
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 beauté de sérialisable est qu'il suffit d'implémenter l'interface Serializable sur une classe et ses enfants. C'est une interface de marqueur, ce qui signifie qu'il n'y a pas de méthode à implémenter, Java fera tout son possible pour le sérialiser efficacement.
Le problème avec cette approche est que la réflexion est utilisée et que le processus est lent. Ce mécanisme a également tendance à créer beaucoup d'objets temporaires et à causer un peu de ramassage des ordures.
Parcelable, The Speed
Qu'est-ce que Parcelable?
Parcelable est une autre interface. Malgré son rival (Serializable au cas où vous auriez oublié), il fait partie du Android SDK. Désormais, Parcelable a été spécifiquement conçu de manière à éviter toute réflexion lors de son utilisation. C'est parce que nous sommes vraiment explicites pour le processus de sérialisation.
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];
}
};
}
Maintenant, le gagnant est
Les résultats des tests menés par Philippe Breault montrent que Parcelable est plus de 10 fois plus rapide que Serializable. Certains autres ingénieurs de Google soutiennent également cette affirmation.
Selon eux, l'approche Serializable par défaut est plus lente que Parcelable. Et ici nous avons un accord entre les deux parties! MAIS, il est injuste de comparer ces deux! En effet, avec Parcelable, nous écrivons du code personnalisé. Code spécialement créé pour ce seul POJO. Ainsi, aucun déchet n'est créé et les résultats sont meilleurs. Mais avec l'approche Serializable par défaut, nous nous appuyons sur le processus de sérialisation automatique de Java. Le processus n'est apparemment pas du tout une coutume et crée beaucoup de déchets! Ainsi, le pire résultat.
Stop Stop !!!!, Avant de prendre une décision
Maintenant, il existe une autre approche . L'ensemble du processus automatique derrière Serializable peut être remplacé par du code personnalisé qui utilise les méthodes writeObject () & readObject (). Ces méthodes sont spécifiques. Si nous voulons utiliser l'approche Serializable en combinaison avec un comportement de sérialisation personnalisé, nous devons inclure ces deux méthodes avec la même signature exacte que celle ci-dessous:
private void writeObject(Java.io.ObjectOutputStream out)
throws IOException;
private void readObject(Java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException;
private void readObjectNoData()
throws ObjectStreamException;
Et maintenant, une comparaison entre Parcelable et Serializable semble juste! Les résultats peuvent être surprenants! L'approche Serializable personnalisée est plus de 3 fois plus rapide en écriture et 1,6 fois plus rapide en lecture que Parcelable.
Dans Parcelable, les développeurs écrivent du code personnalisé pour le marshaling et le dissémination, de sorte qu'il crée moins d'objets parasites par rapport à la sérialisation. Grâce à cette implémentation personnalisée, les performances de Parcelable over Serialization sont considérablement améliorées (environ deux fois plus rapidement).
La sérialisation est une interface de marqueur, ce qui implique que l'utilisateur ne peut pas rassembler les données en fonction de ses besoins. Dans la sérialisation, une opération de marshaling est effectuée sur une machine virtuelle (JVM) Java à l'aide de l'API de réflexion Java. Cela aide à identifier le membre et le comportement de l'objet Java, mais finit également par créer de nombreux objets parasites. Pour cette raison, le processus de sérialisation est lent par rapport à Parcelable.
Edit: Quel est le sens du marshalling et de l'unmarshalling?
En peu de mots, "marshalling" fait référence au processus de conversion des données ou des objets dans un flux d'octets, et "unmarshalling" est le processus inverse de la conversion de la marque de flux d'octets en données ou objet d'origine. La conversion est réalisée par "sérialisation".
Je vais en fait être le seul à préconiser le Serializable. La différence de vitesse n’est plus aussi drastique puisque les appareils sont bien meilleurs qu’il ya plusieurs années et qu’il existe d’autres différences plus subtiles. Voir mon blog poste sur la question pour plus d'informations.
1. Sérialisable
@see http://docs.Oracle.com/javase/7/docs/api/Java/io/Serializable.html
Interface de quoi?
- est une interface Java standard
La vitesse
- plus lent que colisable
2. colis
@see http://developer.Android.com/reference/Android/os/Parcelable.html
Interface de quoi?
- est l'interface Android.os
- ce qui signifie que Google a développé Parcelable pour de meilleures performances sous Android
La vitesse
- plus rapide (car il est optimisé pour une utilisation sur Android développement)
> En conclusion
Sachez que Serializable est une interface Java standard et que Parcelable est destiné à Android Développement.
Il y a un problème de performance en ce qui concerne le marshaling et le démarshaling. Parcelable est deux fois plus rapide que Serializable.
Veuillez passer par le lien suivant:
http://www.3pillarglobal.com/insights/parcelable-vs-Java-serialization-in-Android-app-development
Parcelable est en quelque sorte un standard du développement Android. Mais pas à cause de la vitesse
Parcelable est l'approche recommandée pour les transferts de données. Mais si vous utilisez correctement sérialisable comme indiqué dans ce dépôt , vous verrez que la possibilité de sérialiser est parfois encore plus rapide que parcelable. Ou au moins les horaires sont comparables.
Est-ce que Parcelable est plus rapide que Serializable?
La sérialisation habituelle Java sur un périphérique moyen Android (si correctement *) est environ 3,6 fois plus rapide que Parcelable pour les écritures et environ 1,6 fois plus rapide pour les lectures. Cela prouve également que la sérialisation Java (si elle est bien effectuée) est un mécanisme de stockage rapide qui donne des résultats acceptables même avec des graphiques d'objet relativement volumineux de 11 000 objets de 10 champs chacun.
* Le principe est que, habituellement, tous ceux qui déclarent aveuglément que "Parcelable va rapidement" sont comparés à la sérialisation automatique par défaut, qui utilise beaucoup de réflexion à l'intérieur. Cette comparaison est injuste, car Parcelable utilise une procédure manuelle (et très compliquée) d’écriture de données dans le flux. Ce qui n'est généralement pas mentionné est que la norme Java sérialisable selon la documentation peut également être effectuée manuellement, à l'aide des méthodes writeObject () et readObject (). Pour plus d'informations, voir JavaDocs. Voici comment procéder pour obtenir les meilleures performances.
Donc, si la sérialisation est plus rapide et plus facile à mettre en œuvre, pourquoi Android a-t-il du tout des parcelles?
La raison est le code natif. Parcelable est créé non seulement pour la communication interprocessus. Il peut également être utilisé pour une communication intercode . Vous pouvez envoyer et recevoir des objets de la couche native C++. C'est ça.
Que devriez-vous choisir? Les deux fonctionneront bien. Mais je pense que Parcelable est un meilleur choix car il est recommandé par Google et comme vous pouvez le voir sur ce fil, il est beaucoup plus apprécié.
L'implémentation de parcelable peut être plus rapide si vous utilisez un plugin paracelable dans Android studio. rechercher Android Générateur de code parcellaire
Colisable beaucoup plus rapidement que sérialisable avec Binder, parce que sérialisable utilise la réflexion et provoque de nombreuses GC. Parcelable est conçu pour optimiser afin de transmettre un objet.
Voici le lien vers la référence. http://www.developerphil.com/parcelable-vs-serializable/
L’interface Serializable peut être utilisée de la même manière que celle de Parcelable, ce qui permet d’obtenir de meilleures performances. Écrasez simplement ces deux méthodes pour gérer les processus de triage et de démarchage manuel:
private void writeObject(Java.io.ObjectOutputStream out)
throws IOException
private void readObject(Java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException
Néanmoins, il me semble que lors du développement d’Android natif, utiliser l’application Android est le bon choix.
Voir:
vous pouvez utiliser les objets sérialisables dans les intentions, mais lors de la sérialisation d'un objet pouvant être parcellisé, il peut donner une exception sérieuse comme NotSerializableException. N'est-il pas recommandé d'utiliser sérialisable avec Parcelable. Il est donc préférable d’étendre Parcelable avec l’objet que vous souhaitez utiliser avec bundle et intent. Comme ce composant est spécifique à Android, il n'a donc aucun effet secondaire. :)