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)

자바 결과 : 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());
}

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

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

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

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 유형 이점이 있습니다.

하나 이상의 반환 값을 반환하려면 컬렉션을 사용해야합니다

귀하의 경우 코드를 다음과 같이 작성하십시오

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

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

Pair / Tuple type 객체를 사용하면 Apache commons-lang에 의존하는 경우 객체를 만들 필요조차 없습니다. Pair 클래스를 사용하십시오 .

아무도 더 우아한 콜백 솔루션을 찾지 못한 이유가 궁금합니다. 따라서 반환 형식을 사용하는 대신 메서드에 인수로 전달 된 처리기를 사용합니다. 아래 예에는 두 가지 대조적 인 접근 방식이 있습니다. 나는 둘 중 어느 것이 나에게 더 우아한 지 알고 있습니다. :-)

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

두 개의 다른 값을 반환하기 위해 자신의 클래스를 만들 필요는 없습니다. 다음과 같이 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);
}

타입 안전의 이점도 있습니다.

내 생각에 가장 좋은 것은 생성자가 필요한 함수 인 새 클래스를 만드는 것입니다.

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 개 결과"로 사용할 수 있습니다.

또한 변경 가능한 객체를 매개 변수로 보낼 수 있습니다. 메소드를 사용하여 수정하면 함수에서 돌아올 때 수정됩니다. 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

객체 배열 반환

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

첫째, Java에 여러 값을 반환하는 튜플이 있으면 더 좋습니다.

둘째, 가장 간단한 Pair클래스를 코딩 하거나 배열을 사용하십시오.

당신이 경우에, 이렇게 한 쌍을 반환 할 필요가, (다음 클래스 명, 필드 이름으로 시작) 무엇을 나타내는 개념 고려 - 그것을 당신이 생각했던 것보다 더 큰 역할을하고 있는지, 그리고 도움이 될 경우 전체적인 디자인은을 가지고 그것에 대한 명시 적 추상화. 어쩌면 그것은 code hint...
제발 참고 : 나는 독단적으로 도움 이 될 것이라고 말하지 는 않지만, 그것이 도움이 되는지 아닌지 확인 하는 것입니다.

그리고 이것이 JS에서하는 방법입니다 : return { objA, valueB }. 나는 그것이 주제가 아니라는 것을 알고 있지만 Java에서 완전히 새로운 클래스가 어떻게 구현되어야하는지 본 후에이 의견을 남길 수는 없습니다. JavaScript-인생 낭비를 멈추고 스크립팅을 시작하십시오!