Java Top

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE

1. Overview

In this tutorial, we'll learn different ways to return multiple values from a Java method.

First, we'll return arrays and collections. Then, we'll show how to use container classes for complex data. And finally, we'll learn how to create generic tuple classes.

2. Using Arrays

Arrays can be used to return both primitive and reference data types.

For example, the following getCoordinates method returns an array of two double values:

double[] getCoordinatesDoubleArray() {
  
    double[] coordinates = new double[2];

    coordinates[0] = 10;
    coordinates[1] = 12.5;
  
    return coordinates;
}

If we want to return an array of different reference types, we can use a common parent type as the array's type:

Number[] getCoordinatesNumberArray() {
  
    Number[] coordinates = new Number[2];

    coordinates[0] = 10;   // Integer
    coordinates[1] = 12.5; // Double
  
    return coordinates;
}

Here we've defined the coordinates array of type Number because it's the common class between Integer and Double elements.

3. Using Collections

With generic Java collections, we can return multiple values of a common type.

The collections framework has a wide spectrum of classes and interfaces. However, in this section, we'll limit our discussion to the List and Map interfaces.

3.1. Returning Values of Similar Type in a List

To start with, let's rewrite the previous array example using List<Number>:

List<Number> getCoordinatesList() {
  
    List<Number> coordinates = new ArrayList<>();
  
    coordinates.add(10);  // Integer
    coordinates.add(12.5);  // Double
  
    return coordinates;
}

Like Number[], the List<Number> collection holds a sequence of mixed-type elements all of the same common type.

3.2. Returning Named Values in a Map

If we'd like to name each entry in our collection, a Map can be used instead:

Map<String, Number> getCoordinatesMap() {
  
    Map<String, Number> coordinates = new HashMap<>();
  
    coordinates.put("longitude", 10);
    coordinates.put("latitude", 12.5);
  
    return coordinates;
}

Users of the getCoordinatesMap method can use the “longitude” or “latitude” keys with the Map#get method to retrieve the corresponding value.

4. Using Container Classes

Unlike arrays and collections, container classes (POJOs) can wrap multiple fields with different data types.

For instance, the following Coordinates class has two different data types, double and String:

public class Coordinates {
  
    private double longitude;
    private double latitude;
    private String placeName;
  
    public Coordinates(double longitude, double latitude, String placeName) {
  
        this.longitude = longitude;
        this.latitude = latitude;
        this.placeName = placeName;
    }
  
    // getters and setters
}

Using container classes like Coordinates enables us to model complex data types with meaningful names.

The next step is to instantiate and return an instance of Coordinates:

Coordinates getCoordinates() {
  
    double longitude = 10;
    double latitude = 12.5;
    String placeName = "home";
  
    return new Coordinates(longitude, latitude, placeName);
}

We should note that it's recommended that we make data classes like Coordinates immutable. By doing so, we create simple, thread-safe, sharable objects.

5. Using Tuples

Like containers, tuples store fields of different types. However, they differ in that they are not application-specific.

They are specialized when we use them to describe which types we want them to handle, but are general purpose container of a certain number of values. This means we do not need to write custom code to have them, and we can use a library, or create a common single implementation.

A tuple can be of any number of fields and is often called Tuplen, where n is the number of fields. For example, Tuple2 is a two-field tuple, Tuple3 is a three-field tuple, and so on.

To demonstrate the importance of tuples, let's consider the following example. Suppose that we want to find the distance between a Coordinates point and all other points inside a List<Coordinates>. Then, we need to return that most distant Coordinate object, along with the distance.

Let's first create a generic two-fields tuple:

public class Tuple2<K, V> {

    private K first;
    private V second;
  
    public Tuple2(K first, V second){
        this.first = first;
        this.second = second;
    }

    // getters and setters
}

Next, let's implement our logic and use a Tuple2<Coordinates, Double> instance to wrap the results:

Tuple2<Coordinates, Double> getMostDistantPoint(List<Coordinates> coordinatesList, 
                                                       Coordinates target) {

    return coordinatesList.stream()
      .map(coor -> new Tuple2<>(coor, coor.calculateDistance(target)))
      .max((d1, d2) -> Double.compare(d1.getSecond(), d2.getSecond())) // compare distances
      .get();
}

Using Tuple2<Coordinates, Double> in the previous example has saved us from creating a separate container class for one-time use with this particular method.

Like containers, tuples should be immutable. Additionally, due to their general-purpose nature, we should use tuples internally rather than as part of our public API.

6. Conclusion

In this article, we've learned how to use arrays, collections, containers, and tuples to return multiple values from a method. We can use arrays and collections in simple cases since they wrap a single data type.

On the other hand, containers and tuples are useful in creating complex types, with containers offering better readability.

As usual, the source code for this article is available over on GitHub.

Java bottom

I just announced the new Learn Spring course, focused on the fundamentals of Spring 5 and Spring Boot 2:

>> CHECK OUT THE COURSE

2
Leave a Reply

avatar
1 Comment threads
1 Thread replies
0 Followers
 
Most reacted comment
Hottest comment thread
2 Comment authors
Loredana CrusoveanuPavlo Sidelov Recent comment authors
  Subscribe  
newest oldest most voted
Notify of
Pavlo Sidelov
Guest

Great article! Long term looking into this problem, thank you for the clarification!

Loredana Crusoveanu
Guest

Hi Pavlo,

Thanks for the feedback; happy to help.

Cheers.