How to implement iterator as an attribute of a class in Java

Question

let's say I have this simple MyArray class, with two simple methods: add, delete and an iterator. In the main method we can see how it is supposed to be used:

public class MyArray {
int start;
int end;
int[] arr;
myIterator it;
public MyArray(){
    this.start=0;
    this.end=0;
    this.arr=new int[500];
    it=new myIterator();
}
public void add(int el){
    this.arr[this.end]=el;
    this.end++;
}
public void delete(){
    this.arr[this.start]=0;
    this.start++;
}

public static void main(String[] args){
    MyArray m=new MyArray();

    m.add(3);
    m.add(299);
    m.add(19);
    m.add(27);
    while(m.it.hasNext()){
        System.out.println(m.it.next());
    }
}

And then MyIterator should be implemented somehow:

import java.util.Iterator;

public class myIterator implements Iterator{

@Override
public boolean hasNext() {
    // TODO Auto-generated method stub
    return false;
}

@Override
public Object next() {
    // TODO Auto-generated method stub
    return null;
}

@Override
public void remove() {
    // TODO Auto-generated method stub

}

}

MyIterator should iterate arr from MyArray class, from start to end values; both are also attributes of MyArray. So, as MyIterator should use MyArray attributes, how should MyIterator be implemented? Perhaps I can send the current object in the initialization:

it=new myIterator(this);

But I guess it's not the best soultion. Or maybe MyArray itself should implement Iterator interface? How is this solved?

EDIT:

Ok, thanks to everybody. This was a simple example of what I wnat to do, so don't care about fixed length array. Waht I really want to do is a circular FIFO, that's why start and end are the cursors.

This circular FIFO will be an array of pairs of ints with, e.g., size 300: int[][] arr=new int[300][2].

When iterating a circular array I have to take care if the counter arrives to the end and make it start from the beginning, so this is how I have solved it:

if  (this.start >= this.end )   temp_end=this.end+this.buff.length; 
else    temp_end=this.end;
int ii;
int j=0;
int[] value=new int[2];
for(int i=this.start; i<temp_end; i++){
    ii=i% this.arr.length;
    value=this.buff[ii]; 
    //do anything with value

}

But I would like to avoid worrying about these things and just iterate in a simple way, I can do this with iterator interface, but then I have 2 problems: the first one I already explained and has been solved by many answers, and the second one is that my array is made of pairs of ints, and I can't use iterator with primitive types.

Emil · Accepted Answer · 2013-03-08 17:02:51Z

8

Its very unusual to maintain an iterator as an instance variable of the class. You can only traverse the array once - probably not what you want. More likely, you want your class to provide an iterator to anyone that wants to traverse your array. A more traditional iterator is below.

Java 5+ code - I haven't tried to compile or run, so it may be contain errors (not near a dev machine right now). It also uses autobox'ing for converting Integer to int.

public class MyArray implements Iterable<Integer> {

    public static class MyIterator implements Iterator<Integer> {

        private final MyArray myArray;
        private int current;

        MyIterator(MyArray myArray) {
            this.myArray = myArray;
            this.current = myArray.start;
        }

        @Override
        public boolean hasNext() {
            return current < myArray.end;
        }

        @Override
        public Integer next() {
            if (! hasNext())   throw new NoSuchElementException();
            return myArray.arr[current++];
        }

        @Override
        public void remove() {
            // Choose exception or implementation: 
            throw new OperationNotSupportedException();
            // or
            //// if (! hasNext())   throw new NoSuchElementException();
            //// if (currrent + 1 < myArray.end) {
            ////     System.arraycopy(myArray.arr, current+1, myArray.arr, current, myArray.end - current-1);
            //// }
            //// myArray.end--;
        }
    }

    ....

    // Most of the rest of MyArray is the same except adding a new iterator method ....

    public Iterator<Integer> iterator() {
        return new MyIterator();
    }

    // The rest of MyArray is the same ....

}

Also note: be careful of not hitting that 500 element limit on your static array. Consider using the ArrayList class instead if you can.

edited Mar 8, 2013 at 17:02

Emil

7,25618 gold badges80 silver badges135 bronze badges

answered Dec 26, 2010 at 11:47

Bert F

88k12 gold badges114 silver badges126 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Evan Plaice Over a year ago

WTF? Why would you implement the iterator as a static class? You're creating unnecessary global scope that could lead to some serious thread-safety issues down the road. Also, by declaring myArray as final you're introducing an unnecessary constraint that makes it impossible to resize the array after it's initially created.

Evan Plaice Over a year ago

You suggest using the ArrayList class but at it's core all an ArrayList is, is a List implementation that uses a resizable array internally. With a little work, this class could easily be extended with a resizable array internally. I'd consider downvoting but I'd rather provide a better answer.

user432219 · Accepted Answer · 2010-12-26 11:32:39Z

4

In my opinion it is better to implement MyArray as common Iterable object, so it can be used in a for statement.

My suggestion:

/**
 * My array
 */
public class MyArray<TItem> implements Iterable<TItem>
{
    /**
     * Internal used iterator.
     */
    private class MyArrayIterator<TItem> implements Iterator<TItem>
    {
        private MyArray<TItem> _array;

        /**
         * @param array The underlying array.
         */
        public MyArrayIterator(MyArray<TItem> array)
        {
            this._array = array;
        }

        /**
         * Gets the underlying array.
         * 
         * @return The underlying array.
         */
        public MyArray<TItem> getArray() {
            return this._array;
        }

        @Override
        public boolean hasNext() {
            // TODO Auto-generated method stub
            return false;
        }

        @Override
        public TItem next() {
            // TODO Auto-generated method stub
            return null;
        }

        @Override
        public void remove() {
            // TODO Auto-generated method stub

        }

    }

    public void add(int el){
        // do add
    }

    public void delete(){
        // do delete
    }

    @Override
    public Iterator<TItem> iterator() {
        // TODO Auto-generated method stub
        return new MyArrayIterator<TItem>(this);
    }
}

As I said you can use it in a for statement:

private static void test(MyArray<String> strArray)
{
    for (String str: strArray) {
        // do something
    }
}

answered Dec 26, 2010 at 11:32

user432219

2 Comments

de3 Over a year ago

What if my TItem is supposed to be an array of ints, int[], instead of a String? this is primitive type so I can't use it as a parameter

Sean Patrick Floyd Over a year ago

@de3 you can not implement either Iterator or Iterable with primitive types. Iterator only supports objects.

score 2 · Accepted Answer · 2010-12-26 11:34:30Z

Iterator is an interface . Iterator<E> which means only Object can go here (E) . Iterator<Integer> is legal but Integer<int> is not because int is primitive data type

You can change the array to the ArrayList and then iterate over this arraylist. I added getIterator() method that returns the arraylist.iterator() and test it in main() method

import java.util.ArrayList;
import java.util.Iterator;

public class MyArray {
 int start;
 int end;
 ArrayList<Integer> arr;


 public MyArray() {
  this.start = 0;
  this.end = 0;
  arr = new ArrayList<Integer>(500);
 }

 public void add(int el) {
  arr.add(el);
  this.end++;
 }

 public void delete() {
  arr.remove(arr.size()-1);
  this.start++;
 }

 public Iterator<Integer> getIterator(){
  return arr.iterator();
 }

 public static void main(String[] args) {
  MyArray m = new MyArray();

  m.add(3);
  m.add(299);
  m.add(19);
  m.add(27);

  Iterator<Integer> it = m.getIterator();

  while(it.hasNext()){
   System.out.println(it.next());
  }

 }

}

vanje · Accepted Answer · 2010-12-26 12:08:44Z

2

My suggestion is to let MyArray implement the interface java.lang.Iterable and create an instance of an iterator per iterator() call (as an anonymous class). Then you can use an instance of MyArray directly in a foreach construct:

public class MyArray implements Iterable {

  // ...

  // Only arr is needed now as an instance variable.
  // int start;
  // int end;
  int[] arr;
  // myIterator it;

  /**
   *  From interface Iterable.
   */
  public Iterator<Integer> iterator() {

    return new Iterator<Integer>() {
      // The next array position to return
      int pos = 0;

      public boolean hasNext() {
        return pos < arr.length;
      }

      public Integer next() {
        if(hasNext()) 
          return arr[pos++];
        else
          throw new NoSuchElementException();
      }

      public void remove() {
        throw new UnsupportedOperationException();
      }
    }
  }


}

Update: According to BertF's comment I updated my code to make it clear, that the only instance variable for class MyArray is now arr. The state for the iterator is now inside the anonymous Iterator implementation. So you can create multiple iterator instances which don't interfere each other.

edited Dec 26, 2010 at 12:08

answered Dec 26, 2010 at 11:43

vanje

10.4k2 gold badges34 silver badges48 bronze badges

3 Comments

Bert F Over a year ago

My attention to his instance variables.

vanje Over a year ago

I updated my code to emphasize that there is no need for the original start, end and it instance variables.

Bert F Over a year ago

start is how he deletes and end is how he adds. Without them, he'll have to reallocate/resize the array everytime he adds and deletes from it.

kaboom · Accepted Answer · 2010-12-26 11:36:04Z

1

EDIT: this does not work for arrays of primitive types: you could use Arrays for this:

it = new Arrays.asList(arr).subList(start, end).iterator(); END OF EDIT

If you really want to implement your own iterator, I would suggest an internal class in this scenario. This way you can access MyArray.this from myIterator.

public class MyArray {
    ....
    private class myIterator implements Iterator{
        ....
    }
}

edited Dec 26, 2010 at 11:36

answered Dec 26, 2010 at 11:30

kaboom

6211 gold badge8 silver badges17 bronze badges

Comments

Aravind Yarram · Accepted Answer · 2010-12-26 11:30:49Z

0

MyArray should implement the Iterator as it is also responsible for maintaining the array. Simple encapsulation principle.

answered Dec 26, 2010 at 11:30

Aravind Yarram

80.5k49 gold badges239 silver badges335 bronze badges

Collectives™ on Stack Overflow

How to implement iterator as an attribute of a class in Java

6 Answers 6

2 Comments

2 Comments

Comments

3 Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

2 Comments

2 Comments

Comments

3 Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related