Android: Difference between Parcelable and Serializable?
Asked Answered
A

16

418

Why does Android provide 2 interfaces for serializing objects? Do Serializable objects interopt with Android Binder and AIDL files?

Alkahest answered 23/7, 2010 at 23:26 Comment(0)
C
582

In Android we cannot just pass objects to activities. To do this the objects must either implement Serializable or Parcelable interface.

Serializable

Serializable is a standard Java interface. You just mark your class with the Serializable interface. The problem with this approach is that reflection is used and it is a slow process. This method creates a lot of temporary objects and causes quite a bit of garbage collection. However, Serializable interface is easier to implement.

Look at the example below (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;
    }

    // return age
    public int 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

Parcelable process is much faster than Serializable. One of the reasons for this is that we are being explicit about the serialization process instead of using reflection to infer it. It also stands to reason that the code has been heavily optimized for this purpose.

Look at the example below (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");

You can pass ArrayList of Parcelable objects 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");

Conclusion

  1. Parcelable is faster than Serializable interface
  2. Parcelable interface takes more time to implement compared to Serializable interface
  3. Serializable interface is easier to implement
  4. Serializable interface creates a lot of temporary objects and causes quite a bit of garbage collection
  5. Parcelable array can be passed via Intent in android
Contractor answered 14/5, 2014 at 6:46 Comment(13)
@Contractor what do you mean by reflection is used? What is reflection?Massingill
@AbhinavVutukuri Reflection is the term for inspecting objects, fields and methods at run-time via Object.getClass() and such.Exaggerate
what about boolean variables? how to read boolean values from parcel? source.readBoolean() not found...Demilitarize
got it... #6201811Demilitarize
Does serialization copy the object, or send the reference? Let's say I have a Dog dog = new Dog(); in my MainActivity. Can I access this object in the new activity? Or is the object only copied, and I can only access a new object?Richmond
Serializables are better for persisting data , parcelable objects on the other hand should not be persisted at all . It's a really bad practiceSmitty
@Contractor As more than one person has stated, Parcelable objects can't be persisted (reliably) but Serializable ones can (within limits). Since your answer is the highest-scoring and gives the impression of covering all the important differences, you should probably mention that point.Generative
Now the implementation of Parcelable is as fast as Serializable, just press ALT + INSERT on any class implementing Parcelable in Android Studio and the IDE will do it.Delrosario
So for Parcel , if reflections is not used, then how the data is transmitted among VMs like Serialization does for JVMs ? And does parcel data read using ParcelObject.getterMethods() and if not found, will it throw an exception?Excite
@Excite Parcelable is simply an interface for converting an object into its primitive types and vice-versa.Arabella
Both of them convert an object to byte stream. So the user can pass the data between one activity to another activity.Misti
@AliNem For kotlin projects there is also the Parcelize annotation: developer.android.com/kotlin/parcelizeIlluminometer
You fail to reason about the speed properly. What about readObject() and writeObject() to manually speed up things for your specific use-case? What makes Parcelable faster? How much is the speedup?Boiled
G
223

Serializable is a standard Java interface. You simply mark a class Serializable by implementing the interface, and Java will automatically serialize it in certain situations.

Parcelable is an Android specific interface where you implement the serialization yourself. It was created to be far more efficient that Serializable, and to get around some problems with the default Java serialization scheme.

I believe that Binder and AIDL work with Parcelable objects.

However, you can use Serializable objects in Intents.

Gurl answered 24/7, 2010 at 2:21 Comment(5)
how do I serialize a Parcelable object? How do I make it persistent?Germany
@Haded Get the contents of the objects state and store it in a file or SQLLite database. Seriliasing is useful for making objects transferable between different components in android or different applications altogether.Peddling
This is a great explanation. I also noticed this: "Parcel is not a general-purpose serialization mechanism. This class (and the corresponding Parcelable API for placing arbitrary objects into a Parcel) is designed as a high-performance IPC transport. As such, it is not appropriate to place any Parcel data in to persistent storage: changes in the underlying implementation of any of the data in the Parcel can render older data unreadable." developer.android.com/reference/android/os/Parcel.htmlStander
@Zhisheng what is meant by arbitrary objects? what kind of objects we can put into the Parcel?Winebaum
How about converting objects to json string instead with gson?Glaydsglaze
C
59

In Parcelable, developers write custom code for marshalling and unmarshalling so it creates fewer garbage objects in comparison to Serialization. The performance of Parcelable over Serialization dramatically improves (around two times faster), because of this custom implementation.

Serializable is a marker interface, which implies that users cannot marshal the data according to their requirements. In Serialization, a marshalling operation is performed on a Java Virtual Machine (JVM) using the Java reflection API. This helps identify the Java object's member and behaviour, but also ends up creating a lot of garbage objects. Due to this, the Serialization process is slow in comparison to Parcelable.

What is the meaning of marshalling and unmarshalling?

In few words, "marshalling" refers to the process of converting the data or the objects into a byte-stream, and "unmarshalling" is the reverse process of converting the byte-stream back to their original data or object. The conversion is achieved through "serialization".

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

Compulsion answered 1/2, 2017 at 6:26 Comment(1)
Pretty good explanation even without a verbose example. Just what I needed for revision.Morello
E
43

Parcelable is sort of a standard in Android development. But not because of speed

Parcelable is recommended approach for data transfers. But if you use serializable correctly as shown in this repo, you will see that serializable is sometimes even faster then parcelable. Or at least timings are comparable.

Is Parcelable faster then Serializable?

No, if serialization is done right.

Usual Java serialization on an average Android device (if done right *) is about 3.6 times faster than Parcelable for writes and about 1.6 times faster for reads. Also it proves that Java Serialization (if done right) is fast storage mechanism that gives acceptable results even with relatively large object graphs of 11000 objects with 10 fields each.

* The sidenote is that usually everybody who blindly states that "Parcelable is mush faster" compares it to default automatic serialization, which uses much reflection inside. This is unfair comparison, because Parcelable uses manual (and very complicated) procedure of writing data to the stream. What is usually not mentioned is that standard Java Serializable according to the docs can also be done in a manual way, using writeObject() and readObject() methods. For more info see JavaDocs. This is how it should be done for the best performance.

So, if serializable is faster and easier to implement, why android has parcelable at all?

The reason is native code. Parcelable is created not just for interprocess communication. It also can be used for intercode communication. You can send and recieve objects from C++ native layer. That's it.

What should you choose? Both will work good. But I think that Parcelable is better choice since it is recommended by google and as you can see from this thread is much more appreciated.

Emma answered 12/12, 2018 at 7:6 Comment(5)
Can you site your sources? I would really appreciate it. Thanks!!Weakwilled
That answer I got from experienced developer who work on AOSP related project twitter.com/bwdude. He said that native C++ code for communication with SDK layer uses its own implementation of Parcelable. I guess he talk about this class android.googlesource.com/platform/frameworks/native/+/… I know that this is not the best explanation, but it is the best I have right now. If you will find something else, be sure to post it here =)Emma
Wish I could upvote you more than once. I have seen great Android and Java experts go for the most upvoted answer here. Lack of documentation has really prevented any limelight for Serializable. Feels like these are effects of promoting a specific API. THanks!Booker
Can you explain what is inter-code communicationDeepsix
I guess that's when you want to communicate between c++ and java. Not only between java and java.Emma
J
42

If you want to be a good citizen, take the extra time to implement Parcelable since it will perform 10 times faster and use less resources.

However, in most cases, the slowness of Serializable won’t be noticeable. Feel free to use it but remember that serialization is an expensive operation so keep it to a minimum.

If you are trying to pass a list with thousands of serialized objects, it is possible that the whole process will take more than a second. It can make transitions or rotation from portrait to lanscape feel very sluggish.

Source to this point: http://www.developerphil.com/parcelable-vs-serializable/

Jefferson answered 12/3, 2014 at 11:44 Comment(1)
However, in most cases, the slowness of Serializable won’t be noticeable.Deepsix
R
22

I'm actually going to be the one guy advocating for the Serializable. The speed difference is not so drastic any more since the devices are far better than several years ago and also there are other, more subtle differences. See my blog post on the issue for more info.

Renown answered 25/3, 2015 at 2:12 Comment(2)
Thank you for the share. Its less complex to implement serializeable and the trade off needs to be decided in those rare and hyper optimization cases.Musket
The alternative viewpoint, especially when backed with experiments and results, is very helpful. I have to work with a lot of existing Parcelable based source code, and may refactor some of it now that I've read your blog post.Ignoramus
J
12

1. Serializable

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

Interface of what?

  • is a standard Java interface

Speed

  • slower than Parcelable

2. Parcelable

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

Interface of what?

  • is android.os interface
    • which means Google developped Parcelable for better performance on android

Speed

  • faster ( because it is optimized for usage on android development)

> In Conclusion

Be aware that Serializable is a standard Java interface, and Parcelable is for Android Development

Judicious answered 18/8, 2015 at 8:37 Comment(1)
You should add the uses of them too.Commingle
A
8

There is some performance issue regarding to marshaling and unmarshaling. Parcelable is twice faster than Serializable.

Please go through the following link:

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

Adjective answered 31/12, 2015 at 8:1 Comment(1)
Yes you are right geeksforandroidgeeks.com/android/…Lucerne
A
4

Implementation of parcelable can be faster if you use paracelable plugin in android studio. search for Android Parcelable code generator

Aerostation answered 22/8, 2016 at 4:25 Comment(0)
S
4

The Serializable interface can be used the same way as the Parcelable one, resulting in (not much) better performances. Just overwrite those two methods to handle manual marshalling and unmarshalling process:

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

Still, it seems to me that when developing native Android, using the Android api is the way to go.

See :

Spica answered 24/4, 2017 at 8:3 Comment(0)
A
4

1. Serializable

The interface is a marker (an interface without abstract methods), nothing needs to be redefined.

2. Parcelable

An interface that has abstract methods. When implementing it, you need to redefine all abstract methods, specifying which fields and in what order you need to write/read (Usually the studio itself can generate them).

enter image description here

Practically no one writes in Kotlin. There is a special annotation for this, thanks to which the implementation of this interface will be generated automatically. To use it, you need to add a special plugin.

  • In build.gradle in the plugins section, add another plugin: id 'kotlin-parcelize'

enter image description here

  • Synchronize the project

You don't have to worry about implementing methods, all you need is to implement the Parcelable interface and add the @Parcelize annotation.

enter image description here

Everything will be fine and work quickly!

Results

The implementation process is faster if you implement the Parcelable interface instead of Serializable.

Aegean answered 22/7, 2022 at 15:50 Comment(0)
T
2

Parcelable much faster than serializable with Binder, because serializable use reflection and cause many GC. Parcelable is design to optimize to pass object.

Here's link to reference. http://www.developerphil.com/parcelable-vs-serializable/

Tourane answered 15/7, 2014 at 15:14 Comment(0)
B
2

I am late in answer, but posting with hope that it will help others.

In terms of Speed, Parcelable > Serializable. But, Custom Serializable is exception. It is almost in range of Parcelable or even more faster.

Reference : https://www.geeksforgeeks.org/customized-serialization-and-deserialization-in-java/

Example :

Custom Class to be serialized

class MySerialized implements Serializable { 

    String deviceAddress = "MyAndroid-04"; 

    transient String token = "AABCDS"; // sensitive information which I do not want to serialize

    private void writeObject(ObjectOutputStream oos) throws Exception {
        oos.defaultWriteObject();
        oos.writeObject("111111" + token); // Encrypted token to be serialized
    }

    private void readObject(ObjectInputStream ois) throws Exception {
        ois.defaultReadObject(); 
        token = ((String) ois.readObject()).subString(6);  // Decrypting token
    }

}
Bonnice answered 15/11, 2019 at 10:44 Comment(0)
C
1

you can use the serializable objects in the intents but at the time of making serialize a Parcelable object it can give a serious exception like NotSerializableException. Is it not recommended using serializable with Parcelable . So it is better to extends Parcelable with the object that you want to use with bundle and intents. As this Parcelable is android specific so it doesn't have any side effects. :)

Christhood answered 16/4, 2012 at 7:32 Comment(0)
P
1

Parcelable converts an object to byte stream to pass the object between processes in Android.

Serialization converts POJO to a String (JSON String) and be used across platforms to transfer object info.

Purpose answered 14/8, 2022 at 20:2 Comment(0)
D
0

Serializable

Serializable is a markable interface or we can call as an empty interface. It doesn’t have any pre-implemented methods. Serializable is going to convert an object to byte stream. So the user can pass the data between one activity to another activity. The main advantage of serializable is the creation and passing data is very easy but it is a slow process compare to parcelable.

Parcelable

Parcel able is faster than serializable. Parcel able is going to convert object to byte stream and pass the data between two activities. Writing parcel able code is little bit complex compare to serialization. It doesn’t create more temp objects while passing the data between two activities.

Delapaz answered 9/9, 2019 at 4:15 Comment(1)
Parcelable is faster than serializable .Not always!Deepsix

© 2022 - 2024 — McMap. All rights reserved.