Android: Différence entre Parcelable et Serializable?

Pourquoi Android fournit-il 2 interfaces pour la sérialisation des objects? Les objects Serializable interceptent-ils avec les fichiers Android Binder et AIDL?

    Dans Android, nous soaps que nous ne pouvons pas simplement passer des objects à des activités. Pour ce faire, les objects doivent implémenter l’interface Serializable ou Parcelable.

    Sérialisable

    Serializable est une interface Java standard. Vous pouvez simplement implémenter une interface Serializable et append des méthodes de substitution. Le problème avec cette approche est que la reflection est utilisée et que le processus est lent. Cette méthode crée beaucoup d’objects temporaires et provoque pas mal de récupération de place. L’interface sérialisable est plus facile à implémenter.

    Regardez l’exemple ci-dessous (sérialisable)

     //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 Ssortingng name; private int age; public ArrayList address; public MyObjects(Ssortingng 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 Ssortingng getName() { return name; } public Ssortingng 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

    Le processus parcellable est beaucoup plus rapide que le sérialisable. Une des raisons à cela est que nous sums explicites sur le processus de sérialisation au lieu d’utiliser la reflection pour l’inférer. Il va de soi 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 Ssortingng name; private ArrayList address; public MyObjects(Ssortingng name, int age, ArrayList address) { this.name = name; this.age = age; this.address = address; } public MyObjects(Parcel source) { age = source.readInt(); name = source.readSsortingng(); address = source.createSsortingngArrayList(); } @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeInt(age); dest.writeSsortingng(name); dest.writeSsortingngList(address); } public int getAge() { return age; } public Ssortingng 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"); 

    Conclusion.

    1. Parcelable est plus rapide que l’interface sérialisable
    2. L’interface parcellaire prend plus de temps à implémenter que l’interface sérialisable
    3. L’interface sérialisable est plus facile à implémenter
    4. L’interface sérialisable crée un grand nombre d’objects temporaires et provoque pas mal de récupération de place
    5. Un tableau parcellable peut être transmis via Intent dans Android

    Serializable est une interface Java standard. Vous marquez simplement une classe Serializable en implémentant l’interface, et Java va automatiquement la sérialiser 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 contourner certains problèmes avec le schéma de sérialisation Java par défaut.

    Je crois que Binder et AIDL fonctionnent avec des objects Parcelable.

    Toutefois, vous pouvez utiliser des objects Serializable dans les Intentions.

    Si vous voulez être un bon citoyen, prenez le temps nécessaire pour implémenter Parcelable, car il fonctionnera 10 fois plus rapidement et utilisera 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, gardez-la au minimum.

    Si vous essayez de transmettre une liste contenant des milliers d’objects sérialisés, il est possible que l’ensemble du processus prenne plus d’une seconde. Il peut faire des transitions ou des rotations de portrait en paysage très lentes.

    Source à ce point: http://www.developerphil.com/parcelable-vs-serializable/

    Dans Parcelable, les développeurs écrivent du code personnalisé pour marshaling et unmarshaling afin de créer moins d’objects indésirables que la sérialisation. Les performances de Parcelable over Serialization s’améliorent considérablement (environ deux fois plus rapidement) grâce à cette implémentation personnalisée.

    La sérialisation est une interface de marqueur, ce qui implique que l’utilisateur ne peut pas regrouper les données en fonction de leurs besoins. Dans la sérialisation, une opération de marshaling est effectuée sur une machine virtuelle Java (JVM) à l’aide de l’API de reflection Java. Cela aide à identifier le membre et le comportement de l’object Java, mais finit également par créer de nombreux objects indésirables. De ce fait, le processus de sérialisation est lent par rapport à Parcelable.

    Edit: Quelle est la signification de la formation et du démasquage?

    En quelques mots, “marshalling” fait référence au processus de conversion des données ou des objects dans un stream d’octets, et “unmarshalling” est le processus inverse de conversion du stream d’octets en données ou en object d’origine. La conversion est réalisée par “sérialisation”.

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

    Je vais être le seul qui prône le Serializable. La différence de vitesse n’est plus aussi radicale 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 sur le problème pour plus d’informations.

    1. sérialisable

    @voir 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 Parcelable

    2. Parcelable

    @voir 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 une meilleure performance sur Android

    La vitesse

    • plus rapide (parce qu’il est optimisé pour une utilisation sur le développement Android)

    > En conclusion

    Serializable est une interface Java standard, et Parcelable est destiné au développement Android

    Parcelable vs Serializable Je renvoie ces deux.

    Serializable, la simplicité

    Qu’est-ce que Serializable?

    Serializable est une interface Java standard. Ce n’est pas une partie du SDK Android. Sa simplicité est sa beauté. Juste en implémentant cette interface, votre POJO sera prêt à passer d’une activité à une autre.

     public class TestModel implements Serializable { Ssortingng name; public TestModel(Ssortingng name) { this.name = name; } public Ssortingng getName() { return name; } public void setName(Ssortingng name) { this.name = name; } } 
    • La beauté de serializable est que vous devez seulement 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 à mettre en œuvre, Java fera tout son possible pour la sérialiser efficacement.

    • Le problème avec cette approche est que la reflection est utilisée et que le processus est lent. Ce mécanisme a également tendance à créer beaucoup d’objects temporaires et à provoquer un certain gaspillage.

    Parcelable, la vitesse

    Qu’est-ce qui est parcellable?

    Parcelable est une autre interface. Malgré son rival (Serializable au cas où vous avez oublié), il fait partie du SDK Android. Maintenant, Parcelable a été spécifiquement conçu de telle manière qu’il n’y a pas de reflection lors de son utilisation. C’est parce que nous sums très explicites pour le processus de sérialisation.

     public class TestModel implements Parcelable { Ssortingng name; public TestModel(Ssortingng name, Ssortingng id) { this.name = name; } protected TestModel(Parcel in) { this.name = in.readSsortingng(); } public Ssortingng getName() { return name; } public void setName(Ssortingng name) { this.name = name; } @Override public int describeContents() { return 0; } @Override public void writeToParcel(Parcel dest, int flags) { dest.writeSsortingng(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]; } }; } 

    Maintenant, le gagnant est

    entrer la description de l'image ici

    Les résultats des tests effectué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 déclaration.

    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 les comparer du tout! Car avec Parcelable, nous écrivons en fait du code personnalisé. Code spécifiquement 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 personnalisé du tout et crée beaucoup de déchets! Ainsi, les pires résultats.

    Stop Stop !!!!, Avant de prendre une décision

    Maintenant, il y a une autre approche . L’ensemble du processus automatique derrière Serializable peut être remplacé par du code personnalisé qui utilise les méthodes writeObject () et 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 personnalisé semble juste! Les résultats peuvent être surprenants! L’approche Serializable personnalisée est plus de 3 fois plus rapide pour les écritures et 1,6 fois plus rapide pour les lectures que Parcelable.

    Il y a un problème de performance lié au marshaling et au unmarshaling. Parcelable est deux fois plus rapide que Serializable.

    S’il vous plaît passer par le lien suivant:

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

    L’implémentation de Parcelable peut être plus rapide si vous utilisez un plugin paracelable dans Android Studio. rechercher le générateur de code Android Parcelable

    L’interface sérialisable peut être utilisée de la même manière que l’appareil Parcelable, ce qui se traduit par de meilleures performances. Il suffit de remplacer ces deux méthodes pour gérer le processus de mise en forme et de désarrangement manuel:

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

    Pourtant, il me semble que lors du développement d’Android natif, utiliser l’api Android est la voie à suivre.

    Voir:

    vous pouvez utiliser les objects sérialisables dans les intentions mais au moment de sérialiser un object Parcelable, il peut donner une exception sérieuse telle que NotSerializableException. N’est-il pas recommandé d’utiliser serializable avec Parcelable? Il vaut donc mieux étendre Parcelable avec l’object que vous souhaitez utiliser avec bundle et intents. Comme ce Parcelable est spécifique à Android, il n’a aucun effet secondaire. 🙂

    Parcelable beaucoup plus vite que sérialisable avec Binder, car sérialisable utilise la reflection et provoque beaucoup de GC. Parcelable est la conception pour optimiser pour passer un object.

    Voici un lien vers la référence. http://www.developerphil.com/parcelable-vs-serializable/