Return more than one variable from Java method

My first question with these sort of issues is, what's the relationship between these two results ?

If they're unrelated, does that point to your method doing two different things ?

If they're related (they appear to be in this case), then wrap them in a custom object. This gives you the chance to add more results later into this object, and you can attach behaviour to this object.

Your other solution is to pass a callback object into this method, so you don't return anything at all, but rather your method then calls a method on this object e.g.

// do some processing callbackObject.furtherMethod(m, n); 

This has the advantage of following the OO principle of getting objects to do things for you, rather than asking them for info and doing it yourself.

create a separate class and have m and z as variables in that object , create and populate that object and return that object

class result { int m ; int z ; // define getters and setters } public result stringLengthCheck(String pathToFile) { // your code result r = new result(); r.setM(m); r.setZ(z); return r ; } 

how about return a map. eg:

Map<String,Integer> result = new HashMap<String,Integer>(); result.put("ok",m); result.put("fail",z); return result; 

and your method should be changed to:

public Map stringLenghtCheck(String pathToCheckedFile) 

at last, you could get the result by checking out the map:

map.get("ok") map.get("fail") 

You cannot return more than one variable from method. You need to return something else instead. There many suggestions can take place:

1. set these variables in class where your method is, and then access them (outside this class?)
   • plus: simple notation like set and get
   • plus: never mix up your variables
   • minus: some garbage in class
2. return an array or list with variables
   • plus: simplicity of storing
   • plus: possibility to iterate over the data
   • minus: you can easily mix up variables (need convention about variables' places)
   • minus: extra memory allocation - may be sufficient when storing few variables
3. return a wrapper (instance of class that contains needed variables)
   • plus: simplicity of storing and reading
   • plus: never mix up your variables
   • minus: ugly code (possibly) if wrapper is not frequently-used

4. use callback (like void setToArray(int[] array, args...)) - the same +/- that 1-3 points say and

   • plus: memory allocation decrease is possible
   • minus: more ugly method signature

   And some hacks (hacks - not for casual cases!) also can take place:

5. use concatenation. You can join several strings in one by using delimiters, or store two integers in long

   • all possible minuses, no pluses, but funny
6. use InputStream and OutputStream
   • plus: possibility of usage all the code for stream handling (storing/reading to file, for example)
   • minus: no random access to data
7. use Iterator (I placed it under 'hacks' only because in many ways it assumes storing variables like in wrapper)
   • plus: possibility to iterate over the data
   • plus: possibility to avoid extra memory allocation
   • minus: no random access to data
8. store all in String (or byte[]) and parse when needed
   • plus: String can be transmitted anyhow
   • minus: parsing is an expensive procedure

For storing two integers Point and Dimension classes are often used. But for code given I would suggest simple array usage or storing variables in class FileQualityChecker, because m and z don't seem to fit to coordinates or dimensions context.

You could create a custom class or return a list:

return Arrays.asList(m, z); 

(the return type of your method would be List<Integer>)

Or in your case, since m and z are class members, you could return nothing (void) and provide getters to get the values of m and z once the method has returned.

No you can't but it is easy to write a class that would contain those fields:

class StrAndInt { String str; int num; StrAndInt(String str, int num) { this.str = str; this.num = num; } } class MyApplication { .... .... StrAndInt myMethod() { .... .... return new StrAndInt("The value returned", 10); } 

Another option is to not return anything as you have the results in fields you can use other methods to obtain these.

FileQualityChecker fqc = .. fqc.stringLenghtCheck(fileName); int okCount = fqc.getOkCount(); int failedCount = fqc.getFailedCount(); 

I don't think you can return two variables from a method as a method can have only one return type. So IMO you have two options:

1) Create a class with the same type of variables and generate getter-setter for those variables you defined in that class. Now from the method from where you want to return the variables create the object of that class and use setters to set the value of instance variables with the value of variables you want to return return that object.

2) Create an array of those variables and return that array.

1.I hope m and n uses pass by values. 2.Instead use Pass by Reference.To do Pass by Reference in Java, it has to be a Java Object. 3.So create new Integer object m=new Integer();.

You could place both variables in an int[] and extract both values when you call the method.

return new Integer[]{m, z}; 

After calling the method:

Integer[] array = Foo.method(); int m = array[0]; int z = array[1]; 

You could simply construct an object.

However, if you must return more than one variable, you can return an array of similarly typed variables, example below:

public static StringBuilder[] remedySBarrayreturner() { sbbb.append("huhu"); sbcc.append("hihi"); return new StringBuilder[] {sbbb, sbcc}; }