[Quelle] Java java.util.AbstractMap.SimpleImmutableEntry für Details

Die Verwendung von Tupeln in Java

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

/**
     * Ein Eintrag, der einen unveränderlichen Schlüssel und Wert beibehält.  Diese Klasse
     * unterstützt die Methode <tt>setValue</tt> nicht.  Diese Klasse kann sein:
     * praktisch in Methoden, die threadsichere Schnappschüsse von
     * Schlüssel-Wert-Abbildungen.
     *
     * @since 1.6
     */
    öffentliche statische Klasse SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        private statische Final-LangserienVersionUID = 7138329143949025153L;

        privater Endschlüssel K;
        privater Endwert V;

        /**
         * Erstellt einen Eintrag, der eine Abbildung aus der angegebenen Karte darstellt
         * Schlüssel zum angegebenen Wert.
         *
         * @param Schlüssel den Schlüssel, der durch diesen Eintrag dargestellt wird
         * @param Wert den durch diesen Eintrag dargestellten Wert
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = Schlüssel;
            this.value = value;
        }

        /**
         * Erstellt einen Eintrag, der dieselbe Abbildung wie die
         * angegebener Eintrag.
         *
         * @param den Eintrag zum Kopieren eintragen
         */
        public SimpleImmutableEntry(Entry<? erweitert K, ? erweitert V> Eintrag) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Gibt den Schlüssel zurück, der diesem Eintrag entspricht.
         *
         * @return der Schlüssel, der diesem Eintrag entspricht
         */
        public K getKey() {
            Rückgabeschlüssel;
        }

        /**
         * Gibt den Wert zurück, der diesem Eintrag entspricht.
         *
         * @return den Wert, der diesem Eintrag entspricht
         */
        public V getValue() {
            Rückgabewert;
        }

        /**
         * Ersetzt den Wert, der diesem Eintrag entspricht, durch den angegebenen
         * Wert (optionale Operation).  Diese Implementierung wirft einfach
         * <tt>UnsupportedOperationException</tt>, wie diese Klasse implementiert wird
         * ein <i>unveränderlicher</i> Karteneintrag.
         *
         * @param Wert neuer Wert in diesem Eintrag zu speichern
         * @return (Kehrt nicht zurück)
         * @throws UnsupportedOperationException immer
         */
        public V setValue(V value) {
            neue UnsupportedOperationException() werfen;
        }

        /**
         * Vergleicht das angegebene Objekt mit diesem Eintrag zur Gleichheit.
         * Returns {@codetrue}, wenn das gegebene Objekt ebenfalls ein Abbildungseintrag ist und
         * die beiden Einträge stellen dieselbe Abbildung dar.  Formeller gesagt, zwei
         * Einträge {@code e1} und {@code e2} repräsentieren dieselbe Abbildung
         *wenn<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().equals(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().equals(e2.getValue()))</pre>
         * Dies stellt sicher, dass die {@code gleich}-Methode korrekt über die gesamte Methode funktioniert
         * verschiedene Implementierungen der {@code Map.Entry}-Schnittstelle.
         *
         * @param o Objekt, das für Gleichheit mit diesem Karteneintrag verglichen werden soll, um Gleichheit zu gewährleisten
         * @return {@code true}, wenn das spezifizierte Objekt gleich dieser Abbildung ist
         *Eintrag
         * @see #hashCode
         */
        öffentliche boolesche gleich(Objekt o) {
            wenn (!( o Instanz von Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) && eq(value, e.getValue());
        }

        /**
         * Gibt den Hashcode-Wert für diesen Karteneintrag zurück.  Der Hashcode
         * eines Abbildungseintrags {@code e} ist definiert als: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Dies stellt sicher, dass {@code e1.gleich(e2)} impliziert, dass
         * {@code e1.hashCode()==e2.hashCode()} für beliebige zwei Einträge
         * {@code e1} und {@code e2}, wie vom General gefordert
         * Vertrag von {@linkObjekt#hashCode}.
         *
         * @return den Hashcode-Wert für diesen Karteneintrag
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (Wert == null ? 0 : value.hashCode());
        }

        /**
         * Gibt eine String-Darstellung dieses Karteneintrags zurück.  Das
         * Implementierung gibt die String-Darstellung dieser zurück
         * Eingabeschlüssel gefolgt vom Gleichzeichen-Zeichen ("<tt>=</tt>")
         * gefolgt von der Zeichenkettendarstellung des Wertes dieses Eintrags.
         *
         * @return eine String-Darstellung dieses Karteneintrags
         */
        public String toString() {
            Rückgabetaste + "=" + Wert;
        }

    }