[Forrás] Java java.util.AbstractMap.SimpleImmutableEntry részletekért

A tuple-ok használata Jáván

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

/**
     * Egy bejegyzés, amely megváltozhatatlan kulcsot és értéket tart fenn.  Ez az osztály
     * nem támogatja <tt>a setValue</tt> metódot.  Ez az osztály lehet
     * kényelmes olyan metódusokban, amelyek szálbiztonsági pillanatképeket adnak vissza
     * kulcsérték-leképezések.
     *
     * @since 1.6
     */
    public static class SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        private statikus végső hosszú sorozatVersionUID = 7138329143949025153L;

        privát végső K billentyű;
        magán végső V érték;

        /**
         * Egy bejegyzést hoz létre, amely egy leképezést jelöl a megadott
         * kulcs a megadott értékhez.
         *
         * @param a kulcsot, amelyet ez a bejegyzés képvisel
         * @param az ebben az értékben szereplő értéket
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = kulcs;
            this.value = érték;
        }

        /**
         * Létrehoz egy bejegyzést, amely ugyanazt a leképezést képviseli, mint a
         * meghatározott bejegyzés.
         *
         * @param belépni a bejegyzés a másoláshoz
         */
        public SimpleImmutableEntry(Entry<? extend K, ? extend V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Visszaadja a kulcsot, amely ehhez a bejegyzéshez tartozik.
         *
         * @return a kulcs, amely ehhez a bejegyzéshez tartozik
         */
        public K getKey() {
            visszacsatolási kulcs;
        }

        /**
         * Visszaadja ennek a bejegyzésnek megfelelő értéket.
         *
         * @return ennek a bejegyzésnek megfelelő értéket
         */
        public V getValue() {
            megtérülési érték;
        }

        /**
         * A bejegyzéshez tartozó értéket a megadott értékre cseréli
         * érték (opcionális művelet).  Ez a megvalósítás egyszerűen dobja
         * <tt>UnsupportedOperationException</tt>, ahogy ez az osztály megvalósítja
         * egy <i>megváltoztathatatlan</i> térképbejegyzés.
         *
         * @param érték, új érték, amelyet ebben a bejegyzésben tárolunk
         * @return (Nem tér vissza)
         * @throws UnsupportedOperationException mindig
         */
        public V setValue(V value) {
            dobjuk az új UnsupportedOperationException();
        }

        /**
         * Összehasonlítja a megadott objektumot ezzel a bejegyzéssel az egyenlőség érdekében.
         * Visszatérítések {@codetrue}, ha az adott objektum egyben egy térkép bejegyzés is, és
         * a két bejegyzés ugyanazt a leképezést képviseli.  Formálisabban: két
         * A {@code e1} és {@code e2} bejegyzések ugyanazt a leképezést képviselik.
         *ha<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().equals(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().equals(e2.getValue()))</pre>
         * Ez biztosítja, hogy a {@code equals} módszer megfelelően működjön a különböző területeken
         * a {@code Map.Entry} különböző megvalósításai.
         *
         * @param olyan objektum, amelyet összehasonlítani egyenlő céljából ezzel a térképbejegyzéssel
         * @return {@code true}, ha a megadott objektum egyenlő ezzel a leképezéssel
         *bejegyzés
         * @see #hashCode
         */
        public boolean equals(Object o) {
            ha (!( o instanceof Map.Entry))
                hamis;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) && eq(value, e.getValue());
        }

        /**
         * Visszaadja ennek a térképbejegyzésnek a hash kód értékét.  A hash kód
         * egy térképbejegyzés {@code e} definiálva definiálható: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Ez biztosítja, hogy {@code e1.equals(e2)} azt jelenti, hogy
         * {@code e1.hashCode()==e2.hashCode()} bármely két bejegyzéshez
         * {@code e1} és {@code e2}, ahogy az általános előírások szerint
         * { szerződése@linkObject#hashCode}.
         *
         * @return ennek a térképbejegyzésnek a hash kód értékét
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (érték == null ? 0 : érték.hashCode());
        }

        /**
         * Adja vissza a String reprezentációt ehhez a térképbejegyzéshez.  Ez
         * a megvalósítás adja vissza ennek a string reprezentációját
         * a bejegyzés kulcsa, majd az egyenlő karakter ("<tt>=</tt>")
         * ezt követi a bejegyzés értékének string reprezentációja.
         *
         * @return a térkép bejegyzés string reprezentációja
         */
        public String toString() {
            return kulcs + "=" + érték;
        }

    }