How to use the method iterator()?

[Antoine Compagnie]

Good evening!

I'm still learning java and tonight I'm stumbling over the way my teacher used the iterator method of the interface Collection.

Indeed, my teacher defined such a following value method of a class of elements HashConcret:

public double value(){
    double sum=0;
    int =1;

    Iterator it =iterator();
    for (i=1,(it.hasNext()),i++){
        sum +=((valuable)it.hasNext()).value();
    }

    return sum/i;

I don't see any elements being passed as arguments, entering it the iterator... to have their value being moved up to the sum!
So does it actually work? And if it does, how?

[table="width: 500, class: outer_border"]
[tr]
[td]Class Composant is abstract and defined the characteristics of a named given composant. It is characterized by a name and realize two interfaces Named and Valuable defined below. Two composants are equals if they have same name and same value.

Class Atome is a composant characterized by a name and a double value. An atome is equal to another atome if they have same value. The name of an atome is not given at creation. it is formed by its parent's name. followed by "_" and its value.

Abstract class Composite is defined by the characteristics of a complex composant having a collection of named elements of type Atome or Coposite. The class composite forbidden dupplicates. It realizes the interface ComposantManagement. Two objects are equals if they have same name and same elements.

Class HashConcret is a subclass of Composite which doesn't allow to have duplications and which elements aren't sorted out. The value of an instance of HashConcret is the mean of the value of its elements.[/td]
[/tr]
[/table]

this description corresponds to the following code: HashConcret is at the bottom!

/////////////////////////////       ATOME        ////////////////
package java_td.td6_composite2;
 
public class Atome extends Composant{
    private double value;
 
    public Atome(Named parent, double value){
            ?????????????
        this.value = value;
  }
 
  public double value(){
        return value;
  }
 
  public boolean equals(Object object){
    System.out.println("equals Atome");
  return ??????????;                                    C1
  }
 
  public String toString(){
       return super.toString()+"\n";
  }
}//Fin Atome
 
//////////////////////        COMPOSANT         //////////////
 
package java_td.td6_composite2;
public abstract class Composant implements Named, Valuable, Comparable{
  private String name;
 
    public Composant(String name){
        this.name=name;
    }
 
    public String name(){
        return name;
}
/****************************************************************
/*                 Interface Valuable                                
********************************************************************/
    public abstract double value();
 
/**********           **********************************************/
/*                Redefined methods                                   /****************************************************************/
 
    public boolean equals(Object object){
        boolean result=false;
        System.out.println("equals Objet Composant entrée");
        if (???){
        System.out.println("equals Objet Composant cas Named");
        Named temp = (Named) object;
        result= equals(temp);System.out.println("equals res. interm. "+result);
        }
       if (???????){
        System.out.println("equals Objet Composant cas Value");
        result = ????????????????????                       C2
          }
     return result;
    }//end equals(Object object)
 
    ?????? boolean equals(Named object){
        System.out.println("equals Named Composant");
    return name() == (object.name());
    }
    ?????? boolean equals(Valuable object){
        System.out.println("equals Valuable Composant");
    return ????????????????;
  }
     */ Compares this object to another Object. This function behaves
     * of the <code>compareTo(String)</code> function in taking into account
     * the String represention of the both objects. */
  public int compareTo (Object object) {
       if (object instanceof Valuable){
       return compareTo(((Valuable)object));
         }
    return 1;
    }//end compareTo
 
    ???????????  int compareTo(Valuable object){
    return        ???????????????????;                      C3
    }
    public int hashCode(){
    return toString().hashCode();
    }
    public String toString(){
    return " name : "+name() +"\t value : "+value();
    }//end toString()
} // Fin COMPOSANT
 
interface Named{
    String name();
}
 
interface Valuable{
    double value();
}
///////////////////////         COMPOSITE       ////////////////////////
 
package java_td.td6_composite2;
import java.util.*;
public abstract class Composite extends Composant implements ComposantManagement{
    private Set elements;
    double truc=0;
     */Initializes a newly created <code>AbstractComposite</code> object
     * with the name passed as argument.*/
     *
  ????????? Composite( String name, Set elements){              C4
    super(name);
    setElements(elements);
  }
 
  ????????? void setElements(Set  elements){
    this.elements = elements;
  }
 
  /****************************************************************
  /*        Interface ComposantManagement                          
  /*                 Element Management                                 ******************************************************************/
  protected Set getElements(){
    return elements;
  }
 
    */returns true if the evaluation composite object has an element
      that is the same as the value argument.Otherwise returns false./
     
  public boolean hasElement(Object object) {
    return getElements().contains(object);
  }
 
  public Iterator iterator(){
        return ??????????????? ;                            C5
  }
 
  public boolean add(Object value){
    if (value instanceof Named){return getElements().add(value);
    }
    return false;
  }//end add
 
  public boolean remove(Object element){
    return getElements().remove(element);
  }
    public int size(){
       return getElements().size();
  }//end size()
 
public Object get(Object element){
        Iterator it=iterator();
        Object result=null;
 
??????????????????????????                          C6
 
    return result;
    }
 
    public String toString(){
    return super.toString()+"  elements: \n"+ getElements()+"\n";
    }
}// Fin COMPOSITE
 
/****************************************************************
/*        Interface ComposantManagement                          
/*                 Element Management                            *****************************************************************/
interface ComposantManagement extends Valuable{
   //retourne l'élément de l'ensemble qui est égaux ‡ l'objet passé en argument
   Object get(Object object);
   //retourne vrai si object est élément de l'ensemble sinon retourne faux
   boolean hasElement(Object object) ;
   //retourne un objet de type Iterator
   Iterator iterator();
   //ajoute un élément dans l'ensemble
   boolean add(Object value);
   double truc=1;
}
 
//////////////////////////      HASHCONCRET       //////////////////
package java_td.td6_composite2;
import java.util.*;
    public class HashConcret extends Composite{
        public HashConcret(String name) {
        super(name, new HashSet());
    }
    public double value(){
 
        *****************                               C8
    }
 
}

I want to understand the method value() of class Composite.

[Greg Charles]

Hi Antoine, I'm moving your question over to our Java In General forum. The JForum forum is really for questions about the JForum application, which manages the forums here at Java Ranch, and many other sites as well.

You're right that the "i" variable of your for loop doesn't have any effect on the iterator since, as you pointed out, it's not passed to it as a parameter. In fact, it's more common to see an iterator used in a while loop. Basically, you ask it via the hasNext() method if there are any more elements to look at, and then you get the next element with the next() method. I see that you are trying to iterate over a Set called elements. I'm not sure what the assignment is, but you could ask that set to create an iterator for you. If your assignment is to write your own iterator, you could create a class that implements the Iterator interface and is instantiated with the Set elements.

[Campbell Ritchie]

Welcome to the Ranch

Why not use one of the ready made List implementations and use its Iterator? Or better still, a Stream (Java8 only).

List<Expediable> exList = new XYZList<>();
exList.add(...);
sum = exList.stream()
            .mapToDouble(ex -> ex.value())
            .sum();

The stream method creates a Stream object which iterates the contents of the List; since it “knows” the List contains Expiables, it will be a Stream of Expiables.
The map to double method creates a stream of doubles and the bit with -> in takes an argument (ex for an Expiable) and then goes to its value method which appears to return a double.
Once you have a stream of doubles, you can use its sum method whose intent should be obvious from its name.

If you are going to use an Iterator explicitly, don't make it a plain simple Iterator. Call it an Iterator<Valuable> then you son't have to mess about with casts.