Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import java.util.Iterator;
- /*
- * Iterable<E>
- * Es una interface que permite utilizar la estructura de control
- * de ejecución de código "for-each"
- *
- * for (tipo_de_dato variable : colección) {
- * ...
- * }
- *
- * La clase se compromete a implementar el método iterator() que
- * devuelve un objeto del tipo Iterator<?>
- *
- * @Override
- * public Iterator<E> iterator() {
- * return new MyIterator();
- * }
- *
- * Generalmente se implementa mediante otra clase, la mayoría de las
- * veces privada cuya característica es que debe implementar la
- * interface Iterator<E>
- *
- * Esta interface logra que los objetos de una clase respondan a dos
- * mensajes o métodos particulares; hasNext() y next()
- *
- * El primero de ellos es hasNext(), que devuelve verdadero cuando
- * hay un elemento disponible, y
- * *
- * @Override
- * public boolean hasNext() {
- * return ???; // si existe al menos un elemento sino false
- * }
- *
- *El segundo de ellos es next(), que devuelve el elemento actual y
- *se prepara para acceder al siguiente elemento
- *
- * @Override
- * public E next() {
- * if (!this.hasNext()) {
- * throw new RuntimeException("La lista está vacía...");
- * }
- * E elemento = ???;
- * se prepara para acceder al siguiente;
- * return elemento;
- * }
- *
- * La forma en que se utilizan estos métodos es la siguiente:
- *
- * Iterator<E> iter = coleccion.iterator();
- * while (iter.hasNext()) {
- * hacer algo con iter.next()
- * }
- *
- *
- * La JCF - Java Collection Framework tambien cuenta con una interface
- * conocida como Enumeration<E> de manera que los objetos que implementan
- * esta interfaz responden a los mensajes o métodos hasMoreElements() y
- * nextElement() que tienen la misma funcionalidad explicada para hasNext()
- * y next() de la interface Iterator<E> que además permite implementar el
- * metodo remove() que extrae o remueve el elemento de la colección
- *
- * */
- public class List<E> implements Iterable<E>{
- /**
- * Campos en la estructura interna o privada de la clase
- */
- private Node head;
- private int count;
- private Node tail;
- /**
- * Getter para count
- *
- * @return cantidad de elementos en la lista
- */
- public int getCount() {
- return this.count;
- }
- /**
- * Constructor por defecto
- */
- public List() {
- this.head = null;
- this.count = 0;
- this.tail = null;
- }
- /**
- * Agrega al principio
- * Este código puede y debe mejorarse
- *
- * @param item elemento que se agrega a la lista
- */
- public void AddFirst(E item) {
- // si esta vacía
- if (this.count == 0) {
- // se crea un nodo con el elemento a agregar
- // el nuevo nodo es el primero y el último
- this.head = this.tail = new Node(item, null);
- // incrementa la cuenta de elementos
- ++this.count;
- }
- else {
- // se crea un nodo con el elemento a agregar
- Node temp = new Node(item, null);
- // el siguiente del nuevo nodo es el actual primero
- temp.next = this.head;
- // el nuevo nodo se convierte en el primero
- this.head = temp;
- // incrementa la cuenta de elementos
- ++this.count;
- }
- }
- /*
- public void AddFirst(E item) {
- Node temp = new Node(item, this.head);
- if (this.count == 0) {
- this.tail = temp;
- }
- this.head = temp;
- ++this.count;
- }
- */
- /**
- * Agrega al final
- * Este código puede y debe mejorarse
- *
- * @param item elemento que se agrega a la lista
- */
- public void AddLast(E item) {
- if (this.count == 0) {
- this.head = this.tail = new Node(item, null);
- ++this.count;
- }
- else {
- Node temp = new Node(item, null);
- this.tail.next = temp;
- this.tail = temp;
- ++this.count;
- }
- }
- /*
- public void AddLast(E item) {
- Node temp = new Node(item, null);
- if (this.count == 0) {
- this.head = temp;
- }
- else {
- this.tail.next = temp;
- }
- this.tail = temp;
- ++this.count;
- }
- */
- /**
- * Extrae y devuelve el primer elemento de la lista
- *
- * @return el elemento que se encuentra al principio de la lista
- * @exception Lista vacía
- */
- public E RemoveFirst() {
- if (this.count == 0) {
- throw new RuntimeException("La lista está vacía...");
- }
- // toma el elemento que está en el primer nodo
- E item = this.head.item;
- // avanza el primer nodo al siguiente
- this.head = this.head.next;
- // si no hay mas nodos
- if (this.head == null) {
- // vaciar la lista
- this.tail = null;
- }
- // decrementa la cuenta de elementos
- --this.count;
- // regresar el elemento
- return item;
- }
- /**
- * Extrae y devuelve el último elemento de la lista
- *
- * @return el elemento que se encuentra al final de la lista
- * @exception Lista vacía
- */
- public E RemoveLast() {
- if (this.count == 0) {
- throw new RuntimeException("La lista está vacía...");
- }
- E item = this.tail.item;
- // si es el único nodo
- if (this.head.next == null) {
- // vacía la lista
- this.head = this.tail = null;
- } else {
- // esta implementación del Tipo de Dato Abstracto tiene Orden O(n)
- // comienza con el primer nodo
- Node skip = this.head;
- // recorre la lista mientras haya dos nodos más
- for ( ; skip.next.next != null; skip = skip.next) { }
- // skip es el penúltimo nodo que ahora será el último
- this.tail = skip;
- // anula la referencia al siguiente nodo
- this.tail.next = null;
- }
- // decrementa la cuenta de elementos
- --this.count;
- // regresa el elemento
- return item;
- }
- /**
- * Muestra en la salida estándar todos los elementos de la lista
- *
- * Para evitar código como este, se aconseja implementar interfaces
- * que permitan recorrer la lista, como ser Iterable e Iterator
- *
- */
- public void Mostrar() {
- for (Node skip = this.head; skip != null; skip = skip.next) {
- System.out.printf("%s ", skip.toString());
- }
- }
- /**
- * Clase privada para los nodos de la lista
- */
- private class Node {
- /**
- * Campos en la estructura interna o privada de la clase
- */
- public E item;
- public Node next;
- /**
- * Constructor por defecto
- */
- public Node() {
- this(null, null);
- }
- /**
- * Constructor especializado
- *
- * @param item elemento a mantener en el nodo
- */
- public Node(E item) {
- this(item, null);
- }
- /**
- * Constructor especializado
- *
- * @param item elemento a mantener en el nodo
- * @param next referencia al siguiente nodo
- */
- public Node(E item, Node next) {
- this.item = item;
- this.next = next;
- }
- /**
- * Devuelve una cadena de texto que representa el contenido
- * del elemento que está en el nodo
- *
- * Esto es un ejemplo de "delegación"
- */
- public String toString() {
- return this.item.toString();
- }
- }
- @Override
- public Iterator<E> iterator() {
- return new MyIterator(this.head);
- }
- /**
- * Implementación de un iterador para la clase List
- *
- */
- private class MyIterator implements Iterator<E> {
- private Node actual;
- public MyIterator(Node inicio) {
- this.actual = inicio;
- }
- @Override
- public boolean hasNext() {
- return this.actual != null;
- }
- @Override
- public E next() {
- if (!this.hasNext()) {
- throw new RuntimeException("La lista está vacía...");
- }
- E item = this.actual.item;
- this.actual = this.actual.next;
- return item;
- }
- }
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement