Understanding Parcelable vs. Serializable in Android

In Android development, efficient data transfer between components such as activities and fragments is crucial for building high-performance applications. Two common mechanisms for this purpose are Serializable and Parcelable. Both serve the purpose of object serialization but have distinct differences in performance and use cases. In this blog, we will delve deep into these two mechanisms, compare their performance, and explore their use cases with practical examples.

What is Serialization?

Serialization is the process of converting an object into a format that can be easily stored or transmitted and later reconstructed. In Java and Android, serialization is commonly achieved using the Serializable interface or the Parcelable interface.

Serializable

Serializable is a standard Java interface used for object serialization. To use Serializable, a class must implement this interface.

How It Works:

• Reflection-Based: Serializable uses Java reflection to inspect and manipulate the fields of an object. Reflection involves examining the object at runtime to discover its structure, which is computationally expensive.
• Automated: The Java Serialization mechanism automatically handles the serialization and deserialization of objects, including their fields.

Code Example:

import java.io.Serializable;
public class Book implements Serializable {
    private static final long serialVersionUID = 1L;
    private String title;
    private String author;
    private int pages;
    

    public Book(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
    }
    // Getters and Setters
}

Usage in Android:

// In MainActivity
Book book = new Book("1984", "George Orwell", 328);
Intent intent = new Intent(this, DetailActivity.class);
intent.putExtra("book", book);
startActivity(intent);



// In DetailActivity
Book book = (Book) getIntent().getSerializableExtra("book");

Pros:

• Simplicity: Easy to implement as it requires minimal code.
• Automatic: Handles complex object graphs and nested objects.

Cons:

• Performance: Slower due to reflection-based serialization.
• Memory Overhead: May create additional garbage and involve more memory consumption.

Parcelable

Parcelable is an Android-specific interface designed to provide a more efficient way of serializing objects. It requires developers to manually specify how an object should be serialized and deserialized.

How It Works:

• Manual Implementation: Developers explicitly define how to read and write the object’s data to a Parcel. This approach is optimized for Android's IPC (Inter-Process Communication) needs.
• Optimized: Parcelable is optimized for Android and typically results in faster serialization and deserialization.

Code Example:

import android.os.Parcel
import android.os.Parcelable
data class Book(val title: String, val author: String, val pages: Int) : Parcelable {
    constructor(parcel: Parcel) : this(
        parcel.readString() ?: "",
        parcel.readString() ?: "",
        parcel.readInt()
    )


    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeString(title)
        parcel.writeString(author)
        parcel.writeInt(pages)
    }

    override fun describeContents(): Int = 0

    companion object CREATOR : Parcelable.Creator<Book> {
        override fun createFromParcel(parcel: Parcel): Book = Book(parcel)

        override fun newArray(size: Int): Array<Book?> = arrayOfNulls(size)
    }
}

Usage in Android:

// In MainActivity
val book = Book("1984", "George Orwell", 328)
val intent = Intent(this, DetailActivity::class.java)
intent.putExtra("book", book)
startActivity(intent)


// In DetailActivity
val book = intent.getParcelableExtra<Book>("book")

Pros:

• Performance: Faster and more memory-efficient compared to Serializable.
• Control: Gives developers more control over how the data is written to and read from the Parcel.

Cons:

• Complexity: Requires manual implementation and maintenance of serialization code.
• Limited to Android: Parcelable is specific to Android and not usable outside of Android environments.

Performance Comparison

To illustrate the performance difference between Parcelable and Serializable, consider the following benchmarks:

Serializable Performance Test:

import java.io.*;
public class SerializablePerformanceTest {
    public static void main(String[] args) {
        try {
            long startTime = System.currentTimeMillis();
            Book book = new Book("1984", "George Orwell", 328);
            // Serialize
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(book);
            oos.close();
            // Deserialize
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            Book deserializedBook = (Book) ois.readObject();
            ois.close();
            long endTime = System.currentTimeMillis();
            System.out.println("Serializable time: " + (endTime - startTime) + " ms");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Parcelable Performance Test:

import android.os.Parcel
fun testParcelablePerformance() {
    val startTime = System.currentTimeMillis()
    val book = Book("1984", "George Orwell", 328)
    // Serialize
    val parcel = Parcel.obtain()
    book.writeToParcel(parcel, 0)
    val bytes = parcel.marshall()
    parcel.recycle()
    // Deserialize
    val newParcel = Parcel.obtain()
    newParcel.unmarshall(bytes, 0, bytes.size)
    newParcel.setDataPosition(0)
    val deserializedBook = Book.CREATOR.createFromParcel(newParcel)
    newParcel.recycle()
    val endTime = System.currentTimeMillis()
    println("Parcelable time: " + (endTime - startTime) + " ms")
}

Observation: Parcelable generally performs faster and uses less memory compared to Serializable, which involves reflection and creates more temporary objects.

When to Use Which

• Use Parcelable when:
• Performance is a critical factor.
• You are working within the Android ecosystem.
• You need to pass data between activities or fragments efficiently.
• Use Serializable when:
• You are dealing with non-Android environments or cross-platform scenarios.
• Simplicity and ease of implementation are more important than performance.
• You do not need to optimize for performance and memory usage.

Conclusion

Understanding the differences between Parcelable and Serializable helps in making informed decisions based on the requirements of your Android application. While Serializable offers simplicity and ease of use, Parcelable provides better performance and efficiency tailored for Android. By leveraging the strengths of each mechanism, developers can build high-performance and resource-efficient applications.

Feel free to share your thoughts and experiences with Parcelable and Serializable in the comments below!

Happy Coding!