[Source] Java java.util.AbstractMap.SimpleImmutableEntry pour plus de détails

L’utilisation des tuples à Java

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

/**
     * Une Entrée conservant une clé et une valeur immuables.  Cette classe
     * ne prend pas en charge la méthode <tt>setValue</tt>.  Cette classe peut être
     * pratique dans les méthodes qui retournent des instantanés thread-safe de
     * correspondances clé-valeur.
     *
     * @since 1.6
     */
    classe statique publique SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        private static final long serialVersionUID = 7138329143949025153L ;

        clé finale privée ;
        valeur finale privée de V ;

        /**
         * Crée une entrée représentant une correspondance à partir du spécifié
         * clé vers la valeur spécifiée.
         *
         * @param la clé représentée par cette entrée
         * @param valeur la valeur représentée par cette entrée
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = clé ;
            this.value = valeur ;
        }

        /**
         * Crée une entrée représentant la même application que la
         * entrée spécifiée.
         *
         * @param entrée l’entrée à copier
         */
        public SimpleImmutableEntry(Entry< ? étends K, ? étend V> entry) {
            this.key = entry.getKey() ;
            this.value = entry.getValue() ;
        }

        /**
         * Retourne la clé correspondant à cette entrée.
         *
         * @return la clé correspondant à cette entrée
         */
        public K getKey() {
            touche retour ;
        }

        /**
         * Retourne la valeur correspondant à cette entrée.
         *
         * @return la valeur correspondant à cette entrée
         */
        public V getValue() {
            valeur de retour ;
        }

        /**
         * Remplace la valeur correspondant à cette entrée par la spécifiée
         * valeur (opération optionnelle).  Cette implémentation se contente de déstabiliser
         * <tt>UnsupportedOperationException</tt>, telle que cette classe l’implémente
         * <i>une entrée</i> immuable sur la carte.
         *
         * @param valeur nouvelle valeur à stocker dans cette entrée
         * @return (Ne revient pas)
         * @throws UnsupportedOperationException toujours
         */
        public V setValue(V value) {
            lancer un nouveau UnsupportedOperationException() ;
        }

        /**
         * Compare l’objet spécifié avec cette entrée pour l’égalité.
         * retourne {@codevrai} si l’objet donné est aussi une entrée de mappage et
         * les deux entrées représentent la même correspondance.  Plus formellement, deux
         * Les entrées {@code e1} et {@code e2} représentent la même correspondance
         *si<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().égal(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().égal(e2.getValue()))</pre>
         * Cela garantit que la méthode {@code égale} fonctionne correctement à travers
         * différentes implémentations de l’interface {@code Map.Entry}.
         *
         * @param O objet à comparer pour l’égalité avec cette entrée de la carte
         * @return {@code vrai} si l’objet spécifié est égal à cette application
         *entrée
         * @see #hashCode
         */
        public boolean égal à (Objet o) {
            si ( !( ou instance de Map.Entry))
                return false ;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o ;
            return eq(key, e.getKey()) & & eq(value, e.getValue()) ;
        }

        /**
         * Retourne la valeur du code de hachage pour cette entrée de la carte.  Le code de hachage
         * d’une entrée de la carte {@code e} est définie comme : <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Cela garantit que {@code é1.égaux(e2)} implique que
         * {@code e1.hashCode()==e2.hashCode()} pour deux entrées quelconques
         * {@code e1} et {@code e2}, selon l’exigence générale
         * contrat de {@linkObject#hashCode}.
         *
         * @return la valeur du code de hachage pour cette entrée de la carte
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (value == null ? 0 : value.hashCode()) ;
        }

        /**
         * Retourne une représentation String de cette entrée de la carte.  Ceci
         * implémentation retourne la représentation de la chaîne de ce
         * la touche d’entrée suivie du caractère égal (« <tt>=</tt> »)
         * suivi de la représentation de la chaîne de la valeur de cette entrée.
         *
         * @return une représentation de chaîne de cette entrée de la carte
         */
        public String toString() {
            touche retour + « = » + valeur ;
        }

    }