Data classes

Two annoyances, one word

At the end of Lesson 1.14 we left two things broken. Here they are together:

1class Note(val id: Int, val text: String)
2
3fun main() {
4  val a = Note(1, "Milk")
5  val b = Note(1, "Milk")
6  println(a)
7  println(a == b)
8}

1Note@4517d9a3
2false

The first line tells you nothing. The second is worse: two notes with the same id and the same text are reported as not equal.

Now change one word — put data in front of class — and run it again:

1Note(id=1, text=Milk)
2true

Nothing else changed. That is what this lesson is about.

What the word buys you

data class Note(val id: Int, val text: String)

That single line generates five things you would otherwise write by hand.

All of it comes from the properties in the constructor brackets. That is the deal: a data class is a thing defined by its contents, so Kotlin uses those contents for everything.

Writing that lot yourself is about forty lines of pure boilerplate — code that carries no meaning but must exist. Deleting boilerplate is one of Kotlin's main jobs.

Comparison by contents

1val a = Note(1, "Milk")
2val b = Note(1, "Milk")
3println(a == b)   // true
4println(a === b)  // false

== asks is this the same information? That is structural equality, and it is what you almost always mean.

===, with three signs, asks is this literally the same object in memory? Two separately built notes are two objects, so it says false. You will need it roughly never, but it is worth knowing the difference exists so the two-sign version is not mysterious.

Because equality works properly, so does everything built on it:

println(setOf(a, b).size)

That prints 1. The set looked at both notes, saw identical contents, and kept one. With a plain class it would have printed 2.

copy — change one thing, keep the rest

You cannot edit a val. So how do you change a note's text?

You do not. You make a new note that is the same except for the text:

1val c = a.copy(text = "Milk and eggs")
2println(a)
3println(c)

1Note(id=1, text=Milk)
2Note(id=1, text=Milk and eggs)

copy takes named arguments for whatever you want different, and quietly carries everything else over. The original is untouched — a still says Milk.

Destructuring — unpack in one line

1val (id, text) = c
2println("$id -> $text")

Destructuring pulls the properties out into separate names, in constructor order. You already used it in Lesson 1.11 to unpack a map entry into a key and a value — that works for exactly the same reason.

The order matters and the names do not. val (text, id) = c compiles perfectly and gives you completely wrong data, so keep the order honest.

When not to use one

A data class is right when the thing is its contents: a note, a dice roll, a saved setting, the state of a screen.

A plain class is right when the thing has behaviour and an identity of its own — a game engine, a database connection, a timer that is currently running. Two timers that happen to show the same number are not the same timer.

Two rules the compiler enforces:

• A data class must have at least one parameter in its constructor. An empty one would have nothing to compare.
• Only the constructor properties count. Anything declared inside the braces is invisible to toString, equals and copy.

1Note(id=1, text=Milk)
2true
3false
4Note(id=1, text=Milk and eggs)
51
61 -> Milk and eggs