alvinalexander.com | career | drupal | java | mac | mysql | perl | scala | uml | unix  
* <td ALIGN=CENTER>Throws exception * <td ALIGN=CENTER>Returns special value * </tr> * <tr> * <td>Insert * <td>{@link #add add(e)} * <td>{@link #offer offer(e)} * </tr> * <tr> * <td>Remove * <td>{@link #remove remove()} * <td>{@link #poll poll()} * </tr> * <tr> * <td>Examine * <td>{@link #element element()} * <td>{@link #peek peek()} * </tr> * </table> * * <p>Queues typically, but do not necessarily, order elements in a * FIFO (first-in-first-out) manner. Among the exceptions are * priority queues, which order elements according to a supplied * comparator, or the elements' natural ordering, and LIFO queues (or * stacks) which order the elements LIFO (last-in-first-out). * Whatever the ordering used, the <em>head of the queue is that * element which would be removed by a call to {@link #remove() } or * {@link #poll()}. In a FIFO queue, all new elements are inserted at * the <em> tail of the queue. Other kinds of queues may use * different placement rules. Every <tt>Queue implementation * must specify its ordering properties. * * <p>The {@link #offer offer} method inserts an element if possible, * otherwise returning <tt>false. This differs from the {@link * java.util.Collection#add Collection.add} method, which can fail to * add an element only by throwing an unchecked exception. The * <tt>offer method is designed for use when failure is a normal, * rather than exceptional occurrence, for example, in fixed-capacity * (or "bounded") queues. * * <p>The {@link #remove()} and {@link #poll()} methods remove and * return the head of the queue. * Exactly which element is removed from the queue is a * function of the queue's ordering policy, which differs from * implementation to implementation. The <tt>remove() and * <tt>poll() methods differ only in their behavior when the * queue is empty: the <tt>remove() method throws an exception, * while the <tt>poll() method returns null. * * <p>The {@link #element()} and {@link #peek()} methods return, but do * not remove, the head of the queue. * * <p>The Queue interface does not define the blocking queue * methods</i>, which are common in concurrent programming. These methods, * which wait for elements to appear or for space to become available, are * defined in the {@link edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue} interface, which * extends this interface. * * <p>Queue implementations generally do not allow insertion * of <tt>null elements, although some implementations, such as * {@link LinkedList}, do not prohibit insertion of <tt>null. * Even in the implementations that permit it, <tt>null should * not be inserted into a <tt>Queue, as null is also * used as a special return value by the <tt>poll method to * indicate that the queue contains no elements. * * <p>Queue implementations generally do not define * element-based versions of methods <tt>equals and * <tt>hashCode but instead inherit the identity based versions * from class <tt>Object, because element-based equality is not * always well-defined for queues with the same elements but different * ordering properties. * * * <p>This interface is a member of the * <a href="{@docRoot}/../technotes/guides/collections/index.html"> * Java Collections Framework</a>. * * @see java.util.Collection * @see LinkedList * @see PriorityQueue * @see edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue * @see edu.emory.mathcs.backport.java.util.concurrent.BlockingQueue * @see edu.emory.mathcs.backport.java.util.concurrent.ArrayBlockingQueue * @see edu.emory.mathcs.backport.java.util.concurrent.LinkedBlockingQueue * @see edu.emory.mathcs.backport.java.util.concurrent.PriorityBlockingQueue * @since 1.5 * @author Doug Lea */ public interface Queue extends Collection { /** * Inserts the specified element into this queue if it is possible to do so * immediately without violating capacity restrictions, returning * <tt>true upon success and throwing an IllegalStateException * if no space is currently available. * * @param e the element to add * @return <tt>true (as specified by {@link Collection#add}) * @throws IllegalStateException if the element cannot be added at this * time due to capacity restrictions * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null and * this queue not permit null elements * @throws IllegalArgumentException if some property of this element * prevents it from being added to this queue */ boolean add(Object e); /** * Inserts the specified element into this queue if it is possible to do * so immediately without violating capacity restrictions. * When using a capacity-restricted queue, this method is generally * preferable to {@link #add}, which can fail to insert an element only * by throwing an exception. * * @param e the element to add * @return <tt>true if the element was added to this queue, else * <tt>false * @throws ClassCastException if the class of the specified element * prevents it from being added to this queue * @throws NullPointerException if the specified element is null and * this queue does not permit null elements * @throws IllegalArgumentException if some property of this element * prevents it from being added to this queue */ boolean offer(Object e); /** * Retrieves and removes the head of this queue. This method differs * from {@link #poll poll} only in that it throws an exception if this * queue is empty. * is empty. * * @return the head of this queue * @throws NoSuchElementException if this queue is empty */ Object remove(); /** * Retrieves and removes the head of this queue, * or returns <tt>null if this queue is empty. * * @return the head of this queue, or <tt>null if this queue is empty */ Object poll(); /** * Retrieves, but does not remove, the head of this queue. This method * differs from {@link #peek peek} only in that it throws an exception * if this queue is empty. * * @return the head of this queue * @throws NoSuchElementException if this queue is empty */ Object element(); /** * Retrieves, but does not remove, the head of this queue, * or returns <tt>null if this queue is empty. * * @return the head of this queue, or <tt>null if this queue is empty */ Object peek(); }

Other Scala examples (source code examples)

Here is a short list of links related to this Scala Queue.java source code file:

Scala example source code file (Queue.java)

This example Scala source code file (Queue.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" TM.

Java - Scala tags/keywords

collection, collection, object, object, queue, queue, util

The Scala Queue.java source code

/*
 * Written by Doug Lea with assistance from members of JCP JSR-166
 * Expert Group and released to the public domain, as explained at
 * http://creativecommons.org/licenses/publicdomain
 */

package scala.actors.threadpool;

import java.util.Collection;

/**
 * A collection designed for holding elements prior to processing.
 * Besides basic {@link java.util.Collection Collection} operations,
 * queues provide additional insertion, extraction, and inspection
 * operations.  Each of these methods exists in two forms: one throws
 * an exception if the operation fails, the other returns a special
 * value (either <tt>null or false, depending on the
 * operation).  The latter form of the insert operation is designed
 * specifically for use with capacity-restricted <tt>Queue
 * implementations; in most implementations, insert operations cannot
 * fail.
 *
 * <p>
 * <table BORDER CELLPADDING=3 CELLSPACING=1>
 *  <tr>
 *    <td>
... this post is sponsored by my books ...

#1 New Release!

FP Best Seller

 

new blog posts

 

Copyright 1998-2021 Alvin Alexander, alvinalexander.com
All Rights Reserved.

A percentage of advertising revenue from
pages under the /java/jwarehouse URI on this website is
paid back to open source projects.