Parcelable的writeXXX与writeBundle对比：接口实现困惑问询

Great question! I totally get why this sequential approach feels odd at first—especially when you see that Parcel can handle Bundles, which use a nice, intuitive key-value system. Let’s break down the reasoning behind this design choice:

1. Parcelable is built for raw performance #

The core goal of Parcelable is to enable fast, low-overhead inter-process communication (IPC). When you write fields sequentially to a Parcel, you skip the overhead of storing and looking up string keys. Every key you add to a Bundle takes up extra memory, and every lookup adds a tiny bit of processing time. For simple objects this might not matter, but when you’re passing large lists of objects (like in a RecyclerView adapter) or doing frequent IPC calls, those small overheads add up quickly.

Bundle, on the other hand, is designed for flexibility and readability. It’s perfect for passing arbitrary sets of data between components (like Activity extras) where you might not know all the fields upfront, or where you want to easily inspect the data. But that flexibility comes at a cost—one that Parcelable is explicitly designed to avoid.

2. Strict ordering enforces consistency #

The sequential rule (write in the same order you read) isn’t just an arbitrary hoop to jump through—it ensures that your data is deserialized correctly. When you read from a Parcel, it doesn’t have any metadata about what’s stored where; it just pulls values in the order they were written. This forces you to keep your writeToParcel and CREATOR logic in sync, which prevents subtle bugs that could come from typos in key names (a common issue with Bundles, honestly).

3. You can use key-value with Parcelable—but it defeats the purpose #

If you really prefer the key-value pattern, you could wrap your fields in a Bundle and write that to the Parcel, like this:

class MyData(
    val name: String,
    val isActive: Boolean,
    val items: List<String>
) : Parcelable {
    constructor(parcel: Parcel) : this(
        parcel.readBundle(javaClass.classLoader)!!.run {
            getString("name")!!,
            getBoolean("isActive"),
            getStringArrayList("items")!!
        }
    )

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        val bundle = Bundle().apply {
            putString("name", name)
            putBoolean("isActive", isActive)
            putStringArrayList("items", ArrayList(items))
        }
        parcel.writeBundle(bundle)
    }

    override fun describeContents(): Int = 0

    companion object CREATOR : Parcelable.Creator<MyData> {
        override fun createFromParcel(parcel: Parcel): MyData = MyData(parcel)
        override fun newArray(size: Int): Array<MyData?> = arrayOfNulls(size)
    }
}

But this essentially turns your Parcelable into a wrapper for a Bundle, throwing away all the performance benefits that make Parcelable worth using. You’re better off just passing the Bundle directly if you don’t need the speed.

Wrapping up #

At the end of the day, it’s a tradeoff: speed vs. flexibility. Parcelable’s sequential design is optimized for when you need to move data between processes as efficiently as possible. Bundle’s key-value system is for when you want ease of use and dynamic data structures. Both have their place—you just need to pick the right tool for the job.

内容的提问来源于stack exchange，提问作者Dan Chaltiel