How to return multiple objects from a Java method?

java

functions

best-practices

collections

byNikita Barsukov·Jan 26, 2025

In Java, you can return multiple objects from a method by using a Pair or Tuple class. For a simpler and more concise solution, you can wrap the objects into a custom class with relevant attributes. Here is an illustrative example:

class TwoObjects {
    Object first, second;
   
    // Two penguins waddle into the bar. 🐧🐧 They walk out as bundled objects!
    TwoObjects(Object a, Object b) { first = a; second = b; } 
}

TwoObjects bundleTwoObjects() {
    // Let's mix it up! One blue object, one red object.
    return new TwoObjects(new Object(), new Object()); 
}

An encapsulating custom class represents an efficient and organized way to bundle and return multiple objects from a method.

Deep dive into returning multiples

1. Bundle objects with elegance: Custom classes

Create a custom class with named attributes to encapsulate multiple objects. This strategy provides more structure and readability:

class PersonInfo {
    String name;
    int age;
    Address address;
    
    // We just learned his name, age, and don't forget his address!
    PersonInfo(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }
}

2. Using Lists and Maps: When order matters

Returning List<Object> or Map<String, Object> is useful when the number of objects to be returned is dynamic:

List<Object> collectObjects() {
    // It's like shopping at a supermarket, throw everything in the cart.
    return Arrays.asList(object1, object2, object3); 
}

Map<String, Object> mapObjects() {
    Map<String, Object> objectsMap = new HashMap<>();
    // Keys are tags, and objects are values. It's like a giant wardrobe!
    objectsMap.put("Key1", object1);
    objectsMap.put("Key2", object2);
    return objectsMap;
}

3. Pairs and Tuples: When simplicity matters

Pair and Tuple classes offer an easy, quick solution for returning two or more objects:

import org.apache.commons.lang3.tuple.Pair;

Pair<String, Integer> getNameAndAge() {
    // Boom! Pair soup is ready. 🍲
    return Pair.of("Alice", 30); 
}

4. Arrays: Old but gold

Arrays, an oldie but goodie, are a straightforward way to return multiple objects:

Object[] arrayReturn() {
    // One array to hold them all
    return new Object[] {object1, object2}; 
}

Navigating complexities and nuances

1. Custom structuring: Beyond basic pairs

For more complex structures or when dealing with related objects, consider creating custom container classes:

class EmployeeProfile {
    PersonInfo personInfo;
    JobDetails jobDetails;
    ContactInfo contactInfo;

    // Bundle these three like a happy little family.
}

2. Ensure type safety and usability

While Object arrays and Tuple classes are handy, they may compromise type safety. Always cast carefully when retrieving elements, or use generics:

Pair<Integer, String> getPair() {
    // Don't mix up integers and strings. It would be int-olerable! 😆
    return Pair.of(1, "one"); // Generics in action! 
}

3. Performance and maintainability: Choose wisely

Your chosen approach should consider the performance impact and maintainability of your code. Strive for balanced code that is self-explanatory and easy to maintain.

Exploring alternative strategies

1. Custom containers: Using structured data

Define custom containers when your data is structured or related. This not only improves readability but offers a focused API:

class UserData {
    User user;
    Preferences preferences;
    Statistics statistics;
    
    // It's like a user's personal locker, storing all their data! 🗃️
}