[Fuente] Java java.util.AbstractMap.SimpleImmutableEntry para detalles

El uso de tuplas en Java

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

/**
     * Una Entrada que mantiene una clave y un valor inmutables.  Esta clase
     * no soporta el método <tt>setValue</tt>.  Esta clase puede ser
     * convenientes en métodos que devuelven instantáneas seguras en hilos de
     * mapeos clave-valor.
     *
     * @since 1.6
     */
    clase pública estática SimpleImmutableEntry<K,V>
        implements Entry<K,V>, java.io.Serializable
    {
        estático privado final long serialVersionUID = 7138329143949025153L;

        llave privada final de K;
        valor final privado de V;

        /**
         * Crea una entrada que representa una correspondencia a partir de la especificada
         * clave para el valor especificado.
         *
         * @param clave la clave representada por esta entrada
         * @param valor el valor representado por esta entrada
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = clave;
            this.value = value;
        }

        /**
         * Crea una entrada que representa la misma aplicación que la
         * entrada especificada.
         *
         * @param entrada la entrada para copiar
         */
        publica SimpleImmutableEntry(Entry<? extiende K, ? extiende V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Devuelve la clave correspondiente a esta entrada.
         *
         * @return la clave correspondiente a esta entrada
         */
        public K getKey() {
            tecla de retorno;
        }

        /**
         * Devuelve el valor correspondiente a esta entrada.
         *
         * @return el valor correspondiente a esta entrada
         */
        public V getValue() {
            return value;
        }

        /**
         * Sustituye el valor correspondiente a esta entrada por el especificado
         * valor (operación opcional).  Esta implementación simplemente lanza
         * <tt>UnsupportedOperationException</tt>, tal como implementa esta clase
         * una entrada <i>inmutable</i> en el mapa.
         *
         * @param valor nuevo que se almacenará en esta entrada
         * @return (No regresa)
         * @throws UnsupportedOperationException siempre
         */
        public V setValue(V value) {
            lanzar un nuevo UnsupportedOperationException();
        }

        /**
         * Compara el objeto especificado con esta entrada para igualdad.
         * Retorna {@codetrue} si el objeto dado es también una entrada de mapa y
         * las dos entradas representan el mismo mapeo.  Más formalmente, dos
         * las entradas {@code e1} y {@code e2} representan la misma correspondencia
         *si<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().igual(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().igual(e2.getValue()))</pre>
         * Esto asegura que el método {@code es igual a} funciona correctamente entre
         * diferentes implementaciones de la interfaz {@code Map.Entry}.
         *
         * @param o objeto a comparar para igualdad con esta entrada de mapa
         * @return {@code verdadero} si el objeto especificado es igual a esta aplicación
         *entrada
         * @see #hashCode
         */
        booleano público es igual a (Objeto o) {
            si (!( o instancia de Map.Entry))
                return false;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) & & eq(value, e.getValue());
        }

        /**
         * Devuelve el valor del código hash para esta entrada del mapa.  El código hash
         * de una entrada de mapa {@code e} se define como: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Esto asegura que {@code e1.iguales a (e2)} implica que
         * {@code e1.hashCode()==e2.hashCode()} para cualquier par de entradas
         * {@code e1} y {@code e2}, según lo requiera el general
         * contrato de {@linkObjeto#hashCode}.
         *
         * @return el valor del código hash para esta entrada del mapa
         * @see #equals
         */
        public int hashCode() {
            return (clave == null ? 0 : clave.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

        /**
         * Devuelve una representación de cadena de esta entrada del mapa.  Éste
         * implementación devuelve la representación de cadenas de esta
         * la clave de entrada seguida del carácter de igual ("<tt>=</tt>")
         * seguido de la representación de la cadena del valor de esta entrada.
         *
         * @return una representación de cadena de esta entrada de mapa
         */
        public String toString() {
            tecla return + "=" + valor;
        }

    }