Advertisement
jtentor

List.java [iterable e iterator]

Oct 22nd, 2016
186
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. import java.util.Iterator;
  2.  
  3. /*
  4.  * Iterable<E>
  5.  * Es una interface que permite utilizar la estructura de control  
  6.  * de ejecución de código "for-each"
  7.  *
  8.  *     for (tipo_de_dato variable : colección) {
  9.  *         ...
  10.  *     }
  11.  *
  12.  * La clase se compromete a implementar el método iterator() que
  13.  * devuelve un objeto del tipo Iterator<?>
  14.  *
  15.  *      @Override
  16.  *      public Iterator<E> iterator() {
  17.  *          return new MyIterator();
  18.  *      }
  19.  *
  20.  * Generalmente se implementa mediante otra clase, la mayoría de las
  21.  * veces privada cuya característica es que debe implementar la
  22.  * interface Iterator<E>  
  23.  *
  24.  * Esta interface logra que los objetos de una clase respondan a dos
  25.  * mensajes o métodos particulares; hasNext() y next()
  26.  *
  27.  * El primero de ellos es hasNext(), que devuelve verdadero cuando
  28.  * hay un elemento disponible, y
  29.  *  *
  30.  *      @Override
  31.  *      public boolean hasNext() {
  32.  *          return ???; // si existe al menos un elemento sino false
  33.  *      }
  34.  *
  35.  *El segundo de ellos es next(), que devuelve el elemento actual y
  36.  *se prepara para acceder al siguiente elemento
  37.  *
  38.  *      @Override
  39.  *      public E next() {
  40.  *          if (!this.hasNext()) {
  41.  *              throw new RuntimeException("La lista está vacía...");
  42.  *          }
  43.  *          E elemento = ???;
  44.  *          se prepara para acceder al siguiente;
  45.  *          return elemento;
  46.  *      }
  47.  *
  48.  * La forma en que se utilizan estos métodos es la siguiente:
  49.  *
  50.  *      Iterator<E> iter = coleccion.iterator();
  51.  *      while (iter.hasNext()) {
  52.  *          hacer algo con iter.next()
  53.  *      }
  54.  *
  55.  *
  56.  * La JCF - Java Collection Framework tambien cuenta con una interface
  57.  * conocida como Enumeration<E> de manera que los objetos que implementan
  58.  * esta interfaz responden a los mensajes o métodos hasMoreElements() y
  59.  * nextElement() que tienen la misma funcionalidad explicada para hasNext()
  60.  * y next() de la interface Iterator<E> que además permite implementar el
  61.  * metodo remove() que extrae o remueve el elemento de la colección
  62.  *
  63.  * */
  64.  
  65. public class List<E> implements Iterable<E>{
  66.     /**
  67.      * Campos en la estructura interna o privada de la clase
  68.      */
  69.     private Node head;
  70.     private int count;
  71.     private Node tail;
  72.  
  73.     /**
  74.      * Getter para count
  75.      *
  76.      * @return cantidad de elementos en la lista
  77.      */
  78.     public int getCount() {
  79.         return this.count;
  80.     }
  81.  
  82.     /**
  83.      * Constructor por defecto
  84.      */
  85.     public List() {
  86.         this.head = null;
  87.         this.count = 0;
  88.         this.tail = null;
  89.     }
  90.    
  91.     /**
  92.      * Agrega al principio
  93.      * Este código puede y debe mejorarse
  94.      *
  95.      * @param item elemento que se agrega a la lista
  96.      */
  97.     public void AddFirst(E item) {
  98.         // si esta vacía
  99.         if (this.count == 0) {
  100.             // se crea un nodo con el elemento a agregar
  101.             // el nuevo nodo es el primero y el último
  102.             this.head = this.tail = new Node(item, null);
  103.             // incrementa la cuenta de elementos
  104.             ++this.count;
  105.         }
  106.         else {
  107.             // se crea un nodo con el elemento a agregar
  108.             Node temp = new Node(item, null);
  109.             // el siguiente del nuevo nodo es el actual primero
  110.             temp.next = this.head;
  111.             // el nuevo nodo se convierte en el primero
  112.             this.head = temp;
  113.             // incrementa la cuenta de elementos
  114.             ++this.count;
  115.         }
  116.     }
  117.  
  118. /* 
  119.     public void AddFirst(E item) {
  120.         Node temp = new Node(item, this.head);
  121.         if (this.count == 0) {
  122.             this.tail = temp;
  123.         }
  124.         this.head = temp;
  125.         ++this.count;
  126.     }
  127. */
  128.    
  129.     /**
  130.      * Agrega al final
  131.      * Este código puede y debe mejorarse
  132.      *
  133.      * @param item elemento que se agrega a la lista
  134.      */
  135.     public void AddLast(E item) {
  136.         if (this.count == 0) {
  137.             this.head = this.tail = new Node(item, null);
  138.             ++this.count;
  139.         }
  140.         else {
  141.             Node temp = new Node(item, null);
  142.             this.tail.next = temp;
  143.             this.tail = temp;
  144.             ++this.count;
  145.         }
  146.     }
  147.  
  148. /* 
  149.     public void AddLast(E item) {
  150.         Node temp = new Node(item, null);
  151.         if (this.count == 0) {
  152.             this.head = temp;
  153.         }
  154.         else {
  155.             this.tail.next = temp;
  156.         }
  157.         this.tail = temp;
  158.         ++this.count;
  159.     }
  160. */ 
  161.  
  162.     /**
  163.      * Extrae y devuelve el primer elemento de la lista
  164.      *
  165.      * @return el elemento que se encuentra al principio de la lista
  166.      * @exception Lista vacía
  167.      */
  168.     public E RemoveFirst() {
  169.         if (this.count == 0) {
  170.             throw new RuntimeException("La lista está vacía...");
  171.         }
  172.  
  173.         // toma el elemento que está en el primer nodo
  174.         E item = this.head.item;
  175.         // avanza el primer nodo al siguiente
  176.         this.head = this.head.next;
  177.         // si no hay mas nodos
  178.         if (this.head == null) {
  179.             // vaciar la lista
  180.             this.tail = null;
  181.         }
  182.         // decrementa la cuenta de elementos
  183.         --this.count;
  184.         // regresar el elemento
  185.         return item;
  186.     }
  187.  
  188.     /**
  189.      * Extrae y devuelve el último elemento de la lista
  190.      *
  191.      * @return el elemento que se encuentra al final de la lista
  192.      * @exception Lista vacía
  193.      */
  194.     public E RemoveLast() {
  195.         if (this.count == 0) {
  196.             throw new RuntimeException("La lista está vacía...");
  197.         }
  198.  
  199.         E item = this.tail.item;
  200.  
  201.         // si es el único nodo
  202.         if (this.head.next == null) {
  203.             // vacía la lista
  204.             this.head = this.tail = null;
  205.         } else {
  206.             // esta implementación del Tipo de Dato Abstracto tiene Orden O(n)
  207.             // comienza con el primer nodo
  208.             Node skip = this.head;
  209.             // recorre la lista mientras haya dos nodos más
  210.             for ( ; skip.next.next != null; skip = skip.next) { }
  211.             // skip es el penúltimo nodo que ahora será el último
  212.             this.tail = skip;
  213.             // anula la referencia al siguiente nodo
  214.             this.tail.next = null;
  215.         }
  216.         // decrementa la cuenta de elementos
  217.         --this.count;
  218.         // regresa el elemento
  219.         return item;
  220.        
  221.     }
  222.    
  223.     /**
  224.      * Muestra en la salida estándar todos los elementos de la lista
  225.      *
  226.      * Para evitar código como este, se aconseja implementar interfaces
  227.      * que permitan recorrer la lista, como ser Iterable e Iterator
  228.      *  
  229.      */
  230.     public void Mostrar() {
  231.         for (Node skip = this.head; skip != null; skip = skip.next) {
  232.             System.out.printf("%s ", skip.toString());
  233.         }
  234.     }
  235.    
  236.  
  237.    
  238.    
  239.    
  240.    
  241.  
  242.    
  243.    
  244.    
  245.    
  246.    
  247.    
  248.    
  249.    
  250.  
  251.     /**
  252.      * Clase privada para los nodos de la lista
  253.      */
  254.     private class Node {
  255.         /**
  256.          * Campos en la estructura interna o privada de la clase
  257.          */
  258.         public E item;
  259.         public Node next;
  260.        
  261.         /**
  262.          * Constructor por defecto
  263.          */
  264.         public Node() {
  265.             this(null, null);
  266.         }
  267.  
  268.         /**
  269.          * Constructor especializado
  270.          *
  271.          * @param item elemento a mantener en el nodo
  272.          */
  273.         public Node(E item) {
  274.             this(item, null);
  275.         }
  276.        
  277.         /**
  278.          * Constructor especializado
  279.          *
  280.          * @param item elemento a mantener en el nodo
  281.          * @param next referencia al siguiente nodo
  282.          */
  283.         public Node(E item, Node next) {
  284.             this.item = item;
  285.             this.next = next;
  286.         }
  287.  
  288.         /**
  289.          * Devuelve una cadena de texto que representa el contenido
  290.          * del elemento que está en el nodo
  291.          *
  292.          * Esto es un ejemplo de "delegación"
  293.          */
  294.         public String toString() {
  295.             return this.item.toString();
  296.         }
  297.     }
  298.  
  299.  
  300.  
  301.  
  302.  
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.     @Override
  314.     public Iterator<E> iterator() {
  315.         return new MyIterator(this.head);
  316.     }
  317.  
  318.     /**
  319.      * Implementación de un iterador para la clase List
  320.      *
  321.      */
  322.     private class MyIterator implements Iterator<E> {
  323.         private Node actual;
  324.        
  325.         public MyIterator(Node inicio) {
  326.             this.actual = inicio;
  327.         }
  328.        
  329.         @Override
  330.         public boolean hasNext() {
  331.             return this.actual != null;
  332.         }
  333.  
  334.         @Override
  335.         public E next() {
  336.             if (!this.hasNext()) {
  337.                 throw new RuntimeException("La lista está vacía...");
  338.             }
  339.             E item = this.actual.item;
  340.             this.actual = this.actual.next;
  341.             return item;
  342.         }
  343.        
  344.     }
  345.    
  346.    
  347. }
Advertisement
RAW Paste Data Copied
Advertisement