Java >> Java tutorial >  >> Tag >> new

Sådan opretter du en ny post på et kort

1. Oversigt

I denne øvelse vil vi diskutere, hvordan du bruger Javas indbyggede klasser, tredjepartsbiblioteker og vores tilpassede implementering til at oprette en indgang objekt, der repræsenterer en nøgleværditilknytning i et Kort .

2. Brug af indbyggede Java-klasser

Java leverer kortet .Indgang grænseflade med to simple implementeringer for at oprette en indgang . Lad os tage et kig på dem.

2.1. Brug af AbstractMap .SimpleEntry

SimpleEntry klasse er en statisk indlejret klasse i AbstractMap klasse. Det giver to forskellige konstruktører til at initialisere en instans:

AbstractMap.SimpleEntry<String, String> firstEntry = new AbstractMap.SimpleEntry<>("key1", "value1");
AbstractMap.SimpleEntry<String, String> secondEntry = new AbstractMap.SimpleEntry<>("key2", "value2");
AbstractMap.SimpleEntry<String, String> thirdEntry = new AbstractMap.SimpleEntry<>(firstEntry);
thirdEntry.setValue("a different value");

assertThat(Stream.of(firstEntry, secondEntry, thirdEntry))
  .extracting("key", "value")
  .containsExactly(
    tuple("key1", "value1"),
    tuple("key2", "value2"),
    tuple("key1", "a different value"));

Som vi kan se her, accepterer en af ​​konstruktørerne nøglen og værdien, mens den anden accepterer en indtastning forekomst for at initialisere en ny indgang eksempel.

2.2. Brug af AbstractMap .SimpleImmutableEntry

Ligesom med SimpleEntry , kan vi bruge SimpleImmutableEntry for at oprette poster:

AbstractMap.SimpleImmutableEntry<String, String> firstEntry = new AbstractMap.SimpleImmutableEntry<>("key1", "value1");
AbstractMap.SimpleImmutableEntry<String, String> secondEntry = new AbstractMap.SimpleImmutableEntry<>("key2", "value2");
AbstractMap.SimpleImmutableEntry<String, String> thirdEntry = new AbstractMap.SimpleImmutableEntry<>(firstEntry);

assertThat(Stream.of(firstEntry, secondEntry, thirdEntry))
  .extracting("key", "value")
  .containsExactly(
    tuple("key1", "value1"),
    tuple("key2", "value2"),
    tuple("key1", "value1"));

I modsætning til SimpleEntry , SimpleImmutableEntry tillader os ikke at ændre værdien efter initialisering af indtastningen eksempel. Hvis vi forsøger at ændre værdien, kaster den java.lang.UnsupportedOperationException.

2.3. Bruger Kort .indgang

Siden version 9 har Java en statisk metode entry() i kortet grænseflade for at oprette en indgang :

Map.Entry<String, String> entry = Map.entry("key", "value");

assertThat(entry.getKey()).isEqualTo("key");
assertThat(entry.getValue()).isEqualTo("value");

Vi skal huske på, at den indgang, der er oprettet på denne måde, også er uforanderlig og ville føre til en java.lang.UnsupportedOperationException hvis vi forsøger at ændre værdien efter initialiseringen.

3. Tredjepartsbiblioteker

Udover selve Java er der et par populære biblioteker, der giver gode måder at oprette poster på.

3.1. Brug af Apache commons-collections4 Bibliotek

Lad os starte med at inkludere vores Maven-afhængighed først:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-collections4</artifactId>
</dependency>

Vi bør nævne det udover indgangen grænseflade, giver biblioteket også en grænseflade kaldet KeyValue:

Map.Entry<String, String> firstEntry = new DefaultMapEntry<>("key1", "value1");
KeyValue<String, String> secondEntry = new DefaultMapEntry<>("key2", "value2");

KeyValue<String, String> thirdEntry = new DefaultMapEntry<>(firstEntry);
KeyValue<String, String> fourthEntry = new DefaultMapEntry<>(secondEntry);

firstEntry.setValue("a different value");

assertThat(firstEntry)
  .extracting("key", "value")
  .containsExactly("key1", "a different value");

assertThat(Stream.of(secondEntry, thirdEntry, fourthEntry))
  .extracting("key", "value")
  .containsExactly(
    tuple("key2", "value2"),
    tuple("key1", "value1"),
    tuple("key2", "value2"));

DefaultMapEntry klasse giver tre forskellige konstruktører. Mens den første accepterer nøgleværdi-parret, accepterer den anden og den tredje parametertypen Entry  og Nøgleværdi, hhv.

UnmodifiableMapEntry klasse opfører sig også på samme måde:

Map.Entry<String, String> firstEntry = new UnmodifiableMapEntry<>("key1", "value1");
KeyValue<String, String> secondEntry = new UnmodifiableMapEntry<>("key2", "value2");

KeyValue<String, String> thirdEntry = new UnmodifiableMapEntry<>(firstEntry);
KeyValue<String, String> fourthEntry = new UnmodifiableMapEntry<>(secondEntry);

assertThat(firstEntry)
  .extracting("key", "value")
  .containsExactly("key1", "value1");

assertThat(Stream.of(secondEntry, thirdEntry, fourthEntry))
  .extracting("key", "value")
  .containsExactly(
    tuple("key2", "value2"),
    tuple("key1", "value1"),
    tuple("key2", "value2"));

Men som vi kan forstå ud fra navnet, UnmodifiableMapEntry tillader os heller ikke at ændre værdien efter initialiseringen .

3.2. Brug af Google Guava Library

Lad os først inkludere vores Maven-afhængighed:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
 </dependency>

Lad os nu se, hvordan vi kan bruge immutableEntry() metode:

Map.Entry<String, String> firstEntry = Maps.immutableEntry("key1", "value1");
Map.Entry<String, String> secondEntry = Maps.immutableEntry("key2", "value2");

assertThat(Stream.of(firstEntry, secondEntry))
  .extracting("key", "value")
  .containsExactly(
    tuple("key1", "value1"),
    tuple("key2", "value2"));

Da det opretter en uforanderlig post, kaster den java.lang.UnsupportedOperationException, hvis vi forsøger at ændre værdien.

4. Tilpasset implementering

Indtil videre har vi set et par muligheder for at oprette en indgang forekomst for at repræsentere en nøgleværdisammenslutning. Disse klasser er designet på en måde, så de skal overholde den interne logik i kortet grænsefladeimplementeringer såsom HashMap .

Det betyder, at så længe vi overholder det samme, kan vi oprette vores egen implementering af Entry interface. Lad os først tilføje en simpel implementering:

public class SimpleCustomKeyValue<K, V> implements Map.Entry<K, V> {

    private final K key;
    private V value;

    public SimpleCustomKeyValue(K key, V value) {
        this.key = key;
        this.value = value;
    }
    // standard getters and setters
    // standard equals and hashcode
    // standard toString
}

Lad os endelig se et par eksempler på brug:

Map.Entry<String, String> firstEntry = new SimpleCustomKeyValue<>("key1", "value1");

Map.Entry<String, String> secondEntry = new SimpleCustomKeyValue<>("key2", "value2");
secondEntry.setValue("different value");

Map<String, String> map = Map.ofEntries(firstEntry, secondEntry);

assertThat(map)
  .isEqualTo(ImmutableMap.<String, String>builder()
    .put("key1", "value1")
    .put("key2", "different value")
    .build());

5. Konklusion

I denne artikel lærte vi, hvordan vi kunne bruge de eksisterende muligheder, som Java giver, og et par alternativer, som nogle populære tredjepartsbiblioteker tilbyder, til at oprette en indgang eksempel. Derudover oprettede vi også en tilpasset implementering og viste nogle få eksempler på brug.

Som altid er koden til disse eksempler tilgængelig på GitHub.


Java tag