5

古い試験用紙でこの試験問題を見つけたので、次の試験の準備をしています。私はそれを把握することはできません ：

以下は、Iterable インターフェースを実装する考案された部分クラスを示しています。このクラスの唯一の目的は、属性を反復処理するメソッドを提供することですthings.

クラスを終了するには、クラスで記入する必要があるものが 2 つあります。クラスはこちら

private class PartialIterableClass /*FILL IN */ {
   private String[] things;
   public PartialIterableClass( String[] things ){
      this.things = things;
   }
   /*FILL IN 2*/
}

私はそれが次のようなものであるべきだと推測しています:

private class PartialIterableClass implements Iterable<PrivateIterableClass> {
   private String[] things;
   public PartialIterableClass( String[] things ){
      this.things = things;
   }
   public Iterator<PartialIterableClass> iterator( ){
   return new Iterator<PartialIterableClass>( ) {

   }
   }
}

この質問に対する答えを具体化する方法がよくわかりませんが、誰か助けてもらえますか?

4

4 に答える 4

3

反復ロジックをカプセル化するにはIterator、インターフェースからすべてのメソッドを実装する必要があります。Iterator

あなたの場合、現在の反復インデックスを配列に保持する必要があります。ArrayIteratorcommons-collections から見ることができます

于 2011-05-18T20:13:32.333 に答える
2

おそらく最も簡単な方法はnew ArrayList<String>()、 の値を取り込んだを作成し、そのメソッドthingsへの呼び出しの結果を返すことです。.iterator()それは確かに、限られた時間 (試験など) の状況で私が行うことであり、物事を単純にするために、現実世界のシナリオで行う可能性が非常に高いです。

独自のArrayIteratorクラスを作成するか、Web で見つけることができるさまざまなライブラリのいずれかを使用することができますが、それは不要な複雑さを追加するようです。

于 2011-05-18T20:15:28.783 に答える
0 
private class PartialIterableClass implements Iterable<String> {
    private String[] things;
    public PartialIterableClass( String[] things ){
        this.things = things;
    }

    @Override
    public Iterator<String> iterator() {
        return Arrays.asList(things).iterator();
    }
}
于 2011-05-18T20:50:16.643 に答える
0

を使用するArrayIteratorか、次のように独自のイテレータを作成できます。

package arrayiterator;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class ArrayIterator_int
{

    public static void main(String[] args)
    {
        int [] arr = { 5, 4, 3, 2, 1 };

        ArrayIterator_int iterator = new ArrayIterator_int(arr);

        while (iterator.hasNext())
        {
            System.out.println("  " + iterator.next());
        }
    }

    private int cursor;
    private final int [] array;
    private static final Lock lock = new ReentrantLock();

    public ArrayIterator_int (int [] array)
    {
        this.array = array;
        this.cursor = 0;
    }

    public boolean hasNext ()
    {
        boolean hasNext = false;
        lock.lock();

        try
        {
            hasNext = ((this.cursor+1) < this.array.length);
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
            return hasNext;
        }

    }

    public int next () throws ArrayIndexOutOfBoundsException
    {
        int next = 0;
        lock.lock();

        try
        {
            next = this.array[++this.cursor];
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            throw e;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
            return next;
        }
    }

    public int read () throws ArrayIndexOutOfBoundsException
    {
        int read = 0;
        lock.lock();

        try
        {
            read = this.array[this.cursor];
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            throw e;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
            return read;
        }
    }

    public void write (int newVal) throws ArrayIndexOutOfBoundsException
    {
        lock.lock();

        try
        {
            this.array[this.cursor] = newVal;
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            throw e;
        }
        catch(Exception e)
        {
            e.printStackTrace();
        }
        finally
        {
            lock.unlock();
        }
    }

}
于 2014-12-03T06:33:11.200 に答える