JAVA Returning an object or pass by reference

Question

Here a beginners question.

Is there any difference in JAVA between passing an object as argument to a method or returning that object from the method. For instance: Is it better to pass a List as an argument and fill it in the method or just allow the method to return a list?

My guess is that it should be no difference since a reference is returned and nothing is copied. But is there something more subtle behind?

thanks in advance

Altober

Answer 1

Many of the comments seem to have misunderstood what you mean.

I believe you're asking the difference between

public void myMethod(List list) {
    list.add(new Object());
}

and

public List myMethod() {
    List list = new ArrayList();
    list.add(new Object());
    return list;
}

Correct me if I'm wrong.

There is no rule to say which one is right. It all depends on how you wish to design your program. The latter method won't allow you to use existing Lists, so there may be performance issues to be considered.

You can also perform method chaining when returning values from a method, so sometimes you could take both a parameter and returning a value. A variation from this is a method that will use an existing List if it is passed as a parameter, but create a new List if the parameter is null. However this can be confusing to the caller.

Answer 2

First, there is no "pass by reference" in Java: the language is passing references by value (it is not the same thing).

The answer to your question is "it depends": passing an object as an argument to a method lets you reuse the same object in multiple invocations, while returning an object forces the method to supply a new or an existing object to the caller.

Consider this example: you are collecting data from several methods, and you need to put all the data in one list. You can have methods returning lists with their data

interface DataSource {
    void supplyData(List<Data> list);
}

or you could pass these methods a list, and have them add their data to the same list:

interface DataSource {
    List<Data> supplyData(); 
}

In the first case, you could loop through multiple data sources, passing them the same list:

List<Data> bigList = new ArrayList<Data>();
foreach (DataSource s : mySources) {
    s.supplyData(bigList);
}

In the second case, you would need to get individual lists from the calls of supplyData, and put their content in a big list that you keep in your loop:

List<Data> bigList = new ArrayList<Data>();
foreach (DataSource s : mySources) {
    List<Data> tmp = s.supplyData();
    bigList.addAll(tmp);
}

In the second case each invocation creates a temporary list tmp that gets discarded after its content is added to the big list.

Note that passing an existing list is not necessarily a better solution - in fact, there are situations when you should avoid that.

For example, when you deal with externally supplied plug-ins, you should prefer the second strategy. Otherwise, a malicious implementation of the DataSource interface would be able to manipulate the common list in ways not expected by your program, such as adding its items ahead of everyone else's, removing items that came from other sources, examining items from other sources, and so on.

Answer 3

In addition to the answer from dasblinkenlight, which is correct (it depends), returning a list from the method also has advantages over passing a list as argument.

By passing a list as argument, the caller has the responsibility to choose the appropriate List implementation, to initialize it to the appropriate size, and to pass a list that is compatible with the algorithm of the called method. Often, the caller doesn't have the knowledge that is necessary to make the good choice.

Whereas if the called method returns a list, it can:

• return Collections.emptyList() if nothing has to be returned
• return a well-dimensioned ArrayList
• return a subList or an unmodifable view or transformed view of a list it already has in memory, instead of making a copy
• do anything with the list it creates without fearing that the list passed as argument is unmodifiable, or fixed-size, or already contains elements.

Answer 4

No difference, both are references to list object. Personally I prefer that results are given by return and leave the arguments. But that might force you to create a new list, and that might cost you (performance, memory).

Returning allows for chaining.

Answer 5

As you are probably aware, everything in Java is pass-by-value.

Is there any difference in JAVA between passing an object as argument to a method or returning that object from the method?

No real difference as it is the reference that is being passed around in both cases.

Is it better to pass a List as an argument and fill it in the method or just allow the method to return a list?

Depends on your requirements I guess. Does the method require a list as input or can it construct it entirely by itself?

My guess is that it should be no difference since a reference is returned and nothing is copied?

Strictly speaking, this is not true as a copy of the reference is returned.