Comment renvoyer 2 valeurs à partir d'une méthode Java?

J'essaie de retourner 2 valeurs à partir d'une méthode Java mais j'obtiens ces erreurs. Voici mon code:

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

Erreur:

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)

Résultat Java: 1

136
demandé sur Michael 2010-05-14 11:22:49

14 réponses

Au lieu de renvoyer un tableau contenant les deux valeurs ou d'utiliser une classe générique Pair, envisagez de créer une classe qui représente le résultat que vous souhaitez renvoyer et renvoyez une instance de cette classe. Donnez à la classe un nom significatif. Les avantages de cette approche par rapport à l'utilisation d'un tableau sont la sécurité de type et cela rendra votre programme beaucoup plus facile à comprendre.

Note: Une classe générique Pair, comme proposé dans certaines des autres réponses ici, vous donne également la sécurité de type, mais ne le fait pas transmettre ce que le résultat représente.

Exemple (qui n'utilise pas de noms vraiment significatifs):

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());
}
195
répondu Jesper 2010-05-14 11:47:13

Java ne prend pas en charge les retours multi-valeurs. Retourne un tableau de valeurs.

// 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]);
}
60
répondu Matt 2010-05-14 07:25:51

Vous pouvez implémenter un Pair générique si vous êtes sûr que vous avez juste besoin de retourner deux valeurs:

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

Et ensuite la méthode retourne Pair:

public Pair<Object, Object> getSomePair();
33
répondu Lars Andren 2016-12-29 12:17:16

Vous ne pouvez renvoyer qu'une seule valeur en Java, donc la manière la plus soignée est la suivante:

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

Voici une version mise à jour de votre code:

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;
    }
}
22
répondu richj 2010-05-14 08:17:49

Essayez ceci :

// 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]);
}
7
répondu monn 2010-05-14 07:26:27

Vous devez utiliser des collections pour renvoyer plus d'une valeur de retour

, Dans votre cas, vous écrivez votre code

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();
    }
5
répondu GuruKulki 2010-05-14 07:24:13

Utilisez un objet de Type Pair / Tuple, vous n'avez même pas besoin d'en créer un si vous dépendez D'Apache commons-lang. Utilisez simplement la classePair .

4
répondu UserF40 2016-07-28 09:35:06
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
2
répondu siva 2014-01-24 22:09:37

Vous n'avez pas besoin de créer votre propre classe pour renvoyer deux valeurs différentes. Utilisez simplement un HashMap comme ceci:

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

, Vous avez même l'avantage de la sécurité de type.

2
répondu Code ninetyninepointnine 2015-09-11 20:13:05

, À mon avis, le mieux est de créer une nouvelle classe dont le constructeur est la fonction dont vous avez besoin, par exemple:

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

Ensuite, utilisez simplement le constructeur comme vous utiliseriez la fonction:

pairReturn pR = new pairReturn(15);

Et vous pouvez utiliser pR.sth1, pR.sth2 comme "2 résultats de la fonction"

2
répondu Jacob 2016-07-28 09:25:36

Vous pouvez également envoyer des objets mutables en tant que paramètres, si vous utilisez des méthodes pour les modifier, ils seront modifiés lorsque vous reviendrez de la fonction. Cela ne fonctionnera pas sur des choses comme Float, car il est immuable.

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

Le résultat est: Rutger

1
répondu Andreas 2014-01-05 23:12:53

Voici la solution très simple et courte avec SimpleEntry:

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

String question=myTwoCents.getKey();
Float answer=myTwoCents.getValue();

Utilise uniquement des fonctions intégrées Java et il est livré avec le type safty benefit.

1
répondu Code ninetyninepointnine 2018-06-02 11:21:39

Retourne un tableau D'objets

private static Object[] f () 
{ 
     double x =1.0;  
     int y= 2 ;
     return new Object[]{Double.valueOf(x),Integer.valueOf(y)};  
}
0
répondu M.C. 2017-08-31 09:51:38

Je suis curieux de savoir pourquoi personne n'a trouvé la solution de rappel la plus élégante. Donc, au lieu d'utiliser un type de retour, vous utilisez un gestionnaire passé dans la méthode en tant qu'argument. L'exemple ci-dessous présente les deux approches contrastées. Je sais lequel des deux est le plus élégant de moi. :-)

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);
        });
    }
}
0
répondu Steve O 1969 2017-11-14 11:57:31