[Fonte] Java java.util.AbstractMap.SimpleImmutableEntry per dettagli

L'uso delle tuple in Giava

https://www.itsvse.com/thread-10055-1-1.html

/**
     * Una voce che mantiene una chiave e un valore immutabili.  Questa classe
     * non supporta il metodo <tt>setValue</tt>.  Questa classe può essere
     * comodi nei metodi che restituiscono istantanee thread-safe di
     * mappature chiave-valore.
     *
     * @since 1.6
     */
    classe statica pubblica SimpleImmutableEntry<K,V>
        implementa Entry<K,V>, java.io.Serializable
    {
        statico privato finale long serialVersionUID = 7138329143949025153L;

        chiave finale K privata;
        valore finale V privato;

        /**
         * Crea una voce che rappresenta una mappatura dal specifico
         * chiave del valore specificato.
         *
         * @param la chiave rappresentata da questa voce
         * @param valore il valore rappresentato da questa voce
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = tonalità;
            this.value = value;
        }

        /**
         * Crea una voce che rappresenta la stessa mappatura del
         * voce specificata.
         *
         * @param voce la voce da copiare
         */
        public SimpleImmutableEntry(Entry<? estende K, ? estende V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Restituisce la chiave corrispondente a questa voce.
         *
         * @return la chiave corrispondente a questa voce
         */
        public K getKey() {
            tasto di ritorno;
        }

        /**
         * Restituisce il valore corrispondente a questa voce.
         *
         * @return il valore corrispondente a questa voce
         */
        public V getValue() {
            valore di ritorno;
        }

        /**
         * Sostituisce il valore corrispondente a questa voce con il specificato
         * valore (operazione opzionale).  Questa implementazione semplicemente getta
         * <tt>UnsupportedOperationException</tt>, come implementa questa classe
         * una voce <i>immutabile</i> sulla mappa.
         *
         * @param valore nuovo valore da memorizzare in questa voce
         * @return (Non ritorna)
         * @throws UnsupportedOperationException sempre
         */
        public V setValue(V value) {
            lancia nuova UnsupportedOperationException();
        }

        /**
         * Confronta l'oggetto specificato con questa voce per l'uguaglianza.
         * Ritorna {@codevero} se l'oggetto dato è anche una voce di mappa e
         * le due voci rappresentano la stessa mappatura.  Più formalmente, due
         * le voci {@code e1} e {@code e2} rappresentano la stessa mappatura
         *se<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().equals(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().uguale(e2.getValue()))</pre>
         * Questo garantisce che il metodo {@code uguale} funzioni correttamente tra le parti
         * diverse implementazioni dell'interfaccia {@code Map.Entry}.
         *
         * @param o oggetto da confrontare per l'uguaglianza con questa voce della mappa
         * @return {@code true} se l'oggetto specificato è uguale a questa mappa
         *entrata
         * @see #hashCode
         */
        public boolean uguale a (Object o) {
            se (!( o istanza di Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) & & eq(value, e.getValue());
        }

        /**
         * Restituisce il valore del codice hash per questa voce della mappa.  Il codice hash
         * di una voce mappa {@code e} è definita come: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Questo garantisce che {@code e1.uguale (e2)} implichi che
         * {@code e1.hashCode()==e2.hashCode()} per due voci qualsiasi
         * {@code e1} e {@code e2}, come richiesto dal generale
         * contratto di {@linkOggetto#hashCode}.
         *
         * @return il valore del codice hash per questa voce della mappa
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

        /**
         * Restituisce una rappresentazione String di questa voce della mappa.  Questo
         * implementazione restituisce la rappresentazione della stringa di questo
         * la chiave di voce seguita dal carattere uguale ("<tt>=</tt>")
         * seguito dalla rappresentazione della stringa del valore di questa voce.
         *
         * @return una rappresentazione di stringa di questa voce della mappa
         */
        public Stringa a Stringa() {
            tasto di ritorno + "=" + valore;
        }

    }