如何从Java方法返回2个值？

我想从Java方法返回2个值，但我得到这些错误。 这是我的代码：

// Method code public static int something(){ int number1 = 1; int number2 = 2; return number1, number2; } // Main method code public static void main(String[] args) { something(); System.out.println(number1 + number2); } 

错误：

 Exception in thread "main" java.lang.RuntimeException: Uncompilable source code - missing return statement at assignment.Main.something(Main.java:86) at assignment.Main.main(Main.java:53) 

Java结果：1

Answer 1

不要返回一个包含两个值的数组，或者使用一个普通的Pair类，考虑创build一个代表你想要返回的结果的类，然后返回该类的一个实例。 给class级一个有意义的名字。 这种方法比使用数组的好处是types安全，它会使程序更容易理解。

注意：在这里的一些其他答案中提出的通用Pair类也给了types安全性，但是不能传达结果代表什么。

示例（不使用真正有意义的名称）：

 final class MyResult { private final int first; private final int second; public MyResult(int first, int second) { this.first = first; this.second = second; } public int getFirst() { return first; } public int getSecond() { return second; } } // ... public static MyResult something() { int number1 = 1; int number2 = 2; return new MyResult(number1, number2); } public static void main(String[] args) { MyResult result = something(); System.out.println(result.getFirst() + result.getSecond()); } 

Answer 2

Java不支持多值返回。 返回值的数组。

 // Function code public static int[] something(){ int number1 = 1; int number2 = 2; return new int[] {number1, number2}; } // Main class code public static void main(String[] args) { int result[] = something(); System.out.println(result[0] + result[1]); } 

Answer 3

如果您确定只需要返回两个值，则可以实现一个通用Pair ：

 public class Pair<U, V> { /** * The first element of this <code>Pair</code> */ private U first; /** * The second element of this <code>Pair</code> */ private V second; /** * Constructs a new <code>Pair</code> with the given values. * * @param first the first element * @param second the second element */ public Pair(U first, V second) { this.first = first; this.second = second; } //getter for first and second 

然后让方法返回Pair ：

 public Pair<Object, Object> getSomePair(); 

Answer 4

你只能用Java返回一个值，所以最简单的方法是这样的：

 return new Pair<Integer>(number1, number2); 

以下是您的代码的更新版本：

 public class Scratch { // Function code public static Pair<Integer> something() { int number1 = 1; int number2 = 2; return new Pair<Integer>(number1, number2); } // Main class code public static void main(String[] args) { Pair<Integer> pair = something(); System.out.println(pair.first() + pair.second()); } } class Pair<T> { private final T m_first; private final T m_second; public Pair(T first, T second) { m_first = first; m_second = second; } public T first() { return m_first; } public T second() { return m_second; } } 

Answer 5

尝试这个 ：

 // Function code public static int[] something(){ int number1 = 1; int number2 = 2; return new int[] {number1, number2}; } // Main class code public static void main(String[] args) { int[] ret = something(); System.out.println(ret[0] + ret[1]); } 

Answer 6

你必须使用集合来返回更多的返回值

在你的情况下，你写你的代码

 public static List something(){ List<Integer> list = new ArrayList<Integer>(); int number1 = 1; int number2 = 2; list.add(number1); list.add(number2); return list; } // Main class code public static void main(String[] args) { something(); List<Integer> numList = something(); } 

Answer 7

使用Pair / Tupletypes的对象，如果你依赖Apache commons-lang，你甚至不需要创build它。 只需使用Pair类。

Answer 8

 public class Mulretun { public String name;; public String location; public String[] getExample() { String ar[] = new String[2]; ar[0]="siva"; ar[1]="dallas"; return ar; //returning two values at once } public static void main(String[] args) { Mulretun m=new Mulretun(); String ar[] =m.getExample(); int i; for(i=0;i<ar.length;i++) System.out.println("return values are: " + ar[i]); } } o/p: return values are: siva return values are: dallas 

Answer 9

你不需要创build自己的类来返回两个不同的值。 只需使用这样的HashMap：

 private HashMap<Toy, GameLevel> getToyAndLevelOfSpatial(Spatial spatial) { Toy toyWithSpatial = firstValue; GameLevel levelToyFound = secondValue; HashMap<Toy,GameLevel> hm=new HashMap<>(); hm.put(toyWithSpatial, levelToyFound); return hm; } private void findStuff() { HashMap<Toy, GameLevel> hm = getToyAndLevelOfSpatial(spatial); Toy firstValue = hm.keySet().iterator().next(); GameLevel secondValue = hm.get(firstValue); } 

你甚至有types安全的好处。

Answer 10

在我看来最好的是创build一个新的类，构造函数是你需要的function，例如：

 public class pairReturn{ //name your parameters: public int sth1; public double sth2; public pairReturn(int param){ //place the code of your function, eg: sth1=param*5; sth2=param*10; } } 

然后就像使用函数一样简单地使用构造函数：

 pairReturn pR = new pairReturn(15); 

你可以使用pR.sth1，pR.sth2作为“2个函数的结果”

Answer 11

您也可以发送可变对象作为参数，如果您使用方法来修改它们，那么当您从函数返回时，它们将被修改。 它不会像Float那样工作，因为它是不可变的。

 public class HelloWorld{ public static void main(String []args){ HelloWorld world = new HelloWorld(); world.run(); } private class Dog { private String name; public void setName(String s) { name = s; } public String getName() { return name;} public Dog(String name) { setName(name); } } public void run() { Dog newDog = new Dog("John"); nameThatDog(newDog); System.out.println(newDog.getName()); } public void nameThatDog(Dog dog) { dog.setName("Rutger"); } } 

结果是：Rutger

Answer 12

返回一个对象数组

 private static Object[] f () { double x =1.0; int y= 2 ; return new Object[]{Double.valueOf(x),Integer.valueOf(y)}; } 

Answer 13

我很好奇为什么没有人提出更优雅的callback解决scheme。 因此，不要使用返回types，而是使用传递给方法的处理程序作为参数。 下面的例子有两个对比的方法。 我知道哪一个对我更优雅。 🙂

 public class DiceExample { public interface Pair<T1, T2> { T1 getLeft(); T2 getRight(); } private Pair<Integer, Integer> rollDiceWithReturnType() { double dice1 = (Math.random() * 6); double dice2 = (Math.random() * 6); return new Pair<Integer, Integer>() { @Override public Integer getLeft() { return (int) Math.ceil(dice1); } @Override public Integer getRight() { return (int) Math.ceil(dice2); } }; } @FunctionalInterface public interface ResultHandler { void handleDice(int ceil, int ceil2); } private void rollDiceWithResultHandler(ResultHandler resultHandler) { double dice1 = (Math.random() * 6); double dice2 = (Math.random() * 6); resultHandler.handleDice((int) Math.ceil(dice1), (int) Math.ceil(dice2)); } public static void main(String[] args) { DiceExample object = new DiceExample(); Pair<Integer, Integer> result = object.rollDiceWithReturnType(); System.out.println("Dice 1: " + result.getLeft()); System.out.println("Dice 2: " + result.getRight()); object.rollDiceWithResultHandler((dice1, dice2) -> { System.out.println("Dice 1: " + dice1); System.out.println("Dice 2: " + dice2); }); } } 

Answer 14

有很多种方法可以做到这一点，但经过试验，我发现这个解决scheme非常简单。 我将粘贴滚动2个骰子的代码并返回两个结果，然后我会解释。

源代码：

 import java.lang.Math; import java.util.*; public class DiceRolling { private static String roll2Dice(double dice1, double dice2) { String methodSatisfier = ""; dice1 = (Math.random()*6); dice2 = (Math.random()*6); if (dice1 < 1) { dice1 = Math.ceil(dice1); } if (dice2 < 1) { dice2 = Math.ceil(dice2); } System.out.printf("First die: %.0f\nSecond die: %.0f", dice1, dice2); return methodSatisfier; } public static void main(String[] args) { DiceRolling object = new DiceRolling(); System.out.println(object.roll2Dice(0, 0)); 

解释：

发现声明一个简单的静态双重方法后，我发现你可以使用一个string值来终止没有编译器错误的方法，同时也给你你想要的结果。 这样，你可以传递两个double值（你的骰子值）到静态String方法，并允许它返回你的两个掷骰子（双打）在一个string，而不是两个单独的双打。 在最后一行代码中调用方法时，我将两个0作为parameter passing，以便骰子可以均匀地滚动，并且，因为该方法需要两个双重参数。 如果您有任何疑问，我可以进一步满足任何有关上述代码和解释的查询。