Come restituire 2 valori da un metodo Java?

Sto cercando di restituire 2 valori da un metodo Java ma ottengo questi errori. Ecco il mio codice:

// 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); } 

Errore:

 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) 

Risultato Java: 1

Invece di restituire un array che contiene i due valori o utilizzare una class Pair generica, prendere in considerazione la creazione di una class che rappresenta il risultato che si desidera restituire e restituire un’istanza di tale class. Dai alla class un nome significativo. I vantaggi di questo approccio rispetto all’utilizzo di un array sono la sicurezza del tipo e renderà il programma molto più facile da capire.

Nota: una class Pair generica, come proposto in alcune delle altre risposte qui, fornisce anche sicurezza del tipo, ma non comunica ciò che rappresenta il risultato.

Esempio (che non usa nomi veramente significativi):

 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()); } 

Java non supporta i ritorni a più valori. Restituisce una matrice di valori.

 // 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]); } 

Potresti implementare una Pair generica se sei sicuro di dover solo restituire due valori:

 public class Pair { /** * The first element of this Pair */ private U first; /** * The second element of this Pair */ private V second; /** * Constructs a new Pair 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 

e quindi avere il metodo restituire quella Pair :

 public Pair getSomePair(); 

È ansible restituire un solo valore in Java, quindi il modo più accurato è il seguente:

 return new Pair(number1, number2); 

Ecco una versione aggiornata del tuo codice:

 public class Scratch { // Function code public static Pair something() { int number1 = 1; int number2 = 2; return new Pair(number1, number2); } // Main class code public static void main(String[] args) { Pair pair = something(); System.out.println(pair.first() + pair.second()); } } class Pair { 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; } } 

Prova questo :

 // 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]); } 

devi usare le collezioni per restituire più di un valore di ritorno

nel tuo caso scrivi il tuo codice come

 public static List something(){ List list = new ArrayList(); 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 numList = something(); } 

Usa un object di tipo Pair / Tupla, non hai nemmeno bisogno di crearne uno se dipendi da Apache commons-lang. Basta usare la class Pair .

 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 

Non è necessario creare la propria class per restituire due valori diversi. Usa una HashMap in questo modo:

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

Hai anche il vantaggio della sicurezza del tipo.

A mio avviso, la cosa migliore è creare una nuova class che il costruttore sia la funzione di cui hai bisogno, ad esempio:

 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; } } 

Quindi usa semplicemente il costruttore come useresti la funzione:

 pairReturn pR = new pairReturn(15); 

e puoi usare pR.sth1, pR.sth2 come “2 risultati della funzione”

È anche ansible inviare oggetti mutabili come parametri, se si utilizzano metodi per modificarli, questi verranno modificati quando si ritorna dalla funzione. Non funzionerà su cose come Float, dato che è immutabile.

 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"); } } 

Il risultato è: Rutger

Ecco la soluzione davvero semplice e breve con SimpleEntry:

 AbstractMap.Entry myTwoCents=new AbstractMap.SimpleEntry<>("maximum possible performance reached" , 99.9f); String question=myTwoCents.getKey(); Float answer=myTwoCents.getValue(); 

Utilizza solo funzioni integrate Java e viene fornito con il beneficio di sicurezza del tipo.

Restituisce una matrice di oggetti

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

Sono curioso di sapere perché nessuno ha inventato la più elegante soluzione di callback. Quindi, invece di usare un tipo di ritorno, usi un gestore passato al metodo come argomento. L’esempio sotto ha i due approcci contrastanti. So quale dei due è più elegante per me. 🙂

 public class DiceExample { public interface Pair { T1 getLeft(); T2 getRight(); } private Pair rollDiceWithReturnType() { double dice1 = (Math.random() * 6); double dice2 = (Math.random() * 6); return new Pair() { @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 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); }); } }