Как вернуть 2 значения из метода Java?

Я пытаюсь вернуть 2 значения из метода Java, но получаю эти ошибки. Вот мой код:

// 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

ОТВЕТЫ

Ответ 1

Вместо того, чтобы возвращать массив, содержащий два значения, или с помощью общего класса Pair, подумайте о создании класса, представляющего результат, который вы хотите вернуть, и верните экземпляр этого класса. Дайте классу значащее имя. Преимущества такого подхода в использовании массива - это безопасность типов, и это значительно упростит вашу программу.

Примечание. Общий класс Pair, как предлагается в некоторых других ответах здесь, также дает вам безопасность типа, но не передает то, что представляет результат.

Пример (который не использует реально значимые имена):

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

Ответ 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]);
}

Ответ 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();

Ответ 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;
    }
}

Ответ 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]);
}

Ответ 6

Вот действительно простое и краткое решение с SimpleEntry:

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

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

Использует только встроенные функции Java и обладает преимуществом типа safty.

Ответ 7

вам нужно использовать коллекции для возврата более одного возвращаемого значения

в вашем случае вы пишете свой код как

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

Ответ 8

Используйте объект типа Pair/Tuple, вам даже не нужно создавать его, если u зависит от Apocal commons-lang. Просто используйте класс Pair.

Ответ 9

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

Ответ 10

Вам не нужно создавать свой собственный класс для возврата двух разных значений. Просто используйте 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);
}

У вас даже есть преимущество безопасности типа.

Ответ 11

На мой взгляд, лучше всего создать новый класс, конструктор которого - это необходимая функция, например:

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

Затем просто используйте конструктор, как вы бы использовали функцию:

pairReturn pR = new pairReturn(15);

и вы можете использовать pR.sth1, pR.sth2 как "2 результата функции"

Ответ 12

Мне любопытно, почему никто не придумал более элегантное решение обратного вызова. Поэтому вместо использования возвращаемого типа вы используете обработчик, переданный в метод в качестве аргумента. В приведенном ниже примере представлены два контрастных подхода. Я знаю, какая из них для меня более элегантна.: -)

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

Ответ 13

Вы также можете отправлять измененные объекты в качестве параметров, если вы используете методы для их изменения, тогда они будут изменены, когда вы вернетесь из функции. Он не будет работать на таких материалах, как 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");
     }
}

Результат: Рутгер

Ответ 14

Возвращает массив объектов

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

Ответ 15

Во-первых, было бы лучше, если бы в Java были кортежи для возврата нескольких значений.

Во-вторых, закодируйте самый простой из возможных классов Pair или используйте массив.

Но, если вам нужно вернуть пару, подумайте, какую концепцию она представляет (начиная с имен ее полей, затем имени класса) - и играет ли она более важную роль, чем вы думали, и поможет ли ваш общий дизайн иметь явная абстракция для него. Может быть, это code hint...
Обратите внимание: я не говорю, что это поможет, а просто посмотрю, чтобы увидеть, если да... или нет.

Ответ 16

и вот как вы делаете это в JS: return { objA, valueB }. Я знаю, это оффтоп, но я не могу оставить этот комментарий, увидев, как в Java должен быть реализован целый новый класс. JavaScript - перестань тратить свою жизнь и начни писать сценарии!

Ответ 17

Существуют различные способы сделать это, но после экспериментов я нашел это решение довольно простым. Я вставлю код для прокатки 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 для завершения метода без ошибки компилятора, а также для получения нужного результата. Таким образом, вы можете передать два двойных значения (ваши значения в кости) в статический метод String и разрешить ему возвращать две свернутые кости (удваивания) в String, а не два отдельных двойника. Когда вы вызываете метод в последней строке кода, я передал два аргумента 0s в качестве аргументов, так что кости можно катить равномерно и потому, что для этого метода нужны два двойных аргумента. Если у вас есть какие-либо вопросы, я могу дополнительно удовлетворить любые запросы о вышеуказанном коде и объяснении.