Java - Come creare una nuova voce (chiave, valore)

Mi piacerebbe creare nuovo elemento che in modo simile a Util.Map.Entryche conterrà la struttura key, value.

Il problema è che non posso creare un'istanza Map.Entryperché è un'interfaccia.

Qualcuno sa come creare un nuovo oggetto chiave / valore generico per Map.Entry?

Puoi semplicemente implementare l' Map.Entry<K, V>interfaccia da solo:

import java.util.Map;

final class MyEntry<K, V> implements Map.Entry<K, V> {
    private final K key;
    private V value;

    public MyEntry(K key, V value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public K getKey() {
        return key;
    }

    @Override
    public V getValue() {
        return value;
    }

    @Override
    public V setValue(V value) {
        V old = this.value;
        this.value = value;
        return old;
    }
}

E poi usalo:

Map.Entry<String, Object> entry = new MyEntry<String, Object>("Hello", 123);
System.out.println(entry.getKey());
System.out.println(entry.getValue());

C'è public static class AbstractMap.SimpleEntry<K,V>. Non lasciare che la Abstractparte del nome ti induca in errore: in realtà NON è una abstractclasse (ma il suo livello principale AbstractMapè).

Il fatto che sia una staticclasse nidificata significa che NON è necessaria AbstractMapun'istanza chiusa per istanziarla, quindi qualcosa di simile si compila bene:

Map.Entry<String,Integer> entry =
    new AbstractMap.SimpleEntry<String, Integer>("exmpleString", 42);

Come notato in un'altra risposta, Guava ha anche un comodo staticmetodo di fabbrica Maps.immutableEntryche puoi usare.

Tu hai detto:

Non posso usare Map.Entryse stesso perché apparentemente è un oggetto di sola lettura che non posso creare un'istanza di nuovoinstanceof

Non è del tutto esatto. Il motivo per cui non puoi istanziarlo direttamente (cioè con new) è perché è un interface Map.Entry.

Avvertenza e punta

Come indicato nella documentazione, AbstractMap.SimpleEntryè@since 1.6 , quindi se sei bloccato su 5.0, non è disponibile per te.

Per cercare un'altra classe conosciuta che implements Map.Entry, in effetti, puoi andare direttamente al javadoc. Dalla versione Java 6

Interface Map.Entry

Tutte le classi di esecuzione conosciute :

• AbstractMap.SimpleEntry, AbstractMap.SimpleImmutableEntry

Sfortunatamente la versione 1.5 non elenca nessuna classe di implementazione nota che puoi usare, quindi potresti essere bloccato con l'implementazione della tua.

A partire da Java 9, esiste un nuovo metodo di utilità che consente di creare una voce immutabile che è Map#entry(Object, Object).

Qui c'è un semplice esempio:

Entry<String, String> entry = Map.entry("foo", "bar");

Poiché è immutabile, la chiamata setValuegenererà un UnsupportedOperationException. Le altre limitazioni sono il fatto che non è serializzabile e nullcome chiave o valore è proibito, se non è accettabile per te, dovrai usare AbstractMap.SimpleImmutableEntryo AbstractMap.SimpleEntryinvece.

NB: Se hai bisogno di creare direttamente una Mapcoppia da 0 a un massimo di 10 (chiave, valore), puoi invece usare i metodi di tipo Map.of(K key1, V value1, ...).

Prova Maps.immutableEntry di Guava

Questo ha il vantaggio di essere compatibile con Java 5 (a differenza del AbstractMap.SimpleEntryquale richiede Java 6.)

Esempio di AbstractMap.SimpleEntry:

import java.util.Map; 
import java.util.AbstractMap;
import java.util.AbstractMap.SimpleEntry;

Instantiate:

ArrayList<Map.Entry<Integer, Integer>> arr = 
    new ArrayList<Map.Entry<Integer, Integer>>();

Aggiungi righe:

arr.add(new AbstractMap.SimpleEntry(2, 3));
arr.add(new AbstractMap.SimpleEntry(20, 30));
arr.add(new AbstractMap.SimpleEntry(2, 4));

Recupera righe:

System.out.println(arr.get(0).getKey());
System.out.println(arr.get(0).getValue());
System.out.println(arr.get(1).getKey());
System.out.println(arr.get(1).getValue());
System.out.println(arr.get(2).getKey());
System.out.println(arr.get(2).getValue());

Dovrebbe stampare:

2
3
20
30
2
4

È utile per definire i bordi delle strutture grafiche. Come quelli tra i neuroni nella tua testa.

In realtà potresti andare con: Map.Entry<String, String> en= Maps.immutableEntry(key, value);

Perché Map.Entry ? Immagino che qualcosa come una coppia chiave-valore sia adatto al caso.

Usa java.util.AbstractMap.SimpleImmutableEntryojava.util.AbstractMap.SimpleEntry

org.apache.commons.lang3.tuple.Pairimplementa java.util.Map.Entrye può anche essere usato autonomamente.

Inoltre, come altri hanno già detto, Guava com.google.common.collect.Maps.immutableEntry(K, V)fa il trucco.

Preferisco Pairper la sua Pair.of(L, R)sintassi fluida .

Ho definito una classe Pair generica che utilizzo sempre. È ottimo. Come bonus, definendo un metodo factory statico (Pair.create) devo solo scrivere gli argomenti di tipo la metà delle volte.

public class Pair<A, B> {

    private A component1;
    private B component2;

    public Pair() {
            super();
    }

    public Pair(A component1, B component2) {
            this.component1 = component1;
            this.component2 = component2;
    }

    public A fst() {
            return component1;
    }

    public void setComponent1(A component1) {
            this.component1 = component1;
    }

    public B snd() {
            return component2;
    }

    public void setComponent2(B component2) {
            this.component2 = component2;
    }

    @Override
    public String toString() {
            return "<" + component1 + "," + component2 + ">";
    }

    @Override
    public int hashCode() {
            final int prime = 31;
            int result = 1;
            result = prime * result
                            + ((component1 == null) ? 0 : component1.hashCode());
            result = prime * result
                            + ((component2 == null) ? 0 : component2.hashCode());
            return result;
    }

    @Override
    public boolean equals(Object obj) {
            if (this == obj)
                    return true;
            if (obj == null)
                    return false;
            if (getClass() != obj.getClass())
                    return false;
            final Pair<?, ?> other = (Pair<?, ?>) obj;
            if (component1 == null) {
                    if (other.component1 != null)
                            return false;
            } else if (!component1.equals(other.component1))
                    return false;
            if (component2 == null) {
                    if (other.component2 != null)
                            return false;
            } else if (!component2.equals(other.component2))
                    return false;
            return true;
    }

    public static <A, B> Pair<A, B> create(A component1, B component2) {
            return new Pair<A, B>(component1, component2);
    }

}

Se stai usando Clojure, hai un'altra opzione:

(defn map-entry
  [k v]
  (clojure.lang.MapEntry/create k v))