एक स्विच केस स्टेटमेंट के लिए दो मानों का उपयोग करना

Question

मेरे कोड में, प्रोग्राम उपयोगकर्ता द्वारा दर्ज किए गए पाठ के आधार पर कुछ करता है। मेरा कोड ऐसा दिखता है:

switch (name) {
        case text1: {
            //blah
            break;
        }
        case text2: {
            //blah
            break;
        }
        case text3: {
            //blah
            break;
        }
        case text4: {
            //blah
            break;
        }

हालांकि, मामलों के अंदर कोड text1और text4समान है। इसलिए मैं सोच रहा था कि क्या मेरे लिए ऐसा कुछ लागू करना संभव होगा

case text1||text4: {
            //blah
            break;
        }

मुझे पता है कि ||ऑपरेटर केस स्टेटमेंट में काम नहीं करेगा लेकिन क्या ऐसा ही कुछ मैं उपयोग कर सकता हूं।

Comments

एक बुनियादी सवाल होने के नाते यह कुछ भी हो जाता है अगर कुछ भी हो जाए तो यह अपवोट के लिए अधिक योग्य होता है, अगर यह डुप्लिकेट नहीं है जैसा कि व्यापक रूप से उपयोगी है। और यह कुछ ऐसा है जो मेरे लिए संभव नहीं था, लेकिन अब जब मुझे यह स्पष्ट रूप से स्पष्ट है। तो सभी एक बहुत बढ़िया क्यू एंड ए में

— रिचर्ड टिंगल

@RichardTingle - क्या आप डफ डिवाइस से परिचित हैं - en.wikipedia.org/wiki/Duff%27s_device

— user93353

"क्यों इतने सारे upvotes? इंटरनेट में" जावा स्विच "की खोज करें और एक हजार स्पष्टीकरण पढ़ें।" <- आपको क्या लगता है कि मैं क्या कर रहा था?

— ब्रेंडन

मैंने शाब्दिक रूप से "एक लाइन जावा में कई मामले" खोजे और यह क्यू एंड ए पहला परिणाम था।

— domenix

चयनित उत्तर में स्विच डेमो अब reDrased जा सकता है कि JDK-12 ने JEP-325 को एकीकृत किया है। :)

— नमन

Answer 1

आप दोनों CASEकथनों का उपयोग इस प्रकार कर सकते हैं ।

  case text1: 
  case text4:{
            //blah
            break;
        }

इस उदाहरण को देखें: कोड उदाहरण एक विशेष महीने में दिनों की संख्या की गणना करता है:

class SwitchDemo {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                numDays = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                numDays = 30;
                break;
            case 2:
                if (((year % 4 == 0) && 
                     !(year % 100 == 0))
                     || (year % 400 == 0))
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = "
                           + numDays);
    }
}

यह कोड से आउटपुट है:

Number of Days = 29

असफल:

ब्याज का एक और बिंदु ब्रेक स्टेटमेंट है। प्रत्येक ब्रेक स्टेटमेंट, संलग्नक स्विच स्टेटमेंट को समाप्त करता है। नियंत्रण प्रवाह स्विच ब्लॉक के बाद पहले बयान के साथ जारी है। ब्रेक स्टेटमेंट आवश्यक हैं क्योंकि उनके बिना, स्विच ब्लॉक में बयान fall through: मिलान केस लेबल के बाद के सभी स्टेटमेंट क्रम में निष्पादित किए जाते हैं, बाद के केस लेबल की अभिव्यक्ति की परवाह किए बिना, जब तक कि एक ब्रेक स्टेटमेंट का सामना नहीं किया जाता है।

उदाहरण कोड:

public class SwitchFallThrough {

    public static void main(String[] args) {
        java.util.ArrayList<String> futureMonths =
            new java.util.ArrayList<String>();

        int month = 8;

        switch (month) {
            case 1:  futureMonths.add("January");
            case 2:  futureMonths.add("February");
            case 3:  futureMonths.add("March");
            case 4:  futureMonths.add("April");
            case 5:  futureMonths.add("May");
            case 6:  futureMonths.add("June");
            case 7:  futureMonths.add("July");
            case 8:  futureMonths.add("August");
            case 9:  futureMonths.add("September");
            case 10: futureMonths.add("October");
            case 11: futureMonths.add("November");
            case 12: futureMonths.add("December");
            default: break;
        }

        if (futureMonths.isEmpty()) {
            System.out.println("Invalid month number");
        } else {
            for (String monthName : futureMonths) {
               System.out.println(monthName);
            }
        }
    }
}

यह कोड से आउटपुट है:

August
September
October
November
December

स्विच स्टेटमेंट में स्ट्रिंग्स का उपयोग करना

जावा एसई 7 और बाद में, आप स्विच स्टेटमेंट की अभिव्यक्ति में स्ट्रिंग ऑब्जेक्ट का उपयोग कर सकते हैं। निम्न कोड उदाहरण, स्ट्रिंग नाम के महीने के आधार पर महीने की संख्या प्रदर्शित करता है:

public class StringSwitchDemo {

    public static int getMonthNumber(String month) {

        int monthNumber = 0;

        if (month == null) {
            return monthNumber;
        }

        switch (month.toLowerCase()) {
            case "january":
                monthNumber = 1;
                break;
            case "february":
                monthNumber = 2;
                break;
            case "march":
                monthNumber = 3;
                break;
            case "april":
                monthNumber = 4;
                break;
            case "may":
                monthNumber = 5;
                break;
            case "june":
                monthNumber = 6;
                break;
            case "july":
                monthNumber = 7;
                break;
            case "august":
                monthNumber = 8;
                break;
            case "september":
                monthNumber = 9;
                break;
            case "october":
                monthNumber = 10;
                break;
            case "november":
                monthNumber = 11;
                break;
            case "december":
                monthNumber = 12;
                break;
            default: 
                monthNumber = 0;
                break;
        }

        return monthNumber;
    }

    public static void main(String[] args) {

        String month = "August";

        int returnedMonthNumber =
            StringSwitchDemo.getMonthNumber(month);

        if (returnedMonthNumber == 0) {
            System.out.println("Invalid month");
        } else {
            System.out.println(returnedMonthNumber);
        }
    }
}

इस कोड से आउटपुट 8 है।

जावा डॉक्स से

Comments

ओह ठीक। वह तो आसान था। मुझे नहीं पता था कि मैं कर सकता हूँ

— अंकुश

यह उल्लेख के लायक है कि इस भाषा की विशेषता को परित्याग कहा जाता है। बिना मामलों को breakमूल रूप से अगले मामले ब्लॉक के साथ जोड़ दिया जाता है जो नेत्रहीन नीचे है, इसलिए इसके माध्यम से गिर जाते हैं ।

— सम्राट ओरियन

@ Kobor42 पहले सार्वजनिक स्थलों पर बात करना सीखें। कैसे आपके सुझाव से मदद मिलती है। धन्यवाद

— PSR

@ Kobor42 कैसे के बारे में: आपने उस प्रारूपण का उपयोग क्यों किया है? मामलों को क्षैतिज रूप से रखना कोड को कम पठनीय बनाता है और आमतौर पर इसे बुरा व्यवहार माना जाता है [संदर्भ वैकल्पिक लेकिन वांछित]। मैंने हमेशा महसूस किया है कि स्विच स्टेटमेंट एक विशेष रूप से पठनीय प्रारूप हैं, लेकिन इस तरह प्रस्तुत किया कि वे सब खो देते हैं।

— रिचर्ड टिंगल

स्विच डेमो को अब फिर से जोड़ दिया जा सकता है कि JDK-12 ने JEP-325 को एकीकृत किया है। :)

— नमन

Answer 2

आप ऐसा कर सकते हैं:

case text1:
case text4: {
            //blah
            break;
}

Comments

ओपी के लिए: यह भी पढ़ें जावा स्विच के मामले: ब्रेसिज़ के साथ या बिना?

— ब्रिजेश चौहान

Answer 3

caseमूल्यों सिर्फ codeless "गोटो" अंक है कि एक ही प्रवेश बिंदु साझा कर सकते हैं कर रहे हैं:

case text1:
case text4: 
    //blah
    break;

ध्यान दें कि ब्रेस बेमानी हैं।

Comments

@ ट्रीट लोल। मैं उस तरह का एक बहुत हाल ही में कर रहा हूँ - iPhone अंगूठे टाइपिंग दोष। चीयर्स

— बोहेमियन

Answer 4

बस करो

case text1: case text4: 
     do stuff;
     break;

Answer 5

JEP 325: स्विच एक्सप्रेशंस (प्रीव्यू) को JDK-12 के शुरुआती एक्सेस बिल्ड्स के एकीकरण के साथ , अब स्विच लेबल के नए रूप का उपयोग कर सकते हैं: -

case text1, text4 -> {
     //blah
} 

या किसी एक उत्तर से डेमो रीफ़्रेज़ करने के लिए , कुछ इस तरह से: -

public class RephraseDemo {

    public static void main(String[] args) {
        int month = 9;
        int year = 2018;
        int numDays = 0;

        switch (month) {
            case 1, 3, 5, 7, 8, 10, 12 ->{
                numDays = 31;
            }
            case 4, 6, 9, 11 ->{
                numDays = 30;
            }
            case 2 ->{
                if (((year % 4 == 0) &&
                        !(year % 100 == 0))
                        || (year % 400 == 0))
                    numDays = 29;
                else
                    numDays = 28;
            }
            default ->{
                System.out.println("Invalid month.");

            }
        }
        System.out.println("Number of Days = " + numDays);
    }
}

यहाँ आप इसे कैसे आज़मा सकते हैं - मावेन के साथ एक JDK12 पूर्वावलोकन सुविधा संकलित करें

Answer 6

कोष्ठक अनावश्यक हैं। बस करो

case text1:
case text4:
  doSomethingHere();
  break;
case text2:
  doSomethingElse()
  break;

अगर किसी को उत्सुकता है, तो इसे केस फालतू कहा जाता है। ऐसा करने की क्षमता यही कारण है कि break;केस स्टेटमेंट को समाप्त करना आवश्यक है। अधिक जानकारी के लिए, विकिपीडिया लेख http://en.wikipedia.org/wiki/Switch_statement देखें ।

Answer 7

fallthroughदूसरों के द्वारा जवाब अच्छे हैं।

हालाँकि, एक अन्य दृष्टिकोण आपके केस स्टेटमेंट की सामग्री से बाहर निकालने के तरीके होंगे और फिर प्रत्येक मामले से उपयुक्त विधि को कॉल करेंगे।

नीचे दिए गए उदाहरण में, 'text1' और केस 'text4' दोनों समान हैं:

switch (name) {
        case text1: {
            method1();
            break;
        }
        case text2: {
            method2();
            break;
        }
        case text3: {
            method3();
            break;
        }
        case text4: {
            method1();
            break;
        }

मैं व्यक्तिगत रूप से केस स्टेटमेंट लिखने की इस शैली को अधिक प्राप्य और थोड़ा अधिक पठनीय पाता हूं, खासकर जब आपके द्वारा बुलाए गए तरीकों में अच्छे वर्णनात्मक नाम हों।

Comments

भविष्य में बदलाव की परवाह किए बिना यह अधिक संधारणीय नहीं होगा text1और text4ALMOST CERTAINLY एक ही काम करेगा। यदि उन्हें हमेशा लिंक किया जाना चाहिए, तो मामले में बदलाव करना text1(मतलब यह बदलना कि किस विधि को कॉल करता है) में बदलाव की आवश्यकता होगी text4। इस मामले में यह स्पष्ट रूप से अधिक रखरखाव योग्य नहीं है। यह स्थिति पर निर्भर करता है।

— निक फ्रीमैन

मैं कहूंगा कि इस विधि को शायद वैसे भी दूसरे तरीके के साथ जोड़ा जाना चाहिए, क्योंकि स्विच स्टेटमेंट (IMHO) सबसे सुंदर प्रोग्रामिंग संरचना नहीं हैं।

— निक फ्रीमैन

Answer 8

दृष्टिकोण के माध्यम से पतन सबसे अच्छा मुझे लगता है।

case text1:
case text4: {
        //Yada yada
        break;
} 

Answer 9

आप उपयोग कर सकते हैं:

case text1: case text4: 
     do stuff;
     break;

Answer 10

मामले के मान सिर्फ कोड रहित "गोटो" बिंदु हैं जो समान प्रविष्टि बिंदु साझा कर सकते हैं:

केस टेक्स्ट 1:
केस टेक्स्ट 4: {
// कुछ
तोड़ो;
}

ध्यान दें कि ब्रेस बेमानी हैं।

Answer 11

JEP 354: JDK-13 में स्विच एक्सप्रेशंस (पूर्वावलोकन) और JEP 361: JDK-14 में स्विच एक्सप्रेशंस (स्टैंडर्ड) स्विच स्टेटमेंट का विस्तार करेगा,इसलिए इसे एक अभिव्यक्ति के रूप में इस्तेमाल किया जा सकता है।

अब आप कर सकते हैं:

• स्विच अभिव्यक्ति से सीधे चर असाइन करें ,
• स्विच लेबल के नए रूप का उपयोग करें ( case L ->):

  "केस एल ->" स्विच लेबल के दाईं ओर कोड एक अभिव्यक्ति, एक ब्लॉक, या (सुविधा के लिए) एक फेंक स्टेटमेंट होना प्रतिबंधित है।

• प्रति मामले में कई स्थिरांक का उपयोग करें, अल्पविराम द्वारा अलग किए गए,
• और भी अधिक मूल्य विराम नहीं हैं :

  एक स्विच अभिव्यक्ति से एक मूल्य प्राप्त करने के लिए, breakमूल्य कथन के साथ एक yieldबयान के पक्ष में गिरा दिया जाता है ।

तो जवाब में से एक डेमो इस तरह लग सकता है:

public class SwitchExpression {

  public static void main(String[] args) {
      int month = 9;
      int year = 2018;
      int numDays = switch (month) {
        case 1, 3, 5, 7, 8, 10, 12 -> 31;
        case 4, 6, 9, 11 -> 30;
        case 2 -> {
          if (java.time.Year.of(year).isLeap()) {
            System.out.println("Wow! It's leap year!");
            yield 29;
          } else {
            yield 28;
          }
        }
        default -> {
          System.out.println("Invalid month.");
          yield 0;
        }
      };
      System.out.println("Number of Days = " + numDays);
  }
}