Cola

import java.util.Arrays;

public class Cola<T> {

 //region Constantes

 private final static Integer defaulDimension = 10;

 //endregion

 //region Atributos

 private T [] data;
 private int head;
 private int tail;
 private int count;

 //endregion

 //region Constructores

 public Cola() {
     this(Cola.defaulDimension);
 }
 public Cola(int dimension) {
     this.data = (T[]) new Object[dimension];
     this.head = 0;
     this.tail = 0;
     this.count = 0;
 }
 //endregion

 //region Metodos Internos de la Cola
 private int next(int pos) {
     if (++pos >= this.data.length) {
         pos = 0;
     }
     return pos;
 }
 //endregion


 //region Metodos de la Cola

 // Operación EnQueue en la teoría de Estructura de Datos
 //
 // Inserta un elemento especificado en la cola si esto es posible de hacer entonces
 // inmediatamente sin violar las restricciones, retorna verdadero sobre
 // el exito y arroja una IllegalStateException si no hay espacio concurrentemente
 // disponible.
 public boolean add(T element) {

     if (this.size() >= this.data.length) {
         throw new IllegalStateException("Cola llena ...");
     }

     this.data[this.tail] = element;
     this.tail = this.next(this.tail);
     ++this.count;

     return true;
 }

 // Operación peek en la teoría de Estructura de Datos
 //
 // Recupera, pero no remueve, la cabeza de la cola. Este difiere del peek
 // solo en que este arroja una excepción si la cola esta vacia.
 public T element() {

     if (this.size() <= 0) {
         throw new IllegalStateException("Cola vacía ...");
     }

     return this.data[this.head];
 }

 // Operación EnQueue en la teoría de Estructura de Datos
 //
 // Inserta un elemento especificado en la cola si si esto es posible de hacer entonces
 // inmediatamente sin violar las restricciones. Cuando se usa una
 // capacidad-restringidad en cola, este metodo prefiere generalmente agregar (E),
 // el cual puede fallar al insertar un elemento solo por arrojar una excepción.
 public boolean offer(T element) {

     if (this.size() >= this.data.length) {
         return false;
     }

     this.data[this.tail] = element;
     this.tail = this.next(this.tail);
     ++this.count;

     return true;
 }

 // Recupera, pero no remueve, la cabeza de la cola, o retorna nulo si
 // la cola esta vacia.
 public T peek() {
     if (this.size() <= 0) {
         return null;
     }

     return this.data[this.head];
 }

 // Operación DeQueue en la teoría de Estructura de Datos
 //
 // Recupera y remueve la cabeza de la cola, o retorna nulo si la cola
 // esta vacia.
 public T pool() {
     if (this.size() <= 0) {
         return null;
     }

     T result = this.data[this.head];
     this.head = this.next(this.head);
     --this.count;

     return result;
 }

 // Operación DeQueue en la teoría de Estructura de Datos
 //
 // Recupera y remueve la cabeza de la cola. Este difiere del poll()
 // solo en que este arroja una excepción si la cola esta vacia.
 public T remove() {
     if (this.size() <= 0) {
         throw new IllegalStateException("Cola vacía ...");
     }

     T result = this.data[this.head];
     this.head = this.next(this.head);
     --this.count;

     return result;
 }
 //endregion


 //region Override Object basic methods

 @Override
 public String toString() {

     if (this.size() <=0) {
         return "";
     }

     // from https://docs.oracle.com/en/java/javase/15/docs/api/java.base/java/lang/StringBuilder.html
     StringBuilder sb = new StringBuilder();
     sb.append("[" + this.data[this.head].toString());

     for (int cta = 1, pos = this.next(this.head); cta < this.size(); ++cta, pos = this.next(pos)) {
         sb.append(", " + this.data[pos].toString());
     }

     sb.append("]");
     return sb.toString();
 }
 //endregion


 //region Metodos de la Colleccion

 public boolean isEmpty() {
     return this.count <= 0;
 }

 public int size() {
     return this.count;
 }

 public Object[] toArray() {
     Object[] result = new Object[this.count];
     for(int i = 0, pos = this.head, cta = this.size(); cta > 0; ++i, pos = this.next(pos), --cta) {
         result[i] = this.data[pos];
     }
     return result;
 }
 //endregion


 //region Caso Ejemplo b) Methods

 public static Cola<Object> union(Cola<?> stack1, Cola<?> stack2) {

     Cola<Object> result = new Cola<Object>(stack1.size() + stack2.size());

     for(int pos = stack1.head, cta = stack1.size(); cta > 0; pos = stack1.next(pos), --cta) {
         result.offer( stack1.data[pos] );
     }
     for(int pos = stack2.head, cta = stack2.size(); cta > 0; pos = stack2.next(pos), --cta) {
         result.offer( stack2.data[pos] );
     }

     return result;
 }

 public Cola<Object> union(Cola<?> stack2) {
     return Cola.union(this, stack2);
 }
 //endregion