Kotlin Academy · Lezione

Operatori di confronto

compareTo ed equals

Operatori di confronto è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Confronto tra tipi personalizzati

Per utilizzare <, >, <=, >= con il proprio tipo, definisca un operator fun compareTo che restituisca un Int.

data class Money(val cents: Int) {
    operator fun compareTo(o: Money) = cents - o.cents
}

fun main() {
    println(Money(500) > Money(200))
}

Il contratto di compareTo

compareTo restituisce un numero negativo se il ricevitore è minore, zero se è uguale e un numero positivo se è maggiore.

data class Version(val n: Int) {
    operator fun compareTo(o: Version) = n - o.n
}

fun main() {
    println(Version(2).compareTo(Version(5)))
}

Implementazione di Comparable

Implementare l’interfaccia Comparable<T> è l’approccio idiomatico; il suo compareTo è già un operatore.

data class Score(val value: Int) : Comparable<Score> {
    override fun compareTo(other: Score) = value - other.value
}

fun main() {
    println(Score(10) < Score(20))
}

Ordinamento con Comparable

Quando un tipo è Comparable, le funzioni delle raccolte come sorted() funzionano automaticamente.

data class Player(val rank: Int) : Comparable<Player> {
    override fun compareTo(other: Player) = rank - other.rank
}

fun main() {
    val sorted = listOf(Player(3), Player(1), Player(2)).sorted()
    println(sorted.map { it.rank })
}

Utilizzo di compareValuesBy

Per i confronti su più campi, compareValuesBy confronta i valori in base a ciascun selettore, nell’ordine.

data class Person(val age: Int, val name: String) : Comparable<Person> {
    override fun compareTo(other: Person) =
        compareValuesBy(this, other, { it.age }, { it.name })
}

fun main() {
    println(Person(30, "Al") < Person(30, "Bo"))
}

Uguaglianza con equals

L’operatore == chiama equals, non compareTo. Esegua l’override di equals per controllare l’uguaglianza dei valori.

class Id(val value: Int) {
    override fun equals(other: Any?) =
        other is Id && other.value == value
    override fun hashCode() = value
}

fun main() {
    println(Id(7) == Id(7))
}

equals e hashCode insieme

Se esegue l’override di equals, deve eseguire l’override anche di hashCode, affinché gli oggetti uguali condividano lo stesso hash e le raccolte basate su hash rimangano corrette.

class Tag(val name: String) {
    override fun equals(other: Any?) = other is Tag && other.name == name
    override fun hashCode() = name.hashCode()
}

fun main() {
    val set = hashSetOf(Tag("a"), Tag("a"))
    println(set.size)
}

Le data class lo fanno automaticamente

Una data class genera automaticamente equals e hashCode a partire dalle proprie proprietà, quindi == confronta i valori.

data class Coord(val x: Int, val y: Int)

fun main() {
    println(Coord(1, 2) == Coord(1, 2))
}

Uguaglianza e identità

== chiama equals (uguaglianza dei valori); === verifica l’identità del riferimento. I due risultati possono differire.

data class Box(val n: Int)

fun main() {
    val a = Box(1)
    val b = Box(1)
    println(a == b)
    println(a === b)
}

Confronto nelle condizioni

Quando compareTo è definito, il proprio tipo funziona nelle espressioni if e when come i numeri.

data class Weight(val g: Int) : Comparable<Weight> {
    override fun compareTo(other: Weight) = g - other.g
}

fun main() {
    val w = Weight(50)
    println(if (w > Weight(40)) "heavy" else "light")
}

maxOf e minOf

I tipi Comparable funzionano con maxOf e minOf.

data class T(val v: Int) : Comparable<T> {
    override fun compareTo(other: T) = v - other.v
}

fun main() {
    println(maxOf(T(3), T(8)).v)
}

Verifica rapida

Verifichi la sua comprensione degli operatori di confronto.

Riepilogo

Ha imparato a conoscere gli operatori di confronto:

compareTo implementa <, >, <=, >= e restituisce un valore negativo, zero o positivo.
Implementi Comparable<T> per ottenere ordinamento e sorting idiomatici.
== utilizza equals; lo associ sempre a hashCode.
Le data class generano automaticamente equals/hashCode.

data class S(val v: Int) : Comparable<S> {
    override fun compareTo(other: S) = v - other.v
}

fun main() {
    println(S(2) < S(5))
}

Domande Frequenti

La lezione «Operatori di confronto» è gratuita?

Sì — il testo completo di «Operatori di confronto» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «Operatori di confronto»?

compareTo ed equals Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Operatori di confronto»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Kotlin Academy