[Sursă] Java java.util.AbstractMap.SimpleImmutableEntry pentru detalii

Utilizarea tuplelor în Java

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

/**
     * O Intrare care menține o cheie și o valoare imuabile.  Această clasă
     * nu suportă <tt>metoda setValue</tt>.  Această clasă poate fi
     * convenabil în metode care returnează instantanee sigure la thread ale lui
     * mapări cheie-valoare.
     *
     * @since 1.6
     */
    clasa statică publică SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        static privat final long serialVersionUID = 7138329143949025153L;

        cheia finală K privată;
        valoarea finală V privată;

        /**
         * Creează o intrare care reprezintă o mapare din specificatul
         * cheia valorii specificate.
         *
         * @param cheia reprezentată de această intrare
         * @param valoarea reprezentată de această intrare
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = cheie;
            this.value = value;
        }

        /**
         * Creează o intrare care reprezintă aceeași aplicație ca și
         * intrare specificată.
         *
         * @param înscrierea pentru a copia
         */
        public SimpleImmutableEntry(Entry<? extinde K, ? extinde V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Returnează cheia corespunzătoare acestei intrări.
         *
         * @return cheia corespunzătoare acestei intrări
         */
        public K getKey() {
            tasta de return;
        }

        /**
         * Returnează valoarea corespunzătoare acestei intrări.
         *
         * @return valoarea corespunzătoare acestei intrări
         */
        public V getValue() {
            returnează valoare;
        }

        /**
         * Înlocuiește valoarea corespunzătoare acestei intrări cu cea specificată
         * valoare (operațiune opțională).  Această implementare pur și simplu aruncă
         * <tt>UnsupportedOperationException</tt>, așa cum implementează această clasă
         * o intrare <i>imuabilă</i> pe hartă.
         *
         * @param valoare nouă care trebuie stocată în această intrare
         * @return (Nu revine)
         * @throws UnsupportedOperationException întotdeauna
         */
        public V setValue(V value) {
            aruncă un nou UnsupportedOperationException();
        }

        /**
         * Compară obiectul specificat cu această intrare pentru egalitate.
         * returnează {@codeadevărat} dacă obiectul dat este și o intrare pe hartă și
         * cele două intrări reprezintă aceeași aplicație.  Mai formal, două
         * intrările {@code e1} și {@code e2} reprezintă aceeași mapare
         *dacă<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().egal(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().egal(e2.getValue()))</pre>
         * Acest lucru asigură că metoda {@code egală} funcționează corect între
         * implementări diferite ale interfeței {@code Map.Entry}.
         *
         * @param o obiect de comparat pentru egalitate cu această intrare pe aplicație
         * @return {@code adevărat} dacă obiectul specificat este egal cu această aplicație
         *intrare
         * @see #hashCode
         */
        public boolean egal cu Object o) {
            dacă (!( o instanță a Map.Entry))
                returnează false;
            Hart.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) & & eq(value, e.getValue());
        }

        /**
         * Returnează valoarea codului hash pentru această intrare pe hartă.  Codul hash
         * dintr-o intrare pe hartă {@code e} este definit astfel: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Aceasta asigură că {@code e1.egal(e2)} implică că
         * {@code e1.hashCode()==e2.hashCode()} pentru orice două Intrări
         * {@code e1} și {@code e2}, conform cerințelor generalului
         * contract al lui {@linkObiect#hashCode}.
         *
         * @return valoarea codului hash pentru această intrare pe hartă
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

        /**
         * Returnează o reprezentare String a acestei intrări pe hartă.  Acest
         * implementarea returnează reprezentarea șirurilor a acestei
         * cheia de intrare urmată de caracterul egal ("<tt>=</tt>")
         * urmată de reprezentarea șirului valorii acestei însemnări.
         *
         * @return o reprezentare String a acestei intrări pe hartă
         */
        public String toString() {
            tasta return + "=" + valoare;
        }

    }