কিভাবে জাভা 'প্রত্যেকের জন্য' লুপ কাজ করে?

1498

বিবেচনা:

List<String> someList = new ArrayList<String>();
// add "monkey", "donkey", "skeleton key" to someList

for (String item : someList) {
    System.out.println(item);
}

প্রতিটি সিনট্যাক্স forব্যবহার না করে সমতুল্য লুপটি দেখতে কেমন হবে ?

java foreach syntactic-sugar

— জে আর।
সূত্র

: JLS অনুযায়ী এটিকে দুটি রূপ আছে stackoverflow.com/a/33232565/1216775

— akhil_mittal

1175

for (Iterator<String> i = someIterable.iterator(); i.hasNext();) {
    String item = i.next();
    System.out.println(item);
}

মনে রাখবেন যে i.remove();আপনার লুপটি ব্যবহার করতে বা কোনও উপায়ে প্রকৃত পুনরাবৃত্তির অ্যাক্সেসের প্রয়োজন হলে আপনি প্রবাদটি ব্যবহার করতে পারবেন না for ( : ), যেহেতু প্রকৃত পুনরাবৃত্তিটি কেবল অনুমিত হয়।

যেমনটি ডেনিস বুয়েনো দ্বারা উল্লিখিত ছিল, এই কোডটি এমন কোনও বস্তুর জন্য কাজ করে যা Iterableইন্টারফেস প্রয়োগ করে ।

এছাড়াও, যদি for (:)আইডিয়মের ডান হাতের কোনও অংশের arrayপরিবর্তে হয় Iterableতবে অভ্যন্তরীণ কোডটি কোনও ইনটেক্স সূচি পাল্টা ব্যবহার করে এবং এর array.lengthপরিবর্তে পরীক্ষা করে। দেখুন জাভা ল্যাঙ্গুয়েজ স্পেসিফিকেশন ।

— nsayer
সূত্র

14

আমি সবেমাত্র কিছুক্ষণের মতো কল পেয়েছি (someList.hasMoreElements ()) do // কিছু করুন}} - আমাকে কোডিং করুণার সাথে কাছে পেয়েছে যখন আমি এই প্রশ্নের জন্য অনুসন্ধান করব তখন আমি খুঁজে পেতে আশা করব।

— জেমস টি স্নেল

6

এছাড়াও ডকস.ওরাকল.com/javase/1.5.0/docs/guide/language/foreach.html যা পূর্বাভাস লুপ ব্যাখ্যা করে (কখন এটি চালু হয়েছিল) দেখুন

— ফোনিক্স

1

অ্যান্ড্রয়েড স্টুডিও বিকাশকারীদের জন্য: import java.util.Iterator;এবংimport java.lang.Iterable;

— ডিএসডিএসডিএসডিএসডি

হতাশাজনকভাবে, java.util.Iteratorবাস্তবায়ন করে না Iterableতাই আপনি পারবেন না for(String s : (Iterator<String>)foo)। আমি বুঝতে পারছি কেন এই, কিন্তু এটা করা হয় জ্বালাময়।

— ক্রিস্টোফার

499

কনস্ট্রাক্ট প্রত্যেকের জন্য এছাড়াও অ্যারে জন্য বৈধ। যেমন

String[] fruits = new String[] { "Orange", "Apple", "Pear", "Strawberry" };

for (String fruit : fruits) {
    // fruit is an element of the `fruits` array.
}

যা মূলত সমতুল্য

for (int i = 0; i < fruits.length; i++) {
    String fruit = fruits[i];
    // fruit is an element of the `fruits` array.
}

সুতরাং, সামগ্রিক সারাংশ:
[nsayer] নীচেরটি যা ঘটছে তার দীর্ঘ রূপ:

for(Iterator<String> i = someList.iterator(); i.hasNext(); ) {
  String item = i.next();
  System.out.println(item);
}
মনে রাখবেন যে আপনার যদি i.remove () ব্যবহারের প্রয়োজন হয়; আপনার লুপে বা কোনও উপায়ে প্রকৃত পুনরাবৃত্তিকে অ্যাক্সেস করতে পারেন, তবে আপনি (:) প্রতিচ্ছবি ব্যবহার করতে পারবেন না, যেহেতু প্রকৃত আইট্রেটার কেবল অনুমিত।

[ডেনিস বুয়েনো]

এটি এনসায়রের উত্তরের মাধ্যমে বোঝানো হয়েছে, তবে এটি লক্ষণীয় যে "ওপরের জন্য (..) সিনট্যাক্স কাজ করবে যখন" সামারলিস্ট "এমন কিছু যা জাভা.এলং বাস্তবায়িত করে।যে উল্লেখযোগ্য - এটি কোনও তালিকা বা কোনও সংগ্রহ হতে পারে না java.util। এমনকি আপনার নিজস্ব প্রকারগুলিও তাই এই সিনট্যাক্সের সাথে ব্যবহার করা যেতে পারে।

— Mikezx6r
সূত্র

161

foreachলুপ , যোগ জাভা 5 (নামেও "লুপ জন্য উন্নত"), একটি ব্যবহার সমতূল্য java.util.Iteratorএকই জিনিসের জন্য --it এর অন্বিত চিনি। সুতরাং, প্রতিটি উপাদান পড়ার সময় একে একে এবং foreachযথাযথভাবে একটি পুনরুক্তিকারীর উপরে সর্বদা একটি চয়ন করা উচিত, কারণ এটি আরও সুবিধাজনক এবং সংক্ষিপ্ত।

প্রতিটির জন্য, প্রত্যেকটির জন্য

for(int i : intList) {
   System.out.println("An element in the list: " + i);
}

iterator

Iterator<Integer> intItr = intList.iterator();
while(intItr.hasNext()) {
   System.out.println("An element in the list: " + intItr.next());
}

এমন পরিস্থিতি রয়েছে যেখানে আপনাকে অবশ্যই Iteratorসরাসরি ব্যবহার করতে হবে । উদাহরণস্বরূপ, একটি ক্যান ব্যবহার করার সময় কোনও উপাদান মোছার চেষ্টা করা foreach(উইল?) এর ফলে ক ConcurrentModificationException।

`foreach`বনাম `for`: বেসিক পার্থক্য

মধ্যে শুধুমাত্র ব্যবহারিক পার্থক্য forএবং foreachযে, সূচিযোগ্য বস্তুর ক্ষেত্রে, আপনি সূচক এক্সেস হবে না। যখন মৌলিক forলুপটি প্রয়োজন হয় তখন একটি উদাহরণ :

for(int i = 0; i < array.length; i++) {
   if(i < 5) {
      // Do something special
   }  else {
      // Do other stuff
   }
}

যদিও আপনি ম্যানুয়ালি আলাদা আলাদা সূচক ইন্ট-ভেরিয়েবল এর সাথে তৈরি করতে পারেন foreach,

int idx = -1;
for(int i : intArray) {
   idx++;
   ...
}

এটি সুপারিশ করা হয় না, যেহেতু ভেরিয়েবল-স্কোপটি আদর্শ নয়, এবং বুনিয়াদি forলুপটি কেবল এই ব্যবহারের ক্ষেত্রে আদর্শ এবং প্রত্যাশিত বিন্যাস।

`foreach`বনাম `for`: পারফরম্যান্স

যখন সংগ্রহের অ্যাক্সেস, একটি foreachহল উল্লেখযোগ্যভাবে দ্রুততর মৌলিক চেয়ে forলুপ এর অ্যারে অ্যাক্সেস। অ্যারে অ্যাক্সেস করার সময়, যদিও - অন্তত আদিম এবং মোড়ক-অ্যারে সহ - সূচীর মাধ্যমে অ্যাক্সেস নাটকীয়ভাবে দ্রুত হয়।

প্রারম্ভিক ইন-অ্যারেগুলির জন্য পুনরাবৃত্তকারী এবং সূচক অ্যাক্সেসের মধ্যে পার্থক্যের সময় নির্ধারণ করা

অ্যাক্সেস বা অ্যারে করার সময় সূচকগুলি পুনরাবৃত্তির তুলনায় 23- 40 শতাংশ দ্রুত হয় । এই পোস্টের নীচে টেস্টিং ক্লাস থেকে আউটপুট এখানে দেওয়া হয়েছে, যা 100-উপাদানগুলির আদিম-আন্ত অ্যারেতে সংখ্যার যোগফল দেয় (A পুনরুত্থক, বি সূচক হয়):intInteger

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 358,597,622 nanoseconds
Test B: 269,167,681 nanoseconds
B faster by 89,429,941 nanoseconds (24.438799231635727% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 377,461,823 nanoseconds
Test B: 278,694,271 nanoseconds
B faster by 98,767,552 nanoseconds (25.666236154695838% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 288,953,495 nanoseconds
Test B: 207,050,523 nanoseconds
B faster by 81,902,972 nanoseconds (27.844689860906513% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,373,765 nanoseconds
Test B: 283,813,875 nanoseconds
B faster by 91,559,890 nanoseconds (23.891659337194227% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 375,790,818 nanoseconds
Test B: 220,770,915 nanoseconds
B faster by 155,019,903 nanoseconds (40.75164734599769% faster)

[C:\java_code\]java TimeIteratorVsIndexIntArray 1000000
Test A: 326,373,762 nanoseconds
Test B: 202,555,566 nanoseconds
B faster by 123,818,196 nanoseconds (37.437545972215744% faster)

আমি এটি Integerঅ্যারের জন্যও চালিয়েছি, এবং সূচকগুলি এখনও স্পষ্ট বিজয়ী, তবে কেবল 18 থেকে 25 শতাংশের মধ্যে দ্রুত।

সংগ্রহের জন্য, পুনরাবৃত্তিগুলি সূচকের চেয়ে দ্রুত

একটি জন্য Listএর Integersঅবশ্য iterators স্পষ্ট বিজয়ী হয়। কেবল পরীক্ষার শ্রেণিতে অন্তর্-অ্যারেটি পরিবর্তন করুন:

List<Integer> intList = Arrays.asList(new Integer[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100});

আর পরীক্ষা ফাংশন প্রয়োজনীয় পরিবর্তন করুন ( int[]থেকে List<Integer>, lengthথেকে size(), ইত্যাদি):

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,429,929,976 nanoseconds
Test B: 5,262,782,488 nanoseconds
A faster by 1,832,852,512 nanoseconds (34.326681820485675% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,907,391,427 nanoseconds
Test B: 3,957,718,459 nanoseconds
A faster by 1,050,327,032 nanoseconds (26.038700083921256% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,566,004,688 nanoseconds
Test B: 4,221,746,521 nanoseconds
A faster by 1,655,741,833 nanoseconds (38.71935684115413% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 2,770,945,276 nanoseconds
Test B: 3,829,077,158 nanoseconds
A faster by 1,058,131,882 nanoseconds (27.134122749113843% faster)

[C:\java_code\]java TimeIteratorVsIndexIntegerList 1000000
Test A: 3,467,474,055 nanoseconds
Test B: 5,183,149,104 nanoseconds
A faster by 1,715,675,049 nanoseconds (32.60101667104192% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,439,983,933 nanoseconds
Test B: 3,509,530,312 nanoseconds
A faster by 69,546,379 nanoseconds (1.4816434912159906% faster)

[C:\java_code\]java TimeIteratorVsIndexIntList 1000000
Test A: 3,451,101,466 nanoseconds
Test B: 5,057,979,210 nanoseconds
A faster by 1,606,877,744 nanoseconds (31.269164666060377% faster)

একটি পরীক্ষায় তারা প্রায় সমান, তবে সংগ্রহের সাথে পুনরাবৃত্তির জয় হয়।

* এই পোস্টটি স্ট্যাক ওভারফ্লোতে আমি যে দুটি উত্তর লিখেছি তার উপর ভিত্তি করে:

আরও কিছু তথ্য: কোনটি আরও দক্ষ, প্রতিটি লুপের জন্য বা একটি পুনরুক্তিযোগ্য?

সম্পূর্ণ পরীক্ষার ক্লাস

স্ট্যাক ওভারফ্লোতে এই প্রশ্নটি পড়ার পরে আমি এই তুলনা-সময়ের-তুলনায়-কোনও-দুটি-জিনিস শ্রেণীর তৈরি করেছি :

import  java.text.NumberFormat;
import  java.util.Locale;

/**
   &lt;P&gt;{@code java TimeIteratorVsIndexIntArray 1000000}&lt;/P&gt;

   @see  &lt;CODE&gt;&lt;A HREF=&quot;/programming/180158/how-do-i-time-a-methods-execution-in-java&quot;&gt;/programming/180158/how-do-i-time-a-methods-execution-in-java&lt;/A&gt;&lt;/CODE&gt;
 **/
public class TimeIteratorVsIndexIntArray {

    public static final NumberFormat nf = NumberFormat.getNumberInstance(Locale.US);

    public static final void main(String[] tryCount_inParamIdx0) {
        int testCount;

        // Get try-count from a command-line parameter
        try {
           testCount = Integer.parseInt(tryCount_inParamIdx0[0]);
        }
        catch(ArrayIndexOutOfBoundsException | NumberFormatException x) {
           throw  new IllegalArgumentException("Missing or invalid command line parameter: The number of testCount for each test. " + x);
        }

        //Test proper...START
        int[] intArray = new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100};

        long lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testIterator(intArray);
        }

        long lADuration = outputGetNanoDuration("A", lStart);

        lStart = System.nanoTime();
        for(int i = 0; i < testCount; i++) {
           testFor(intArray);
        }

        long lBDuration = outputGetNanoDuration("B", lStart);

        outputGetABTestNanoDifference(lADuration, lBDuration, "A", "B");
    }

    private static final void testIterator(int[] int_array) {
       int total = 0;
       for(int i = 0; i < int_array.length; i++) {
          total += int_array[i];
       }
    }

    private static final void testFor(int[] int_array) {
       int total = 0;
       for(int i : int_array) {
          total += i;
       }
    }
    //Test proper...END

    //Timer testing utilities...START
    public static final long outputGetNanoDuration(String s_testName, long l_nanoStart) {
        long lDuration = System.nanoTime() - l_nanoStart;
        System.out.println("Test " + s_testName + ": " + nf.format(lDuration) + " nanoseconds");
        return  lDuration;
    }

    public static final long outputGetABTestNanoDifference(long l_aDuration, long l_bDuration, String s_aTestName, String s_bTestName) {
        long lDiff = -1;
        double dPct = -1.0;
        String sFaster = null;
        if(l_aDuration > l_bDuration) {
            lDiff = l_aDuration - l_bDuration;
            dPct = 100.00 - (l_bDuration * 100.0 / l_aDuration + 0.5);
            sFaster = "B";
        }
        else {
            lDiff = l_bDuration - l_aDuration;
            dPct = 100.00 - (l_aDuration * 100.0 / l_bDuration + 0.5);
            sFaster = "A";
        }
        System.out.println(sFaster + " faster by " + nf.format(lDiff) + " nanoseconds (" + dPct + "% faster)");
        return  lDiff;
   }

   //Timer testing utilities...END

}

— aliteralmind
সূত্র

4

এই উত্তরটি এখন একটি ব্লগ পোস্ট এবং আমার লেখা দুটি সম্পর্কিত উত্তর থেকে তৈরি হয়েছিল: এখানে এবং এখানে । এটিতে দুটি কার্যের গতির তুলনায় (নীচে) জেনারালি উপযোগী বর্গ অন্তর্ভুক্ত রয়েছে।

— aliteralmind

1

এখানে কেবল একটি ছোটখাটো মন্তব্য, আপনার স্পষ্টতই বলা উচিত নয় যে (:) সিনট্যাক্স সংগ্রহে অ্যাক্সেস করার জন্য সর্বদা ভাল; আপনি যদি একটি অ্যারে তালিকা ব্যবহার করছেন তবে (:) i লেন; অ্যারেলিস্ট.সাইজ (); আই <লেন; আই ++) এর চেয়ে (:) লুপটি প্রায় 2 x ধীর হবে। আমি মনে করি আপনি উল্লেখ করেছেন যে [লিঙ্ক] ( স্ট্যাকওভারফ্লো.com / প্রশ্নস / ২১১৩২২6/২ ) লিঙ্কটিতে যাইহোক, তবে তা তুলে ধরা গুরুত্বপূর্ণ ...

— লিও

@ লিও এটি একটি ভাল পয়েন্ট। একটি অ্যারেলিস্ট হ'ল সংগ্রহ, তবে এটি অ্যারে দ্বারা সমর্থনযুক্ত, যার জন্য এটি এর জন্য স্বাভাবিক better

— aliteralmind

আমি অনুমান করি যে এটি for(int value : int_array) {/* loop content */}আপনার পরীক্ষার সবচেয়ে ধীরতম কারণ এটি সিনট্যাক্টিক্যালি সমান for(int i = 0; i < int_array.length; i++) {int value = int_array[i]; /* loop content */}, যা আপনার পরীক্ষার সাথে তুলনা করে না।

— ডাইসকোগ

(উপায় দ্বারা, আমি বলছি না আপনার পরীক্ষার অবৈধ, কিন্তু এটা যাতে পার্থক্য পিছনে কারণ লক্ষ মানুষ নির্বাচন করতে পারবেন যে কি তাদের নির্দিষ্ট দৃশ্যকল্প জন্য সঠিক মূল্য হতে পারে। তারা একটি করছ তাহলে int value = int_array[i];তাদের জন্য শুরুতে লুপ, তারপরে তারা পাশাপাশি

— ভবিষ্যদ্বাণীও ব্যবহার করতে পারে Un যদি না

129

এখানে একটি উত্তর যা জাভা আইট্রেটারদের জ্ঞান গ্রহণ করে না। এটি কম সুনির্দিষ্ট, তবে এটি শিক্ষার জন্য কার্যকর।

প্রোগ্রামিং করার সময় আমরা প্রায়শই এমন কোড লিখি যা নিম্নলিখিতগুলির মতো দেখায়:

char[] grades = ....
for(int i = 0; i < grades.length; i++) {   // for i goes from 0 to grades.length
    System.out.print(grades[i]);           // Print grades[i]
}

পূর্বাঞ্চ সিনট্যাক্স এই সাধারণ প্যাটার্নটিকে আরও প্রাকৃতিক এবং কম সিন্ট্যাক্টিক্যালি কোলাহলপূর্ণভাবে লেখার অনুমতি দেয়।

for(char grade : grades) {   // foreach grade in grades
    System.out.print(grade); // print that grade
}

অতিরিক্তভাবে এই সিনট্যাক্সটি তালিকা বা সেটগুলি যেমন অ্যারে সূচককে সমর্থন করে না তবে জাভা আইটারেবল ইন্টারফেস বাস্তবায়িত করে এমন বস্তুর জন্য বৈধ।

— MRocklin
সূত্র

40

জাভা-এর প্রতিটি লুপ অন্তর্নিহিত পুনরুক্তি পদ্ধতি ব্যবহার করে। সুতরাং এটি নিম্নলিখিত অনুরূপ:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
  String item = iterator.next();
  System.out.println(item);
}

— toluju
সূত্র

25

জাভা 8 বৈশিষ্ট্যে আপনি এটি ব্যবহার করতে পারেন:

List<String> messages = Arrays.asList("First", "Second", "Third");

void forTest(){
    messages.forEach(System.out::println);
}

আউটপুট

First
Second
Third

— Jrovalle
সূত্র

7

এই এলোমেলো তথ্য এমনকি দূরবর্তী প্রশ্নের প্রশ্নের উত্তর দেয় না

— টিম

25

এটি এনসায়রের উত্তরের মাধ্যমে বোঝানো হয়েছে, তবে এটি লক্ষণীয় যে "ওপরের জন্য (..) সিনট্যাক্স কাজ করবে যখন" সামারলিস্ট "এমন কিছু যা জাভা.এলং বাস্তবায়িত করে।যে উল্লেখযোগ্য - এটি কোনও তালিকা বা কোনও সংগ্রহ হতে পারে না java.util। এমনকি আপনার নিজস্ব প্রকারগুলিও তাই এই সিনট্যাক্সের সাথে ব্যবহার করা যেতে পারে।

— EfForEffort
সূত্র

1

fd সঠিক - অভ্যন্তরীণ কোডটি যখন এর জন্য ডান হাতের (:) প্রতিচ্ছবিটি কোনও আইট্রেটার আনার পরিবর্তে কোনও int এবং অ্যারে.লেন্থ ব্যবহার করে। forums.sun.com/thread.jspa?messageID=2743233

— nsayer

24

প্রতিটি লুপের জন্য জেএলএসে সংজ্ঞায়িত হিসাবে দুটি ফর্ম থাকতে পারে:

এক্সপ্রেশনের ধরণটি যদি একটি সাব টাইপ হয় Iterableতবে অনুবাদটি হ'ল:

List<String> someList = new ArrayList<String>();
someList.add("Apple");
someList.add("Ball");
for (String item : someList) {
    System.out.println(item);
}

// IS TRANSLATED TO:

for(Iterator<String> stringIterator = someList.iterator(); stringIterator.hasNext(); ) {
    String item = stringIterator.next();
    System.out.println(item);
}

এক্সপ্রেশনটি অগত্যা যদি অ্যারে টাইপ করে থাকে T[]তবে:

String[] someArray = new String[2];
someArray[0] = "Apple";
someArray[1] = "Ball";

for(String item2 : someArray) {
    System.out.println(item2);
}

// IS TRANSLATED TO:
for (int i = 0; i < someArray.length; i++) {
    String item2 = someArray[i];
    System.out.println(item2);
}

জাভা 8 স্ট্রিমগুলি চালু করেছে যা সাধারণত আরও ভাল সম্পাদন করে। আমরা সেগুলি হিসাবে ব্যবহার করতে পারি:

someList.stream().forEach(System.out::println);
Arrays.stream(someArray).forEach(System.out::println);

— akhil_mittal
সূত্র

2

সবচেয়ে প্রাসঙ্গিক এবং সঠিক উত্তর। এর জন্য এনচ্যানডের দুটি অনুবাদই রয়েছে।

— জারিয়াল

23

একটি অগ্রণী লুপ সিনট্যাক্স হ'ল:

for (type obj:array) {...}

উদাহরণ:

String[] s = {"Java", "Coffe", "Is", "Cool"};
for (String str:s /*s is the array*/) {
    System.out.println(str);
}

আউটপুট:

Java
Coffe
Is
Cool

সতর্কতা: আপনি foreach লুপ দিয়ে অ্যারে উপাদান অ্যাক্সেস করতে পারেন, কিন্তু আপনি তাদের আরম্ভ করতে পারবেন না। এর forজন্য আসল লুপটি ব্যবহার করুন।

সতর্কতা: আপনাকে অবশ্যই অন্য অবজেক্টের সাথে অ্যারের ধরণটি মেলাতে হবে।

for (double b:s) // Invalid-double is not String

আপনি যদি উপাদানগুলি সম্পাদনা করতে চান তবে মূল forলুপটি এই জাতীয়ভাবে ব্যবহার করুন :

for (int i = 0; i < s.length-1 /*-1 because of the 0 index */; i++) {
    if (i==1) //1 because once again I say the 0 index
        s[i]="2 is cool";
    else
        s[i] = "hello";
}

এখন যদি আমরা কনসোলে এস ডাম্প করি তবে আমরা পাই:

hello
2 is cool
hello
hello

— PrivateName
সূত্র

21

জাভা "প্রত্যেকের জন্য" লুপ কনস্ট্রাক্ট দুটি ধরণের অবজেক্টের উপর পুনরাবৃত্তির অনুমতি দেবে:

T[] (যে কোনও ধরণের অ্যারে)
java.lang.Iterable<T>

Iterable<T>ইন্টারফেস মাত্র এক পদ্ধতি রয়েছে: Iterator<T> iterator()। এটি ধরণের জিনিসগুলিতে কাজ করে Collection<T>কারণ Collection<T>ইন্টারফেস প্রসারিত হয় Iterable<T>।

— রায়ান দেলুচি
সূত্র

16

উইকিপিডিয়ায় উল্লিখিত ফোরচ লুপের ধারণাটি নীচে হাইলাইট করা হয়েছে:

লুপ কন্সট্রাক্টসের জন্য অন্যগুলির মতো নয় তবে, ফোরচ লুপগুলি সাধারণত কোনও স্পষ্ট কাউন্টার বজায় রাখে না : তারা মূলত "এই x বার করুন" এর পরিবর্তে "এই সেটটিতে সমস্ত কিছু করার জন্য" বলে say এটি একের পর এক সম্ভাব্য ত্রুটিগুলি এড়িয়ে যায় এবং কোডটি পড়ার পক্ষে সহজ করে তোলে।

সুতরাং ফোরচ লুপের ধারণাটি বর্ণনা করে যে লুপটি কোনও স্পষ্ট কাউন্টার ব্যবহার করে না যার অর্থ তালিকাগুলি অনুসরণ করার জন্য সূচীগুলি ব্যবহার করার দরকার নেই সুতরাং এটি ব্যবহারকারীকে বাইরের ত্রুটি থেকে বাঁচায়। এই অফ-বাই ওয়ান ত্রুটির সাধারণ ধারণাটি বর্ণনা করতে, আসুন সূচীগুলি ব্যবহার করে একটি তালিকায় প্রবেশ করতে একটি লুপের উদাহরণ নিই take

// In this loop it is assumed that the list starts with index 0
for(int i=0; i<list.length; i++){

}

তবে ধরুন যদি তালিকাটি সূচক 1 দিয়ে শুরু হয় তবে এই লুপটি একটি ব্যতিক্রম ছুঁড়ে যাচ্ছে কারণ এটি সূচক 0 তে কোনও উপাদান খুঁজে পাবে না এবং এই ত্রুটিটিকে অফ-বাই-ওয়ান ত্রুটি বলে। সুতরাং এই অফ-ওয়ান ত্রুটিটি এড়াতে ফোরচ লুপের ধারণাটি ব্যবহৃত হয়। অন্যান্য সুবিধাগুলিও থাকতে পারে তবে আমি মনে করি এটিই মূল ধারণা এবং ফোরচ লুপ ব্যবহারের সুবিধা।

— oneConsciousness
সূত্র

13

জাভা 8-এ, তারা প্রত্যেকের জন্য প্রবর্তন করেছিলেন। এটি তালিকা ব্যবহার করে মানচিত্র লুপ করা যায়।

প্রতিটি জন্য ব্যবহার করে একটি তালিকা লুপ করুন

List<String> someList = new ArrayList<String>();
someList.add("A");
someList.add("B");
someList.add("C");

someList.forEach(listItem -> System.out.println(listItem))

অথবা

someList.forEach(listItem-> {
     System.out.println(listItem); 
});

প্রতিটি জন্য ব্যবহার করে একটি মানচিত্র লুপ করুন

Map<String, String> mapList = new HashMap<>();
    mapList.put("Key1", "Value1");
    mapList.put("Key2", "Value2");
    mapList.put("Key3", "Value3");

mapList.forEach((key,value)->System.out.println("Key: " + key + " Value : " + value));

অথবা

mapList.forEach((key,value)->{
    System.out.println("Key : " + key + " Value : " + value);
});

— vivekkurien
সূত্র

12

for (Iterator<String> itr = someList.iterator(); itr.hasNext(); ) {
   String item = itr.next();
   System.out.println(item);
}

— রজার লিন্ডসে
সূত্র

11

Java 7আপনি সহ পুরানো জাভা সংস্করণ ব্যবহার করে নীচে foreachলুপ ব্যবহার করতে পারেন ।

List<String> items = new ArrayList<>();
        items.add("A");
        items.add("B");
        items.add("C");
        items.add("D");
        items.add("E");

        for(String item : items){
            System.out.println(item);
        }

foreachলুপ ইন ব্যবহারের অতি সাম্প্রতিক উপায় নিম্নলিখিতটিJava 8

( forEach+ ল্যাম্বদা এক্সপ্রেশন বা পদ্ধতি রেফারেন্স সহ একটি তালিকা লুপ করুন )

//lambda
    //Output : A,B,C,D,E
    items.forEach(item->System.out.println(item));


//method reference
    //Output : A,B,C,D,E
    items.forEach(System.out::println);

আরও তথ্যের জন্য এই লিঙ্কটি দেখুন।

https://www.mkyong.com/java8/java-8-foreach-examples/

— ডুলিথ দে কস্তা
সূত্র

10

এখানে একটি সমতুল্য প্রকাশ।

for(Iterator<String> sit = someList.iterator(); sit.hasNext(); ) {
    System.out.println(sit.next());
}

— হ্যাঁক
সূত্র

10

এছাড়াও নোট করুন যে মূল প্রশ্নে "ফরচ" পদ্ধতিটি ব্যবহার করার কিছু সীমাবদ্ধতা রয়েছে যেমন পুনরাবৃত্তির সময় তালিকাগুলি থেকে আইটেমগুলি সরাতে না পারা।

নতুন ফর্মের লুপটি পড়া সহজ এবং পৃথক পুনরাবৃত্তির প্রয়োজনীয়তা অপসারণ করা সহজ, তবে কেবল পঠনযোগ্য পুনরাবৃত্তি পাসগুলিতে কেবল ব্যবহারযোগ্য।

— billjamesdev
সূত্র

1

এই ক্ষেত্রে, সঠিক ব্যবহার removeIfহতে পারে

— ncmathsadist

9

আপনার "প্রত্যেকের জন্য" এড়াতে forEach এর বিকল্প:

List<String> someList = new ArrayList<String>();

বৈকল্পিক 1 (সমতল):

someList.stream().forEach(listItem -> {
    System.out.println(listItem);
});

বৈকল্পিক 2 (সমান্তরাল সম্পাদন (দ্রুত)):

someList.parallelStream().forEach(listItem -> {
    System.out.println(listItem);
});

— আলেকজান্ডার দ্রোবিশেভস্কি
সূত্র

2

এটি জাভা 1.8-এ যুক্ত হয়েছে উল্লেখ করা উচিত

— TheLibrarian

একই থ্রেড ব্যবহৃত হয়েছে তা আমরা 100% নিশ্চিত হতে পারি না। আমি for(একই থ্রেডটি ব্যবহৃত হয়েছে কিনা তা নিশ্চিত করতে চাইলে আমি ফর্মটি ব্যবহার করতে চাই। আমি যদি মাল্টিথ্রেডেড কার্যকরকরণের অনুমতি দিতে চাই তবে আমি স্ট্রিম-ফর্মটি ব্যবহার করতে চাই।

— গ্রিম

8

এটি সমস্ত বেসিক লুপিং বিশৃঙ্খলা অপসারণ করে আপনার কোডে সৌন্দর্য যোগ করে। এটি নীচে ন্যায়সঙ্গত, আপনার কোডটিকে একটি পরিষ্কার চেহারা দেয়।

সাধারণ forলুপ:

void cancelAll(Collection<TimerTask> list) {
    for (Iterator<TimerTask> i = list.iterator(); i.hasNext();)
         i.next().cancel();
}

প্রত্যেকের জন্য ব্যবহার:

void cancelAll(Collection<TimerTask> list) {
    for (TimerTask t : list)
        t.cancel();
}

প্রত্যেকটির জন্য হ'ল একটি সংগ্রহের উপরে নির্মাণ যা আইট্রেটার প্রয়োগ করে । মনে রাখবেন, আপনার সংগ্রহে আইট্রেটার প্রয়োগ করা উচিত ; অন্যথায় আপনি একে একে জন্য ব্যবহার করতে পারবেন না।

নিম্নলিখিত লাইন "হিসাবে পড়া হয় তালিকার প্রতিটি TimerTask টি জন্য। "

for (TimerTask t : list)

প্রতিটির ক্ষেত্রে ত্রুটির সম্ভাবনা কম রয়েছে। আপনাকে পুনরাবৃত্তকারী শুরু করতে বা লুপের কাউন্টারটি শুরু করতে এবং এটি (যেখানে ত্রুটির সুযোগ রয়েছে) সমাপ্ত করার বিষয়ে আপনাকে চিন্তা করতে হবে না।

— মনোহর
সূত্র

8

জাভা 8 এর পূর্বে আপনাকে নিম্নলিখিতগুলি ব্যবহার করতে হবে:

Iterator<String> iterator = someList.iterator();

while (iterator.hasNext()) {
    String item = iterator.next();
    System.out.println(item);
}

তবে জাভা 8-এ স্ট্রিমস প্রবর্তনের সাথে আপনি একই জিনিসটি অনেক কম সিনট্যাক্সে করতে পারেন। উদাহরণস্বরূপ, আপনার জন্য someListআপনি এটি করতে পারেন:

someList.stream().forEach(System.out::println);

আপনি এখানে স্ট্রিম সম্পর্কে আরও জানতে পারেন ।

— stackFan
সূত্র

The foreach loop, added in Java 5 (also called the "enhanced for loop"), is equivalent to using a java.util.Iterator

— অ্যালেক্স 78191

7

এটি দেখতে এমন কিছু লাগবে। খুব ক্রুফটি।

for (Iterator<String> i = someList.iterator(); i.hasNext(); )
        System.out.println(i.next());

সেখানে একটি ভালো কাজের মধ্যে থাকবেন হয় প্রত্যেকের জন্য এ সূর্যের ডকুমেন্টেশন ।

— পিট
সূত্র

6

যেহেতু অনেকগুলি ভাল উত্তর বলেছে, কোনও বস্তুকে অবশ্যই এটি প্রয়োগ করতে হবে Iterable interfaceযদি এটি for-eachলুপ ব্যবহার করতে চায় ।

আমি একটি সাধারণ উদাহরণ পোস্ট করব এবং একটি for-eachলুপ কীভাবে কাজ করে তা অন্যভাবে ব্যাখ্যা করার চেষ্টা করব ।

for-eachলুপ উদাহরণ:

public class ForEachTest {

    public static void main(String[] args) {

        List<String> list = new ArrayList<String>();
        list.add("111");
        list.add("222");

        for (String str : list) {
            System.out.println(str);
        }
    }
}

তারপরে, আমরা যদি javapএই ক্লাসটি সংক্ষেপিত করতে ব্যবহার করি তবে আমরা এই বাইকোড নমুনাটি পেয়ে যাব:

public static void main(java.lang.String[]);
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #16                 // class java/util/ArrayList
         3: dup
         4: invokespecial #18                 // Method java/util/ArrayList."<init>":()V
         7: astore_1
         8: aload_1
         9: ldc           #19                 // String 111
        11: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        16: pop
        17: aload_1
        18: ldc           #27                 // String 222
        20: invokeinterface #21,  2           // InterfaceMethod java/util/List.add:(Ljava/lang/Object;)Z
        25: pop
        26: aload_1
        27: invokeinterface #29,  1           // InterfaceMethod java/util/List.iterator:()Ljava/util/Iterator;

আমরা যেমন নমুনার শেষ লাইনটি থেকে দেখতে পাচ্ছি, সংকলক স্বয়ংক্রিয়ভাবে for-eachকীওয়ার্ডের ব্যবহারটি Iteratorসংকলন সময়ে ব্যবহারের ক্ষেত্রে রূপান্তর করবে । এটি ব্যাখ্যা করতে পারে যে বস্তুটি, যা বাস্তবায়ন করে না Iterable interface, Exceptionযখন এটি for-eachলুপটি ব্যবহার করার চেষ্টা করে তখন একটি নিক্ষেপ করবে ।

— এল জো
সূত্র

6

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

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

কোনও লুপ সূচনা নেই, কোনও বুলিয়ান শর্ত নেই এবং পদক্ষেপের মান অন্তর্নিহিত এবং একটি সাধারণ বর্ধন। এ কারণেই এগুলিকে লুপের জন্য নিয়মিত তুলনায় এতো সহজ বলে বিবেচনা করা হয়।

লুপগুলির জন্য বর্ধিত করা কার্যকরকরণের এই আদেশটি অনুসরণ করে:

1) লুপ শরীর

2) পুরো অ্যারে বা সংগ্রহটি ট্র্যাভার করা না হওয়া পর্যন্ত পদক্ষেপ 1 থেকে পুনরাবৃত্তি করুন

উদাহরণ - পূর্ণসংখ্যার অ্যারে

int [] intArray = {1, 3, 5, 7, 9};
for(int currentValue : intArray) {
  System.out.println(currentValue);
}

কারেন্টভ্যালু ভেরিয়েবলটি বর্তমান মানটি ইনআরে অ্যারেতে লুপ করা হচ্ছে। লক্ষ্য করুন কোনও সুস্পষ্ট পদক্ষেপের মান নেই - এটি সর্বদা 1 দ্বারা বৃদ্ধি হয়।

কোলনকে "ইন" বলে বোঝা যায়। সুতরাং লুপ ঘোষণার জন্য বর্ধিত রাজ্যটি জানিয়েছে: ইনট্রে অ্যারে লুপের উপরে এবং বর্তমানের অ্যারে- ইন মানটি বর্তমানের ভেরিয়েবলের মধ্যে সঞ্চয় করে ।

আউটপুট:

উদাহরণ - স্ট্রিং অ্যারে

স্ট্রিংগুলির একটি অ্যারেতে পুনরাবৃত্তি করতে আমরা প্রতিটি লুপ ব্যবহার করতে পারি। লুপ ঘোষণা পদ বলে: ওভার myStrings স্ট্রিং অ্যারে লুপ এবং বর্তমান স্ট্রিং মান সংরক্ষণ মধ্যে currentString পরিবর্তনশীল।

String [] myStrings  = {
  "alpha",
  "beta",
  "gamma",
  "delta"
};

for(String currentString : myStrings) {
  System.out.println(currentString);
}

আউটপুট:

alpha
beta
gamma
delta

উদাহরণ - তালিকা

লুপের জন্য বর্ধিত বর্ধিত অংশটি java.util- এর উপরে পুনরাবৃত্তি করতে ব্যবহার করা যেতে পারে ist নীচে তালিকাভুক্ত করুন:

List<String> myList = new ArrayList<String>();
myList.add("alpha");
myList.add("beta");
myList.add("gamma");
myList.add("delta");

for(String currentItem : myList) {
  System.out.println(currentItem);
}

লুপ ঘোষণা পদ বলে: myList স্ট্রিং তালিকা উপর লুপ এবং বর্তমান তালিকা মান সংরক্ষণ মধ্যে CURRENTITEM পরিবর্তনশীল।

আউটপুট:

alpha
beta
gamma
delta

উদাহরণ - সেট

লুপের জন্য বর্ধিত বর্ধিত অংশটি java.util এর উপরে পুনরাবৃত্তি করতে ব্যবহার করা যেতে পারে et নীচে সেট করুন:

Set<String> mySet = new HashSet<String>();
mySet.add("alpha");
mySet.add("alpha");
mySet.add("beta");
mySet.add("gamma");
mySet.add("gamma");
mySet.add("delta");

for(String currentItem : mySet) {
  System.out.println(currentItem);
}

লুপ ঘোষণায় বলা হয়েছে: স্ট্রিংসের মাইসেট সেট ওভার করুন এবং বর্তমান সেট মানটি বর্তমান আইটেম ভেরিয়েবলের মধ্যে সঞ্চয় করুন store লক্ষ্য করুন যেহেতু এটি একটি সেট, তাই নকল স্ট্রিংয়ের মান সংরক্ষণ করা হয় না।

আউটপুট:

alpha
delta
beta
gamma

উত্স: জাভা এ লুপ - চূড়ান্ত গাইড

— gomisha
সূত্র

4

public static Boolean Add_Tag(int totalsize)
{ List<String> fullst = new ArrayList<String>();
            for(int k=0;k<totalsize;k++)
            {
              fullst.addAll();
            }
}

— সন্তোষ রাজকুমার
সূত্র

3

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

— TheArchon
সূত্র

-1: এটি কম পাঠযোগ্য (সাধারণভাবে): এমনকি আপনার নিজের উদাহরণ (প্রথমটি )ও ভুল, কারণ এটি অ্যারের প্রথম উপাদানটি বাদ দেয়।

— ওন্দ্রেজ স্কোপেক

2

এটিকে পাগল দেখাচ্ছে তবে ওহে এটি কাজ করে

List<String> someList = new ArrayList<>(); //has content
someList.forEach(System.out::println);

এইটা কাজ করে. জাদু

— রে ব্রাউন
সূত্র

1

এটি জাভা 1.8 +

— বার্নি

2

এমনকি দূরবর্তী অবস্থান থেকে প্রশ্নের উত্তর দেয় না

— টিম

2

অন্যান্য অনেক উত্তর সঠিকভাবে জানিয়েছে for each loopযে , এটি কেবল একই পুরানোটির চেয়ে বেশি সিনট্যাকটিক চিনি for loopএবং সংকলক লুপের জন্য এটি একই পুরানোতে অনুবাদ করে।

জাভাক (ওপেন জেডিকে) এর একটি স্যুইচ রয়েছে -XD-printflat, যা জাভা ফাইল তৈরি করে যা সমস্ত সিনট্যাকটিক চিনি অপসারণ করে। সম্পূর্ণ কমান্ড এর মত দেখাচ্ছে

javac -XD-printflat -d src/ MyFile.java

//-d is used to specify the directory for output java file

সুতরাং সিনট্যাকটিকাল চিনির অপসারণ করতে দিন

এই প্রশ্নের উত্তর দেওয়ার জন্য, আমি একটি ফাইল তৈরি করেছি এবং এর দুটি সংস্করণ লিখেছি for each, একটিতে arrayএকটি এবং অন্যটি দিয়ে list। আমার javaফাইলটি এরকম দেখাচ্ছে।

import java.util.*;
public class Temp{

    private static void forEachArray(){
        int[] arr = new int[]{1,2,3,4,5};
        for(int i: arr){
            System.out.print(i);
        }
    }

    private static void forEachList(){
        List<Integer> list = Arrays.asList(1,2,3,4,5);
        for(Integer i: list){
            System.out.print(i);
        }
    }
}

compiledউপরের স্যুইচ সহ আমি যখন এই ফাইলটি পেলাম তখন আমি নিম্নলিখিত ফলাফলটি পেয়েছি।

import java.util.*;

public class Temp {

    public Temp() {
        super();
    }

    private static void forEachArray() {
        int[] arr = new int[]{1, 2, 3, 4, 5};
        for (/*synthetic*/ int[] arr$ = arr, len$ = arr$.length, i$ = 0; i$ < len$; ++i$) {
            int i = arr$[i$];
            {
                System.out.print(i);
            }
        }
    }

    private static void forEachList() {
        List list = Arrays.asList(new Integer[]{Integer.valueOf(1), Integer.valueOf(2), Integer.valueOf(3), Integer.valueOf(4), Integer.valueOf(5)});
        for (/*synthetic*/ Iterator i$ = list.iterator(); i$.hasNext(); ) {
            Integer i = (Integer)i$.next();
            {
                System.out.print(i);
            }
        }
    }
}

আপনি দেখতে পাচ্ছেন যে প্রতিটি লুপের জন্য অন্যান্য সিনট্যাকটিক চিনির সাথে (অটোবক্সিং) সাধারণ লুপে পরিবর্তিত হয়েছে।

— mightyWOZ
সূত্র

-2

List<Item> Items = obj.getItems();
for(Item item:Items)
             {
                System.out.println(item); 
             }

আইটেম টেবিলের সমস্ত বস্তুর উপরে আইট্রেটস।

— shubhranshu
সূত্র

1

ব্যবহারকারী সিনট্যাক্সের জন্য জিজ্ঞাসা

— করেননি

কিভাবে জাভা 'প্রত্যেকের জন্য' লুপ কাজ করে?

প্রতিটির জন্য, প্রত্যেকটির জন্য

iterator

foreachবনাম for: বেসিক পার্থক্য

foreachবনাম for: পারফরম্যান্স

প্রারম্ভিক ইন-অ্যারেগুলির জন্য পুনরাবৃত্তকারী এবং সূচক অ্যাক্সেসের মধ্যে পার্থক্যের সময় নির্ধারণ করা

সংগ্রহের জন্য, পুনরাবৃত্তিগুলি সূচকের চেয়ে দ্রুত

সম্পূর্ণ পরীক্ষার ক্লাস

আউটপুট

সুতরাং সিনট্যাকটিকাল চিনির অপসারণ করতে দিন

`foreach`বনাম `for`: বেসিক পার্থক্য

`foreach`বনাম `for`: পারফরম্যান্স