जावा विधि से 2 मान कैसे लौटाएं?

Question

मैं एक जावा विधि से 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)

जावा परिणाम: १

Comments

क्या उस डुप्लिकेट को दूसरे रास्ते पर जाना चाहिए? यहां जवाब बेहतर लगता है।

— जे रिचर्ड स्नेप

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

Comments

यह मेरा पसंदीदा मार्ग होगा - संभवतः संख्याओं की जोड़ी का कुछ अर्थ है, और यह अच्छा होगा यदि रिटर्न प्रकार इस का प्रतिनिधित्व करता है।

— आर्मंड

आप SimpleEntry <type_of_value_1, type_of_value_2> java.util.AbstractMap.SimpleEntry से और इसे getKey () के साथ उपयोग कर सकते हैं (1 वस्तु पाने के लिए और getVueue) () ऑब्जेक्ट 2 पाने के लिए

— क्रिस्टलनिक्स

मुझे बहुत दृढ़ता से लगता है कि जावा को आपको कई मान वापस करने की अनुमति देनी चाहिए। यह हर बार जब आप कुछ अलग करना चाहते हैं तो यह तेज़ (कम निर्मित वस्तुएँ) और हर बार अतिरिक्त कक्षाओं (फूला हुआ कोड) की आवश्यकता नहीं होगी। मुझे कोई गिरावट नहीं दिख रही है, शायद कोई मुझे बता सकता है?

— क्रिस सेलिन

यह पूछे गए प्रश्न के लिए सिर्फ एक काम है, जो अभी भी "कैसे हम पायथन में करते हैं" विधि से 2 मानों को वापस करने के लिए खड़ा है।

— ओम् शेराज़

@AnumSheraz "पायथन में जैसे ... कैसे" का उत्तर है: आप नहीं, क्योंकि जावा में ऐसी भाषा सुविधा नहीं है ...

— जेसपर

Answer 2

जावा बहु-मूल्य रिटर्न का समर्थन नहीं करता है। मूल्यों की एक सरणी लौटें।

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

Comments

यह लगभग हमेशा गलत काम करने के लिए होता है, खासकर अगर दो परिणाम मूल्यों के प्रकार अलग-अलग होते हैं।

— केविन सिटज

@BarAkiva, इसका कारण गलत है क्योंकि आप ढीली प्रकार की सुरक्षा करते हैं। यदि आप एक समरूप प्रकार के मान लौटा रहे हैं, तो आपको हमेशा एक सरणी पर एक सूची पसंद करनी चाहिए। विशेष रूप से, यदि आप सामान्य मानों के साथ काम कर रहे हैं, तो एक सूची <T> को हमेशा T [] पर वापसी मान के रूप में पसंद किया जाता है क्योंकि आप हमेशा एक सामान्य प्रकार पर एक सूची का निर्माण कर सकते हैं, लेकिन कभी सरणी नहीं; आप ऐसा नहीं कर सकते: "नई टी [लंबाई];" विषम प्रकारों के लिए यहां इंगित किए गए एक जोड़ी वर्ग बनाने का दृष्टिकोण विषम प्रकार के लिए एक बेहतर विकल्प है।

— केविन सीटेज़ सेप

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

Comments

इस पद्धति की वापसी क्या दिखती है?

— Jwan622

की पंक्तियों के साथ कुछ: जोड़ी = नई जोड़ी (thing1, thing2) .... वापसी जोड़ी;

— लार्स एंड्रेन

Answer 4

आप जावा में केवल एक मान वापस कर सकते हैं, इसलिए सबसे साफ तरीका इस प्रकार है:

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

यहाँ SimpleEntry के साथ वास्तव में सरल और संक्षिप्त समाधान है:

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

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

केवल कार्यों में निर्मित जावा का उपयोग करता है और यह प्रकार के सुरक्षित लाभ के साथ आता है।

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

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 8

एक जोड़ी / टपल प्रकार की वस्तु का उपयोग करें, यदि आप अपाचे कॉमन्स-लैंग पर निर्भर करते हैं तो आपको एक बनाने की भी आवश्यकता नहीं है। बस जोड़ी वर्ग का उपयोग करें ।

Comments

यह और अधिक क्यों नहीं है?

— रौनी लिलेमेट्स

Answer 9

मैं इस बात से उत्सुक हूं कि कोई भी अधिक सुरुचिपूर्ण कॉलबैक समाधान के साथ क्यों नहीं आया है। इसलिए रिटर्न प्रकार का उपयोग करने के बजाय आप तर्क के रूप में विधि में पारित एक हैंडलर का उपयोग करें। नीचे दिए गए उदाहरण में दो विपरीत दृष्टिकोण हैं। मुझे पता है कि दोनों में से कौन मेरे लिए ज्यादा खूबसूरत है। :-)

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

यहां तक ​​कि आपको टाइप सेफ्टी का भी फायदा है।

Comments

तुम भी एक HashMap की जरूरत नहीं है, बस एक SimpleEntry का उपयोग करें!

— ज़ेरुस

क्यों एक HashMap, मैं पूछ सकता हूँ? यह यहाँ उपयोग करने के लिए एक अजीब डेटा संरचना की तरह लगता है।

— नील चौधरी

@ नील चौधरी इसके अलावा और कोई कारण नहीं है क्योंकि यह एक सुगम निर्मित वर्ग है जिसमें दो निश्चित पैरामीटर हैं। जैसा कि ज़ेरुस ने बताया, AbstractMap.SimpleEntry यहाँ अधिक हल्का विकल्प है। कृपया नीचे दिए गए संबंधित उत्तर को देखें!

— कोड Ninetyninepointnine

Answer 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 परिणाम" के रूप में उपयोग कर सकते हैं

Answer 12

आप उत्परिवर्तित वस्तुओं को मापदंडों के रूप में भी भेज सकते हैं, यदि आप उन्हें संशोधित करने के लिए तरीकों का उपयोग करते हैं तो फ़ंक्शन से लौटने पर उन्हें संशोधित किया जाएगा। यह फ्लोट जैसे सामान पर काम नहीं करेगा, क्योंकि यह अपरिवर्तनीय है।

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 13

ऑब्जेक्ट्स का एक ऐरे वापस करें

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

Answer 14

सबसे पहले, यह बेहतर होगा यदि जावा में कई मानों को लौटाने के लिए ट्यूपल्स हों।

दूसरा, सबसे सरल संभव Pairवर्ग कोड , या एक सरणी का उपयोग करें।

लेकिन, अगर आपको एक जोड़ी वापस करने की आवश्यकता है, तो विचार करें कि यह किस अवधारणा का प्रतिनिधित्व करता है (इसके क्षेत्र के नाम, फिर वर्ग का नाम के साथ शुरू) - और क्या यह आपके विचार से बड़ी भूमिका निभाता है, और यदि यह आपके समग्र डिजाइन में मदद करेगा इसके लिए स्पष्ट अमूर्तता। शायद यह एक है code hint...
कृपया ध्यान दें: मैं हठधर्मिता से कह रहा हूँ नहीं यह होगा मदद, लेकिन सिर्फ देखो करने के लिए, करने के लिए देख अगर यह होता है ... या यह करता है नहीं तो।

Answer 15

और यह कैसे आप इसे जे एस में क्या है: return { objA, valueB }। मुझे पता है कि यह अपमानजनक है, लेकिन मैं इस टिप्पणी को छोड़ने से परहेज नहीं कर सकता हूं कि यह देखने के बाद कि जावा में एक पूरी नई कक्षा कैसे लागू की जाती है। जावास्क्रिप्ट - अपना जीवन बर्बाद करना बंद करो और स्क्रिप्टिंग शुरू करो!