I have a custom class filled with information of a User. I use an ArrayList to hold all the User class data. I would like to pass the array to another activity where the it can be read and modified. Since the array could be large, I need this process to be done as efficiently and fast as possible, which is why I choose to use Parcelable instead of Serializable.

I am having trouble doing this using Kotlin. There are lots of Java tutorials but none are in Kotlin, which is what makes this question different then all the others. Can someone please provide and explain the code in Kotlin on how this can be achieved?

This is what I have so far:

constructor(`in`:Parcel) {
    CollegeName = `in`.readString()
override fun describeContents(): Int {
    return 0
override fun writeToParcel(dest: Parcel?, flags: Int) {
private fun readFromParcel(`in`:Parcel) {
    CollegeName = `in`.readString()
companion object {
    @JvmField final val CREATOR: Parcelable.Creator<College> = object: Parcelable.Creator<College> {
        override fun createFromParcel(source: Parcel): College {
            return College(source)
        override fun newArray(size: Int): Array<College?> {
            return arrayOfNulls<College>(size)
   class Series() : Parcelable {
  private var name: String? = null
  private var numOfSeason: Int = 0
  private var numOfEpisode: Int = 0
  constructor(parcel: Parcel) : this() {
    val data = arrayOfNulls<String>(3)
    parcel.readStringArray(data)
    this.name = data[0]
    this.numOfSeason = Integer.parseInt(data[1])
    this.numOfEpisode = Integer.parseInt(data[2])
  override fun writeToParcel(parcel: Parcel, flags: Int) {
    parcel.writeString(name);
    parcel.writeInt(numOfSeason);
    parcel.writeInt(numOfEpisode);
  private fun readFromParcel(parcel: Parcel){
    name = parcel.readString()
    numOfSeason = parcel.readInt()
    numOfEpisode = parcel.readInt()
  override fun describeContents(): Int {
    return 0
  companion object CREATOR : Creator<Series> {
    override fun createFromParcel(parcel: Parcel): Series {
      return Series(parcel)
    override fun newArray(size: Int): Array<Series?> {
      return arrayOfNulls(size)
and then in your Activity
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.main_activity)
        val i = Intent(this, SecondActivity::class.java)
val testing = ArrayList<testparcel>()
i.putParcelableArrayListExtra("extraextra", testing)
startActivity(i)
class SecondActivity :Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
        setContentView(R.layout.secondActivty_activity)
val testing = this.intent.getParcelableArrayListExtra<Parcelable>("extraextra")
Related Solutions
Android – How to save an activity state using the save instance state

You need to override onSaveInstanceState(Bundle savedInstanceState) and write the application state values you want to change to the Bundle parameter like this:
@Override
public void onSaveInstanceState(Bundle savedInstanceState) {
  super.onSaveInstanceState(savedInstanceState);
  // Save UI state changes to the savedInstanceState.
  // This bundle will be passed to onCreate if the process is
  // killed and restarted.
  savedInstanceState.putBoolean("MyBoolean", true);
  savedInstanceState.putDouble("myDouble", 1.9);
  savedInstanceState.putInt("MyInt", 1);
  savedInstanceState.putString("MyString", "Welcome back to Android");
  // etc.
The Bundle is essentially a way of storing a NVP ("Name-Value Pair") map, and it will get passed in to onCreate() and also onRestoreInstanceState() where you would then extract the values from activity like this:
@Override
public void onRestoreInstanceState(Bundle savedInstanceState) {
  super.onRestoreInstanceState(savedInstanceState);
  // Restore UI state from the savedInstanceState.
  // This bundle has also been passed to onCreate.
  boolean myBoolean = savedInstanceState.getBoolean("MyBoolean");
  double myDouble = savedInstanceState.getDouble("myDouble");
  int myInt = savedInstanceState.getInt("MyInt");
  String myString = savedInstanceState.getString("MyString");
Or from a fragment.
@Override
public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
    super.onViewStateRestored(savedInstanceState);
    // Restore UI state from the savedInstanceState.
    // This bundle has also been passed to onCreate.
    boolean myBoolean = savedInstanceState.getBoolean("MyBoolean");
    double myDouble = savedInstanceState.getDouble("myDouble");
    int myInt = savedInstanceState.getInt("MyInt");
    String myString = savedInstanceState.getString("MyString");
You would usually use this technique to store instance values for your application (selections, unsaved text, etc.).
    
Android – How to send an object from one Android Activity to another using Intents

If you're just passing objects around then Parcelable was designed for this. It requires a little more effort to use than using Java's native serialization, but it's way faster (and I mean way, WAY faster).
From the docs, a simple example for how to implement is:
// simple class that just has one member property as an example
public class MyParcelable implements Parcelable {
    private int mData;
    /* everything below here is for implementing Parcelable */
    // 99.9% of the time you can just ignore this
    @Override
    public int describeContents() {
        return 0;
    // write your object's data to the passed-in Parcel
    @Override
    public void writeToParcel(Parcel out, int flags) {
        out.writeInt(mData);
    // this is used to regenerate your object. All Parcelables must have a CREATOR that implements these two methods
    public static final Parcelable.Creator<MyParcelable> CREATOR = new Parcelable.Creator<MyParcelable>() {
        public MyParcelable createFromParcel(Parcel in) {
            return new MyParcelable(in);
        public MyParcelable[] newArray(int size) {
            return new MyParcelable[size];
    // example constructor that takes a Parcel and gives you an object populated with it's values
    private MyParcelable(Parcel in) {
        mData = in.readInt();
Observe that in the case you have more than one field to retrieve from a given Parcel, you must do this in the same order you put them in (that is, in a FIFO approach).
Once you have your objects implement Parcelable it's just a matter of putting them into your Intents with putExtra():
Intent i = new Intent();
i.putExtra("name_of_extra", myParcelableObject);
Then you can pull them back out with getParcelableExtra():
Intent i = getIntent();
MyParcelable myParcelableObject = (MyParcelable) i.getParcelableExtra("name_of_extra");
If your Object Class implements Parcelable and Serializable then make sure you do cast to one of the following:
i.putExtra("parcelable_extra", (Parcelable) myParcelableObject);
i.putExtra("serializable_extra", (Serializable) myParcelableObject);