জাভা ইটারেটর কেন ইটেটেবল নয়?

Question

Iteratorইন্টারফেসটি কেন বাড়ে না Iterable?

iterator()পদ্ধতি কেবল ফিরে আসতে পারে this।

এটি উদ্দেশ্য বা জাভা ডিজাইনারদের শুধুমাত্র একটি তদারকি?

এটির মতো পুনরাবৃত্তকারীগুলির সাথে প্রতিটি লুপ ব্যবহার করতে সক্ষম হওয়াই সুবিধাজনক হবে:

for(Object o : someContainer.listSomeObjects()) {
    ....
}

যেখানে listSomeObjects()একটি পুনরাবৃত্তি প্রদান করে।

Comments

ঠিক আছে - আমি আপনার পয়েন্ট বুট দেখতে। এমনকি এটি কোনও শব্দার্থবিজ্ঞানকে কিছুটা

— ভাঙলেও

আমি বুঝতে পেরেছি যে এই প্রশ্নটি অনেক আগে জিজ্ঞাসা করা হয়েছিল, তবে - আপনি কি কোনও আইট্রেটার, বা কোনও সংগ্রহের সাথে সম্পর্কিত কোনও আইট্রেটারকে বোঝাতে চাইছেন?

— einpoklum

Answer 1

কারণ একটি পুনরুক্তিকারী একটি সংগ্রহের মধ্যে একটি একক উদাহরণকে সাধারণত নির্দেশ করে। অপরিবর্তনীয় ইঙ্গিত দেয় যে কোনও ব্যক্তি তার উপাদানগুলিকে অতিক্রম করতে কোনও বস্তুর কাছ থেকে আয়রেটর পেতে পারে - এবং কোনও একক উদাহরণে পুনরাবৃত্তি করার প্রয়োজন নেই, এটিই একটি পুনরুক্তি প্রতিনিধিত্ব করে।

Comments

+1: একটি সংগ্রহ পুনরাবৃত্তিযোগ্য। কোনও পুনরুক্তি করা যায় না কারণ এটি কোনও সংগ্রহ নয় ite

— এস .লট

যদিও আমি উত্তরটির সাথে একমত, আমি জানি না আমি মানসিকতার সাথে একমত হই কিনা। Iteable ইন্টারফেস একটি একক পদ্ধতি উপস্থাপন করে: Iterator <?> পুনরুক্তি (); যা-ই হোক না কেন, আমার প্রত্যেকের জন্য একটি পুনরাবৃত্তি নির্দিষ্ট করতে সক্ষম হওয়া উচিত। আমি এটি কিনতে না।

— ক্রিস কে

@ এস খুব সুন্দর বিজ্ঞপ্তি যুক্তি সেখানে।

— yihtserns

@ এসলট সর্বশেষ প্রচেষ্টা: সংগ্রহ ∈ শ্রদ্ধেয়। Iterator ≠ সংগ্রহ ∴ Iterator ∉ পরিবেশনযোগ্য

— yihtserns

@ এসলট: সংগ্রহ এই আলোচনার পক্ষে সম্পূর্ণ অপ্রাসঙ্গিক। সংগ্রহযোগ্য Iteable এর অনেকগুলি সম্ভব বাস্তবায়নের মধ্যে একটি। যে কোনও জিনিস সংগ্রহ নয় তা সত্য নয় যে এটি কোনও মূল্যবান।

— কলিনড

Answer 2

একটি পুনরাবৃত্তি রাষ্ট্রীয়। ধারণাটি হ'ল আপনি Iterable.iterator()দু'বার কল করলে আপনি স্বাধীন পুনরাবৃত্তকারী পাবেন - বেশিরভাগ পুনরাবৃত্তির জন্য, যাইহোক। আপনার দৃশ্যে এটি স্পষ্টভাবে ঘটবে না।

উদাহরণস্বরূপ, আমি সাধারণত লিখতে পারি:

public void iterateOver(Iterable<String> strings)
{
    for (String x : strings)
    {
         System.out.println(x);
    }
    for (String x : strings)
    {
         System.out.println(x);
    }
}

এটি সংগ্রহটি দু'বার মুদ্রণ করা উচিত - তবে আপনার স্কিমের সাহায্যে দ্বিতীয় লুপটি সর্বদা তাত্ক্ষণিকভাবে শেষ হয়ে যায়।

Comments

@ ক্রিস: যদি কোনও প্রয়োগ দুটি একই পুনরুক্তি ফেরত দেয় তবে পৃথিবীতে কীভাবে এটি ইটারের চুক্তিটি সম্পাদন করতে পারে? আপনি যদি কলটি iteratorব্যবহার করেন এবং ফলাফলটি ব্যবহার করেন, এটি সংগ্রহের মাধ্যমে পুনরাবৃত্তি করতে হবে - যা যদি একই বস্তুটি ইতিমধ্যে সংগ্রহটির উপরে পুনরুক্তি করে তবে তা তা করবে না। আপনি কি কোনও সঠিক বাস্তবায়ন দিতে পারেন (খালি সংগ্রহ ব্যতীত) যেখানে একই পুনরুক্তিটি দুবার ফিরে আসে?

— জন স্কিটি

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

— joelittlejohn

@ জনস্কিট যখন একজন আইট্রেটার <টি> রাষ্ট্রীয়, আইট্রেবল <টি> এর চুক্তিতে স্বতন্ত্র পুনরাবৃত্তি পেতে দু'বার ব্যবহার করতে সক্ষম হওয়া সম্পর্কে কিছুই বলা হয় না, এমনকি এটি 99% ক্ষেত্রে দৃশ্যমান। সমস্ত অপরিবর্তনীয় <টি> বলেছেন যে এটি কোনও বস্তুকে ফোরচের লক্ষ্য হতে দেয়। আপনারা যারা আইট্রেটার <T> আইট্রেবল <টি> না হয়ে অসন্তুষ্ট তাদের জন্য আপনি এই জাতীয় আইট্রেটার <টি> তৈরি করতে নির্দ্বিধায় রয়েছেন। এটি চুক্তিটি কিছুটা ভাঙ্গবে না। যাইহোক - নিজেই এটির পরিবেশনকারীকে পরিমার্জনীয় হওয়া উচিত নয় যেহেতু এটি চক্রাকারে নির্ভর করে এবং এটি আইকি নকশার জন্য ভিত্তি স্থাপন করে।

— সেন্ট্রিল

@ সেন্ট্রিল: ঠিক আছে। সাধারণতiterable দু'বার কল করা আপনাকে স্বাধীন পুনরাবৃত্তি দেবে তা বোঝাতে সম্পাদনা করেছেন ।

— জন স্কিটি

এটি এটি হৃদয় পেতে। নিজেকে পুনরায় সেট করে .iterator () প্রয়োগ করে এমন কোনও Iteable Iterator বাস্তবায়ন করা প্রায় সম্ভব হবে, তবে এই নকশাটি এখনও কিছু পরিস্থিতিতে ভেঙে যেতে পারে, উদাহরণস্বরূপ, যদি এটি এমন কোনও পদ্ধতিতে পাস করা হয় যা একটি Iteable লাগে এবং সমস্ত সম্ভাব্য জোড়গুলি লুপ করে if প্রতিটি লুপের জন্য নেস্ট করে উপাদানগুলির।

— থিওডোর মুরডক

Answer 3

আমার $ 0.02 এর জন্য, আমি সম্পূর্ণরূপে একমত যে Iterator Iteable বাস্তবায়ন করা উচিত নয়, তবে আমি মনে করি লুপের জন্য বর্ধিত বর্ধনকারীটিকে গ্রহণ করা উচিত। আমি মনে করি পুরো "পুনরাবৃত্তিকারীদের পুনরাবৃত্ত করুন" যুক্তিটি ভাষার কোনও ত্রুটির জন্য কাজ হিসাবে আসে।

লুপের জন্য বর্ধিত প্রবর্তনের পুরো কারণটি হ'ল এটি "সংগ্রহ এবং অ্যারেগুলিতে পুনরাবৃত্তি করার সময় পুনরাবৃত্তিকারী এবং সূচক ভেরিয়েবলগুলির কৌতুক এবং ত্রুটি-সর্বনত্বকে সরিয়ে দেয়" [ 1 ]।

Collection<Item> items...

for (Iterator<Item> iter = items.iterator(); iter.hasNext(); ) {
    Item item = iter.next();
    ...
}

for (Item item : items) {
    ...
}

তাহলে কেন এই একই যুক্তি পুনরাবৃত্তকারীদের জন্য রাখা হয় না?

Iterator<Iter> iter...
..
while (iter.hasNext()) {
    Item item = iter.next();
    ...
}

for (Item item : iter) {
    ...
}

উভয় ক্ষেত্রেই, হ্যাসনেক্সট () এবং পরবর্তী () এ কলগুলি সরিয়ে ফেলা হয়েছে, এবং অভ্যন্তরীণ লুপে পুনরাবৃত্তির কোনও রেফারেন্স নেই। হ্যাঁ, আমি বুঝতে পারি যে একাধিক পুনরাবৃত্তকারী তৈরি করতে Iterables পুনরায় ব্যবহার করা যেতে পারে, তবে এটি লুপের বাইরে সমস্ত ঘটে: লুপের ভিতরে কেবল একবারে অগ্রণী অগ্রগতি হয় একবারে পুনরাবৃত্তির দ্বারা ফিরে আসা আইটেমগুলিতে item

এছাড়াও, এর সাহায্যে এনুমারেশনের জন্য লুপটি ব্যবহার করাও সহজ হবে যা অন্য কোথাও দেখানো হয়েছে, আইট্রেটারদের নয় বরং আইট্রেটারদের সাথে সাদৃশ্যপূর্ণ।

সুতরাং Iterator Iteable বাস্তবায়ন করবেন না, কিন্তু হয় লুপ গ্রহণ করার জন্য আপডেট করুন।

চিয়ার্স,

Comments

আমি রাজী. তাত্ত্বিকভাবে একটি পুনরাবৃত্তি পাওয়ার সময়, এর অংশটি ব্যবহার করে এবং তারপরে একটি ভবিষ্যতে রেখে (ভবিষ্যতের "প্রতিটি" চুক্তি ভঙ্গ করে) বিভ্রান্তি হতে পারে, তবে এই বৈশিষ্ট্যটি না রাখার যথেষ্ট কারণ বলে আমি মনে করি না।

— বার্ট ভ্যান হিউকেলোম

অ্যারে পুনরাবৃত্তিযোগ্য সংগ্রহ করার পরিবর্তে অ্যারে গ্রহণ করার জন্য আমরা ইতিমধ্যে লুপ আপডেট / বর্ধিত করেছি। আপনি এই সিদ্ধান্ত যৌক্তিক করতে পারেন?

— Val,

আমি এই জবাবটি অগ্রাহ্য করেছি, এবং এটি একটি ভুল ছিল। আইট্রেটারটি স্টেটফুল, আপনি যদি for(item : iter) {...}সিনট্যাক্সের সাহায্যে কোনও পুনরাবৃত্তির মাধ্যমে পুনরাবৃত্তি প্রচার করেন , তবে একই পুনরুক্তিটি দু'বার পুনরাবৃত্তি করা হলে এটি একটি ত্রুটি প্ররোচিত করবে। কল্পনা করুন যে, Iteratorমধ্যে পাস করা হয়েছে iterateOverপদ্ধতি পরিবর্তে Iterableমধ্যে এই উদাহরণে ।

— ইলিয়া সিলভেস্ট্রভ

এটা সত্যিই কোন ব্যাপার কিনা ব্যবহার করে না for (String x : strings) {...}বা while (strings.hasNext()) {...}শৈলী: যদি আপনি একটি পুনরুক্তিকারীর দুইবার দ্বিতীয় সময় মাধ্যেমে লুপ করতে চেষ্টা কোনো ফলাফল সমর্পণ করা হবে, তাই আমি নিজেই এটি দেখতে না পান উন্নত সিনট্যাক্স যার ফলে বিরুদ্ধে আর্গুমেন্ট হিসাবে। জন এর উত্তর ভিন্ন, সেখানে কারণ তিনি কিভাবে মোড়কে একটি দেখাচ্ছে Iteratorএকটি ইন Iterableসমস্যার কারণ হবে যে ক্ষেত্রে আপনি অনেক বার যেমন পুনরায় ব্যবহার করার জন্য যেমন আপনি পছন্দ পাবে আশা হিসেবে।

— বার্নি

Answer 4

হিসাবে অন্যদের দ্বারা নির্দেশিত, Iteratorএবং Iterableদুটি পৃথক জিনিস।

এছাড়াও, Iteratorবাস্তবায়নগুলি লুপগুলির জন্য বর্ধিত পূর্বরূপ।

একটি সাধারণ অ্যাডাপ্টার পদ্ধতি যা এই স্ট্যাটিক পদ্ধতি আমদানির সাথে ব্যবহার করার সময় দেখায় তেমন সীমাবদ্ধতা অতিক্রম করা তুচ্ছও হয়:

for (String line : in(lines)) {
  System.out.println(line);
}

নমুনা বাস্তবায়ন:

  /**
   * Adapts an {@link Iterator} to an {@link Iterable} for use in enhanced for
   * loops. If {@link Iterable#iterator()} is invoked more than once, an
   * {@link IllegalStateException} is thrown.
   */
  public static <T> Iterable<T> in(final Iterator<T> iterator) {
    assert iterator != null;
    class SingleUseIterable implements Iterable<T> {
      private boolean used = false;

      @Override
      public Iterator<T> iterator() {
        if (used) {
          throw new IllegalStateException("SingleUseIterable already invoked");
        }
        used = true;
        return iterator;
      }
    }
    return new SingleUseIterable();
  }

---

জাভা 8 অভিযোজিত সালে একটি Iteratorএকটি থেকে Iterableসহজ পায়:

for (String s : (Iterable<String>) () -> iterator) {

Comments

আপনি একটি ফাংশনে ক্লাস ঘোষণা করেছেন; আমি কিছু অনুপস্থিত করছি? আমি এই অবৈধ ছিল।

— অ্যাক্টিভেটেকে

জাভাতে একটি শ্রেণিতে একটি শ্রেণি সংজ্ঞায়িত করা যায়। একে স্থানীয় শ্রেণি

— কলিন ডি বেনেট

ধন্যবাদfor (String s : (Iterable<String>) () -> iterator)

— AlikElzin-kilaka

Answer 5

যেমনটি অন্যরা বলেছেন, একটি আইট্রেবলকে একাধিকবার বলা যেতে পারে, প্রতিটি কলটিতে একটি নতুন আইট্রেটারকে ফিরিয়ে দেওয়া; একটি Iterator মাত্র একবার ব্যবহার করা হয়। সুতরাং তারা সম্পর্কিত, কিন্তু বিভিন্ন উদ্দেশ্যে পরিবেশন। হতাশাজনকভাবে, তবে, "কমপ্যাক্ট ফর" পদ্ধতিটি কেবল পুনরাবৃত্তির সাথে কাজ করে।

আমি নীচে যা বর্ণনা করব তা হ'ল উভয় দুনিয়ার সেরা থাকার এক উপায় - তথ্যের অন্তর্নিহিত ক্রমটি এক-অফ থাকা সত্ত্বেও একটি আইটেবল (ভাল সিনট্যাক্সের জন্য) ফেরত দেওয়া।

কৌশলটি হ'ল আইটেবলের একটি বেনামে বাস্তবায়ন ফিরিয়ে দেওয়া যা আসলে কাজটি ট্রিগার করে। সুতরাং সেই কাজটি না করে যা এক-অফ সিকোয়েন্স তৈরি করে এবং তারপরে একটি আইট্রেটারকে ফিরিয়ে দেয়, আপনি একটি আইটেবল ফিরিয়ে দেন যা প্রতিটি সময় এটি অ্যাক্সেস করা হয়, কাজটি আবার করে দেয়। এটি আপত্তিজনক বলে মনে হতে পারে তবে প্রায়শই আপনি কেবল একবারেই Iteable কল করবেন এবং আপনি এটি একাধিকবার কল করলেও এর যুক্তিসঙ্গত শব্দার্থবিজ্ঞান রয়েছে (একটি সাধারণ মোড়কের বিপরীতে যা কোনও আইট্রেটারকে "স্বাদযুক্ত" দেখতে পছন্দ করে, এটি জিতেছে ' টি ব্যর্থ হলে দুবার ব্যবহার করুন)।

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

class MetricDao {
    ...
    /**
     * @return All known metrics.
     */
    public final Iterable<Metric> loadAll() {
        return new Iterable<Metric>() {
            @Override
            public Iterator<Metric> iterator() {
                return sessionFactory.getCurrentSession()
                        .createQuery("from Metric as metric")
                        .iterate();
            }
        };
    }
}

এটি তখন এই জাতীয় কোডে ব্যবহার করা যেতে পারে:

class DaoUser {
    private MetricDao dao;
    for (Metric existing : dao.loadAll()) {
        // do stuff here...
    }
}

যা আমাকে ক্রমবর্ধমান মেমরির ব্যবহারের সময় লুপের জন্য কমপ্যাক্ট ব্যবহার করতে দেয়।

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

সুতরাং বিভিন্ন ক্যাভেট রয়েছে, তবে এটি এখনও অনেক ক্ষেত্রে কার্যকর উপাসনা হতে পারে।

Comments

চমৎকার উত্তর তবে আপনার সাথে returning a fresh Iterator on each callথাকা উচিত কেন অর্থাত্ সম্মতি সমস্যা রোধ করার জন্য ...

— অনিরুদা

Answer 6

অবিশ্বাস্যভাবে, এখনও অন্য কেউ এই উত্তর দেয়নি। আপনি এখানে Iteratorনতুন জাভা 8 Iterator.forEachRemaining()পদ্ধতি ব্যবহার করে কীভাবে "সহজেই" পুনরাবৃত্তি করতে পারবেন তা এখানে :

Iterator<String> it = ...
it.forEachRemaining(System.out::println);

অবশ্যই, একটি "সরল" সমাধান রয়েছে যা সরাসরি ফোরচ লুপের সাথে কাজ করে Iterator, একটি Iterableল্যাম্বডায় মোড়ক করে :

for (String s : (Iterable<String>) () -> it)
    System.out.println(s);

Answer 7

Iteratorএকটি ইন্টারফেস যা আপনাকে কোনও কিছুর উপরে পুনরাবৃত্তি করতে দেয়। এটি কোনও ধরণের সংগ্রহের মধ্য দিয়ে চলার একটি বাস্তবায়ন।

Iterable একটি কার্যকরী ইন্টারফেস যা সূচিত করে যে কোনও কিছুতে অ্যাক্সেসযোগ্য পুনরাবৃত্তি রয়েছে।

জাভা 8-তে, এটি জীবনকে বেশ সহজ করে তোলে ... আপনার যদি এমন একটি Iteratorপ্রয়োজন হয় তবে Iterableকেবল আপনি করতে পারেন:

Iterator<T> someIterator;
Iterable<T> = ()->someIterator;

এটি লুপের জন্যও কাজ করে:

for (T item : ()->someIterator){
    //doSomething with item
}

Answer 8

আমি গৃহীত উত্তরের সাথে একমত, তবে নিজের ব্যাখ্যাটি যুক্ত করতে চাই।

• আইট্রেটর ট্র্যাভারিংয়ের অবস্থার প্রতিনিধিত্ব করে, যেমন, আপনি একটি পুনরুক্তিকারক থেকে বর্তমান উপাদানটি পেতে পারেন এবং পরবর্তীটিতে যেতে পারেন।

• আইটেবারেবল এমন একটি সংকলনকে প্রতিনিধিত্ব করে যা ট্র্যাভার্স করা যেতে পারে, এটি যতগুলি পুনরাবৃত্তির চান আপনি ফিরে আসতে পারেন, প্রত্যেকে নিজের নিজস্ব ট্র্যাভার্সিংয়ের অবস্থা উপস্থাপন করে, একজন পুনরাবৃত্তকারী প্রথম উপাদানটির দিকে নির্দেশ করতে পারে, এবং অন্যটি তৃতীয় উপাদানটির দিকে নির্দেশ করতে পারে।

লুপের জন্য জাভা যদি Iterator এবং Iteable উভয়ই গ্রহণ করে তবে এটি দুর্দান্ত হবে।

Answer 9

java.utilপ্যাকেজের উপর নির্ভরতা এড়াতে

মূল জেএসআর অনুসারে, জাভা ™ প্রোগ্রামিং ল্যাঙ্গুয়েজের প্রস্তাবিত ইন্টারফেসগুলির জন্য লুপের জন্য বর্ধিত :

• java.lang.Iterable
• java.lang.ReadOnlyIterator
  (এর উপর পুনঃপ্রতিষ্ঠিত হওয়ার প্রস্তাব দেওয়া হয়েছিল java.util.Iterator, তবে দৃশ্যত এটি কখনও ঘটেনি)

… java.langবরং প্যাকেজ নেমস্পেস ব্যবহার করার জন্য ডিজাইন করা হয়েছিল java.util।

জেএসআর উদ্ধৃত করতে:

এই নতুন ইন্টারফেসগুলি জাভা.ইউটিলে ভাষার নির্ভরতা রোধ করতে সহায়তা করে যা অন্যথায় ফলাফল হতে পারে।

---

যাইহোক, লাম্বদা সিনট্যাক্সের সাথে ব্যবহারের জন্য ( পুরানো একটি ) জাভা 8+ এ পুরানো java.util.Iterableএকটি নতুন forEachপদ্ধতি অর্জন করেছে Consumer।

এখানে একটি উদাহরণ। Listইন্টারফেস প্রসারিত Iterableইন্টারফেস, কারণ যে কোন তালিকা একটি বহন forEachপদ্ধতি।

List
.of ( "dog" , "cat" , "bird" )
.forEach ( ( String animal ) -> System.out.println ( "animal = " + animal ) );

Answer 10

আমি আরও অনেককে এটি করতে দেখছি:

public Iterator iterator() {
    return this;
}

কিন্তু এটি ঠিক করে না! এই পদ্ধতিটি আপনি চান না!

পদ্ধতিটি iterator()স্ক্র্যাচ থেকে শুরু করে একটি নতুন পুনরুক্তি ফেরানোর কথা রয়েছে। সুতরাং এই জাতীয় কিছু করা দরকার:

public class IterableIterator implements Iterator, Iterable {

  //Constructor
  IterableIterator(SomeType initdata)
  {
    this.initdata = iter.initdata;
  }
  // methods of Iterable

  public Iterator iterator() {
    return new IterableIterator(this.intidata);
  }

  // methods of Iterator

  public boolean hasNext() {
    // ...
  }

  public Object next() {
    // ...
  }

  public void remove() {
    // ...
  }
}

প্রশ্নটি হ'ল: এটি সম্পাদন করে কোনও বিমূর্ত শ্রেণি তৈরি করার কোনও উপায় থাকবে? যাতে একটি IterableIterator পেতে কেবলমাত্র দুটি পদ্ধতি পরবর্তী () এবং hasNext () প্রয়োগ করতে হবে

Answer 11

আপনি যদি এখানে কোনও কাজের সন্ধানে এসেছিলেন, আপনি IteratorIterable ব্যবহার করতে পারেন । (জাভা 1.6 এবং উপরে জন্য উপলব্ধ)

ব্যবহারের উদাহরণ (একটি ভেক্টরকে বিপরীত করে)

import java.util.Vector;
import org.apache.commons.collections4.iterators.IteratorIterable;
import org.apache.commons.collections4.iterators.ReverseListIterator;
public class Test {
    public static void main(String ... args) {
        Vector<String> vs = new Vector<String>();
        vs.add("one");
        vs.add("two");
        for ( String s: vs ) {
            System.out.println(s);
        }
        Iterable<String> is
            = new IteratorIterable(new ReverseListIterator(vs));
        for ( String s: is ) {
            System.out.println(s);
        }
    }
}

কপি করে প্রিন্ট

one
two
two
one

Answer 12

সরলতার স্বার্থে, Iterator এবং Iterable দুটি স্বতন্ত্র ধারণা, Iterable কেবল "I Iterator ফেরত দিতে পারি" এর জন্য একটি শর্টহ্যান্ড। আমি মনে করি যে আপনার কোডটি হওয়া উচিত:

for(Object o : someContainer) {
}

কিছু কনটেইনার উদাহরণস্বরূপ SomeContainer extends Iterable<Object>

Answer 13

একদিকে যেমন: স্কেলার আইট্রেটারে একটি toteteable () পদ্ধতি রয়েছে। পুনরাবৃত্তকারী থেকে পুনরাবৃত্তযোগ্য থেকে স্কেল অন্তর্ভুক্ত বা স্পষ্ট রূপান্তর দেখুন

Answer 14

সম্পর্কিত নোটে, আপনি অ্যাপাচি কমন্স কালেকশন 4-এ দরকারী IteratorIteable অ্যাডাপ্টার খুঁজে পেতে পারেন। কেবলমাত্র একটি পুনরুক্তিকারী থেকে একটি উদাহরণ তৈরি করুন, এবং আপনার সাথে সম্পর্কিত পুনরাবৃত্ত হবে।

https://commons.apache.org/proper/commons-collections/apidocs/org/apache/commons/collections4/iterators/IteratorIterable.html

আইডি: org.apache.commons: কমন্স-সংগ্রহ 4: 4.0 4.0

Answer 15

আইট্রেটাররা রাষ্ট্রীয়, তাদের একটি "পরবর্তী" উপাদান থাকে এবং একবার পুনরাবৃত্তি হয়ে "ক্লান্ত" হয়ে যায়। সমস্যাটি কোথায় তা দেখতে নীচের কোডটি চালান, কত নম্বর মুদ্রিত?

Iterator<Integer> iterator = Arrays.asList(1,2,3).iterator();
Iterable<Integer> myIterable = ()->iterator;
for(Integer i : myIterable) System.out.print(i);
System.out.println();
for(Integer i : myIterable) System.out.print(i);

Answer 16

আপনি নিম্নলিখিত উদাহরণটি ব্যবহার করে দেখতে পারেন:

List ispresent=new ArrayList();
Iterator iterator=ispresent.iterator();
while(iterator.hasNext())
{
    System.out.println(iterator.next());
}