Kotlin: collections

In Kotlin le collections sono utilizzate per memorizzare in una singola unità gruppi di oggetti in relazione tra loro. Utilizzando le collections è pertanto possibile immagazzinare, manipolare e aggregare dati. Le collections possono essere classificate in due differenti classi:

• Immutable collection (o collection) : queste collection permettono unicamente la lettura dei dati. In questa categoria rientrano le liste (listOf), le mappe (mapOf) e i set (setOf).
• Mutable collection : queste collection invece permettono di leggere e scrivere dei dati. In questa categoria rientrano le liste (ArrayListOf, mutableListOf), le mappe (HashMapOf, mutableMapOf) e i set (hashSetOf, mutableSetOf).

Le Liste

In Kotlin, l’interfaccia List definisce il tipo di dato lista ovvero un insieme ordinato di elementi (collection) i quali possono essere modificati (MutableList) o no (List).

Liste Immutable

Esse derivano dalla classe Collection<T> ed i suoi metodi supportano solo l’accesso al dato in lettura. Questo significa che, una volta creata una lista non sarà più possibile aggiungere, modificare o rimuovere un suo elemento. Per utilizzare le liste è necessario utilizzare le funzioni listOf o listOf<T>. Esempio di utilizzo:

var list = listOf("pippo", "pluto", "topolino", 1 , 2 , 3)
var list2 = ListOf<String>("Maria", "Giovanni")
var intList : List<Int> = listOf<Int>(1 , 2 , 3)
var anyList : List<Any> = listOf<Any>( 1, 2, 3, "gatto", "topo")

Di seguito riportiamo alcune funzioni associate alle liste immutable:

• abstract fun contains(element : E) : Boolean : controlla se il determinato elemento (element) è contenuto nella lista.
• abstract fun containsAll(elements : Collection<E>) : Boolean : controlla che tutti gli elementi (elements) specificati siano contenuti nella lista.
• abstract operator fun get(index : Int) : E : restituisce l’elemento in posizione index della lista.
• abstract fun indexOf(element : E) : Int : restituisce l’indice della prima occorrenza in cui è presente l’elemento (element) nella lista. Torna -1 se l’elemento non è presente nella lista.
• abstract fun isEmpty() : Boolean : restituisce vero se la lista è vuota, altrimenti falso.
• abstract fun iterator() : Iterator<E> : restituisce l’iteratore relativo agli elementi della lista.
• abstract fun lastIndexOf(element : E) : Int : restituisce l’indice dell’ultima occorrenza in cui è presente l’elemento (element) nella lista. Torna -1 se l’elemento non è presente nella lista.
• abstract fun listIterator() : ListIterator<E> : restituisce la lista degli iteratori relativa agli elementi della lista nella corretta sequenza.
• abstract fun listIterator(index : Int) : ListIterator<E> : restituisce la lista degli iteratori relativa agli elementi della lista nella corretta sequenza, partendo dall’indice (index).
• abstract fun subList(fromIndex : Int, toIndex : Int) : List : restituisce la parte di lista compresa tra l’indice fromIndex (incluso) e l’indice toIndex (escluso).

Liste Mutable

Le liste mutable derivano anch’esse dalla classe Collection<T> ma la loro interfaccia permette l’accesso al dato non solo in lettura ma anche in scrittura. Le liste mutable non hanno lunghezza fissa ed è possibile aggiungere/rimuovere/modificare un determinato elemento. Per utilizzare le liste mutable è necessario utilizzare le funzioni mutableListOf o mutableListOf<T>. Esempio di utilizzo:

var mutableList = mutableListOf("pippo", "pluto", "topolino", 1 , 2 , 3) 
var mutableList2 = mutableListOf<String>("Maria", "Giovanni")
var intMutableList : MutableList<Int> = mutableListOf<Int>(1 , 2 , 3) 
var anyMutableList : MutableList<Any> = mutableListOf<Any>( 1, 2, 3, "gatto", "topo")

Di seguito riportiamo alcune funzioni associate alle liste mutable:

• abstract fun add(element : E) : Boolean : aggiunge un determinato elemento (element) alla lista.
• abstract fun add(index: Int, element : E) : Boolean : aggiunge un determinato elemento (element) alla lista nella posizione index.
• abstract fun addAll(elements : Collection<E>) : Boolean : aggiunge tutti gli elementi di una data collezione alla lista corrente.
• abstract fun clear() : rimuove tutti gli elementi della lista.
• abstract fun remove(element : E) : Boolean : rimuove l’elemento (element) dalla lista se presente.
• abstract fun removeAll(elements: Collection<E>) : Boolean : rimuove gli elementi elements dalla lista, se presenti.
• abstract fun removeAt(index : Int) : E : rimuove l’elemento in posizione index.
• abstract fun retainAll(elements : Collection<E>) : Boolean : conserva tutti gli elementi elements della lista ed elimina gli altri.
• abstract operator fun set(index : Int, element : E) : E : sostituisce/aggiunge l’elemento element in posizione index.
• abstract fun listIterator() : MutableListIterator<E> : restituisce la lista degli iteratori relativa agli elementi della lista nella corretta sequenza.
• abstract fun listIterator(index : Int) : MutableListIterator<E> : restituisce la lista degli iteratori relativa agli elementi della lista nella corretta sequenza, partendo dall’indice (index).
• abstract fun subList(fromIndex : Int, toIndex : Int) : MutableList<E> : restituisce la parte di lista compresa tra l’indice fromIndex (incluso) e l’indice toIndex (escluso).

Per maggiori informazioni si faccia riferimento a https://kotlinlang.org/docs/collections-overview.html .

Gli ArrayList

In Kotlin gli ArrayList sono una classe che costituiscono degli array dinamici ovvero array la cui dimensione può essere aumentata o diminuita. Come gli Array, gli ArrayList sono mutable ed è quindi possibile leggere e modificare gli elementi. Gli ArrayList possono contenere oggetti duplicati. E’ possibile costruire un ArrayList in tre modi differenti:

• ArrayList<E>() : utilizzato per creare un ArrayList vuoto. Esempio di utilizzo: val arrayList = ArrayList<String>()
• ArrayList(capacity : Int) : utilizzato per creare un ArrayList di dimensione capacity. Esempio di utilizzo: val arrayList = ArrayList<Int>(5)
• ArrayList(elements : Collection<E>) : utilizzato per creare un ArrayList riempito con degli elementi (elements) di una determinata collezione.
• ArrayListOf<E>(elements) : utilizzato per creare un ArrayList contenente valori di tipo Ee riempito con gli elementi elements. E = Any nel caso in cui l’ArrayList contenga elementi misti. Esempio di utilizzo: var intArraList : ArrayList<Int> =  arrayListOf<Int>(1,2,3,4,5)

Di seguito riportiamo alcune funzioni associate alle liste mutable:

• open fun add(element : E) : Boolean : aggiunge uno specifico elemento alla ArrayList.
• open fun add(index: Int, element : E) : Boolean : inserisce un determinato elemento (element) in una determinata posizione (index) dell’ArrayList.
• open fun addAll(elements : Collection<E>) : Boolean : aggiunge una serie di elementi (elements) di una collezione all’ArrayList.
• open fun clear() : rimuove tutti gli elementi dall’ArrayList.
• open fun get(index : Int) : E : ritorna l’elemento associato alla posizione (index) dell’ArrayList.
• open fun indexOf(element : E) : Int : restituisce l’indice della prima occorrenza in cui è presente l’elemento (element) nell’ArrayList. Torna -1 se l’elemento non è presente nell’ArrayList.
• open fun lastIndexOf(element : E) : Int : restituisce l’indice dell’ultima occorrenza in cui è presente l’elemento (element) nell’ArrayList. Torna -1 se l’elemento non è presente nell’ArrayList.
• open fun remove(element : E) : Boolean : rimuove l’elemento (element) dall’ArrayList.
• open fun removeAt(index : Int) : E : rimuove l’elemento di posizione (index) dall’ArrayList.
• open fun removeRange(startIndex : Int, endIndex : Int) : elimina tutti gli elementi dell’ArrayList dalla posizione (startIndex) inclusa alla posizione (endIndex) esclusa.
• open operator fun set(index : Int, element : E) : E : sostuisce l’elemento in posizione (index) dell’ArrayList con l’elemento (element).
• open fun toArray() :  Array<Any?> : restituisce un array di tipo Array<Any?> costituito da tutti gli elementi dell’ArrayList.
• open fun toString() : String : restituisca una rappresentazione “stringa” dell’ArrayList.

Le mappe

In Kotlin anche le mappe sono interfacce di una generica collezione di oggetti. Le mappe memorizzano le informazioni attraverso coppie chiave – valore non necessariamente dello stesso tipo. Come per le liste, anche le mappe possono essere mutable (MutableMap e HashMap) o immutable (Map).

Mappe Immutable

Le mappe immutable o semplicemente Map, sono collezioni con lunghezza fissa di oggetti il cui accesso è limitato alla sola lettura. Questo significa che, una volta creata una mappa non sarà più possibile aggiungere, modificare o rimuovere un suo elemento. Per utilizzare le mappe è necessario utilizzare le funzioni mapOf o mapOf<k,v>. Esempio di utilizzo:

val myMap = mapOf<Int,String>(1 to "pippo", 2 to "pluto", 3 to "topolino")
val myMap2 : Map<Int,String> = mapOf<Int,String>(1 to "gatto", 2 to "topo", 3 to "marmotta")

Di seguito riportiamo le proprietà associate alle mappe immutable:

• abstract val entries : Set<Entry<K,V>> : ritorna tutte le coppie chiave valore della corrente mappa sotto forma di set immutable.
• abstract val keys : Set<K> : ritorna tutte le chiavi della corrente mappa sotto forma di set.
• abstract val size : Int : ritorna il numero di coppie chiave valori contenute nella mappa corrente.
• abstract val values : Collection<V> : ritorna tutti i valori della mappa corrente sotto forma di collection. Si nota che la collection può contenere valori dupplicati perdendo l’informazione sulla chiave.

Di seguito riportiamo alcune funzioni associate alle mappe immutable:

• fun <K,V> Map<key,value>.getValue( key : K) : V  : torna il valore di una determinata chiave o genera un’eccezione se nessun valore è stato trovato per la chiave indicata.
• operator fun <V, V1 : V> Map< in String, V>.getValue( thisRef : Any?, property : KProperty<*>) : V1 : torna il valore della property per il dato oggetto contenuto nella mappa corrente.
• operator fun <K,V> Map< out K, V >.contains( key : K ) : Boolean : controlla se la data chiave (key) è contenuta nella mappa.
• fun <K> Map< out K, *>.containsKey( key : K ) : Boolean : controlla se la data chiave (key) è contenuta nella mappa.
• fun <K,V>Map <K, V>.containsValue( value : V) : Boolean : controlla se il determinato valore (value) è contenuto nella mappa.
• fun <K,V> Map < out K, V>.getOrDefault( key : K, defaultValue : V) : V : ritorna il valore associato alla chiave (key) indicata, altrimenti fornisce il valore di default (defaultValue).
• fun <K,V> Map <out K, V>.asIterable() : Iterable<Entry<K,V>> : crea un’istanza di un oggetto di tipo Iterable che fa un wrap della mappa originale tornando le sue entry quando viene iterato.
• fun<K,V> Map <out K, V>.asSequence() : Sequence<Entry<K,V>> : crea un’istante di un oggetto di tipo Sequence che fa un wrap della mappa originale tornando le sue entry quando viene iterato.
• operator fun <K,V> Map <out  K, V>.iterator() : Iterator<Entry<K,V>> : ritorna un iteratore sull’entry della mappa.
• operator fun <K,V> Map <out K, V>.minus( key : K) : Map<K,V> : torna un mappa che contiene le coppie originali tranne quelli di cui si è indicata la chiave.
• operator fun <K,V> Map <out K, V>.minus( keys : Iterable<K>) : Map<K,V> : torna un mappa che contiene le coppie originali tranne quelli di cui si sono indicate le chiavi nella collezione Iterable.
• operator fun <K,V> Map <out K, V>.minus( keys : Sequence<K>) : Map<K,V> : torna un mappa che contiene le coppie originali tranne quelli di cui si sono indicata le chiavi nella collezione Sequence.
• operator fun <K,V> Map<out K, V>.plus( pair : Pair<K,V>) : Map<K,V> : crea una nuova mappa immutable aggiungendo una nuova coppia chiave – valore (pair)
• operator fun <K,V> Map<out K, V>.plus( pairs : Iterable<K,V>>) : Map<K,V> : crea una nuova mappa immutable aggiungendo nuove coppie chiave – valori (pairs) contenute nella collection di tipo Iterable.
• operator fun <K,V> Map<out K, V>.plus( pairs : Sequence<K,V>>) : Map<K,V> : crea una nuova mappa immutable aggiungendo nuove coppie chiave – valori (pairs) contenute nella collection di tipo Sequence.

Mappe Mutable

Le mappe mutable sono mappe in cui le coppie chiave-valore possono essere non solo lette, ma anche scritte e/o modificate. Per utilizzare tali mappe è necessario utilizzare le funzioni mutableMapOf o mutableMapOf<k,v>. Esempio di utilizzo:

Di seguito riportiamo le proprietà associate alle mappe mutable:

• abstract val entries : MutableSet<Entry<K,V>> : ritorna tutte le coppie chiave valore della corrente mappa sotto forma di set mutable.
• abstract val keys : MutableSet<K> : ritorna tutte le chiavi della corrente mappa sotto forma di set mutable.
• bstract val values : MutableCollection<V> : ritorna tutti i valori della mappa corrente sotto forma di collection mutable. Si nota che la collection può contenere valori dupplicati perdendo l’informazione sulla chiave.

Di seguito riportiamo alcune funzioni associate alle mappe mutable:

• abstract fun put ( key : K, value : V) : V? : aggiunge la coppia chiave valore (key, value) alla mappa.
• abstract fun putAll ( from : Map<out K, V>) : aggiorna la mappa corrente aggiungendo i valori conenuti nella mappa (from).
• abstract fun remove ( key : K) : V? : rimuove la chiave (key) della mappa con i corrispettivi valori se questa è presente nella mappa.
• open fun remove ( key : K, value : V) : Boolean : rimuove la coppia chiave-valore (key, value) se questa è presente nella mappa.
• abstract fun clear () : questa funzione è utilizzata per rimuovere tutti gli elementi di una mappa.
• operator fun <K,V> Map<out K, V>.contains( key  : K) : Boolean : ritorna vero nel caso in cui la chiave (key) è contenuta nella mappa. In caso contrario ritorna falso.
• fun <K> Map<out K, *>.containsKey ( key : K) : Boolean : ritorna vero nel caso in cui la chiave (key) è contenuta nella mappa. In caso contrario ritorna falso.
• abstract fun containsValue( value : V) : Boolean : ritorna vero nel caso il valore (value) è contenuto nella mappa. In caso contrario ritorna falso.
• fun <K,V> Map<K,V>.containsValue ( value : V) : Boolean : ritorna vero nel caso il valore (value) è contenuto nella mappa. In caso contrario ritorna falso.
• fun <K,V> Map<out K, V>.count() : Int : ritorna il numero di coppie chiave-valore presenti nella mappa.
• operator fun <K,V> Map<out K, V> .get( key : K) : V? : restituisce il valore associato ad una determinata chiave (key). In caso contrario restituisce il valore null.
• fun <K,V> Map<out K, V>.getOrDefault( key : K, defaultValue: V) : V : restituisce il valore associato ad una determinata chiave (key) altrimenti, nel caso in cui essa non sia presente nella mappa, restituisce il valore di default (defaultValue).
• fun <K,V> Map<out K, V>.getOrElse( key: K , defaultValue: () -> V) : V : restituisce il valore associato ad una determinata chiave (key) altrimenti, nel caso in cui essa non sia presente nella mappa, esegue la funzione defaultValue.
• fun <K,V> Map <K,V>.getValue( key : K) : V : restituisce il valore associato ad una determinata chiave (key). In caso contrario genera un’eccezione.

Hash Map

Le HashMap sono una classe basate sulle MutableMap in cui queste ultime vengono implementate utilizzando una tabella hash invece di una tabella ad indirizzamento diretto. Se nel secondo caso ad ogni chiave è associata un’aria di memoria dove è immagazzinato il valore (quindi con un’occupazione di memoria pari a quella dei valori presenti con spazi vuoti nella tabella di memoria), nel caso di tabelle hash la funzione di hash permette di connettere chiave a valore attraverso un processo capace di ottimizzare l’allocazione della memoria. Queste mappe non garantiscono quindi l’ordinamento degli elementi chiave-valore. Per utilizzare le HashMap è necessario utilizzare uno dei seguenti costruttori:

• HashMap() : costruisce una mappa di tipo hash vuota.
• HashMap(initialCapacity : Int, loadFactor : Float = 0F) : costruisce una mappa di tipo hash con una dimensione iniziale initialCapacity.
• HashMap(original : Map<out K, V>) : costruisce una mappa di tipo hash partendo da una generica mappa immutable.

oppure è possibile utilizzare anche le funzioni hashMapOf o hashMapOf<k,v>. Esempio di utilizzo:

val hashMap : HashMap<Int,String> = HashMap<Int,String>()
val hashMap2 : HashMap<Int,String> = HashMap<Int,String>(5)
val hashMap3 : HashMap<Int,String> = hashMapOf<Int,String>(1 to "gatto", 2 to "topo", 3 to "cane")
val hashAnyMap : HashMap<Any,Any> = hashMapOf<Any,Any>(1 to "gatto", 2 to 200, "pippo" to "cane")
val hashMap4 : HashMap<Int,String> = hashMapOf<Int,String>()

Di seguito riportiamo alcune funzioni associate alle mappe mutable di tipo hash:

• open fun put( key : K, value: V) : V? : aggiunge la chiave – valore (key, value) alla mappa corrente.
• open operator fun get( key : K) : V? : ritorna il valore associato alla determinata chiave (key) altrimenti null nel caso in cui l’elemento non sia presente.
• open fun containsKey(key : K) : Boolean : ritorna vero se la determinata chiave (key) è presente nella mappa, altrimenti falso.
• open fun containsValue(value : V) : Boolean : ritorna vero se il determinato valore (value) è presente nella mappa, altrimenti falso.
• open fun clear() : rimuove tutti gli elementi dalla mappa.
• open fun remove(key : K) : V? : rimuove l’elemento con determinata chiave (key) dalla mappa.

I set

Un set è una collezione non ordinata di elementi non dupplicati. Come per le liste e le mappe, anche i set possono essere mutable (MutableSet e HashSet) o immutable (Set).

Set Immutable

I set immutable o semplicemente Set, sono collezioni con lunghezza fissa di oggetti il cui accesso è limitato alla sola lettura. Questo significa che, una volta creato un set non sarà più possibile aggiungere, modificare o rimuovere un suo elemento. Per utilizzare i set è necessario utilizzare le funzioni setOf. Esempio di utilizzo:

val intSet = setOf(1,2,3,4,5)
val mySet : Set<Any> = setOf(1,"gatto",2, "topo", "bue")

Di seguito riportiamo le proprietà associate ai set:

• abstract val size : Int : ritorna la dimensione del set ovvero il numero dei suoi elementi.

Di seguito riportiamo alcune funzioni associate ai set:

• abstract fun contains( element : E) : Boolean : ritorna vero se il determinato elemento (element) è contenuto nel set, altrimenti torna falso.
• abstract fun containsAll( elements : Collection<E> ) : Boolean : ritorna vero se tutti gli elementi della collezione (elements) sono contenuti nel set, altrimenti ritorna falso.
• abstract fun isEmpty() : Boolean : ritorna vero se il Set non contiene nessun elemento, altrimenti ritorna falso.
• abstract fun iterator() : Iterator<E> : torna l’iteratore ad un oggetto di tipo Set.
• fun <T> Iterable<T>.all(predicate : (T) -> Boolean) : Boolean : ritorna vero se tutti gli elementi soddisfano la funzione predicate.
• fun <T> Iterable<T>.any() : Boolean : torna vero se la collezione contiene almeno un elemento.
• fun <T> Iterable<T>.count( predicate : (T) -> Boolean) : Int : torna il numero di elementi che soddisfano la funzione predicate.
• fun <T> Iterable<T>.distinct() : List<T> : ritorna una lista contenente solo gli elementi distinti della collezione data.
• fun <T> Iterable<T>.drop( n : Int ) : List<T> : ritorna un lista che contiene tutti gli elementi eccetto i primi n.
• fun<T> Iterable<T>.elementAtOrElse( index : Int, defaultValue : (Int) -> T) : T : ritorna l’elemento associato ad un determinato indice (index). Nel caso in cui questo l’indice sia fuori range viene eseguita la funzione defaultValue.

Set Mutable

I set mutable sono set i cui elementi possono essere non solo letti, ma anche scritti e/o modificati. Per usare tali set è necessario utilizzare le funzioni mutableSetOf. Esempio di utilizzo:

val intMutableSet = mutableSetOf<Int>(2,3,4,11)
val intMutableSet2 : MutableSet<Int> = mutableSetOf<Int>(1,3,5,12)

Di seguito riportiamo le proprietà associate ai set mutable:

• abstract val size : Int : ritorna la dimensione del set ovvero il numero dei suoi elementi.

Di seguito riportiamo alcune funzioni associate ai set mutable:

• abstract fun add( element : E) : Boolean : aggiunge un dato elemento (element) al set.
• abstract fun addAll( elements : Collection<E>) : Boolean : aggiunge gli elementi (elements) al set.
• abstract fun clear() : rimuove tutti gli elementi del set.
• abstract fun iterator() : MutableIterator<E> : ritorna un iteratore sugli elementi del set.
• abstract fun remove ( element : E) : Boolean : rimuove l’elemento (element) dal set se è presente.
• abstract fun removeAll (elements : Collection<E>) : Boolean : rimuove tutti gli elementi (elements) dal set se presenti.
• abstract fun retainAll (elements : Collection<E>) : Boolean : conserva solo gli elementi (elements) del set.
• abstract fun contains( element : E) : Boolean : ritorna vero se l’elemento (element) è contenuto nel set.
• abstract fun containsAll (elements : Collectino<E>) : Boolean : ritorna verso se gli elementi (elements) sono contenuti del set.
• abstract fun isEmpty() : Boolean : ritorna vero se il set è vuoto.
• fun <T> Iterable<T>.any() : Boolean : ritorna vero se è presente almeno un elemento nel set.
• fun <T> Iterable<T>.any( predicate : (T) -> Boolean ) : Boolean : ritorna vero se almeno un elemento soddisfa la funzione predicate.
• un <T> Iterable<T>.distinct() : List<T> : ritorna una lista contenenti sono gli elementi distinti del set.
• fun<T> Iterable<T>.drop( n : Int ) : List<T> : ritorna un lista che contiene tutti gli elementi del set tranne i primi n.
• fun<T> iterable<T>.elementAt ( index : Int ) : T : ritorna l’elemento di indice (index) altrimenti, nel caso in cui l’indice non sia presente nel set, genera un’eccezione di tipo IndexOutBoundException.
• fun<T> iterable<T>.elementAtOrElse ( index : Int, defaultValue : (Int) -> T) : T : ritorna l’elemento di indice (index) altrimenti, nel caso in cui l’indice non sia presente nel set, esegue la funzione defaultValue.
• fun<T:Comparable<T>> Iterable<T>.max() : T? : ritorna il massimo elemento del set, null nel caso in cui il set sia vuoto.
• fun<T:Comparable<T>> Iterable<T>.min() : T? : ritorna l’elemento più piccolo del set, null nel caso in cui il set sia vuoto.
• fun<T>MutableCollection<out T>.remove( element : T ) : Boolean : rimuove l’elemento (element) dal set.
• fun<T>MutableCollection<out T>.removeAll( elements : Collection<T> ) : Boolean : rimuovono gli elementi (elements) dal set.
• fun<T>MutableCollection<out T>.retainAll( elements : Collection<T> ) : Boolean : conserva solo gli elementi (elements) del set.
• fun<T> Iterable<T>.reversed() : List<T> : ritorna una lista con gli elementi del set in ordine inverso.

Hash Set

L’HashSet è una classe che estende la AbstractMutableSet in cui questi ultimi vengono implementate utilizzando una tabella hash invece di una tabella ad indirizzamento diretto. Questi set non garantiscono quindi l’ordinamento degli elementi. Per utilizzare gli HashSet è necessario utilizzare uno dei seguenti costruttori:

• HashSet() : costruisce un set di tipo hash vuoto.
• HashSet(initialCapacity : Int, loadFactor : Float = 0F) : costruisce un set di tipo hash con una dimensione iniziale initialCapacity.
• HashSet(elements: Collection<E>) : costruisce un set di tipo hash partendo da una generica collezione.

oppure è possibile utilizzare anche la funzione hashSetOf. Esempio di utilizzo:

var hashSet : HashSet<Int>(6)
var hashSet1 = hashSetOf<Int>(2,4,6,8)
var hashSet2 : HashSet<String> = hashSetOf<String>("pippo","pluto","gatto")

Di seguito riportiamo le proprietà associate ai set:

• abstract val size : Int : ritorna la dimensione dell’HashSet ovvero il numero dei suoi elementi.

Di seguito riportiamo alcune funzioni associate ai set di tipo hash:

• open fun add ( element : E ) : Boolean : aggiunge il dato elemento (element) al set.
• open operator fun contains ( element : E ) : Boolean : controlla se l’elemento (element) è presente nel set.
• open fun isEmpty() : Boolean : ritorna vero se il set non contiene nessun elemento.
• open fun iterator() : MutableIterator<E> : ritorna l’iteratore agli oggetti del set.
• open fun remove ( element : E ) : Boolean : rimuove l’elemento (element) dal set. Torna vero se l’eliminazione è stata effettuata con successo.
• open fun clear() : cancella tutti gli elementi del set.