java - কিভাবে জাভা মধ্যে nested loops বিরতি?




(20)

আমি এই মত একটি নিস্তেজ লুপ গঠন আছে করেছি:

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

এখন আমি কিভাবে loops উভয় বিরতি আউট করতে পারেন। আমি একই প্রশ্ন তাকিয়ে আছে, কিন্তু কেউ জাভা বিশেষভাবে উদ্বেগ। সর্বাধিক ব্যবহৃত GOTOS কারণ আমি এই সমাধান প্রয়োগ করতে পারে না।

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

হালনাগাদ: আমি লুপগুলি পুনরায় চালু করতে চাই না, যখন আমি লুপ ব্লকটি কার্যকর করে শেষ করেছি।


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

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

আপনি বাইরের লুপ জন্য একটি লেবেল দিয়ে 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

আপনি loops প্রায় একটি নামকরণ ব্লক ব্যবহার করতে পারেন:

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

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

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

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

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

আপনি যদি goto এবং goto গুলি break না চান, তবে অতিরিক্ত বর্ধিত অবস্থার সাথে আপনি ইনফ্রেশের পরিবর্তে লুপের জন্য "প্রথাগত" ব্যবহার করতে পারেন:

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

আপনি শুধু ভেতরের loops ভঙ্গ জন্য লেবেল ব্যবহার করুন

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

আমি this প্রশ্নের উত্তর দিতে চেয়েছিলাম কিন্তু একটি অনুরূপ হিসাবে চিহ্নিত করা হয়েছিল যা আমাকে পোস্ট করা থেকেও বাধা দেয়। তাই এখানে পরিবর্তে এটি পোস্ট!

যদি এটি একটি নতুন বাস্তবায়ন হয় তবে আপনি যদি-else_if-else বিবৃতি হিসাবে যুক্তি পুনরায় লেখার চেষ্টা করতে পারেন।

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) { // things below will not be executed
        continue;
    }

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

HERE! So, while a simple break will not work, it can be made to work using continue.

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


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

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

আমি লেবেল ব্যবহার না। এটা পেতে একটি খারাপ অভ্যাস মত মনে হয়। এখানে আমি কি করবো:

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

এমনকি বাইরের লুপের জন্য একটি পতাকা তৈরি করে এবং অভ্যন্তরীণ লুপের প্রতিটি কার্যকরকরণের উত্তর দেওয়ার পরে এটি যাচাই করা যেতে পারে।

এটার মত :

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

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

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

জাভাতে C ++ রয়েছে এমন একটি গোটা বৈশিষ্ট্য নেই। কিন্তু এখনও, 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");
}

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

যে পঠনযোগ্যতা জন্য বন্ধ দিতে হবে।

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

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

বরং অস্বাভাবিক পদ্ধতির কিন্তু কোড দৈর্ঘ্যের ( কর্মক্ষমতা না ) শর্তাবলীতে আপনি এটি করতে পারেন এমন সহজতম জিনিস:

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

যদি কিছু ফাংশন ভিতরে থাকে তবে কেন আপনি এটি ফেরত দেবেন না:

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

শ্রেষ্ঠ এবং সহজ পদ্ধতি ..

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

হয়তো একটি ফাংশন দিয়ে?

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

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

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

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

তারপর অভ্যন্তরীণ লুপ চলতে থাকবে, কারণ অতিরিক্ত ফ্ল্যাগ নেই যা প্রস্থান করার জন্য এই অভ্যন্তরীণ লুপটি অবহিত করে।

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

সুতরাং, এটি অভ্যন্তরীণ loops খুব 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);
    }
}

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






loops