[Fonte] Java java.util.AbstractMap.SimpleImmutableEntry para detalhes

O uso de tuplas em Java

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

/**
     * Uma Entrada que mantém uma chave e valor imutáveis.  Esta classe
     * não suporta método <tt>setValue</tt>.  Essa classe pode ser
     * conveniente em métodos que retornam instantâneos thread-safe de
     * mapeamentos chave-valor.
     *
     * @since 1.6
     */
    classe pública estática SimpleImmutableEntry<K,V>
        implementa Entry<K,V>, java.io.Serializable
    {
        private static final long serialVersionUID = 7138329143949025153L;

        chave final particular K;
        valor final privado V;

        /**
         * Cria uma entrada representando um mapeamento a partir do especificado
         * chave para o valor especificado.
         *
         * @param chave a chave representada por esta entrada
         * @param valor o valor representado por esta entrada
         */
        public SimpleImmutableEntry(K key, V value) {
            this.key = chave;
            this.value = value;
        }

        /**
         * Cria uma entrada que representa o mesmo mapeamento que o
         * entrada especificada.
         *
         * @param entrada a entrada para copiar
         */
        publica SimpleImmutableEntry(Entry<? estende K, ? estende V> entry) {
            this.key = entry.getKey();
            this.value = entry.getValue();
        }

        /**
         * Retorna a chave correspondente a esta entrada.
         *
         * @return a chave correspondente a esta entrada
         */
        public K getKey() {
            tecla de retorno;
        }

        /**
         * Retorna o valor correspondente a esta entrada.
         *
         * @return o valor correspondente a esta entrada
         */
        public V getValue() {
            valor de retorno;
        }

        /**
         * Substitui o valor correspondente a essa entrada pelo especificado
         * valor (operação opcional).  Essa implementação simplesmente joga
         * <tt>UnsupportedOperationException</tt>, conforme esta classe implementa
         * <i>uma entrada</i> imutável no mapa.
         *
         * @param valor novo valor a ser armazenado nesta entrada
         * @return (Não retorna)
         * @throws ExceçãoOperaçãoSem Suporte sempre
         */
        public V setValue(V value) {
            lançar um novo UnsupportedOperationException();
        }

        /**
         * Compara o objeto especificado com esta entrada para igualdade.
         * Retorna {@codetrue} se o objeto dado também for uma entrada de mapa e
         * as duas entradas representam o mesmo mapeamento.  Mais formalmente, dois
         * As entradas {@code e1} e {@code e2} representam o mesmo mapeamento
         *se<pre>
         * (e1.getKey()==null ?
         * e2.getKey()==null :
         * e1.getKey().equals(e2.getKey()))
         *   &&
         * (e1.getValue()==null ?
         * e2.getValue()==null :
         * e1.getValue().equals(e2.getValue()))</pre>
         * Isso garante que o método {@code igual} funcione corretamente entre
         * diferentes implementações da interface {@code Map.Entry}.
         *
         * @param o objeto a ser comparado para igualdade com esta entrada do mapa
         * @return {@code verdadeiro} se o objeto especificado for igual a esse mapa
         *entrada
         * @see #hashCode
         */
        booleano público é igual a (Object o) {
            se (!( ou instância de Map.Entry))
                retorne falso;
            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
            return eq(key, e.getKey()) & eq(value, e.getValue());
        }

        /**
         * Retorna o valor do código hash para esta entrada do mapa.  O código hash
         * de uma entrada de mapa {@code e} é definido como: <pre>
         * (e.getKey()==null ? 0 : e.getKey().hashCode()) ^
         * (e.getValue()==null ? 0 : e.getValue().hashCode())</pre>
         * Isso garante que {@code e1.equals(e2)} implica que
         * {@code e1.hashCode()==e2.hashCode()} para quaisquer duas Entradas
         * {@code e1} e {@code e2}, conforme exigido pelo geral
         * contrato de {@linkObject#hashCode}.
         *
         * @return o valor do código hash para esta entrada do mapa
         * @see #equals
         */
        public int hashCode() {
            return (key == null ? 0 : key.hashCode()) ^
                   (value == null ? 0 : value.hashCode());
        }

        /**
         * Retorna uma representação em String desta entrada do mapa.  Este
         * implementação retorna a representação da cadeia deste
         * a chave de entrada seguida pelo caractere de igual ("<tt>=</tt>")
         * seguido pela representação da string do valor desta entrada.
         *
         * @return uma representação de cadeia desta entrada do mapa
         */
        public String toString() {
            Tecla de retorno + "=" + valor;
        }

    }