Java >> Java tutorial >  >> Tag >> HashMap

Fjern en post fra et Java HashMap

HashMap

1. Oversigt

I denne artikel vil vi diskutere forskellige måder at fjerne en post fra et Java HashMap .

2. Introduktion

HashMap gemmer poster i (Nøgle, Værdi) par med unikke nøgler. En idé ville således være at bruge nøglen som en identifikator for at fjerne en tilknyttet post fra kortet.

Vi kan bruge metoderne fra java.util.Map grænseflade til fjernelse af indtastning ved hjælp af tasten som input.

2.1. Brug metoden fjern(Objektnøgle)

Lad os prøve det med et simpelt eksempel. Vi har et kort, der forbinder madvarer med madtyper:

HashMap<String, String> foodItemTypeMap = new HashMap<>();
foodItemTypeMap.put("Apple", "Fruit");
foodItemTypeMap.put("Grape", "Fruit");
foodItemTypeMap.put("Mango", "Fruit");
foodItemTypeMap.put("Carrot", "Vegetable");
foodItemTypeMap.put("Potato", "Vegetable");
foodItemTypeMap.put("Spinach", "Vegetable");

Lad os fjerne posten med tasten "Apple":

foodItemTypeMap.remove("Apple");
// Current Map Status: {Potato=Vegetable, Carrot=Vegetable, Grape=Fruit, Mango=Fruit, Spinach=Vegetable}

2.2. Ved at bruge metoden remove(Object key, Object value)

Dette er en variant af den første metode og accepterer både nøgle og værdi som input. Vi bruger denne metode, hvis vi ønsker at slette en post kun, hvis en nøgle er knyttet til en bestemt værdi .

I foodItemTypeMap , er nøglen "Drue" ikke kortlagt med værdien "Grøntsag".

Som et resultat vil nedenstående handling ikke føre til nogen opdateringer:

foodItemTypeMap.remove("Grape", "Vegetable");
// Current Map Status: {Potato=Vegetable, Carrot=Vegetable, Grape=Fruit, Mango=Fruit, Spinach=Vegetable}

Lad os nu udforske andre scenarier for fjernelse af indtastninger i et HashMap .

3. Fjernelse af en post under gentagelse

HashMap klasse er usynkroniseret . Hvis vi forsøger at tilføje eller slette en post samtidigt, kan det resultere i ConcurrentModificationException . Derfor skal visynkronisere fjern drift eksternt .

3.1. Synkronisering på eksternt objekt

En tilgang er at synkronisere på et objekt, der indkapsler HashMap . For eksempel kan vi bruge entrySet() metoden for java.util.Map  interface for at hente et Set af poster i et HashMap . Det returnerede sæt understøttes af det tilknyttede Kort.

Altså enhver strukturel ændring af sættet ville resultere i en opdatering af kortet såvel.

Lad os fjerne en post fra foodItemTypeMap ved at bruge denne tilgang:

Iterator<Entry<String, String>> iterator = foodItemTypeMap.entrySet().iterator();
while (iterator.hasNext()) {
    if (iterator.next().getKey().equals("Carrot"))
        iterator.remove();
}

Strukturelle ændringer på kortet understøttes muligvis ikke, medmindre vi bruger iteratorens egne metoder til en opdatering. Som vi kan se i ovenstående uddrag, kalder vi remove() metode på iteratorobjektet i stedet for kortet. Dette giver en trådsikker fjernelsesoperation.

Vi kan opnå det samme resultat i Java 8 eller nyere ved at bruge removeIf operation :

foodItemTypeMap.entrySet()
  .removeIf(entry -> entry.getKey().equals("Grape"));

3.2. Brug af ConcurrentHashMap

java.util.concurrent.ConcurrentHashMap klasse leverer trådsikker drift . Iteratorer til ConcurrentHashMap brug kun én tråd ad gangen. Derfor muliggør de deterministisk adfærd for samtidige operationer.

Vi kan angive antallet af samtidige trådoperationer, der er tilladt ved hjælp af ConcurrencyLevel .

Lad os bruge den grundlæggende fjern  metode til at fjerne poster i et ConcurrentHashMap :

ConcurrentHashMap<String, String> foodItemTypeConcMap = new ConcurrentHashMap<>();
foodItemTypeConcMap.put("Apple", "Fruit");
foodItemTypeConcMap.put("Carrot", "Vegetable");
foodItemTypeConcMap.put("Potato", "Vegetable");

for (Entry<String, String> item : foodItemTypeConcMap.entrySet()) {
    if (item.getKey() != null && item.getKey().equals("Potato")) {
        foodItemTypeConcMap.remove(item.getKey());
    }
}

4. Konklusion

Vi har undersøgt forskellige scenarier for fjernelse af indtastninger i et Java HashMap . Hvis det ikke gentages, kan vi bruge standardmetoderne til fjernelse af indtastninger, der leveres af java.util.Map  interface sikkert.

I tilfælde af at vi opdaterer kortet under iteration er det bydende nødvendigt at bruge fjern metoder på et indkapslende objekt. Derudover analyserede vi en alternativ klasse, ConcurrentHashMap , der muliggør trådsikre opdateringsoperationer på Kort .


Java tag