making the enqueue, dequeue, and peek methods in Java

[John Diesal]

I'm new to Java, and this is for school. I'm confused how to approach the methods, and how to build them? Is there an algorithm to build the methods, or a certain type of thinking needed in order to approach the problem?

package  john;

import java.util.EmptyStackException;

/**
 * Class which implements a proper {@code Queue} (including using the CORRECT method names) using a set of singly linked
 * nodes. Besides in the naming convention, this does not include the methods that are inappropriate for a Queue to
 * have,
 *
 * 
 * @param <E> Type of data stored within this Queue.
 */
public class ProperQueue<E> {
  /**
   * The first node in the linked list (or null if the list is empty). This is the end of the list where we remove
   * elements from.
   */
  private Entry<E> head;

  /**
   * The first node in the linked list (or null if the list is empty). This is the end of the list where we add elements
   * to include them on the queue.
   */
  private Entry<E> tail;

  /**
   * The number of elements currently in the queue.
   */
  private int size;

  /** Create a new (empty) instance of this class. */
  public ProperQueue() {
    head = null;
    tail = null;
    size = 0;
  }

  /**
   * Adds an item to the end of the queue. Traditionally, this is the only
   * method available to add data to a Queue.
   *
   * @param item Element to be added to the end of the queue.
   * @return Element added to the Queue (e.g., {@code item}).
   */
  public E enqueue(E item) {
	  
		  
	  
	  
  }

  /**
   * Removes and returns the element at the front of this queue. Traditionally,
   * this is the only method available to remove data from the Queue.
   *
   * @return Element that was removed from the front of the Queue.
   * @throws EmptyQueueException Thrown when the Queue does not have any
   *           elements to remove.
   */
  public E dequeue() {
	return null;
	  
  }

  /**
   * Like {@link #dequeue()}, this returns the element at the front of the
   * queue, but unlike {@link #dequeue} this method DOES NOT remove it from the
   * queue.
   *
   * @return Element that is at the front of the queue.
   * @throws EmptyQueueException Thrown when the Queuedoes not have any elements
   *           to remove.
   */
  public E peek() {
	return null;
	
  
  }



  /**
   * Returns the number of elements in this Queue.
   *
   * @return Items available in the Queue.
   */
  public int size() {
    return size;
  }

  /**
   * Returns whether there are any elements in this Queue.
   *
   * @return True if the Queue does not have any elements; false otherwise.
   */
  public boolean isEmpty() {
    return size == 0;
  }

This is the class that this code uses:

package edu.buffalo.cse116;

/**
 * Class which defines an Entry in a singly-linked list. Because these are used relatively often, this is a standalone
 * (e.g. non-inner) class.
 *
 * @author Matthew Hertz
 * @param <E> Element type for this class.
 */
public class Entry<E> {

  /** Data stored within this node. */
  private E element;

  /** Reference to the node following this one in the linked list. */
  private Entry<E> next;

  /**
   * Creates an empty node.
   */
  public Entry() {
    this(null);
  }

  /**
   * Creates a node storing the specified element.
   *
   * @param elem Element to which the new node should refer
   */
  public Entry(E elem) {
    next = null;
    element = elem;
  }

  /**
   * Get the next node in the linked list.
   *
   * @return Reference to the node following this one
   */
  public Entry<E> getNext() {
    return next;
  }

  /**
   * Specify that the given node should follow the current one in the linked list.
   *
   * @param node node which should follow the current one
   */
  public void setNext(Entry<E> node) {
    next = node;
  }

  /**
   * Get the element stored within this node.
   *
   * @return Element referred to by the node
   */
  public E getElement() {
    return element;
  }

  /**
   * Direct the node to store a new element.
   *
   * @param elem New element which this node should store
   */
  public void setElement(E elem) {
    element = elem;
  }

[Norm Radder]

The methods have some comments describing what they are supposed to do.
Choose one of the methods to work on and ask some questions about what problems you are having designing the code to implement it.

[Rajith Pemabandu]

I suppose you refer this http://eddmann.com/posts/implementing-a-queue-in-java-using-arrays-and-linked-lists/  and try to implement the remaining methods.

[John Diesal]

Rajith Pemabandu

Can you provide another link? The link you sent me doesn't exist.

[Rajith Pemabandu]

My bad.

http://eddmann.com/posts/implementing-a-queue-in-java-using-arrays-and-linked-lists/

[Campbell Ritchie]

Rajith Pemabandu, welcome to the Ranch That is a good link.