Pages: [1]   Go Down
Print
Author Topic: [ RISOLTO ] :Ciclo for-each quali requisiti richiede??  (Read 752 times)
0 Members e 1 Utente non registrato stanno visualizzando questa discussione.
Nessuno
Apprendista Forumista
**
Offline Offline

Posts: 204



« on: 26-09-2011, 11:01:16 »

Salve ragazzi..ma come mai riesco a scorrere la mia Lista "iterabile" con il ciclo while e non con il for-each dandomi il seguente errore...
Errore:
Code:
position_list_iterator01.java:27: foreach not applicable to expression type
  for(Integer x : l1)
                  ^
Note: position_list_iterator01.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.
1 error
IL CODICE è IL SEGUENTE..potreste dirmi perfavore dov'è l'errore??
Code:
//ITERATORI E OGGETTI ITERABILI
//PositionList
import java.util.*;
import java.lang.*;
public class position_list_iterator01{
  public static void main(String[]args){
  
PositionLinkedList<Integer> l1=new PositionLinkedList<Integer>();
  //creo un'arry di nodi
 Dlnode<Integer>[]n1=(Dlnode<Integer>[]) new Dlnode[10];
  //riempio l'array d nodi
  for(int i=0;i<n1.length;i++){
  int j=(int)(100*Math.random());
  n1[i]=new Dlnode<Integer>(j);}
  //creo la struttura lista
  for(int i=0;i<n1.length;i++)
  l1.addFirst(n1[i].getElement()); //utilizzo il metodo getElement() dell'interfaccia Position
  l1.printList();
  System.out.println();
  l1.addAfter(l1.Last(),77); //inceve con "l1.addAfter(l1.next(l1.Last()),77);" genera un eccezione xckè gli passiamo il trailer
  l1.printList();
  Iterator<Integer> MioIteratore=l1.iterator();
  System.out.println("ha elementi?: "+MioIteratore.hasNext());
  //System.out.println(MioIteratore.nextIt());
  Integer sum=0;
  
  for(Integer x : l1)
    sum+=x;//...........NON FUNZIONA????????????
  
  /*while(MioIteratore.hasNext())  //................funziona!!!
    sum+=MioIteratore.next();
    System.out.println("somma: "+sum);*/
  }
}
//interfaccia iTERATOR<E>
interface Iterator<E> {
  public boolean hasNext();
  public E next();}
    
//INTERFACCIA ITERABLE **************************************************************
interface Iterable<E> {
  public Iterator<E> iterator();
}

//interfaccia position *****************************************************************
interface Position<E>{
  E getElement();}
  
//interfaccia PositionList<E>
  //************************************************************************************
  interface PositionList<E> {
  public boolean isEmpty();
  public int size();
  
  public void addAfter(Position<E> n,E e) throws InvalidPositionException;
  public void addBefore(Position<E> n, E e) throws InvalidPositionException;
  
  public Position<E> First(); //ritorna posizione testa
  public Position<E> Last();//ritorna posizione coda
  public Position<E> next(Position<E> n) throws InvalidPositionException,BoundaryViolationException;
  public Position<E> prev(Position<E> n) throws InvalidPositionException,BoundaryViolationException;
  //public void set(Position<E> n,E e) throws InvalidPositionException;
  //public E remove(Position<E> p) throws InvalidPositionException;
  //public Iterator<E> iterator();
  }
  //classe nodo che implementa position<E>
  //classe nodo ***********************************************************************
  class Dlnode<E> implements Position<E> {
    //vaar istanza
    Dlnode<E> prev,next;
    E element;
    //costruttore
    public Dlnode(E e) {
      prev=next=null;
      element=e;}
    public Dlnode(E e,Dlnode<E> n,Dlnode p){
      element=e;
      next=n;
      prev=p;}
    public E getElement(){
      return element;}
    public Dlnode<E> getNext(){
      return next;}
    public Dlnode<E> getPrev(){
      return prev;}
    public void setNext(Dlnode<E> n){
      next=n;}
    public void setPrev(Dlnode<E> p){
      prev=p;}
    public void setInfo(E e){
      element=e;}
    }
    //classe PositionLinkedList ************************************************************
    class PositionLinkedList<E> implements PositionList<E>, Iterable<E> {
      //var di istanza
      protected Dlnode<E> header,trailer;
      protected int size;
      //cotruttore
      public PositionLinkedList(){
        header=new Dlnode<E> (null,null,null);
        trailer=new Dlnode<E>(null,null,header);
        header.setNext(trailer);
        size=0;}
      //METODI******
      public boolean isEmpty(){
        return(size==0);}
      public int size(){
        return size;}
        
      //METODO DELL'INTERFACCIA ITERABLE<E>******************************
      public Iterator<E> iterator(){
          return new MyIterator<E>(this);}// con this gli passo tutta la struttura
        
          //restituisc l'oggetto position in testa
      public Position<E> First(){
        if(isEmpty()) return null; //caso lista vuota
        return header.getNext();}
        
      public Position<E> Last(){
        if(isEmpty()) return null;
        return trailer.getPrev();}
      
      public Position<E> next(Position<E> p) throws InvalidPositionException,BoundaryViolationException{
        Dlnode<E> tmp=checkposition(p);
        if(p == Last()) throw new BoundaryViolationException("fuori range");
        return tmp.getNext();}
        
        public Position<E> prev(Position<E> p) throws InvalidPositionException,BoundaryViolationException{
          if(p==First()) throw new BoundaryViolationException("errore");
          Dlnode<E> tmp=checkposition(p);
          return tmp.getPrev();}
      
      public void addFirst(E element) {
     size++;
     Dlnode<E> newNode = new Dlnode<E>(element,header.getNext(), header);
     header.getNext().setPrev(newNode);
     header.setNext(newNode);
      }
      
      public void addLast(E element){
      size++;
      Dlnode<E> newnode = new Dlnode<E>(element,trailer,trailer.getPrev());
      trailer.getPrev().setNext(newnode);
      trailer.setPrev(newnode);}
        
      public void addAfter(Position<E> p, E e) throws InvalidPositionException{
        if(p==null) throw new InvalidPositionException("errore");
        Dlnode<E> tmp=checkposition(p);
        Dlnode<E> n=new Dlnode<E>(e,tmp.getNext(),tmp);
        tmp.getNext().setPrev(n);
        tmp.setNext(n);
        size++;}
      
      public void addBefore(Position<E> p,E e) throws InvalidPositionException{
        if(p==null) throw new InvalidPositionException("errore");
        Dlnode<E> tmp=checkposition(p);
        Dlnode<E> newnode= new Dlnode<E>(e,tmp,tmp.getPrev());
        tmp.getPrev().setNext(newnode);
        tmp.setPrev(newnode);
        size++;}
        
        //METODO CHECKPOSITION()
      protected Dlnode<E> checkposition(Position<E> p) throws InvalidPositionException {
        if(p==null) throw new InvalidPositionException("erroe");
        if(p==header) throw new InvalidPositionException("errore limite");
        if(p==trailer) throw new InvalidPositionException("errore limite");
        try{
            Dlnode<E> tmp=(Dlnode<E>) p; // CAST
          if((tmp.getPrev()==null)||(tmp.getNext()== null)) throw new InvalidPositionException("errore if-try");
          return tmp;}
          catch(ClassCastException e){
            throw new InvalidPositionException("errore del try");}
          } //fine checkposition()
      //metodo di stampa
        public void printList(){
          if(size==0) System.out.println("lista vuota");
          Dlnode<E> tmp=header.getNext();
          for(; tmp!=trailer;tmp=tmp.getNext())
          System.out.println(tmp.getElement());
        }
    }
    //CLASS MyIterator*******************************************************************+
    class MyIterator<E> implements Iterator<E> //sfruttiamo la linearità della LISTA
    {
      //var di istanza
      PositionLinkedList<E>A;
      Position<E> current; //sarà il nostro puntatore
      //costruttore
      public MyIterator(PositionLinkedList<E> l1) throws EmptyListException
      {
        A=l1; //facciamo puntare la lista A a l1
        if(l1.size==0) throw new EmptyListException("lista vuota");
        current=A.First(); //posiziono current al primo elemento
      }
      //metodo hasNext()
      public boolean hasNext(){
        return (current!=null);
      }
      //metodo next()...con cursore
      public E next()throws EmptyListException {
        if(!hasNext()) throw new EmptyListException("lista vuota");
        Dlnode<E> x=(Dlnode<E>)current; //cast di current nel tipo "nodo"
        E tmp=x.getElement();
        if( current==A.Last())
            current=null;
        else current=A.next(current);
        // se metto current=current.next(current) mi da errore poikè next() non è  un metodo di Position<E> ma bensi' della PositionList<E>
        return tmp;}
    }
    //classe eccezioni******************************************************************
    class InvalidPositionException extends RuntimeException{
      //costruttore
      public InvalidPositionException(String error){
        super(error);}
      }
    class BoundaryViolationException extends RuntimeException{
      //costruttore
      public BoundaryViolationException(String err){
        super(err);}
      }
    class EmptyListException extends RuntimeException{
      public EmptyListException(String err){
        super(err);}
      }
  
GRAZIE MILLE.
« Last Edit: 26-09-2011, 15:06:06 by Nessuno » Logged

Sorridi anche se il tuo sorriso è triste, perchè più triste di un sorriso triste c'è la tristezza di non saper sorridere.

::Jim Morrison::
zElOtO
Forumista
***
Offline Offline

Gender: Male
Posts: 845



WWW
« Reply #1 on: 26-09-2011, 12:45:07 »

Quote
for(Integer x : l1)

Puoi iterare su un array o su un'istanza di java.lang.Iterable
Logged

I computer sono incredibilmente veloci, accurati e stupidi. Gli uomini sono incredibilmente lenti, inaccurati e intelligenti. Insieme sono una potenza che supera l'immaginazione. (A. Einstein)

Damiano Cancemi
www.damianocancemi.com
www.nerdbren.com
www.nerdbren.com/blog
Nessuno
Apprendista Forumista
**
Offline Offline

Posts: 204



« Reply #2 on: 26-09-2011, 14:30:52 »

Grazie, risolto.
« Last Edit: 26-09-2011, 15:08:34 by Nessuno » Logged

Sorridi anche se il tuo sorriso è triste, perchè più triste di un sorriso triste c'è la tristezza di non saper sorridere.

::Jim Morrison::
Pages: [1]   Go Up
Print
Jump to: