Best practice for a Java method returning multiple values?

Question

I need a non-static instance method to return multiple values. For the sake of a simple example let's say these are boolean success and Object obj - but in the general case there could be more and they could be unrelated to each other. Can think of a few different ways of doing this:

Solution 1

private boolean aMethod(int aParam, Object obj) { ...set obj parameter & return value... }

Solution 2

private Pair<Boolean, Object> aMethod(int aParam) { ...set return pair values... }

Solution 3

private Object obj;
...
private boolean aMethod(int aParam) { ...set obj field & return value... }

Solution 4

private class MethodReturn { // Nested class - could be a separate class instead
    boolean success;
    Object obj;
    // ... Getters and setters omitted for brevity
}

private MethodReturn aMethod(int aParam) { ...set return object values... }

Are there any more possibilities I might have missed? And could anyone comment as to the pros and cons of each (and ideally, which might be the best to use under most circumstances)?

Answer 1

In general I'd go for the 4th or for a Map depending by the specific case, but if you need to return multiple unrelated values, I think that you have a serious design issue (Check https://en.wikipedia.org/wiki/Single_responsibility_principle)

In the specific case (after your comment), I'd definitely go with the 4th modeling the Response with all the required fields. Possibly you can also subtype with a ResponseSuccessful and ResponseFailure.

Answer 2

Solution 5 — a callback

With a callback, you can even return multiple 2-tuples:

private void aMethod(int aParam, BiConsumer<Boolean, String> callback) {
    …
    callback.accept(success1, msg1);
    …
    callback.accept(success2, msg2);
    …
}

Usage:

aMethod(42, (success, msg) -> {
    if (!success) {
        log.error(msg);
    }
});

Also, you can return an (n>2)-tuple by composition, without a custom class — e.g. for a 4-tuple:

<A, B, C, D> void aMethod(int aParam, BiFunction<A, B, BiConsumer<C, D>> callback) {
    callback.apply(a, b).accept(c, d);
}

aMethod(42, (a, b) -> (c, d) -> log.debug("" + a + b + c + d));

---

To comment on your solutions:

• Solution 1: it's a bad practice to modify arguments, moreover, String is immutable
• Solution 2: commonly used pattern, a Pair<T,U> or a Tuple2<T,U>
• Solution 3: fragile and discouraged, it has all drawbacks of state-fullness (concurrency, etc.)
• Solution 4: similar to #2, e.g. class MethodReturn implements Pair<Boolean, String> {}

N.B.: The MethodReturn can be an interface you implement on the fly (at the return point), e.g.:

private MethodReturn aMethod(int aParam) {
    …
    return new MethodReturn() {
        @Override
        public Boolean first() { return success; }

        @Override
        public String second() { return msg; }
    };
}

Answer 3

In my programs, if the returned objects are logically related by something, they may need to have their own class: a boolean and a String may be a MessageStatus (edit: i see this is your 4th solution).
To give you a concrete example:

public class TurnToken {
/**
 * Number of available Quick Actions
 */
private int quickActionTimes;
/**
 * Number of available Main Actions
 */
private int mainActionTimes;
[...Etcetera with setters and getters]

This class is only composed by two integers, but it logically represents something which may be considered an entity itself

EDIT: I accidentally cancelled the first part. If your objects are not primitive, but are logically correlated, you may create an interface to collect them:

public interface Adjectivable{
//If they have a commong method even better}

and your method

public List<Adjectivable> myMultiReturningMethod{
    List<Adjectivable> theStuffToReturn = new ArrayList<>();
    Etcetera...
}

Answer 4

Solution 1 won't work, as strings in java are immutable,

Solution 3 you can't always apply, as you holding result in instance, you might nor be able to run your method from that instance as long as you need result.

So that leaves us with solutions 2 and 4 which are very similar. As in both cases you return result wrapped in custom class. If you think Pair is enough for you, i would say, use it, and go with solution number 2.

Answer 5

You may use enum here if results are fixed.

public Enum Status {

     OK("OK"),
     CREATED("Created"),
     ACCEPTED("Accepted"),
     NO_CONTENT("No Content"),
     FORBIDDEN("Forbidden"),
     NOT_FOUND("Not Found");

     private final String reason;

     Status(final String reasonPhrase) {
        this.reason = reasonPhrase;
    }
}

 private Status aMethod(int aParam) {
  ................
  return Status.OK;
 }

Answer 6

Use

Object[] aMethod(){ 

//Create and fill an array of object and return it

}

You can fill as much and different values as you need to caller.