Android中Parcelable对象存加载及Serializable适配实现咨询

Hey there! Let's tackle your questions about handling object serialization in Android—this is a common pain point, so I'll break it down clearly for you.

1. Using Parcelable for In-Memory Object Transfer (Save/Load) #

First, a quick clarification: Parcelable is Android's optimized interface for in-memory object passing (like sending data between Activities, Fragments, or via AIDL), not for persistent storage to external files. Here's how to implement it properly:

Step 1: Implement the Parcelable Interface #

Create your model class and implement Parcelable, then override the required methods and add a static CREATOR object. Example in Kotlin:

data class User(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable {
    // Constructor for reading from a Parcel
    constructor(parcel: Parcel) : this(
        parcel.readInt(),
        parcel.readString() ?: "",
        parcel.readString() ?: ""
    )

    override fun writeToParcel(parcel: Parcel, flags: Int) {
        parcel.writeInt(id)
        parcel.writeString(name)
        parcel.writeString(email)
    }

    override fun describeContents(): Int {
        return 0 // Return 0 unless you're handling special objects like FileDescriptor
    }

    companion object CREATOR : Parcelable.Creator<User> {
        override fun createFromParcel(parcel: Parcel): User {
            return User(parcel)
        }

        override fun newArray(size: Int): Array<User?> {
            return arrayOfNulls(size)
        }
    }
}

Step 2: Pass (Save) and Retrieve (Load) the Object #

To move the object between components:

// Save (pass) the object via Intent
val user = User(1, "Alice", "alice@example.com")
val intent = Intent(this, NextActivity::class.java)
intent.putExtra("USER_KEY", user)
startActivity(intent)

// Load (retrieve) the object in the target Activity
val user = intent.getParcelableExtra<User>("USER_KEY")

2. Is Adding Serializable a Valid Approach for External Storage? #

Absolutely! Serializable is Java's built-in serialization mechanism, and it's exactly what you need for persisting objects to external storage. Parcelable isn't designed for disk persistence—its format isn't guaranteed to stay consistent across app versions or devices, so Serializable is the right call here.

A few key notes:

• Your class and all nested objects must implement Serializable (otherwise you'll hit a NotSerializableException).
• Serializable is less performant than Parcelable, but this doesn't matter for disk operations (the bottleneck is I/O, not serialization speed).
• You can even implement both Parcelable and Serializable in the same class—use Parcelable for in-memory transfers, and Serializable for persistence.

Example of a Serializable class:

data class User(
    val id: Int,
    val name: String,
    val email: String
) : Serializable {
    // No extra methods needed—Java handles serialization automatically
}

3. Implementing Save/Load Logic for External Storage #

To persist your Serializable object to external storage, use ObjectOutputStream for saving and ObjectInputStream for loading. Here's a practical implementation:

Save the Object to External Storage #

fun saveUserToExternalStorage(user: User) {
    // Use your app's private external storage (no permissions needed on Android 10+)
    val file = File(getExternalFilesDir(null), "user_data.ser")

    try {
        ObjectOutputStream(FileOutputStream(file)).use { outputStream ->
            outputStream.writeObject(user)
        }
    } catch (e: IOException) {
        e.printStackTrace()
        // Handle error gracefully (e.g., show a toast to the user)
    }
}

Load the Object from External Storage #

fun loadUserFromExternalStorage(): User? {
    val file = File(getExternalFilesDir(null), "user_data.ser")
    if (!file.exists()) return null

    return try {
        ObjectInputStream(FileInputStream(file)).use { inputStream ->
            inputStream.readObject() as User
        }
    } catch (e: IOException) {
        e.printStackTrace()
        null
    } catch (e: ClassNotFoundException) {
        e.printStackTrace()
        null
    }
}

Critical Tips #

• For Android 10 (API 29) and above, getExternalFilesDir() is the recommended path—it's part of your app's private external storage, so no WRITE_EXTERNAL_STORAGE permission is required.
• If targeting older Android versions, you'll need to request the WRITE_EXTERNAL_STORAGE permission (both in the manifest and dynamically at runtime).
• Always handle exceptions gracefully—don't let a failed save/load crash your app.

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