[Kilde] Java java.util.AbstractMap.SimpleImmutableEntry for detaljer

Bruken av tupler i Java

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

/**
     * En oppføring som opprettholder en uforanderlig nøkkel og verdi.  Denne klassen
     * støtter ikke metode <tt>setValue</tt>.  Denne klassen kan være
     * praktisk i metoder som returnerer trådsikre øyeblikksbilder av
     * nøkkel-verdi-kartlegginger.
     *
     * @since 1.6
     */
    offentlig statisk klasse SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        privat statisk endelig lang serieVersjonUID = 7138329143949025153L;

        privat siste K-nøkkel;
        privat sluttverdi V;

        /**
         * Oppretter en oppføring som representerer en avbildning fra den angitte
         * nøkkel til den angitte verdien.
         *
         * @param nøkkelen nøkkelen representert av denne oppføringen
         * @param verdien verdien representert av denne oppføringen
         */
        public SimpleImmutableEntry(K-nøkkel, V-verdi) {
            this.key = nøkkel;
            this.value = value;
        }

        /**
         * Oppretter en oppføring som representerer samme avbildning som
         * spesifisert oppføring.
         *
         * @param legg inn oppføringen for å kopiere
         */
        offentlig SimpleImmutableEntry(Entry<? utvider K, ? utvider V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Returnerer nøkkelen som tilsvarer denne oppføringen.
         *
         * @return nøkkelen som tilsvarer denne oppføringen
         */
        public K getKey() {
            return-nøkkel;
        }

        /**
         * Returnerer verdien som tilsvarer denne oppføringen.
         *
         * @return verdien som tilsvarer denne oppføringen
         */
        public V getValue() {
            returverdi;
        }

        /**
         * Erstatter verdien som tilsvarer denne oppføringen med den spesifiserte
         * verdi (valgfri operasjon).  Denne implementeringen kaster bare
         * <tt>UnsupportedOperationException</tt>, slik denne klassen implementerer
         * en <i>uforanderlig</i> kartoppføring.
         *
         * @param verdi ny verdi som skal lagres i denne oppføringen
         * @return (Kommer ikke tilbake)
         * @throws UnsupportedOperationException alltid
         */
        offentlig V setVerdi(V-verdi) {
            kast ny UnsupportedOperationException();
        }

        /**
         * Sammenligner det angitte objektet med denne oppføringen for likhet.
         * Returnerer {@codesann} hvis det gitte objektet også er en kartoppføring og
         * de to oppføringene representerer samme avbildning.  Mer formelt, to
         * oppføringene {@code e1} og {@code e2} representerer samme avbildning
         *hvis<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().equals(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().equals(e2.getValue()))</pre>
         * Dette sikrer at {@code lik}-metoden fungerer riktig på tvers av
         * ulike implementasjoner av {@code Map.Entry}-grensesnittet.
         *
         * @param o objekt som skal sammenlignes for likhet med denne kartoppføringen
         * @return {@code sann} hvis det spesifiserte objektet er lik denne avbildningen
         *inntreden
         * @see #hashCode
         */
        offentlig boolsk equals(Objekt o) {
            hvis (!( o instans av Map.Entry))
                returner falsk;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) && eq(value, e.getValue());
        }

        /**
         * Returnerer hashkodens verdi for denne kartoppføringen.  Hashkoden
         * av en kartoppføring {@code e} defineres som: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Dette sikrer at {@code e1.likes(e2)} innebærer at
         * {@code e1.hashCode()==e2.hashCode()} for to oppføringer
         * {@code e1} og {@code e2}, slik det kreves av generalen
         * kontrakt av {@linkObjekt#hashkode}.
         *
         * @return hashkoden for denne kartoppføringen
         * @see #equals
         */
        public int hashCode() {
            return (nøkkel == null ? 0 : key.hashCode()) ^
                   (verdi == null ? 0 : verdi.hashkode());
        }

        /**
         * Returnerer en strengrepresentasjon av denne kartoppføringen.  Denne
         * implementasjonen returnerer strengrepresentasjonen av dette
         * Inngangsnøkkelen etterfulgt av likhetstegnet ("<tt>=</tt>")
         * etterfulgt av strengrepresentasjonen av denne oppføringens verdi.
         *
         * @return en strengrepresentasjon av denne kartoppføringen
         */
        offentlig String toString() {
            return-nøkkel + "=" + verdi;
        }

    }