How to return a pair of objects in one method?

Question

What are (1) the common practice and (2) possible solutions for returning a pair of objects in one method in java?

Example: Let's say I have a CheckersBoard class in Model that has a method f that takes BoardFieldIndex start, BoardFieldIndex end describing a movement asked by a View and returns a pair of Figure f (if start is occupied) and MovementVector v (if it is legal on the board).

In C++ I have two popular options:

(I.)

Figure *f; MovementVector *v;
board.f( start, end, f, v );

(II.)

Figure *f; MovementVector *v;
std::Pair<Figure*, MovementVector*> tuple = board.f( start, end );
f = tuple.first; v = tuple.second;

In Java the only solutions I can think of are:

1. Using a List as a substitute for Tuple. But the problem is I do not define types there and using a raw List I think is discouraged.
2. Implement custom generic class Pair.

I would like to know what is the best practice or how can I do it in a way that feels natural for Java. I personally like (I.) best, but it's impossible here. The problem I have with other solutions is that I access the elements of a tuple in a way that doesn't suggest what they contain and I think it goes a bit against literate programming paradigm.

Answer 1

You could define an inner container for the two Objects that implements Map.Entry<Figure,MovementVector>, then use getKey() to get the Figure Object and getValue() to get the MovementVector. For example:

private class MyEntryClass<K,V> implements Map.Entry<K,V> {
    private final K key;
    private V value;

    public MyEntryClass(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() {
        return key;
    }

    public V getValue() {
        return value;
    }

    public V setValue(V value) {
        V old = this.value;
        this.value = value;
        return old;
    }
}

Then (assuming f is your Figure and v is your MovementVector) you could just return new MyEntryClass<Figure,MovementVector>(f,v);

EDIT: made class parameters generic for the sake of extensibility/generalizability

Answer 2

You are only permitted to return one thing, you may not return multiple objects unless they are stored within an array and you return the actual array instead.

It is better to simple store the objects in a List<T> and simply return that List in the method. From that you may directly retrieve any element you want within that array.

I also realised you mentions pair of objects. If you wish to store and retrieve objects in a specific structure you may create (as Max suggested) a custom DTO class and simply returning that.

Answer 3

Common-Lang from Apache already defines a Pair type for your convenience, if you want to use it. The tuple subpackage also defines a lot of useful containers as well.

That said, I'd say that a situation like this would call for an object to encapsulate the two of those values together; if you need to return both of them, then using a wrapper with more meaning than Pair<Figure, MovementVector> may be better for you in the long run.

Answer 4

There are at least 4 basic options I can think of:

1. Return a List<Object> or an Object[].

2. Return a Pair or Tuple class from a non-core library. Public methods should probably not do this as the getters have meaningless names.

3. Create your own custom type and return that. This is often the best solution.

4. Allow one of the method parameters to be mutable. For example if you want to return 3 doubles and a String, you can make one of the method parameters double[] arr. Then the method can assign values to arr[0], arr[1] and arr[2] and return a String. This is a bit clumsy but can be useful at times.

Answer 5

if you're returning two different types, I'd definitely not recommend using a List, for the type reason you mention yourself. My suggestion would be creating a result/response type such as

Tuple<Figure,Movement>

or reuse Map.Entry.

Also, read this question and answers.

Cheers,