Mapa de hash de Kotlin – Barcelona Geeks

Kotlin HashMap es una colección que contiene pares de objetos. Implementación basada en Kotlin Hash Table de la interfaz MutableMap. Almacena los datos en forma de par clave y valor. Las claves del mapa son únicas y el mapa contiene solo un valor para cada clave. Se representa como HashMap<key, value> o HashMap<K, V> .

La implementación basada en tablas hash de HashMap no garantiza el orden de los datos especificados de clave , valor y entradas de colecciones.

Constructores de la clase Kotlin HashMap –

Kotlin HashMap proporciona 4 constructores y el modificador de acceso de cada uno es público:

HashMap() : es el constructor predeterminado que construye una instancia vacía de HashMap.

HashMap(initialCapacity: Int, loadFactor: Float = 0f) : Se utiliza para construir un HashMap de capacidad especificada. Si initialCapacity y loadFactor no se utilizan, ambos serán ignorados.

HashMap(initialCapacity: Int) : Se utiliza para construir un HashMap de capacidad especificada. Si no se usa initialCapacity, se ignorará.

HashMap (original: Map <out K, V>): crea una instancia de HashMap con las mismas asignaciones que el mapa especificado.

Uso de las funciones de HashMap –

Programa Kotlin de uso de funciones HashMap(), HashMap(original: Map), Traversing hashmap, HashMap.get() –

fun main(args: Array<String>) {
    //A simple example of HashMap class define
    // with empty "HashMap of <String, Int>"
    var hashMap : HashMap<String, Int>
            = HashMap<String, Int> ()
  
    //printing the Empty hashMap
    printHashMap(hashMap)
  
    //adding elements to the hashMap using
    // put() function
    hashMap.put("IronMan" , 3000)
    hashMap.put("Thor" , 100)
    hashMap.put("SpiderMan" , 1100)
    hashMap.put("NickFury" , 1200)
    hashMap.put("HawkEye" , 1300)
  
    //printing the non-Empty hashMap
    printHashMap(hashMap)
    //using the overloaded print function of
    //Kotlin language to get the same results
    println("hashMap : " + hashMap + "\n")
  
    //hashMap traversal using a for loop
    for(key in hashMap.keys){
        println("Element at key $key : ${hashMap[key]}")
    }
  
    //creating another hashMap object with
    // the previous version of hashMap object
    var secondHashMap : HashMap<String, Int>
            = HashMap<String, Int> (hashMap)
  
    println("\n" + "Second HashMap : ")
    for(key in secondHashMap.keys){
        //using hashMap.get() function to fetch the values
        println("Element at key $key : ${hashMap.get(key)}")
    }
  
    //this will clear the whole map and make it empty
    println("hashMap.clear()")
    hashMap.clear()
  
    println("After Clearing : " + hashMap)
  
  
}
  
//function to print the hashMap
fun printHashMap(hashMap : HashMap<String, Int>){
    // isEmpty() function to check whether
    // the hashMap is empty or not
    if(hashMap.isEmpty()){
        println("hashMap is empty")
    }else{
        println("hashMap : " + hashMap)
    }
}

Producción :

hashMap is empty : {}

hashMap : {Thor=100, HawkEye=1300, NickFury=1200, IronMan=3000, SpiderMan=1100}
hashMap : {Thor=100, HawkEye=1300, NickFury=1200, IronMan=3000, SpiderMan=1100}

Element at key Thor : 100
Element at key HawkEye : 1300
Element at key NickFury : 1200
Element at key IronMan : 3000
Element at key SpiderMan : 1100

secondHashMap : 
Element at key Thor : 100
Element at key HawkEye : 1300
Element at key IronMan : 3000
Element at key NickFury : 1200
Element at key SpiderMan : 1100

hashMap.clear()
After Clearing : {}

Programa Kotlin de uso de la capacidad inicial de HashMap, HashMap.size –

fun main(args: Array<String>) {
    //HashMap can also be initialize
    // with its initial capacity.
    //The capacity can be changed by
    // adding and replacing its element.
    var hashMap : HashMap<String, Int>
            = HashMap<String, Int> (4)
  
    //adding elements to the hashMap using put() function
    hashMap.put("IronMan" , 3000)
    hashMap.put("Thor" , 100)
    hashMap.put("SpiderMan" , 1100)
    hashMap.put("NickFury" , 1200)
  
    for(key in hashMap.keys) {
        println("Element at key $key : ${hashMap[key]}")
    }
    //returns the size of hashMap
    println("\n" + "hashMap.size : " + hashMap.size )
  
    //adding a new element in the hashMap
    hashMap["BlackWidow"] = 1000;
    println("hashMap.size : " + hashMap.size + "\n")
  
    for(key in hashMap.keys) {
        println("Element at key $key : ${hashMap[key]}")
    }
}

Producción:

Element at key Thor : 100
Element at key IronMan : 3000
Element at key NickFury : 1200
Element at key SpiderMan : 1100

hashMap.size : 4
hashMap.size : 5

Element at key Thor : 100
Element at key BlackWidow : 1000
Element at key IronMan : 3000
Element at key NickFury : 1200
Element at key SpiderMan : 1100

Programa Kotlin de uso de funciones HashMap.get(key), HashMap.replace(), HashMap.put() –

fun main(args: Array<String>) {
    var hashMap : HashMap<String, Int> 
            = HashMap<String, Int> ()
  
    //adding elements to the hashMap 
    // using put() function
    hashMap.put("IronMan" , 3000)
    hashMap.put("Thor" , 100)
    hashMap.put("SpiderMan" , 1100)
    hashMap.put("Cap" , 1200)
  
    for(key in hashMap.keys) {
        println("Element at key $key : ${hashMap[key]}")
    }
  
    //the hashMap's elements can be accessed like this
    println("\nhashMap[\"IronMan\"] : "
            + hashMap["IronMan"])
    hashMap["Thor"] = 2000
    println("hashMap.get(\"Thor\") : " 
            + hashMap.get("Thor") + "\n")
  
    //replacing some values
    hashMap.replace("Cap" , 999);
    hashMap.put("Thor" , 2000);
  
    println("hashMap.replace(\"Cap\" , 999)" +
            " hashMap.replace(\"Thor\" , 2000)) :")
  
    for(key in hashMap.keys) {
        println("Element at key $key : ${hashMap[key]}")
    }
}

Producción:

Element at key Thor : 100
Element at key Cap : 1200
Element at key IronMan : 3000
Element at key SpiderMan : 1100

hashMap["IronMan"] : 3000
hashMap.get("Thor") : 2000

hashMap.replace("Cap", 999) hashMap.replace("Thor", 2000)) :
Element at key Thor : 2000
Element at key Cap : 999
Element at key IronMan : 3000
Element at key SpiderMan : 1100

Complejidad temporal de HashMap –

Kotlin HashMap proporciona tiempo constante o complejidad O(1) para operaciones básicas como obtener y colocar, si la función hash se escribe correctamente y dispersa los elementos correctamente. En caso de buscar en HashMap containsKey() es solo un get() que descarta el valor recuperado, es O(1) (suponiendo que la función hash funcione correctamente).

Algunas otras funciones de la clase Kotlin HashMap:

Boolean containsKey(clave: K): devuelve verdadero si el mapa contiene una clave específica.

Boolean containsValue(valor: V): devuelve verdadero si el mapa asigna una o más claves al valor especificado.

void clear(): Elimina todos los elementos del mapa.

remove(key: K): Elimina la clave especificada y su valor correspondiente del mapa

Publicación traducida automáticamente

Artículo escrito por AvishekMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Constructores de la clase Kotlin HashMap –

Uso de las funciones de HashMap –

Complejidad temporal de HashMap –

Algunas otras funciones de la clase Kotlin HashMap:

Deja una respuesta Cancelar la respuesta