Como Devolver múltiples valores de un método en Java

5 minuto(s)

En esta página:

En Java a veces necesitamos obtener múltiples valores de un método, en este Post vamos aprender a obtener valores en arrays y colecciones, luego aprenderemos a usar clases de contenedor para datos complejos, también aprenderemos a crear clases de tuplas genéricas y a usar librerías para devolver múltiples valores.

Antes de continuar con este Post te invito a escuchar el Podcast: “5 Consejos para ser un Programador más Productivo” (No son los clásicos consejos técnicos de programación, si no de rutinas y buenos hábitos cotidianos):

Spotify:

Sound Cloud:

Bien ahora continuemos con el Post: Como Devolver múltiples valores de un método en Java.

Veamos a continuación las maneras en que podemos devolver múltiples tipos de datos.

Mediante Colecciones

A través de colecciones genéricas de Java, podemos retornar múltiples valores de un tipo común. Cuando hacemos uso de colecciones contamos con un amplio espectro de clases e interfaces a nuestra disposición, pero me limitaré a hablar sobre las interfaces Map y List.

Devolución de valores con nombre en un mapa

Si deseamos nombrar cada entrada de nuestra colección, podemos usar un Map.


Map<String, Number> obtenerCoordenadas() {
   
    Map<String, Number> coordenadas = new HashMap<>();
   
    coordenadas.put("lng", 34);
    coordenadas.put("lat", 73.7);
   
    return coordenadas; 
}

Map<String, Number> obtenerCoordenadas() {

Map<String, Number> coordenadas = new HashMap<>();

coordenadas.put("lng", 34);

coordenadas.put("lat", 73.7);

return coordenadas;

}

En el código anterior, se puede usar las keys lng o lat con el método Map#get para recuperar el valor que corresponde.

Valores devueltos de tipo similar en una List

Podemos reescribir el ejemplo de Arrays que tocamos en el siguiente punto, usando List<Number>


List<Number> obtenerCoordenadasList() {
   
    List<Number> coordenadas = new ArrayList<>();
   
    coordenadas.add(34);  // Integer
    coordenadas.add(73.7);  // Double
   
    return coordenadas;
}

List<Number> obtenerCoordenadasList() {

List<Number> coordenadas = new ArrayList<>();

coordenadas.add(34); // Integer

coordenadas.add(73.7); // Double

return coordenadas;

}

Similar que Number[], la colección List<Number> contiene una secuencia de elementos de tipo mixto, todos del mismo tipo común.

Mediante Arrays

Por medio de los arrays se pueden devolver tipos de datos primitivos y de referencia, por ejemplo en el siguiente código, el método obtenerCoordenadasDobleArray devuelve un array de 2 valores dobles.


double[] obtenerCoordenadasDobleArray() {
   
    double[] coordenadas = new double[2];
 
    coordenadas[0] = 34;
    coordenadas[1] = 73.7;
   
    return coordenadas;
}

double[] obtenerCoordenadasDobleArray() {

double[] coordenadas = new double[2];

coordenadas[0] = 34;

coordenadas[1] = 73.7;

return coordenadas;

}

Si deseamos devolver un array de diferentes tipos de referencia, podemos hacer uso de un tipo padre común como tipo de array:


Number[] obtenerCoordenadasDobleArray() {
   
    Number[] coordenadas = new Number[2];
 
    coordenadas[0] = 34;   // Integer
    coordenadas[1] = 73.7; // Double
   
    return coordenadas;
}

Number[] obtenerCoordenadasDobleArray() {

Number[] coordenadas = new Number[2];

coordenadas[0] = 34; // Integer

coordenadas[1] = 73.7; // Double

return coordenadas;

}

Puedes ver que he definido el array de coordinadas como tipo Number (Número) porque es la clase común entre elementos enteros y dobles.

Clases de Contenedores (Container Classes)

A diferencia de las colecciones y arrays, las clases de contenedores (POJO), pueden ajustar múltiples campos con diferentes tipos de datos, por ejemplo en el siguiente código, la clase Coordenadas tiene 2 tipos de datos diferentes, Double y String.


public class Coordenadas {
   
    private double lng; // Longitud 
    private double lat; // Latitud
    private String nombre; // Nombre 
   
    public Coordenadas(double lng, double lat, String nombre) {
   
        this.lng = lng;
        this.lat = lat;
        this.nombre = nombre;
    }
   
    // Resto del código 
}

public class Coordenadas {

private double lng; // Longitud

private double lat; // Latitud

private String nombre; // Nombre

public Coordenadas(double lng, double lat, String nombre) {

this.lng = lng;

this.lat = lat;

this.nombre = nombre;

}

// Resto del código

}

Hacer uso de clases de contenedor como Coordenadas nos permite modelar tipos de datos complejos con nombres importantes.

Luego debemos crear instancias y devolver una instancia de la clase Coordenadas:


Coordenadas obtenerCoordenadas() {
   
    double lng = 34;
    double lat = 73.7;
    String nombre = "Supermercado";
   
    return new Coordenadas(lng, lat, nombre);
}

Coordenadas obtenerCoordenadas() {

double lng = 34;

double lat = 73.7;

String nombre = "Supermercado";

return new Coordenadas(lng, lat, nombre);

}

Es recomendable hacer que las clases de datos como Coordenadas sean inmutables, al hacer esto, creamos objetos simples, seguros para subprocesos que pueden ser compartibles (Que pueden ser compartidos).

Mediante Tuplas

Las tuplas almacenan campos de diferentes tipo, sin embargo, difieren en que no son específicos de la aplicación. Son usadas para describir que tipos queremos que maneje, pero son contenedores de propósito general de un cierto número de valores, esto quiere decir que no necesitamos escribir código personalizado para tenerlos y podemos usar una librería o crear una implementación única común.

Para ver la importancia de las tuplas, veamos el siguiente ejemplo, imaginemos que queremos encontrar la distancia entre un punto de coordenadas y todos los demás puntos dentro de una List<Coordenadas>. Luego necesitamos devolver el objeto Coordenada mas distante, junto con la distancia.

Creamos un tupla genérica de dos campos:


public class Tupla<K, V> {
 
    private K primero;
    private V segundo;
   
    public Tupla(K primero, V segundo){
        this.primero = primero;
        this.segundo = segundo;
    }
 
    // Resto del código 
}

public class Tupla<K, V> {

private K primero;

private V segundo;

public Tupla(K primero, V segundo){

this.primero = primero;

this.segundo = segundo;

}

// Resto del código

}

Ahora implementemos nuestra lógica y usemos una instancia Tupla<Coordenadas, Double> para ajustar los resultados:


Tuple2<Coordenadas, Double> obtenerPuntoMasDistante(List<Coordenadas> listaCoordenadas, 
                                                       Coordenadas target) {
 
    return listaCoordenadas.stream()
      .map(coor -> new Tupla<>(coor, coor.calcularDistancia(target)))
      .max((d1, d2) -> Double.compare(d1.obtenerSegundo(), d2.obtenerSegundo())) // Comparar distancias 
      .get();
}

Tuple2<Coordenadas, Double> obtenerPuntoMasDistante(List<Coordenadas> listaCoordenadas,

Coordenadas target) {

return listaCoordenadas.stream()

.map(coor -> new Tupla<>(coor, coor.calcularDistancia(target)))

.max((d1, d2) -> Double.compare(d1.obtenerSegundo(), d2.obtenerSegundo())) // Comparar distancias

.get();

}

El uso de Tupla<Coordenadas, Doble> en el código anterior nos ha librado de crear una clase de contenedor separada para usarla una sola vez con este método en particular.

Al igual que los contenedores de clases, las tuplas deben ser inmutables, además debido a su naturaleza de propósito general, debemos usar tuplas internamente y no como parte de nuestra API pública.

Mediante Librerías

Ciertas librerías han implementado un tipo de par o triple inmutable, javatuples y Apache Commons Lang son ejemplos de ello. Una vez que tenemos instaladas esas bibliotecas en nuestra aplicación, podemos usar directamente los tipos Par o Triple proporcionados por las bibliotecas en lugar de crearlas manualmente.


<!-- Archivo pom.xml --> 
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.9</version>
</dependency>

<groupId>org.apache.commons</groupId>

<artifactId>commons-lang3</artifactId>

</dependency>

A continuación veamos unos ejemplos usando Apache Commons Lang para devolver un objeto Par o Triple.

ImmutablePair de Apache Commons Lang

Este tipo ImmutablePair de Apache Commons Lang es exactamente lo que buscamos, un tipo inmutable cuyo uso es sencillo.

Contiene 2 campos izquierdo y derecho, veamos como hacer para que nuestro método obtenerPuntoMasDistante retorne un objeto del tipo ImmutablePair:


ImmutablePair<Coordenadas, Double> obtenerPuntoMasDistante(
  List<Coordenadas> listaCoordenadas, Coordenadas target) {
    return listaCoordenadas.stream()
      .map(coordenadas -> ImmutablePair.of(coordenadas, coordenadas.calcularDistancia(target)))
      .max(Comparator.comparingDouble(Pair::getRight))
      .get();
}

ImmutablePair<Coordenadas, Double> obtenerPuntoMasDistante(

List<Coordenadas> listaCoordenadas, Coordenadas target) {

return listaCoordenadas.stream()

.map(coordenadas -> ImmutablePair.of(coordenadas, coordenadas.calcularDistancia(target)))

.max(Comparator.comparingDouble(Pair::getRight))

.get();

}

ImmutableTriple de Apache Commons Lang

Este es similar al ImmutablePair, la única diferencia es como su nombre lo indica, un ImmutableTriple contiene 3 campos: izquierdo, medio y derecho.

Agreguemos un nuevo método a nuestro cálculo de coordenadas para mostrar cómo usar el tipo ImmutableTriple. Vamos a pasar por todos los puntos en una List<Coordenadas> para averiguar el promedio mínimo (min) y la distancia máxima (max) a un punto dado.

Ahora devolvemos los tres valores con un solo método utilizando la clase ImmutableTriple:


ImmutableTriple<Double, Double, Double> obtenerMinPromedioMaxTriple(
  List<Coordenadas> listaCoordenadas, Coordenadas target) {
    List<Double> listaDistancia = listaCoordenadas.stream()
      .map(coordenadas -> coordenadas.calcularDistancia(target))
      .collect(Collectors.toList());
    Double distanciaMinima = listaDistancia.stream().mapToDouble(Double::doubleValue).min().getAsDouble();
    Double distanciaPromedio = listaDistancia.stream().mapToDouble(Double::doubleValue).average().orElse(0.0D);
    Double distanciaMaxima = listaDistancia.stream().mapToDouble(Double::doubleValue).max().getAsDouble();
 
    return ImmutableTriple.of(distanciaMinima, distanciaPromedio, distanciaMaxima);
}

ImmutableTriple<Double, Double, Double> obtenerMinPromedioMaxTriple(

List<Coordenadas> listaCoordenadas, Coordenadas target) {

List<Double> listaDistancia = listaCoordenadas.stream()

.map(coordenadas -> coordenadas.calcularDistancia(target))

.collect(Collectors.toList());

Double distanciaMinima = listaDistancia.stream().mapToDouble(Double::doubleValue).min().getAsDouble();

Double distanciaPromedio = listaDistancia.stream().mapToDouble(Double::doubleValue).average().orElse(0.0D);

Double distanciaMaxima = listaDistancia.stream().mapToDouble(Double::doubleValue).max().getAsDouble();

return ImmutableTriple.of(distanciaMinima, distanciaPromedio, distanciaMaxima);

}

Conclusión

En este Post hemos aprendido a usar los las colecciones, arrays, contenedores de clases, tuplas y la librería Apache Commons Lang para devolver múltiples valores o datos de un método.

Se puede hacer uso de arrays y colecciones en casos simples, ya que envuelven un solo tipo de datos. Si pones en prácticas lo expuesto en este Post, lograrás dominarlos.

Nota(s)

Algunos enlaces, conceptos y códigos expuestos en este Post, pueden cambiar, quedar obsoletos o continuar, esto no depende de mi, sino de los Desarrolladores que dan soporte a Java y la librería Apache Commons Lang.
No olvides que debemos usar la Tecnología para hacer cosas Buenas por el Mundo.

Síguenos en nuestras Redes Sociales para que no te pierdas nuestros próximos contenidos.