Hashtable i Java

En hashtable (svenska: hashtabell) i Java är en samling av element, där varje element binds till en nyckel. Varje nyckel är unik och det är med hjälp av denna nyckel som man kan man komma åt värdena i en hashtable.

Vad är en hashtable i Java?

Till att börja med, vi kommer använda oss av det engelska uttrycket hashtable i den här artikeln. En hashtable är likt en array, en samling av data. Skillnaden är att i en hashtable binds varje värde till en nyckel. På så sätt kan man komma åt ett visst värde i tabellen med dess motsvarande nyckel utan att hålla reda på något index.

Varje nyckel är unik och det är med hjälp av denna nyckel som man kan man komma åt värdena i hashtabellen.

Kort sammanfattat kan man säga att en hashtable i Java:

En samling av element.
Varje element binds till en nyckel.
Inte sorterad efter index (eftersom varje värde har en nyckel)
Varje nyckel är unik.
Nyckeln är ett valfritt objekt som blir hashad för att få en unik nyckel.

Hur fungerar en hashtable i Java?

I avsnittet om arrayer lärde vi oss att varje element har ett index. I en hashtabell byter vi istället ut indexet mot en nyckel. Detta innebär att hashtabellen inte är sorterad som en array är. Observera att varje nyckel är unik, det vill säga, man kan inte använda samma nyckel två gånger i samma hashtabell. Vilket förstår är logiskt, för hur skulle man i så fall veta vilket värde man vill ha om två värden har samma nyckel?

Man kan använda ett valfritt objekt som nyckel i en hashtabell (exempelvis en String). Objektet blir sedan hashad och det är det hashade värdet som används som index i hashtabellen. Det är därför det kallas hashtabell!

Hashtabeller i Java:

Hur skapar man en hashtabell i Java?

Syntaxen för att skapa en hashtabell i Java ser ut såhär:

// Importera Javas util-paket där hashtable är tillgänglig
import java.util.*; 

// Deklarera en hashtable
Hashtable<Key, Value> hashtableName = new Hashtable<Key, Value>();

import java.util.*; // Importera Javas util-paket där hashtable är tillgänglig

Hashtable<Integer, String> hashtableName = new Hashtable<Integer, String>();

Först måste vi importera paketet där hashtable i Java är tillgängligt. Det gör vi genom att importera Javas paket utils. Vi skapar sedan en hashtabell genom att först ange Hashtable, följt av mindre än/större med <> symboler. Inom symbolerna anger man först vilken datatyp/objekt som nyckeln är. Därefter anger man vilken datatyp/objekt som värdet man vill lagra har. Efter det, anger man namnet man vill ha på sin hashtabell (hashtableName). Till sist anger man new Hashtable med samma objekt som tidigare inom <>.

I detta fall har vi alltså skapat en hashtabell som heter hashtableName. Nyckeln i denna hashtabell kommer vara en Integer, och värdena vi lagrar kommer vara av typen String.

Skapa en hashtabell (hashtable) i Java – Exempel

I följande exempel skapar vi en telefonbok. Varje namn i hashtabellen kommer vara nyckeln, och värdet till tillhörande nyckel kommer vara telefonnumret till motsvarande person.

import java.util.*; // Importera Javas util-paket där hashtable är tillgänglig
class hashtable {
    public static void main(String[] arg) {
        // Skapa en hashtable där både nyckeln och värdet är av typen string
        Hashtable<String, String> phonebook = new Hashtable<String, String>();

        // Lägg till tre värden i tabellen
        phonebook.put("Kalle", "039591");
        phonebook.put("Johan", "854927");
        phonebook.put("Stina", "703580");

        // Skriv ut telefonboken
        System.out.println(phonebook);

        // Skriv ut ett specifikt värde
        System.out.println(phonebook.get("Kalle"));

    }
}

Vi skapar alltså en hashtabell som heter phonebook. Sedan anger vi att både nyckeln och värdena vi vill lagra är av datatypen String. Avslutningsvis, skapar vi tre nycklar Kalle, Johan, Stina och tilldelar värden till dem med metoden put(). Nu kan vi komma åt värden i hashtabellen med metoden get().

I detta exempel får vi alltså utskriften:

{Stina=703580, Kalle=039591, Johan=854927}
039591

Varför hashtabeller?

Hashtabeller är ett bra användningsområde när man vill slå upp värden effektivt. I en array blir alla värden lagrade i en viss ordning. I en hashtabell sköts detta automatiskt för att optimera hastigheten att slå upp ett värde i tabellen. Vet man en viss nyckel, behöver man aldrig ha koll på index eller genomsöka en array för att hitta värdet.

Egenskaper hos en hashtabell:

Det finns flera inbyggda metoder hos hashtabellen. För fullständig dokumentation, se hela listan hos oracle. Några av de viktigaste är dock:

put(K key, V value):

Mappar en specifik nyckel till ett specifikt värde.

get(object key):

Returnerar värdet som tillhör en specifik nyckel. Om det inte finns något värde tillhörande den nyckel du skickar in, kommer hashtabellen returnera null.

clear():

Nollställer tabellen och tar bort alla nycklar och värden.

containsKey(object key):

Returnerar true om nyckeln existerar i hashtabellen, annars false.

keys():

Returnerar alla nycklar i hashtabellen.

Size():

Returnerar antal nycklar i hashtabellen.

Föregående sida

Nästa sida