"जारी रखें" कीवर्ड क्या है और यह जावा में कैसे काम करता है?

Question

मैंने पहली बार यह कीवर्ड देखा था और मैं सोच रहा था कि क्या कोई मुझे समझा सकता है कि यह क्या करता है।

• continueकीवर्ड क्या है ?
• यह कैसे काम करता है?
• इसका उपयोग कब किया जाता है?

Answer 1

एक continueलेबल के बिना एक बयान अंतरतम स्थिति whileया doलूप, और अंतरतम forलूप की अद्यतन अभिव्यक्ति से फिर से निष्पादित करेगा । इसका उपयोग अक्सर लूप के प्रसंस्करण को जल्दी समाप्त करने के लिए किया जाता है और इस तरह से गहराई से नेस्टेड ifबयानों से बचा जाता है । निम्नलिखित उदाहरण continueमें लूप में निम्नलिखित कथन को संसाधित किए बिना, अगली पंक्ति मिलेगी।

while (getNext(line)) {
  if (line.isEmpty() || line.isComment())
    continue;
  // More code here
}

एक लेबल के continueसाथ, अंतर लेबल के बजाय लूप से फिर से निष्पादित होगा, अंतरतम लूप के बजाय। यह गहराई से नेस्टेड छोरों से बचने के लिए, या केवल स्पष्टता के लिए इस्तेमाल किया जा सकता है।

कभी-कभी continueएक खाली लूप बॉडी को अधिक स्पष्ट करने के लिए प्लेसहोल्डर के रूप में भी उपयोग किया जाता है।

for (count = 0; foo.moreData(); count++)
  continue;

बिना लेबल वाला एक ही कथन C और C ++ में भी मौजूद है। पर्ल में बराबर है next।

इस प्रकार के नियंत्रण प्रवाह की सिफारिश नहीं की जाती है, लेकिन यदि आप चुनते हैं तो आप continueसीमित रूप का अनुकरण करने के लिए भी उपयोग कर सकते हैं goto। निम्नलिखित उदाहरण में continueवसीयत खाली for (;;)लूप को फिर से निष्पादित करेगा ।

aLoopName: for (;;) {
  // ...
  while (someCondition)
  // ...
    if (otherCondition)
      continue aLoopName;

Answer 2

continueकी तरह है goto। क्या आप परिचित हैं break? इसके विपरीत उनके बारे में सोचना आसान है:

• break लूप को समाप्त करता है (नीचे दिए गए कोड पर कूदता है)।

• continue वर्तमान पुनरावृत्ति के लिए लूप के भीतर कोड के बाकी प्रसंस्करण को समाप्त करता है, लेकिन लूप जारी रखता है।

Comments

ब्रेक और जारी रखने के लिए अच्छा उदाहरण, मुझे लगा कि यह पहले से समान था। <

— yfsx

असंभव यह एक अच्छा परिपूर्ण 500 बनाने के लिए नहीं! +1

— टोपी

Answer 3

आइए एक उदाहरण देखें:

int sum = 0;
for(int i = 1; i <= 100 ; i++){
    if(i % 2 == 0)
         continue;
    sum += i;
}

इससे 1 से 100 तक केवल विषम संख्याओं का योग होगा।

Answer 4

यदि आप एक लूप के शरीर को एक सबरूटीन के रूप में सोचते हैं, तो continueजैसे है return। C में समान कीवर्ड मौजूद है, और उसी उद्देश्य को पूरा करता है। यहाँ एक उदाहरण दिया गया है:

for(int i=0; i < 10; ++i) {
  if (i % 2 == 0) {
    continue;
  }
  System.out.println(i);
}

यह केवल विषम संख्याओं का ही प्रिंट आउट लेगा।

Answer 5

आम तौर पर, मैं देख रहा हूँ continue(और breakएक चेतावनी है कि कोड के रूप में) हो सकता है कुछ पुनर्रचना का उपयोग, खासकर अगर whileया forपाश घोषणा दृष्टि में तुरंत नहीं है। returnएक विधि के बीच में भी यही सच है , लेकिन थोड़ा अलग कारण से।

जैसा कि दूसरों ने पहले ही कहा है, continueलूप के अगले पुनरावृत्ति के साथ breakचलता है , जबकि एन्कोडिंग लूप से बाहर निकलता है।

ये रखरखाव टाइमबॉम्ब हो सकते हैं क्योंकि continue/ breakऔर लूप के बीच कोई तात्कालिक लिंक नहीं है जो संदर्भ के अलावा जारी / तोड़ रहा है; एक आंतरिक लूप जोड़ें या लूप के "हिम्मत" को एक अलग विधि में स्थानांतरित करें और आपके पास continue/ breakविफल होने का एक छिपा हुआ प्रभाव है ।

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

continue, breakऔर return(आपकी पद्धति के अंत में वन ट्रू रिटर्न के अलावा) सभी "छिपे हुए GOTO" की सामान्य श्रेणी में आते हैं। वे अप्रत्याशित स्थानों में लूप और फ़ंक्शन नियंत्रण रखते हैं, जो अंततः बग का कारण बनता है।

Comments

मुझे इस बात में दिलचस्पी है कि वापसी क्यों खराब है। मुझे पहले से ही लग रहा है कि रिटर्न खराब है क्योंकि स्काला रिटर्न को प्रोत्साहित नहीं करता है ।

— जुस 12

दूसरी ओर, एक विधि को नेस्टेड लूप से लौटने की अनुमति देना सबसे आसान, सबसे पठनीय और चीजों को करने के लिए सबसे उचित तरीका हो सकता है, बजाय अतिरिक्त चर बनाने के बजाय लूप से बाहर निकलने को और अधिक साफ दिखने के लिए।

— डेविड आर ट्रिब्बल

Answer 6

जावा में "जारी" का अर्थ है वर्तमान लूप के अंत में जाना, इसका अर्थ है: यदि कंपाइलर लूप में जारी रहता है, तो यह अगले प्रवाह में जाएगा

उदाहरण: यह 1 से 10 तक विषम संख्याओं को प्रिंट करने के लिए एक कोड है

कंपाइलर प्रिंट कोड को अनदेखा करेगा जब भी यह देखता है कि यह अगले पुनरावृत्ति में आगे बढ़ रहा है

for (int i = 0; i < 10; i++) { 
    if (i%2 == 0) continue;    
    System.out.println(i+"");
}

---

Answer 7

जैसा कि पहले ही उल्लेख किया गया है कि इसके continueनीचे और लूप के अंत तक कोड को संसाधित करना छोड़ देगा। फिर, आपको लूप की स्थिति में ले जाया जाता है और अगली पुनरावृत्ति चलाते हैं यदि यह स्थिति अभी भी (या यदि कोई ध्वज है, तो चिह्नित लूप की स्थिति के लिए)।

यह उजागर किया जाना चाहिए कि आप के मामले में do - whileएक के बाद एक तल पर स्थिति में ले जाया जाता है continue, लूप की शुरुआत में नहीं।

यही कारण है कि बहुत से लोग सही उत्तर देने में विफल रहते हैं कि निम्नलिखित कोड क्या उत्पन्न करेगा।

    Random r = new Random();
    Set<Integer> aSet= new HashSet<Integer>();
    int anInt;
    do {
        anInt = r.nextInt(10);
        if (anInt % 2 == 0)
            continue;
        System.out.println(anInt);
    } while (aSet.add(anInt));
    System.out.println(aSet);

* यदि आपका उत्तर यह है कि aSetकेवल 100% विषम संख्याएँ होंगी ... आप गलत हैं!

Answer 8

जारी रखना एक खोजशब्द है जावा में है और इसका उपयोग वर्तमान पुनरावृत्ति को छोड़ने के लिए किया जाता है।

मान लीजिए आप 1 से 100 तक सभी विषम संख्याओं को प्रिंट करना चाहते हैं

public class Main {

    public static void main(String args[]) {

    //Program to print all odd numbers from 1 to 100

        for(int i=1 ; i<=100 ; i++) {
            if(i % 2 == 0) {
                continue;
            }
            System.out.println(i);
        }

    }
}

उपरोक्त कार्यक्रम में कथन जारी रखें बस पुनरावृत्ति को रोक देता है जब मैं सम हो और विषम होने पर i के मूल्य को प्रिंट करता हूं ।

जारी रखें कथन बस आपको लूप से बाहर ले जाता है, लूप के अंदर शेष कथनों को निष्पादित किए बिना अगले पुनरावृत्ति को चलाता है।

Answer 9

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

public class ContinueBreak {
    public static void main(String[] args) {
        String[] table={"aa","bb","cc","dd"};
        for(String ss:table){
            if("bb".equals(ss)){
                continue;
            }
            System.out.println(ss);
            if("cc".equals(ss)){
                break;
            }
        }
        System.out.println("Out of the loop.");
    }

}

यह प्रिंट करेगा: आ सी सी लूप से।

यदि आप जारी रखने के स्थान पर ब्रेक का उपयोग करते हैं (यदि बाद में।), तो यह बस आउ और लूप से बाहर प्रिंट करेगा ।

यदि स्थिति "bb" ss के बराबर है, तो संतुष्ट है: जारी रखने के लिए: यह अगले पुनरावृत्ति अर्थात "cc" .equals (ss) पर जाता है। ब्रेक के लिए: यह लूप से निकलता है और "लूप से बाहर" प्रिंट करता है।

Comments

बहुत यकीन है कि यह "सीसी"! = "बी बी" के बाद से सीसी भी प्रिंट करेगा और प्रिंट स्टेटमेंट से पहले हैbreak

— टेड देलेज़ेन

Answer 10

मुझे पार्टी में थोड़ी देर हो गई है, लेकिन ...

यह ध्यान देने योग्य है कि continueखाली छोरों के लिए उपयोगी है जहां सभी कार्य लूप को नियंत्रित करने वाले सशर्त अभिव्यक्ति में किया जाता है। उदाहरण के लिए:

while ((buffer[i++] = readChar()) >= 0)
    continue;

इस मामले में, एक चरित्र को पढ़ने और इसे जोड़ने के सभी कार्य लूप को bufferनियंत्रित करने वाले अभिव्यक्ति में किए जाते हैं while। continueबयान है कि पाश एक शरीर की जरूरत नहीं है एक दृश्य संकेत के रूप में कार्य करता है।

यह समतुल्य से थोड़ा अधिक स्पष्ट है:

while (...)
{ }

और निश्चित रूप से बेहतर (और सुरक्षित) कोडिंग शैली की तरह एक खाली बयान का उपयोग करके:

while (...)
    ;

Comments

मैं निश्चित रूप से सहमत हूं कि यह क्लीनर और अधिक पठनीय कोड है, लेकिन मुझे यकीन नहीं है कि मैं अन्य विकल्प की तुलना में "सुरक्षित" होने के बारे में आपके तर्क का पालन करता हूं, जबकि (बयान); एक अर्धविराम का उपयोग करके सीधे सीमांकित।

— एक्सोलोटल

@ अलोक - यह सुरक्षित है क्योंकि एक अकेला अर्धविराम नेत्रहीन को याद करना आसान है। आकस्मिक रूप से बाहर निकलना भी आसान है, जो अगले बयान whileको whileक्लॉज की बॉडी बना देगा , और जो स्पष्ट रूप से स्पष्ट नहीं होगा। एक स्पष्ट स्पष्ट continueहै और एक मंशा बताती है कि एक खाली बयान नहीं देता है।

— डेविड आर ट्रिब्बल

मैं देख रहा हूं, इसलिए आपका मतलब मुख्य रूप से डिजाइन के नजरिए से है। यह समझ आता है। जिस तरह से लूप को ध्यान में रखकर संरचित किया गया है, उसके साथ मेरे पास कुछ अंतर्निहित था।

— axolotl

Answer 11

मूल रूप से जावा में, जारी एक बयान है। तो जारी बयान को सामान्य रूप से वर्तमान पुनरावृत्ति को छोड़ने के लिए छोरों के साथ प्रयोग किया जाता है।

जावा में इसका उपयोग कैसे और कब किया जाता है, नीचे लिंक देखें। इसका उदाहरण के साथ स्पष्टीकरण मिला है।

https://www.flowerbrackets.com/continue-java-example/

आशा है ये मदद करेगा !!

Answer 12

continue एक लूप के अंदर होना चाहिए अन्यथा यह दिखाता है कि नीचे त्रुटि:

लूप के बाहर जारी रखें

Answer 13

जारी बयान का उपयोग लूप नियंत्रण संरचना में किया जाता है जब आपको लूप के अगले पुनरावृत्ति पर तुरंत कूदने की आवश्यकता होती है।

यह लूप या जबकि लूप के लिए इस्तेमाल किया जा सकता है। लूप को जारी रखने के लिए जावा जारी स्टेटमेंट का उपयोग किया जाता है। यह कार्यक्रम का वर्तमान प्रवाह जारी रखता है और निर्दिष्ट स्थिति में शेष कोड को छोड़ देता है।

एक आंतरिक लूप के मामले में, यह केवल आंतरिक लूप जारी रखता है।

हम जावा जारी स्टेटमेंट का उपयोग सभी प्रकार के लूप में कर सकते हैं जैसे कि लूप के लिए, जबकि लूप और डू-जबकि लूप में।

उदाहरण के लिए

class Example{
    public static void main(String args[]){
        System.out.println("Start");
        for(int i=0; i<10; i++){
            if(i==5){continue;}
            System.out.println("i : "+i);   
        }
        System.out.println("End.");
    }
}

उत्पादन:

Start
i : 0
i : 1
i : 2
i : 3
i : 4
i : 6
i : 7
i : 8
i : 9
End.

[संख्या 5 स्किप है]