আমি জাভাতে নেস্টেড লুপগুলি কীভাবে ভাঙ্গবো?


1818

আমি এর মতো নেস্টেড লুপ কনস্ট্রাক্ট পেয়েছি:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             break; // Breaks out of the inner loop
         }
    }
}

এখন আমি উভয় লুপগুলি কীভাবে ভেঙে ফেলব? আমি অনুরূপ প্রশ্নগুলি দেখেছি, তবে জাভা বিশেষভাবে উদ্বেগজনক নয়। আমি এই সমাধানগুলি প্রয়োগ করতে পারিনি কারণ সর্বাধিক ব্যবহৃত গোটোস।

আমি অভ্যন্তরীণ লুপটি কোনও অন্য পদ্ধতিতে রাখতে চাই না।

আমি লুপগুলি পুনরায় চালাতে চাই না। ব্রেক করার সময় আমি লুপ ব্লকটি কার্যকর করে শেষ করি।

উত্তর:


2427

অন্যান্য উত্তরদাতাদের মতো, আমি অবশ্যই আলাদা পদ্ধতিতে লুপগুলি রাখতে পছন্দ করব , যেখানে আপনি কেবল পুনরাবৃত্তি সম্পূর্ণ বন্ধ করতে ফিরে যেতে পারেন। এই উত্তরটি কেবলমাত্র কীভাবে প্রশ্নের প্রয়োজনীয়তা পূরণ করতে পারে তা দেখায়।

আপনি breakবাইরের লুপের জন্য একটি লেবেল ব্যবহার করতে পারেন । উদাহরণ স্বরূপ:

public class Test {
    public static void main(String[] args) {
        outerloop:
        for (int i=0; i < 5; i++) {
            for (int j=0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    break outerloop;
                }
                System.out.println(i + " " + j);
            }
        }
        System.out.println("Done");
    }
}

এই মুদ্রণ:

0 0
0 1
0 2
0 3
0 4
1 0
1 1
1 2
1 3
1 4
2 0
2 1
2 2
2 3
Breaking
Done

286
এই করে লুপ পর সরাসরি তিড়িং লাফ। চেষ্টা করে দেখুন! হ্যাঁ, লেবেলটি লুপের আগে আসে, তবে এটি সেই কারণেই যে আপনি যে স্থানে প্রস্থান করতে চান তার চেয়ে এটি লুপটিকে লেবেল করে। (আপনি একটি লেবেলটি দিয়েও চালিয়ে যেতে পারেন))
জন স্কিটি

2
পার্ল এটির নিজস্ব লেবেল সিস্টেমকেও অনুমতি দেয়। আমি মনে করি অনেকগুলি ভাষা কাজ করে - এটি জাভাতে খুব কমই আমাকে অবাক করে।
ইভান ক্যারল

9
@ ইভান - এই দাবিটি স্পষ্টভাবে সত্য - ভাষাগুলিতে যে প্রতিশ্রুতি দেয় যে এটি সত্য। তবে জাভা সেই প্রতিশ্রুতি দেয় না। কোনও ভাষা যদি আপনার অনুমানের সাথে সাংঘর্ষিক হয়, তবে এটি সম্ভবত আপনার অনুমানের দোষ রয়েছে। এক্ষেত্রে, আমি মনে করি আপনি এখনও আংশিকভাবে সঠিক - নূন্যতম বিস্মিত হওয়া নীতি যারা সেই রূপটি কখনও শুনেনি (বা ভুলে গেছেন) break। তারপরেও ব্যতিক্রমগুলি আরেকটি সুপরিচিত ব্যতিক্রম (দুঃখিত)। তবে আমি এখনও এটি সম্পর্কে অসন্তুষ্ট থাকি যদি এটি সুস্পষ্ট না হয় (ছোট লুপগুলি, সতর্কতা মন্তব্য যদি লেবেল / ব্রেকটি এখনও যথেষ্ট পরিমাণে দৃশ্যমান না হয়)।
স্টিভ 314

6
@ মুহম্মদবাবার: outerloopএকটি লেবেল। আপনি ঠিক কী কোডটি চেষ্টা করেছেন তা আমি জানি না, তবে আমার উত্তরের কোডটি সংকলন করে ঠিক ঠিক চলে runs
জন স্কিটি

4
@ নিসর্গপ্যাটিল সোনারলিঙ্কে থাকার কারণে এটি কোনও কোড গন্ধ পায় না। এর অর্থ হ'ল এমন একজন বিকাশকারী ছিলেন যা এটিকে স্ক্র্যাচ করার জন্য ব্যক্তিগত চুলকানির সাথে সোনারলিন্টের সাথে যুক্ত করেছিল এবং এটি এই ধরণের বিধি দ্বারা পরিপূর্ণ যা কেবল তখনই আপত্তিজনকভাবে কার্যকর হয় বা কিছু বিকাশকারীর বিরুদ্ধে তাদের ব্যক্তিগত বিদ্বেষমূলক ক্রুসেড রয়েছে। আপনি কী করতে চান তা বর্ণনা করার জন্য লেবেলযুক্ত বিরতি এবং অবিরত করা একটি খুব মার্জিত উপায়।
16384

402

প্রযুক্তিগতভাবে সঠিক উত্তরটি বাইরের লুপটি লেবেল করা। অনুশীলনে আপনি যদি কোনও অভ্যন্তরীণ লুপের অভ্যন্তরে যে কোনও বিন্দুতে প্রস্থান করতে চান তবে কোডটি বহিরাগত করে কোনও পদ্ধতিতে (প্রয়োজনে একটি স্ট্যাটিক পদ্ধতি) এবং তারপরে কল করার চেয়ে ভাল।

যা পাঠযোগ্যতার জন্য মূল্য পরিশোধ করবে।

কোডটি এমন কিছু হয়ে উঠবে:

private static String search(...) 
{
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                return search;
            }
        }
    }
    return null; 
}

গৃহীত উত্তরের উদাহরণের সাথে মিলছে:

 public class Test {
    public static void main(String[] args) {
        loop();
        System.out.println("Done");
    }

    public static void loop() {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                if (i * j > 6) {
                    System.out.println("Breaking");
                    return;
                }
                System.out.println(i + " " + j);
            }
        }
    }
}

30
কখনও কখনও আপনি বেশিরভাগ স্থানীয় ভেরিয়েবলগুলি ব্যবহার করেন যা অভ্যন্তরীণ লুপের বাইরে থাকে, সমস্তগুলিতে পাস করা জটিল হয়ে উঠতে পারে।
হাওয়েস্ট

1
তাহলে কীভাবে এই সমাধানটি গৃহীত উত্তরের মতো "সম্পন্ন" মুদ্রণ করবে?
জনডো

1
@ জনডো আপনি এটিকে কল করেছেন এবং তারপরে আপনি System.out.println ("সম্পন্ন") মুদ্রণ করবেন; অনুসন্ধান পদ্ধতিটির মধ্যে}} অবশেষে {try চেষ্টা করাও একটি বিকল্প।
Zo72

2
আমার অনুমান অনুসারে এটি আরও ভাল অনুশীলন, তবে আপনি যদি ভাঙ্গার পরিবর্তে চালিয়ে যেতে চান তবে কি হবে? লেবেলগুলি হয় সমানভাবে ভাল (বা খারাপভাবে!) সমর্থন করে তবে কীভাবে এই যুক্তিটি চালিয়ে যাওয়ার জন্য রূপান্তর করা যায় তা আমি নিশ্চিত নই।
রব গ্রান্ট

@ রবার্টগ্রান্ট যদি আপনি বিরতির পরিবর্তে চালিয়ে যেতে চান তবে loopপদ্ধতির বাইরে বাইরের লুপটি সরান এবং অবিরত পদ্ধতি থেকে ফিরে আসুন ।
মুহাদ

215

আপনি লুপগুলির চারপাশে একটি নামকৃত ব্লক ব্যবহার করতে পারেন:

search: {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition) {
                // Do something and break...
                break search;
            }
        }
    }
}

40
আপনাকে একটি লেবেল ব্যবহার করার জন্য একটি নতুন ব্লক তৈরি করার দরকার নেই।
জন স্কিটি

81
না, তবে এটি উদ্দেশ্যটিকে আরও পরিষ্কার করে দেয়। গৃহীত উত্তরের প্রথম মন্তব্য দেখুন।
বোম্বে

2
এটি আসলে কোনও নামকৃত ব্লক নয়, লেবেলের পরে আপনি কোনও জাভা এক্সপ্রেশন লিখতে পারেন লেবেল ছাড়াই, name: if(...){...}নামকরণের শর্তটি তৈরি করে? :)
লা ভ্লোজেড মেরিলিল

4
এই কন্সট্রাক্টের forসরাসরি লেবেল দেওয়ার চেয়ে বড় সুবিধা রয়েছে । আপনি সর্বশেষের আগে কোড যুক্ত করতে }পারেন যা কেবলমাত্র শর্তটি পূরণ না করলেই সম্পাদিত হবে।
ফ্লোরিয়ান এফ

2
এটি একটি নামযুক্ত ব্লক এবং নামযুক্ত লুপ নয়। আপনি সেই লুপটির মধ্যে "অনুসন্ধান চালিয়ে যেতে" পারেন নি; লুপটির নাম অনুসন্ধান করা হলে এটি সম্পূর্ণ আইনী বাক্য গঠন। আপনি এটি ভাঙ্গতে পারেন, তবে আপনি এটি চালিয়ে যেতে পারবেন না।
তাতারাইজ

132

আমি কখনই লেবেল ব্যবহার করি না। এটি .োকা খারাপ অভ্যাস বলে মনে হচ্ছে। আমি এখানে কি করব:

boolean finished = false;
for (int i = 0; i < 5 && !finished; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            finished = true;
            break;
        }
    }
}

4
এর && !finishedপরিবর্তে হওয়া উচিত নয় || !finished? এবং তারপরে কেন কিছুটা breakব্যবহার && !finishedকরবেন না এবং অভ্যন্তরীণ লুপের জন্যও ব্যবহার করবেন না?
গ্যান্ডালফ

4
আমি breakইচ্ছামত লুপ থেকে প্রস্থান করতে সক্ষম হতে ব্যবহার । যদি এই ifব্লকের পরে কোড breakথাকে তবে এটি কার্যকর করার আগে আপনি তা করতে পারেন । তবে আপনি ঠিক বলেছেন &&। ঠিক কর.
এলে মুন্ডি

2
চমৎকার সমাধান! কোনও অতিরিক্ত কারণে যদি এটি কোনও অতিরিক্ত কার্যক্রমে রাখা ভাল হয় না তবে আমি বাস্তবে এটি কীভাবে করব do
বেনরথ

6
অভ্যন্তরীণ লুপের পরে যদি কিছু যুক্তি থাকে তবে একটি সম্ভাব্য সমস্যা রয়েছে ... যা কার্যকর হতে থাকবে এবং বাইরের লুপটি কেবল তখনই শুরু হবে যখন নতুন পুনরাবৃত্তি শুরু হবে ...
কার্তিক কারুপ্পানান

7
কেন এমনটা করা উচিত তা আমি বুঝতে পারি না। কোড দিয়ে কাজ করা লোকদের একটি ভাষার সমস্ত বৈশিষ্ট্য ব্যবহার করতে সক্ষম হওয়া উচিত। আমি পেয়েছি যে কোডগুলি অন্যরা বুঝতে পারে সেগুলি লিখতে গুরুত্বপূর্ণ, তবে কোনও ভাষা দ্বারা সরবরাহিত অফিশিয়াল সরঞ্জামগুলির ব্যবহারকে সীমাবদ্ধ করে এবং একই কার্যকারিতাটির জন্য কাজের সন্ধান করতে পারে না not বা "খারাপ অভ্যাস" দ্বারা আপনি অন্য কিছু বোঝাতে চেয়েছিলেন?
কোডেবল

107

আপনি লেবেল ব্যবহার করতে পারেন:

label1: 
for (int i = 0;;) {
    for (int g = 0;;) {
      break label1;
    }
}

4
আমার কাছ থেকে একটি +1 করুন। সহজ, বিন্দু, প্রশ্নের উত্তর। বিদ্যমান উত্তরটির পুনরাবৃত্তি করার অভিযোগ করা যাবে না কারণ আপনি একই সময়ে উত্তর দিয়েছিলেন।
হেমডল 16

40

একটি ফাংশন ব্যবহার করুন:

public void doSomething(List<Type> types, List<Type> types2){
  for(Type t1 : types){
    for (Type t : types2) {
      if (some condition) {
         // Do something and return...
         return;
      }
    }
  }
}

20

আপনি একটি অস্থায়ী পরিবর্তনশীল ব্যবহার করতে পারেন:

boolean outerBreak = false;
for (Type type : types) {
   if(outerBreak) break;
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             outerBreak = true;
             break; // Breaks out of the inner loop
         }
    }
}

আপনার ফাংশনের উপর নির্ভর করে আপনি অভ্যন্তরীণ লুপ থেকে প্রস্থান / ফিরে আসতে পারেন:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
             // Do something and break...
             return;
         }
    }
}

7
আমি এই ধরণের বিশৃঙ্খলা খুঁজে পাই।
বাউটা

11
লুপের মাধ্যমে প্রতিবার একটি অতিরিক্ত শর্ত পরীক্ষা করে দেখুন? না ধন্যবাদ.
ryandenki

15

আপনি যদি breakএস এবং gotoএস পছন্দ করেন না , আপনি অতিরিক্ত গর্ভপাত শর্ত সহ ইন-ইন-এর পরিবর্তে লুপের জন্য "traditionalতিহ্যবাহী" ব্যবহার করতে পারেন:

int a, b;
bool abort = false;
for (a = 0; a < 10 && !abort; a++) {
    for (b = 0; b < 10 && !abort; b++) {
        if (condition) {
            doSomeThing();
            abort = true;
        }
    }
}

2
লুপগুলি পূর্বাভাসের জন্য উপযুক্ত নয়।
জন ম্যাকক্লেইন

1
@ জোহানমিসক্লেইন এবং আপনি 9+ বছরের পুরানো প্রশ্নটিতে অনেক উত্তরগুলিতে এটি স্প্যাম করছেন কারণ ...?
কুইন্টেক

12

আমার অনুরূপ কাজ করার দরকার ছিল, তবে আমি লুপের জন্য বর্ধিত ব্যবহার না করা বেছে নিয়েছি।

int s = type.size();
for (int i = 0; i < s; i++) {
    for (int j = 0; j < t.size(); j++) {
        if (condition) {
            // do stuff after which you want 
            // to completely break out of both loops
            s = 0; // enables the _main_ loop to terminate
            break;
        }
    }
}

শর্তটি ভাঙ্গার পরে আমি সমস্ত আইটেম পুনরাবৃত্তি করতে শীতল মনে করি না। সুতরাং আমি অন্য ক্ষেত্রে একটি বিরতি যোগ করতে হবে।
বুটটা

আপনি কীভাবে এই সিদ্ধান্তে পৌঁছেছেন তা আমি নিশ্চিত নই @ বাট্টা শর্তটি সত্য হয়ে গেলে, উভয় লুপগুলি প্রস্থান করা হয়।
সুইফ্টি ম্যাকস্ফটার্টন

ঠিক আছে, আমি 's' ভেরের কারসাজির সাথে অংশটি পাইনি। তবে আমি দেখতে পাই যে ধরণের ধরণের স্টাইলটি আকারকে উপস্থাপন করে। : তারপর আমি স্পষ্ট Vars সঙ্গে ddyer থেকে উত্তর পছন্দ stackoverflow.com/a/25124317/15108
boutta

@ বাউত্তা আপনি এমন কোনও মানতে পরিবর্তন sকরতে পারেন যা এর চেয়ে কম হয় iবা এর চেয়ে iবড় বা সমান মানের পরিবর্তিত হতে পারে s, উভয়েরই কৌশলটি করা উচিত। আপনি পরিবর্তন সম্পর্কে ঠিক বলেছেন s, কারণ এটি পরে অন্য কোথাও ব্যবহার করা যেতে পারে, তবে পরিবর্তনের iক্ষতি হবে না, কেবলমাত্র নিশ্চিত করা forহবে যে প্রথমটি লুপিং চালিয়ে যাবে না।
Zsolti

9

আমি লুপ পরীক্ষায় একটি স্পষ্ট "প্রস্থান" যুক্ত করতে পছন্দ করি। এটি যে কোনও নৈমিত্তিক পাঠকের কাছে স্পষ্ট করে দেয় যে লুপটি শীঘ্রই শেষ হতে পারে।

boolean earlyExit = false;
for(int i = 0 ; i < 10 && !earlyExit; i++) {
     for(int j = 0 ; i < 10 && !earlyExit; j++) { earlyExit = true; }
}

লুপগুলি পূর্বাভাসের জন্য উপযুক্ত নয়।
জন ম্যাকক্লেইন

8

জাভা 8 Streamসমাধান:

List<Type> types1 = ...
List<Type> types2 = ...

types1.stream()
      .flatMap(type1 -> types2.stream().map(type2 -> new Type[]{type1, type2}))
      .filter(types -> /**some condition**/)
      .findFirst()
      .ifPresent(types -> /**do something**/);

1
@ টিভিডি 1 এবং অন্যান্য ব্যবহারকারীর জন্য এখনও কার্যকর, তাই নতুন পদ্ধতি এবং সমাধানগুলি সর্বদা স্বাগত
Andrei Suvorkov

বাহ, এটা কুরুচিপূর্ণ।
ডিএস

7

সাধারণত এই জাতীয় ক্ষেত্রে এটি আরও অর্থবহ যুক্তিযুক্তির ক্ষেত্রের মধ্যে চলে আসে, আসুন প্রশ্নে কিছু পুনরাবৃত্ত 'ফর'-অবজেক্টের জন্য কিছু অনুসন্ধান বা হেরফের বলি, তাই আমি সাধারণত কার্যকরী পদ্ধতির ব্যবহার করি:

public Object searching(Object[] types) { // Or manipulating
    List<Object> typesReferences = new ArrayList<Object>();
    List<Object> typesReferences2 = new ArrayList<Object>();

    for (Object type : typesReferences) {
        Object o = getByCriterion(typesReferences2, type);
        if(o != null) return o;
    }
    return null;
}

private Object getByCriterion(List<Object> typesReferences2, Object criterion) {
    for (Object typeReference : typesReferences2) {
        if(typeReference.equals(criterion)) {
             // here comes other complex or specific logic || typeReference.equals(new Object())
             return typeReference;
        }
    }
    return null;
}

প্রধান কনস:

  • প্রায় দ্বিগুণ লাইন
  • কম্পিউটিং চক্রের আরও বেশি খরচ, যার অর্থ এটি অ্যালগরিদমিক পয়েন্ট-ভিউ থেকে ধীর
  • আরও টাইপিং কাজ

অনুকূল:

  • কার্যক্ষম গ্রানুলারিটির কারণে উদ্বেগের বিচ্ছিন্নতার উচ্চতর অনুপাত
  • পুনঃব্যবহারযোগ্যতা এবং অনুসন্ধান / ম্যানিপুলেটিং যুক্তি ছাড়াই নিয়ন্ত্রণের উচ্চতর অনুপাত
  • পদ্ধতিগুলি দীর্ঘ নয়, সুতরাং এটি আরও কমপ্যাক্ট এবং বোঝা সহজ
  • পাঠযোগ্যতার উচ্চতর অনুপাত

সুতরাং এটি কেবল একটি ভিন্ন পদ্ধতির মাধ্যমে কেস পরিচালনা করছে।

মূলত এই প্রশ্নের লেখকের কাছে একটি প্রশ্ন: আপনি এই পদ্ধতির বিষয়ে কী বিবেচনা করেন?


6

কোনও লেবেল এবং পতাকা ব্যবহার না করে আপনি সমস্ত লুপ থেকে বিরতি ফেলতে পারেন।

এটি কেবল জটিল সমাধান।

এখানে কন্ডিশন 1 হল কন্ডিশন যা লুপ কে এবং জে থেকে বিরতিতে ব্যবহৃত হয় এবং কন্ডিশন 2 কন্ডিশনটি লুপ কে, জে এবং আই থেকে বিরতিতে ব্যবহৃত হয়

উদাহরণ স্বরূপ:

public class BreakTesting {
    public static void main(String[] args) {
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                for (int k = 0; k < 9; k++) {
                    if (condition1) {
                        System.out.println("Breaking from Loop K and J");
                        k = 9;
                        j = 9;
                    }
                    if (condition2) {
                        System.out.println("Breaking from Loop K, J and I");
                        k = 9;
                        j = 9;
                        i = 9;
                    }
                }
            }
        }
        System.out.println("End of I , J , K");
    }
}

2
আমি প্রতিটি লুপের সাথে এটি কীভাবে ব্যবহার করব? ;)
উইল মেন্টজেল

5
List.size ()> 5 এর মতো আপনার আরও পরিশীলিত লুপের অবস্থা থাকলে এটি কাজ করে না। এছাড়াও এটি সত্যই একটি হ্যাক। এটি পড়া কঠিন এবং খারাপ অনুশীলন!
নিউরন

এটি ত্রুটিযুক্ত আপনাকে ভেতরের লুপ পরিবর্তিত কল্পনা (int k = 0; k < 10; k++)এবং তোমাদের সকলের সমাধান করতে না k = 9করতে k = 10। আপনি একটি অসীম লুপ পেতে পারেন।
ফ্লোরিয়ান এফ

5

লেবেলযুক্ত বিরতি ধারণাটি জাভাতে নেস্টেড লুপগুলি ভেঙে ফেলার জন্য ব্যবহৃত হয়, লেবেলযুক্ত বিরতি ব্যবহার করে আপনি যে কোনও অবস্থানে লুপগুলির বাসা ভাঙ্গতে পারেন। উদাহরণ 1:

loop1:
 for(int i= 0; i<6; i++){
    for(int j=0; j<5; j++){
          if(i==3)
            break loop1;
        }
    }

ধরুন এখানে 3 টি লুপ রয়েছে এবং আপনি লুপ 3টি বন্ধ করতে চান: উদাহরণ 2:

loop3: 
for(int i= 0; i<6; i++){
loop2:
  for(int k= 0; k<6; k++){
loop1:
    for(int j=0; j<5; j++){
          if(i==3)
            break loop3;
        }
    }
}

4
boolean broken = false; // declared outside of the loop for efficiency
for (Type type : types) {
    for (Type t : types2) {
        if (some condition) {
            broken = true;
            break;
        }
    }

    if (broken) {
        break;
    }
}

4

এটি যদি কোনও ফাংশনের অভ্যন্তরে থাকে তবে আপনি কেবল এটি ফিরিয়ে দেন না কেন:

for (Type type : types) {
    for (Type t : types2) {
         if (some condition) {
            return value;
         }
    }
}

আমি এই প্যাটার্ন পছন্দ। এটি প্রায়শই আমাকে আলাদা ফাংশনে লুপগুলি ভেঙে ফেলার কারণ করে। আমার কোডটি সবসময় করার পরে ভাল হয়েছে, সুতরাং এই কারণে আমি সত্যিই এই উত্তরটি পছন্দ করি।
বিল কে

4

সেরা এবং সহজ পদ্ধতি ..

outerloop:
for(int i=0; i<10; i++){
    // here we can break Outer loop by 
    break outerloop;

    innerloop:
    for(int i=0; i<10; i++){
        // here we can break innerloop by 
        break innerloop;
     }
}

4
এই ব্রেকিংয়ের উদাহরণগুলি খুব কার্যকর নয়, এমনকি লেবেল ছাড়াও তারা একই পয়েন্টে ভেঙে দেবে। আপনি যে কোডটি বাস্তবে কার্যকর করতে পারেন, এমন কোডটি পাওয়া সর্বদা চমৎকার, যেহেতু আপনার কোডের ক্ষেত্রে এটি হয় না, কারণ অন্তর্লুপটি কখনই পৌঁছাতে পারে না ..
নিউরন

আমি একই জিনিস টাইপ করতে যাচ্ছি। এই ক্ষেত্রে লেবেলগুলি কিছুটা অকেজো।
তাসলিম ওসেনি

4

বরং অস্বাভাবিক দৃষ্টিভঙ্গি কিন্তু কোডের দৈর্ঘ্যের ক্ষেত্রে ( পারফরম্যান্স নয় ) এটি আপনার পক্ষে করা সহজতম কাজ:

for(int i = 0; i++; i < j) {
    if(wanna exit) {
        i = i + j; // if more nested, also add the 
                   // maximum value for the other loops
    }
}


4

আর একটি সমাধান, উদাহরণ ছাড়াই উল্লিখিত (এটি আসলে প্রোড কোডে কাজ করে)।

try {
    for (Type type : types) {
        for (Type t : types2) {
            if (some condition #1) {
                // Do something and break the loop.
                throw new BreakLoopException();
            }
        }
    }
}
catch (BreakLoopException e) {
    // Do something on look breaking.
}

অবশ্যই BreakLoopExceptionঅভ্যন্তরীণ, ব্যক্তিগত এবং নন-স্ট্যাক-ট্রেস সহ গতিযুক্ত হওয়া উচিত:

private static class BreakLoopException extends Exception {
    @Override
    public StackTraceElement[] getStackTrace() {
        return new StackTraceElement[0];
    }
}

1
এটি আসলে উল্লিখিত হয়েছে, একটি উত্তরে -২৩ ভোট পেয়ে ... stackoverflow.com/a/886980/2516301 । এটি কাজটি করবে, তবে এটি একটি খুব খারাপ প্রোগ্রামিং অনুশীলন ...
vefthym

প্রকৃতপক্ষে. তবে আমি এই জাতীয় লিগ্যাসি কোড দেখেছি - 4 টি স্তরের নেস্ট লুপগুলি বেশ কয়েকটি ব্রেকিং শর্ত সহ with এবং এটি ইনলাইনড কোডের চেয়ে ব্যতিক্রমগুলির সাথে আরও পঠনযোগ্য ছিল। -২৩ টি ভোট বেশিরভাগ সংবেদনশীল রেটিং, তবে হ্যাঁ - এই পদ্ধতিটি সাবধানতার সাথে ব্যবহার করা উচিত।
ursa

1
এটি আরও বেশি পঠনযোগ্য হত যদি এটি সেন্টার-রিটার্ন সহ আলাদা ফাংশন কলে পরিণত হয়। প্রায়শই একটি সামান্য চুল্লী দ্বারা আরও ভাল তৈরি করা হয় যাতে এটি স্ট্যান্ড-একা (প্রায়শই পুনরায় ব্যবহারযোগ্য) ফাংশন হিসাবে বোধ করা যায়।
বিল কে

2

for (int j = 0; j < 5; j++) //inner loopসঙ্গে প্রতিস্থাপন করা উচিত for (int j = 0; j < 5 && !exitloops; j++)

এখানে, সেক্ষেত্রে সম্পূর্ণ নেস্টেড লুপগুলি প্রস্থান করা উচিত True। তবে আমরা যদি exitloopsকেবল উপরেরটি ব্যবহার করি loop

 for (int i = 0; i < 5 && !exitloops; i++) //upper loop

তারপরে অভ্যন্তরীণ লুপটি অবিরত থাকবে, কারণ কোনও অতিরিক্ত পতাকা নেই যা এই অভ্যন্তরীণ লুপটি প্রস্থান করার জন্য জানায়।

উদাহরণ: যদি i = 3এবং j=2তারপর শর্ত হয় false। কিন্তু ভেতরের লুপ এর পরবর্তী পুনরাবৃত্তিতে মধ্যে j=3 তারপর শর্ত (i*j)হয়ে 9যা trueকিন্তু পর্যন্ত ভেতরের লুপ অবিরত করা হবে না jহয়ে 5

সুতরাং, এটি অবশ্যই exitloopsঅভ্যন্তরীণ লুপগুলিতে ব্যবহার করা উচিত ।

boolean exitloops = false;
for (int i = 0; i < 5 && !exitloops; i++) { //here should exitloops as a Conditional Statement to get out from the loops if exitloops become true. 
    for (int j = 0; j < 5 && !exitloops; j++) { //here should also use exitloops as a Conditional Statement. 
        if (i * j > 6) {
            exitloops = true;
            System.out.println("Inner loop still Continues For i * j is => "+i*j);
            break;
        }
        System.out.println(i*j);
    }
}

2

@ 1800 তথ্য পরামর্শের মতো, বাইরের লুপের শর্ত হিসাবে অভ্যন্তরীণ লুপকে ভেঙে দেওয়া শর্তটি ব্যবহার করুন:

boolean hasAccess = false;
for (int i = 0; i < x && hasAccess == false; i++){
    for (int j = 0; j < y; j++){
        if (condition == true){
            hasAccess = true;
            break;
        }
    }
}

2

যদি এটি একটি নতুন বাস্তবায়ন হয়, আপনি যুক্তিটি আবার-লেখার চেষ্টা করতে পারেন যেমন-অন্যথায়_আইফ-অন্য বিবৃতি।

while(keep_going) {

    if(keep_going && condition_one_holds) {
        // Code
    }
    if(keep_going && condition_two_holds) {
        // Code
    }
    if(keep_going && condition_three_holds) {
        // Code
    }
    if(keep_going && something_goes_really_bad) {
        keep_going=false;
    }
    if(keep_going && condition_four_holds) {
        // Code
    }
    if(keep_going && condition_five_holds) {
        // Code
    }
}

অন্যথায় আপনি যখন একটি বিশেষ শর্তটি আসবে তখন আপনি পতাকা সেট করার চেষ্টা করতে পারেন এবং আপনার প্রতিটি লুপ-শর্তে সেই পতাকাটির জন্য পরীক্ষা করতে পারেন।

something_bad_has_happened = false;
while(something is true && !something_bad_has_happened){
    // Code, things happen
    while(something else && !something_bad_has_happened){
        // Lots of code, things happens
        if(something happened){
            -> Then control should be returned ->
            something_bad_has_happened=true;
            continue;
        }
    }
    if(something_bad_has_happened) { // The things below will not be executed
        continue;
    }

    // Other things may happen here as well, but they will not be executed
    //  once control is returned from the inner cycle.
}

এখানে! সুতরাং, একটি সাধারণ বিরতি কাজ করবে না, এটি ব্যবহার করে কাজ করা যেতে পারে continue

আপনি যদি কেবল একটি প্রোগ্রামিং ভাষা থেকে জাভাতে যুক্তিটি পোর্ট করেন এবং কেবল জিনিসটি কাজ করতে চান তবে আপনি লেবেলগুলি ব্যবহার করে দেখতে পারেন ।


2

ডেমো জন্য break, continueএবং label:

জাভা কীওয়ার্ড breakএবং continueএকটি ডিফল্ট মান আছে। এটি "নিকটতম লুপ", এবং আজ, জাভা ব্যবহারের কয়েক বছর পরে, আমি কেবল এটি পেয়েছি!

এটি বিরল, তবে দরকারী বলে মনে হচ্ছে।

import org.junit.Test;

/**
 * Created by cui on 17-5-4.
 */

public class BranchLabel {
    @Test
    public void test() {
        System.out.println("testBreak");
        testBreak();

        System.out.println("testBreakLabel");
        testBreakLabel();

        System.out.println("testContinue");
        testContinue();
        System.out.println("testContinueLabel");
        testContinueLabel();
    }

    /**
     testBreak
     a=0,b=0
     a=0,b=1
     a=1,b=0
     a=1,b=1
     a=2,b=0
     a=2,b=1
     a=3,b=0
     a=3,b=1
     a=4,b=0
     a=4,b=1
     */
    public void testBreak() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    break;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testContinue
     a=0,b=0
     a=0,b=1
     a=0,b=3
     a=0,b=4
     a=1,b=0
     a=1,b=1
     a=1,b=3
     a=1,b=4
     a=2,b=0
     a=2,b=1
     a=2,b=3
     a=2,b=4
     a=3,b=0
     a=3,b=1
     a=3,b=3
     a=3,b=4
     a=4,b=0
     a=4,b=1
     a=4,b=3
     a=4,b=4
     */
    public void testContinue() {
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                if (b == 2) {
                    continue;
                }
                System.out.println("a=" + a + ",b=" + b);
            }
        }
    }

    /**
     testBreakLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     * */
    public void testBreakLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        break anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }

    /**
     testContinueLabel
     a=0,b=0,c=0
     a=0,b=0,c=1
     a=1,b=0,c=0
     a=1,b=0,c=1
     a=2,b=0,c=0
     a=2,b=0,c=1
     a=3,b=0,c=0
     a=3,b=0,c=1
     a=4,b=0,c=0
     a=4,b=0,c=1
     */
    public void testContinueLabel() {
        anyName:
        for (int a = 0; a < 5; a++) {
            for (int b = 0; b < 5; b++) {
                for (int c = 0; c < 5; c++) {
                    if (c == 2) {
                        continue anyName;
                    }
                    System.out.println("a=" + a + ",b=" + b + ",c=" + c);
                }
            }
        }
    }
}

2

ডেমো

public static void main(String[] args) {
    outer:
    while (true) {
        while (true) {
            break outer;
        }
    }
}

1

আপনি নিম্নলিখিতটি করতে পারেন:

  1. একটি স্থানীয় ভেরিয়েবল সেট করুন false

  2. trueআপনি যখন ব্রেক করতে চান তখন প্রথম লুপে সেই পরিবর্তনশীলটি সেট করুন

  3. তারপরে আপনি বাইরের লুপটি পরীক্ষা করতে পারেন, কন্ডিশনটি সেট করা আছে কিনা তা পাশাপাশি বাইরের লুপ থেকেও বিরতি।

    boolean isBreakNeeded = false;
    for (int i = 0; i < some.length; i++) {
        for (int j = 0; j < some.lengthasWell; j++) {
            //want to set variable if (){
            isBreakNeeded = true;
            break;
        }
    
        if (isBreakNeeded) {
            break; //will make you break from the outer loop as well
        }
    }

1

কিছু ক্ষেত্রে, আমরা whileকার্যকরভাবে এখানে লুপ ব্যবহার করতে পারি ।

Random rand = new Random();
// Just an example
for (int k = 0; k < 10; ++k) {
    int count = 0;
    while (!(rand.nextInt(200) == 100)) {
       count++;
    }

    results[k] = count;
}

1

সি ++ এর মতো জাভাতে গেটো বৈশিষ্ট্য নেই। তবে এখনও, gotoজাভাতে একটি সংরক্ষিত কীওয়ার্ড। তারা ভবিষ্যতে এটি বাস্তবায়ন করতে পারে। আপনার প্রশ্নের জন্য, উত্তরটি হ'ল জাভাতে এমন একটি লেবেল রয়েছে যা আপনি একটি continueএবং breakবিবৃতি প্রয়োগ করতে পারেন । নীচের কোডটি সন্ধান করুন:

public static void main(String ...args) {
    outerLoop: for(int i=0;i<10;i++) {
    for(int j=10;j>0;j--) {
        System.out.println(i+" "+j);
        if(i==j) {
            System.out.println("Condition Fulfilled");
            break outerLoop;
        }
    }
    }
    System.out.println("Got out of the outer loop");
}

1

এমনকি বাইরের লুপের জন্য একটি পতাকা তৈরি করা এবং অভ্যন্তরীণ লুপের প্রতিটি প্রয়োগের পরে উত্তর হতে পারে তা পরীক্ষা করা।

এটার মত:

for (Type type : types) {
    boolean flag=false;
    for (Type t : types2) {
        if (some condition) {
            // Do something and break...
            flag=true;
            break; // Breaks out of the inner loop
        }
    }
    if(flag)
        break;
}

1
boolean condition = false;
for (Type type : types) {
    for (int i = 0; i < otherTypes.size && !condition; i ++) {
        condition = true; // If your condition is satisfied
    }
}

আপনার conditionপ্রক্রিয়াজাতকরণটি শেষ হওয়ার জন্য একটি পতাকা হিসাবে ব্যবহার করুন । তারপরে শর্তটি পূরণ না করা অবস্থায় কেবল অভ্যন্তরীণ লুপটি চলতে থাকে। যেভাবেই হোক, বাইরের লুপটি চুগগিন রাখবে '।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.