Java: How do I implement a method that takes 2 arrays and returns 2 arrays?

Question

Okay, here is what I want to do:

I want to implement a crossover method for arrays.

It is supposed to take 2 arrays of same size and return two new arrays that are a kind of mix of the two input arrays. as in [a,a,a,a] [b,b,b,b] ------> [a,a,b,b] [b,b,a,a].

Now I wonder what would be the suggested way to do that in Java, since I cannot return more than one value.

My ideas are: - returning a Collection(or array) containing both new arrays.

I dont really like that one because it think would result in a harder to understand code. - avoiding the need to return two results by calling the method for each case but only getting one of the results each time.

I dont like that one either, because there would be no natural order about which solution should be returned. This would need to be specified, though resulting in harder to understand code.

Plus, this will work only for this basic case, but I will want to shuffle the array before the crossover and reverse that afterwards. I cannot do the shuffling isolated from the crossover since I wont want to actually do the operation, instead I want to use the information about the permutation while doing the crossover, which will be a more efficient way I think.

My question is not about the algorithm itself, but about the way to put in in a method(concerning input and output) in Java

Answer 1

Following a suggestion from Bruce Eckel's book Thinking in Java, in my Java projects I frequently include some utility classes for wrapping groups of two or three objects. They are trivial and handy, specially for methods that must return several objects. For example:

public class Pair<TA,TB> {
    public final TA a;
    public final TB b;

    /**
     * factory method
     */
    public static <TA,TB> Pair<TA,TB> createPair(TA a,TB b ){
        return new Pair<TA,TB>(a,b);
    }

    /**
     * private constructor - use instead factory method 
     */
    private Pair(final TA a, final TB b) {
            this.a = a;
            this.b = b; 
    }

    public String toString() {  
        return "(" + a + ", " + b + ")";
    }

}

Answer 2

Read the last section of this article:

http://www.yoda.arachsys.com/java/passing.html

To quote:

This is the real reason why pass by reference is used in many cases - it allows a method to effectively have many return values. Java doesn't allow multiple "real" return values, and it doesn't allow pass by reference semantics which would be used in other single-return-value languages. However, here are some techniques to work around this:

1. If any of your return values are status codes that indicate success or failure of the method, eliminate them immediately. Replace them with exception handling that throws an exception if the method does not complete successfully. The exception is a more standard way of handling error conditions, can be more expressive, and eliminates one of your return values.

2. Find related groups of return values, and encapsulate them into objects that contain each piece of information as fields. The classes for these objects can be expanded to encapsulate their behavior later, to further improve the design of the code. Each set of related return values that you encapsulate into an object removes return values from the method by increasing the level of abstraction of the method's interface. For instance, instead of passing co-ordinates X and Y by reference to allow them to be returned, create a mutable Point class, pass an object reference by value, and update the object's values within the method.

As a bonus, this section was updated by Jon Skeet :)

Answer 3

If it is reasonable for the caller to know the size of the returned arrays ahead of time, you could pass them into the method:

     public void foo(Object[] inOne, Object[] inTwo, Object[] outOne, Object[] outTwo) {
            //etc.
     }

That being said, 90+% of the time multiple return values out of a method are hiding a better design. My solution would be to make the transformation inside an object:

     public class ArrayMixer {
           private Object[] one;
           private Object[] two;
           public ArrayMixer(Object[] first, Object[] second) {
                //Mix the arrays in the constructor and assign to one and two.
           }
           public Object[] getOne() { return one; }
           public Object[] getTwo() { return two; }
     }

I suspect that in your real use case that class and array one and array two can get better names.

Answer 4

Since the specification of your method is that it takes two input arrays and produces output arrays, I agree with you that the method should return both arrays at the same time.

I think that the most natural choice of return value is an int[][] of length 2 (substitute int with whatever type you are using). I don't see any reason it should make the code harder to understand, especially if you specify what the contents of the return value will be.

Edit: in response to your comment, I understand that you have considered this and I am saying that despite your stylistic objections, I don't believe there is a strictly "better" alternative ("better" here being loosely defined in the question).

An alternative approach, largely equivalent to this one, would be to define an object that wraps the two arrays. This has the small distinction of being able to refer to them by names rather than array indices.

Answer 5

The best way to do it would be to do

public void doStuff(int[] array1, int[] array2) {
    // Put code here
}

Since Java arrays in Java pass the reference, any modifications made to the arrays will be made to the array itself. This has several caveats

1. If you are setting it to null you must use a different way (such as encapsulating it in an object)
2. If you are initializing the array (in the method), you must use a different way

You would use this in the format:

// other method
int[] array1 = new int[20];  // the arrays can be whatever size
int[] array2 = new int[20];

doStuff(array1,array2);

// do whatever you need to with the arrays

Edit: This makes the assumption that it is okay to make changes to the input arrays.

If it isn't, then an object (such as in leonbloy's answer is definitely what is called for).

Answer 6

You strictly cannot return more then one value (think object or primitive) in Java. Maybe you could return an instance of a specific "Result" object which has the two arrays as properties?

Answer 7

You could pass the output arrays as parameters to the method. This may give you more control over memory allocation for the arrays too.

Answer 8

The cleanest and easiest to understand way would be to create a container bean that contains two arrays, and return the container from the method. I'd probably also pass in the container into the method, to keep it symmetric.

The most memory efficient way, assuming both arrays are the same length, would be to pass a multidimensional array - Object[2][n] - where n is the length of the arrays.

Answer 9

If you're really against the arbitrary ordering that comes from a 2d array or a collection, perhaps consider making an inner class that reflects the logic of what you're doing. You could simply define a class that holds two arrays and you could have your method return that, with names and function that reflect the logic of exactly what you're doing.

Answer 10

A simple solution to the above problem is to return as Map.The trick of this question is how you will define the keys to identify the objects, let say there are two input arrays [a,a,a,a] [b,b,b,b] and two outputs arrays [a,a,b,b] [b,b,a,a]

For that you can use String variable as a key just to identify objects because String variable is immutable, so they can be used as keys. And as example

   Map<String,String[]> method(String[] x,String[] y){

do your stuff..........

   Hashmap<String,String[]> map =new HashMap<String,String[]>();
map.put("Object2",[b,b,a,a]);

return map;
}