[Bron] Java java.util.AbstractMap.SimpleImmutableEntry voor details

Het gebruik van tupels in Java

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

/**
     * Een Entry die een onveranderlijke sleutel en waarde behoudt.  Deze klasse
     * ondersteunt methode <tt>setValue</tt> niet.  Deze klasse kan zijn
     * handig in methoden die thread-veilige snapshots van
     * sleutelwaarde-mappingen.
     *
     * @since 1.6
     */
    publieke statische klasse SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        privé statische definitieve lange serieVersieUID = 7138329143949025153L;

        privé eind-K-sleutel;
        private eindwaarde V;

        /**
         * Maakt een invoer aan die een mapping vertegenwoordigt vanuit de gespecificeerde
         * sleutel tot de opgegeven waarde.
         *
         * @param sleutel de sleutel die door deze vermelding wordt weergegeven
         * @param de waarde die door deze vermelding wordt weergegeven waardeerd
         */
        publiek SimpleImmutableEntry(K key, V value) {
            this.key = sleutel;
            this.value = value;
        }

        /**
         * Maakt een entry aan die dezelfde mapping vertegenwoordigt als de
         * gespecificeerde invoer.
         *
         * @param invoer de invoer om te kopiëren
         */
        publieke SimpleImmutableEntry(Entry<? extends K, ? extends V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Geeft de sleutel terug die bij deze invoer hoort.
         *
         * @return de sleutel die bij deze invoer hoort
         */
        public K getKey() {
            retoursleutel;
        }

        /**
         * Geeft de waarde terug die bij deze vermelding hoort.
         *
         * @return de waarde die overeenkomt met deze invoer
         */
        public V getValue() {
            retourwaarde;
        }

        /**
         * Vervangt de waarde die overeenkomt met deze invoer door de gespecificeerde
         * waarde (optionele bewerking).  Deze implementatie gooit simpelweg
         * <tt>UnsupportedOperationException</tt>, zoals deze klasse implementeert
         * een <i>onveranderlijke</i> kaartinvoer.
         *
         * @param waarde nieuwe waarde die in deze vermelding wordt opgeslagen
         * @return (Komt niet terug)
         * @throws UnsupportedOperationException altijd
         */
        publieke V setWaarde(V-waarde) {
            gooi nieuwe UnsupportedOperationException();
        }

        /**
         * Vergelijkt het gespecificeerde object met deze invoer voor gelijkheid.
         * Retourneert {@codewaar} als het gegeven object ook een afbeeldingsinvoer is en
         * de twee vermeldingen vertegenwoordigen dezelfde mapping.  Meer formele, twee
         * elementen {@code e1} en {@code e2} vertegenwoordigen dezelfde afbeelding
         *als<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().gelijk aan (e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().equals(e2.getValue()))</pre>
         * Dit zorgt ervoor dat de {@code gelijk}-methode correct werkt over
         * verschillende implementaties van de {@code Map.Entry}-interface.
         *
         * @param o object dat vergeleken moet worden voor gelijkheid met deze afbeeldingsinvoer
         * @return {@code waar} als het gespecificeerde object gelijk is aan deze afbeelding
         *ingang
         * @see #hashCode
         */
        publieke booleaanse equals(Object o) {
            als (!( o instantie van Map.Entry))
                return false;
            Kaart.Invoer<?,?> e = (Kaart.Invoer<?,?>)o;
            return eq(key, e.getKey()) && eq(value, e.getValue());
        }

        /**
         * Geeft de hashcodewaarde terug voor deze map-invoer.  De hashcode
         * van een afbeeldingsinvoer {@code e} wordt gedefinieerd als: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Dit zorgt ervoor dat {@code e1.gelijk aan (e2)} impliceert dat
         * {@code e1.hashCode()==e2.hashCode()} voor twee willekeurige Entries
         * {@code e1} en {@code e2}, zoals vereist door de generaal
         * contract van {@linkObject#hashCode}.
         *
         * @return de hashcodewaarde voor deze kaartvermelding
         * @see #equals
         */
        publieke int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (waarde == null ? 0 : waarde.hashCode());
        }

        /**
         * Geeft een stringrepresentatie van deze kaartinvoer terug.  Dit
         * implementatie geeft de stringrepresentatie hiervan terug
         * Invoersleutel gevolgd door het gelijke teken ("<tt>=</tt>")
         * gevolgd door de stringrepresentatie van de waarde van deze invoer.
         *
         * @return een stringrepresentatie van deze kaartvermelding
         */
        publieke String toString() {
            return key + "=" + waarde;
        }

    }