Vavr 0.10.6 · io.vavr.collection.Queue · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
private static final Queue<?>	EMPTY
private final List<T>	front
private final List<T>	rear
private static final long	serialVersionUID Hides io.vavr.collection.LinearSeq.serialVersionUID.

Access	Constructor and Description
private	Queue(List<T> A List of front elements, in correct order. front, List<T> A List of rear elements, in reverse order. rear) Creates a Queue consisting of a front List and a rear List.

Method Summary

Modifier and Type	Method and Description
public Queue<T>	append(T An element element) Implements io.vavr.collection.LinearSeq.append. Appends an element to this.
public Queue<T>	appendAll(Iterable<? extends T> An Iterable of elements elements) Implements io.vavr.collection.LinearSeq.appendAll. Appends all given elements to this.
public List<T>	asJava() Implements io.vavr.collection.Seq.asJava. Creates an immutable `java.util.List` view on top of this `Seq`, i.e. calling mutators will result in `UnsupportedOperationException` at runtime.
public Queue<T>	asJava(Consumer<? super List<T>> A side-effecting unit of work that operates on an immutable `java.util.List` view. action) Implements io.vavr.collection.LinearSeq.asJava. Creates an immutable `java.util.List` view on top of this `Seq` that is passed to the given `action`.
public List<T>	asJavaMutable() Implements io.vavr.collection.Seq.asJavaMutable. Creates a mutable `java.util.List` view on top of this `Seq`, i.e. all mutator methods of the `java.util.List` are implemented.
public Queue<T>	asJavaMutable(Consumer<? super List<T>> A side-effecting unit of work that operates on a mutable `java.util.List` view. action) Implements io.vavr.collection.LinearSeq.asJavaMutable. Creates a mutable `java.util.List` view on top of this `Seq` that is passed to the given `action`.
public <R> Queue<R>	collect(PartialFunction<? super T, ? extends R> A function that is not necessarily defined of all elements of this traversable. partialFunction) Implements io.vavr.collection.LinearSeq.collect, io.vavr.collection.Traversable.collect. Collects all elements that are in the domain of the given `partialFunction` by mapping the elements to type `R`.
public static < Component type of the Queue. T> Collector<T, ArrayList<T>, Queue<T>>	Returns: A io.vavr.collection.Queue Collector. collector() Returns a `java.util.stream.Collector` which may be used in conjunction with `java.util.stream.Stream#collect(java.util.stream.Collector)` to obtain a `Queue` .
public Queue<Queue<T>>	combinations() Implements io.vavr.collection.LinearSeq.combinations. Returns the union of all combinations from k = 0 to length().
public Queue<Queue<T>>	combinations(int Size of subsets k) Implements io.vavr.collection.LinearSeq.combinations. Returns the k-combination of this traversable, i.e. all subset of this of k distinct elements.
public Iterator<Queue<T>>	crossProduct(int the number of cartesian multiplications power) Implements io.vavr.collection.LinearSeq.crossProduct. Calculates the n-ary cartesian power (or cross product or simply product) of this.
public Queue<T>	distinct() Implements io.vavr.collection.LinearSeq.distinct, io.vavr.collection.Traversable.distinct. Returns a new version of this which contains no duplicates.
public Queue<T>	distinctBy(Comparator<? super T> A comparator comparator) Implements io.vavr.collection.LinearSeq.distinctBy, io.vavr.collection.Traversable.distinctBy. Returns a new version of this which contains no duplicates.
public <U> Queue<T>	distinctBy(Function<? super T, ? extends U> A key extractor keyExtractor) Implements io.vavr.collection.LinearSeq.distinctBy, io.vavr.collection.Traversable.distinctBy. Returns a new version of this which contains no duplicates.
public Queue<T>	drop(int The number of elements to drop. n) Implements io.vavr.collection.LinearSeq.drop, io.vavr.collection.Traversable.drop. Drops the first n elements of this or all elements, if this length < n.
public Queue<T>	dropRight(int The number of elements to drop. n) Implements io.vavr.collection.LinearSeq.dropRight, io.vavr.collection.Traversable.dropRight. Drops the last n elements of this or all elements, if this length < n.
public Queue<T>	dropRightUntil(Predicate<? super T> A condition tested subsequently for this elements, starting from the end. predicate) Implements io.vavr.collection.LinearSeq.dropRightUntil. Drops elements until the predicate holds for the current element, starting from the end.
public Queue<T>	dropRightWhile(Predicate<? super T> A condition tested subsequently for this elements, starting from the end. predicate) Implements io.vavr.collection.LinearSeq.dropRightWhile. Drops elements while the predicate holds for the current element, starting from the end.
public Queue<T>	dropWhile(Predicate<? super T> A condition tested subsequently for this elements. predicate) Implements abstract io.vavr.collection.AbstractQueue.dropWhile. Implements io.vavr.collection.LinearSeq.dropWhile, io.vavr.collection.Traversable.dropWhile. Drops elements while the predicate holds for the current element.
public static < Component type T> Queue<T>	Returns: The empty Queue. empty() Returns the empty Queue.
public Queue<T>	Returns: a new `Queue` instance, containing the new element enqueue(T The new element element) Implements abstract io.vavr.collection.AbstractQueue.enqueue. Enqueues a new element.
public Queue<T>	Returns: a new `Queue` instance, containing the new elements enqueueAll(Iterable<? extends T> An Iterable of elements, may be empty elements) Implements abstract io.vavr.collection.AbstractQueue.enqueueAll. Enqueues the given elements.
public boolean	equals(Object an object, may be null o) Overrides java.lang.Object.equals. Implements io.vavr.collection.Traversable.equals. In Vavr there are four basic classes of collections: Seq (sequential elements) Set (distinct elements) Map (indexed elements) Multimap (indexed collections)
public static < Component type of the Queue T> Queue<T>	Returns: An Queue of size `n`, where each element contains the result supplied by `s`. fill(int The number of elements in the Queue n, Supplier<? extends T> The Supplier computing element values s) Returns a Queue containing `n` values supplied by a given Supplier `s`.
public static < Component type of the Queue T> Queue<T>	Returns: An Queue of size `n`, where each element is the given `element`. fill(int The number of elements in the Queue n, T The element element) Returns a Queue containing `n` times the given `element`
public Queue<T>	filter(Predicate<? super T> A predicate predicate) Implements io.vavr.collection.LinearSeq.filter, io.vavr.collection.Traversable.filter. Returns a new traversable consisting of all elements which satisfy the given predicate.
public <U> Queue<U>	flatMap(Function<? super T, ? extends Iterable<? extends U>> A mapper mapper) Implements io.vavr.collection.LinearSeq.flatMap, io.vavr.collection.Traversable.flatMap. FlatMaps this Traversable.
public T	get(int an index index) Implements io.vavr.collection.Seq.get. Returns the element at the specified index.
public <C> Map<C, Queue<T>>	groupBy(Function<? super T, ? extends C> A function which classifies elements into classes classifier) Implements io.vavr.collection.LinearSeq.groupBy, io.vavr.collection.Traversable.groupBy. Groups this elements by classifying the elements.
public Iterator<Queue<T>>	grouped(int a positive block size size) Implements io.vavr.collection.LinearSeq.grouped, io.vavr.collection.Traversable.grouped. Groups this `Traversable` into fixed size blocks.
public boolean	hasDefiniteSize() Implements io.vavr.collection.Traversable.hasDefiniteSize. Checks if this Traversable is known to have a finite size.
public int	hashCode() Overrides java.lang.Object.hashCode. Implements io.vavr.collection.Traversable.hashCode. Returns the hash code of this collection.
public T	head() Implements io.vavr.collection.Traversable.head. Returns the first element of a non-empty Traversable.
public int	indexOf(T an element element, int start index from) Implements io.vavr.collection.Seq.indexOf. Returns the index of the first occurrence of the given element after or at some start index or -1 if this does not contain the given element.
public Queue<T>	init() Implements abstract io.vavr.collection.AbstractQueue.init. Implements io.vavr.collection.LinearSeq.init, io.vavr.collection.Traversable.init. Dual of tail(), returning all elements except the last.
public Queue<T>	insert(int an index index, T an element element) Implements io.vavr.collection.LinearSeq.insert. Inserts the given element at the specified index.
public Queue<T>	insertAll(int an index index, Iterable<? extends T> An Iterable of elements elements) Implements io.vavr.collection.LinearSeq.insertAll. Inserts the given elements at the specified index.
public Queue<T>	intersperse(T An element. element) Implements io.vavr.collection.LinearSeq.intersperse. Inserts an element between all elements of this Traversable.
public boolean	Returns: false isAsync() Implements io.vavr.Value.isAsync. A `Queue` is computed synchronously.
public boolean	isEmpty() Overrides default io.vavr.collection.Traversable.isEmpty. Checks if this Traversable is empty.
public boolean	Returns: false isLazy() Implements io.vavr.Value.isLazy. A `Queue` is computed eagerly.
public boolean	isTraversableAgain() Implements io.vavr.collection.Traversable.isTraversableAgain. Checks if this Traversable can be repeatedly traversed.
public T	last() Implements io.vavr.collection.Traversable.last. Dual of head(), returning the last element.
public int	lastIndexOf(T an element element, int the end index end) Implements io.vavr.collection.Seq.lastIndexOf. Returns the index of the last occurrence of the given element before or at a given end index or -1 if this does not contain the given element.
public Queue<T>	leftPadTo(int the target length length, T the padding element element) Implements io.vavr.collection.Seq.leftPadTo. A copy of this sequence with an element prepended until a given target length is reached.
public int	length() Implements io.vavr.collection.Traversable.length. Computes the number of elements of this Traversable.
public <U> Queue<U>	map(Function<? super T, ? extends U> A mapper. mapper) Implements io.vavr.collection.LinearSeq.map, io.vavr.collection.Traversable.map. Maps the elements of this `Traversable` to elements of a new type preserving their order, if any.
public static < Component type of the `Queue`. T> Queue<T>	Returns: the given `queue` instance as narrowed type `Queue<T>`. narrow(Queue<? extends T> An `Queue`. queue) Narrows a widened `Queue<?`
public static < The component type T> Queue<T>	Returns: A new Queue instance containing the given element of(T An element. element) Returns a singleton `Queue`, i.e. a `Queue` of one element.
public static < Component type of the Queue. T> Queue<T>	Returns: A queue containing the given elements in the same order. of(T... Zero or more elements. elements) Creates a Queue of the given elements.
public static < Component type of the Queue. T> Queue<T>	Returns: A queue containing the given elements in the same order. ofAll(Iterable<? extends T> An Iterable of elements. elements) Creates a Queue of the given elements.
public static < Component type of the Stream. T> Queue<T>	Returns: A Queue containing the given elements in the same order. ofAll(Stream<? extends T> A `java.util.stream.Stream` javaStream) Creates a Queue that contains the elements of the given `java.util.stream.Stream`.
public static Queue<Boolean>	Returns: A new Queue of Boolean values ofAll(boolean... boolean values elements) Creates a Queue from boolean values.
public static Queue<Byte>	Returns: A new Queue of Byte values ofAll(byte... byte values elements) Creates a Queue from byte values.
public static Queue<Character>	Returns: A new Queue of Character values ofAll(char... char values elements) Creates a Queue from char values.
public static Queue<Double>	Returns: A new Queue of Double values ofAll(double... double values elements) Creates a Queue from double values.
public static Queue<Float>	Returns: A new Queue of Float values ofAll(float... float values elements) Creates a Queue from float values.
public static Queue<Integer>	Returns: A new Queue of Integer values ofAll(int... int values elements) Creates a Queue from int values.
public static Queue<Long>	Returns: A new Queue of Long values ofAll(long... long values elements) Creates a Queue from long values.
public static Queue<Short>	Returns: A new Queue of Short values ofAll(short... short values elements) Creates a Queue from short values.
public Queue<T>	orElse(Iterable<? extends T> An alternative `Traversable` other) Implements io.vavr.collection.LinearSeq.orElse, io.vavr.collection.Traversable.orElse. Returns this `Traversable` if it is nonempty, otherwise return the alternative.
public Queue<T>	orElse(Supplier<? extends Iterable<? extends T>> An alternative `Traversable` supplier supplier) Implements io.vavr.collection.LinearSeq.orElse, io.vavr.collection.Traversable.orElse. Returns this `Traversable` if it is nonempty, otherwise return the result of evaluating supplier.
public Queue<T>	padTo(int the target length length, T the padding element element) Implements io.vavr.collection.LinearSeq.padTo. A copy of this sequence with an element appended until a given target length is reached.
public Tuple2<Queue<T>, Queue<T>>	partition(Predicate<? super T> A predicate which classifies an element if it is in the first or the second traversable. predicate) Implements io.vavr.collection.LinearSeq.partition, io.vavr.collection.Traversable.partition. Creates a partition of this `Traversable` by splitting this elements in two in distinct traversables according to a predicate.
public Queue<T>	patch(int the index of the first replaced element from, Iterable<? extends T> sequence for replacement that, int the number of elements to drop in the original list replaced) Implements io.vavr.collection.LinearSeq.patch. Produces a new list where a slice of elements in this list is replaced by another sequence.
public Queue<Queue<T>>	permutations() Implements io.vavr.collection.LinearSeq.permutations. Computes all unique permutations.
public Queue<T>	prepend(T An element element) Implements io.vavr.collection.LinearSeq.prepend. Prepends an element to this.
public Queue<T>	prependAll(Iterable<? extends T> An Iterable of elements elements) Implements io.vavr.collection.LinearSeq.prependAll. Prepends all given elements to this.
public static Queue<Character>	range(char from, char toExclusive)
public static Queue<Integer>	Returns: a range of int values as specified or `Nil` if `from >= toExclusive` range(int the first number from, int the last number + 1 toExclusive) Creates a Queue of int numbers starting from `from`, extending to `toExclusive - 1`.
public static Queue<Long>	Returns: a range of long values as specified or `Nil` if `from >= toExclusive` range(long the first number from, long the last number + 1 toExclusive) Creates a Queue of long numbers starting from `from`, extending to `toExclusive - 1`.
public static Queue<Character>	rangeBy(char from, char toExclusive, int step)
public static Queue<Double>	rangeBy(double from, double toExclusive, double step)
public static Queue<Integer>	Returns: a range of long values as specified or `Nil` if `from >= toInclusive` and `step > 0` or `from <= toInclusive` and `step < 0` rangeBy(int the first number from, int the last number + 1 toExclusive, int the step step) Creates a Queue of int numbers starting from `from`, extending to `toExclusive - 1`, with `step`.
public static Queue<Long>	Returns: a range of long values as specified or `Nil` if `from >= toInclusive` and `step > 0` or `from <= toInclusive` and `step < 0` rangeBy(long the first number from, long the last number + 1 toExclusive, long the step step) Creates a Queue of long numbers starting from `from`, extending to `toExclusive - 1`, with `step`.
public static Queue<Character>	rangeClosed(char from, char toInclusive)
public static Queue<Integer>	Returns: a range of int values as specified or `Nil` if `from > toInclusive` rangeClosed(int the first number from, int the last number toInclusive) Creates a Queue of int numbers starting from `from`, extending to `toInclusive`.
public static Queue<Long>	Returns: a range of long values as specified or `Nil` if `from > toInclusive` rangeClosed(long the first number from, long the last number toInclusive) Creates a Queue of long numbers starting from `from`, extending to `toInclusive`.
public static Queue<Character>	rangeClosedBy(char from, char toInclusive, int step)
public static Queue<Double>	rangeClosedBy(double from, double toInclusive, double step)
public static Queue<Integer>	Returns: a range of int values as specified or `Nil` if `from > toInclusive` and `step > 0` or `from < toInclusive` and `step < 0` rangeClosedBy(int the first number from, int the last number toInclusive, int the step step) Creates a Queue of int numbers starting from `from`, extending to `toInclusive`, with `step`.
public static Queue<Long>	Returns: a range of int values as specified or `Nil` if `from > toInclusive` and `step > 0` or `from < toInclusive` and `step < 0` rangeClosedBy(long the first number from, long the last number toInclusive, long the step step) Creates a Queue of long numbers starting from `from`, extending to `toInclusive`, with `step`.
private Object	readResolve()
public Queue<T>	remove(T An element to be removed from this Seq. element) Implements io.vavr.collection.LinearSeq.remove. Removes the first occurrence of the given element.
public Queue<T>	removeAll(T An element to be removed from this Seq. element) Implements io.vavr.collection.LinearSeq.removeAll. Removes all occurrences of the given element.
public Queue<T>	removeAt(int position of element to remove index) Implements io.vavr.collection.LinearSeq.removeAt. Removes the element at the specified position in this sequence.
public Queue<T>	removeFirst(Predicate<T> an predicate predicate) Implements io.vavr.collection.LinearSeq.removeFirst. Removes the first occurrence that satisfy predicate
public Queue<T>	removeLast(Predicate<T> an predicate predicate) Implements io.vavr.collection.LinearSeq.removeLast. Removes the last occurrence that satisfy predicate
public Queue<T>	replace(T An element to be substituted. currentElement, T A replacement for currentElement. newElement) Implements io.vavr.collection.LinearSeq.replace, io.vavr.collection.Traversable.replace. Replaces the first occurrence (if exists) of the given currentElement with newElement.
public Queue<T>	replaceAll(T An element to be substituted. currentElement, T A replacement for currentElement. newElement) Implements io.vavr.collection.LinearSeq.replaceAll, io.vavr.collection.Traversable.replaceAll. Replaces all occurrences of the given currentElement with newElement.
public Queue<T>	reverse() Implements io.vavr.collection.LinearSeq.reverse. Reverses the order of elements.
public Queue<T>	rotateLeft(int distance of left rotation n) Implements io.vavr.collection.LinearSeq.rotateLeft. Circular rotates the elements by the specified distance to the left direction.
public Queue<T>	rotateRight(int distance of right rotation n) Implements io.vavr.collection.LinearSeq.rotateRight. Circular rotates the elements by the specified distance to the right direction.
public Queue<T>	scan(T neutral element for the operator op zero, BiFunction<? super T, ? super T, ? extends T> the associative operator for the scan operation) Implements io.vavr.collection.LinearSeq.scan, io.vavr.collection.Traversable.scan. Computes a prefix scan of the elements of the collection.
public <U> Queue<U>	scanLeft(U the initial value zero, BiFunction<? super U, ? super T, ? extends U> the binary operator applied to the intermediate result and the element operation) Implements io.vavr.collection.LinearSeq.scanLeft, io.vavr.collection.Traversable.scanLeft. Produces a collection containing cumulative results of applying the operator going left to right.
public <U> Queue<U>	scanRight(U the initial value zero, BiFunction<? super T, ? super U, ? extends U> the binary operator applied to the intermediate result and the element operation) Implements io.vavr.collection.LinearSeq.scanRight, io.vavr.collection.Traversable.scanRight. Produces a collection containing cumulative results of applying the operator going right to left.
public Queue<T>	shuffle() Implements io.vavr.collection.LinearSeq.shuffle. Randomize the order of the elements in the current sequence.
public Queue<T>	slice(int the beginning index, inclusive beginIndex, int the end index, exclusive endIndex) Implements io.vavr.collection.LinearSeq.slice. Returns a Seq that is a slice of this.
public Iterator<Queue<T>>	slideBy(Function<? super T, ?> A function which classifies elements into classes classifier) Implements io.vavr.collection.LinearSeq.slideBy, io.vavr.collection.Traversable.slideBy. Slides a non-overlapping window of a variable size over this `Traversable`.
public Iterator<Queue<T>>	sliding(int a positive window size size) Implements io.vavr.collection.LinearSeq.sliding, io.vavr.collection.Traversable.sliding. Slides a window of a specific `size` and step size 1 over this `Traversable` by calling `sliding(int, int)`.
public Iterator<Queue<T>>	sliding(int a positive window size size, int a positive step size step) Implements io.vavr.collection.LinearSeq.sliding, io.vavr.collection.Traversable.sliding. Slides a window of a specific `size` and `step` size over this `Traversable`.
public <U extends Comparable<? super U>> Queue<T>	sortBy(Function<? super T, ? extends U> A mapper mapper) Implements io.vavr.collection.LinearSeq.sortBy. Sorts this elements by comparing the elements in a different domain, using the given `mapper`.
public <U> Queue<T>	sortBy(Comparator<? super U> A comparator comparator, Function<? super T, ? extends U> A mapper mapper) Implements io.vavr.collection.LinearSeq.sortBy. Sorts this elements by comparing the elements in a different domain, using the given `mapper`.
public Queue<T>	sorted() Implements io.vavr.collection.LinearSeq.sorted. Sorts this elements according to their natural order.
public Queue<T>	sorted(Comparator<? super T> A comparator comparator) Implements io.vavr.collection.LinearSeq.sorted. Sorts this elements according to the provided `Comparator`.
public Tuple2<Queue<T>, Queue<T>>	span(Predicate<? super T> A predicate. predicate) Implements io.vavr.collection.LinearSeq.span, io.vavr.collection.Traversable.span. Returns a tuple where the first element is the longest prefix of elements that satisfy the given `predicate` and the second element is the remainder.
public Tuple2<Queue<T>, Queue<T>>	splitAt(int An index. n) Implements io.vavr.collection.Seq.splitAt. Splits a Seq at the specified index.
public Tuple2<Queue<T>, Queue<T>>	splitAt(Predicate<? super T> An predicate predicate) Implements io.vavr.collection.Seq.splitAt. Splits a sequence at the first element which satisfies the `Predicate`, e.g. Tuple(init, element+tail).
public Tuple2<Queue<T>, Queue<T>>	splitAtInclusive(Predicate<? super T> An predicate predicate) Implements io.vavr.collection.Seq.splitAtInclusive. Splits a sequence at the first element which satisfies the `Predicate`, e.g. Tuple(init+element, tail).
public boolean	startsWith(Iterable<? extends T> the sequence to test that, int the index where the sequence is searched. offset) Overrides default io.vavr.collection.Seq.startsWith. Tests whether this list contains the given sequence at a given index.
public String	stringPrefix() Implements io.vavr.Value.stringPrefix. Returns the name of this Value type, which is used by toString().
public Queue<T>	subSequence(int the beginning index, inclusive beginIndex) Implements io.vavr.collection.LinearSeq.subSequence. Returns a Seq that is a subsequence of this.
public Queue<T>	subSequence(int the beginning index, inclusive beginIndex, int the end index, exclusive endIndex) Implements io.vavr.collection.LinearSeq.subSequence. Returns a Seq that is a subsequence of this.
public static < Component type of the Queue T> Queue<T>	Returns: A Queue consisting of elements `f(0),f(1), ..., f(n - 1)` tabulate(int The number of elements in the Queue n, Function<? super Integer, ? extends T> The Function computing element values f) Returns a Queue containing `n` values of a given Function `f` over a range of integer values from 0 to `n - 1`.
public Queue<T>	tail() Implements abstract io.vavr.collection.AbstractQueue.tail. Implements io.vavr.collection.LinearSeq.tail, io.vavr.collection.Traversable.tail. Drops the first element of a non-empty Traversable.
public Queue<T>	take(int The number of elements to take. n) Implements io.vavr.collection.LinearSeq.take, io.vavr.collection.Traversable.take. Takes the first n elements of this or all elements, if this length < n.
public Queue<T>	takeRight(int The number of elements to take. n) Implements io.vavr.collection.LinearSeq.takeRight, io.vavr.collection.Traversable.takeRight. Takes the last n elements of this or all elements, if this length < n.
public Queue<T>	takeRightUntil(Predicate<? super T> A condition tested subsequently for this elements, starting from the end. predicate) Implements io.vavr.collection.LinearSeq.takeRightUntil. Takes elements until the predicate holds for the current element, starting from the end.
public Queue<T>	takeRightWhile(Predicate<? super T> A condition tested subsequently for this elements, starting from the end. predicate) Implements io.vavr.collection.LinearSeq.takeRightWhile. Takes elements while the predicate holds for the current element, starting from the end.
public Queue<T>	takeUntil(Predicate<? super T> A condition tested subsequently for this elements. predicate) Implements abstract io.vavr.collection.AbstractQueue.takeUntil. Implements io.vavr.collection.LinearSeq.takeUntil, io.vavr.collection.Traversable.takeUntil. Takes elements until the predicate holds for the current element.
public < Type of transformation result U> U	Returns: An instance of type `U` transform(Function<? super Queue<T>, ? extends U> A transformation f) Transforms this `Queue`.
public static < matrix element type T> Queue<Queue<T>>	Returns: a transposed `Queue` matrix. transpose(Queue<Queue<T>> to be transposed. matrix) Transposes the rows and columns of a `Queue` matrix.
public static < type of seeds and unfolded values T> Queue<T>	Returns: a Queue with the values built up by the iteration unfold(T the start value for the iteration seed, Function<? super T, Option<Tuple2<? extends T, ? extends T>>> the function to get the next step of the iteration f) Creates a Queue from a seed value and a function.
public static < type of seeds T, type of unfolded values U> Queue<U>	Returns: a Queue with the values built up by the iteration unfoldLeft(T the start value for the iteration seed, Function<? super T, Option<Tuple2<? extends T, ? extends U>>> the function to get the next step of the iteration f) Creates a Queue from a seed value and a function.
public static < type of seeds T, type of unfolded values U> Queue<U>	Returns: a Queue with the values built up by the iteration unfoldRight(T the start value for the iteration seed, Function<? super T, Option<Tuple2<? extends U, ? extends T>>> the function to get the next step of the iteration f) Creates a Queue from a seed value and a function.
public <T1, T2> Tuple2<Queue<T1>, Queue<T2>>	unzip(Function<? super T, Tuple2<? extends T1, ? extends T2>> a function which converts elements of this to pairs unzipper) Implements io.vavr.collection.LinearSeq.unzip, io.vavr.collection.Traversable.unzip. Unzips this elements by mapping this elements to pairs which are subsequently split into two distinct sets.
public <T1, T2, T3> Tuple3<Queue<T1>, Queue<T2>, Queue<T3>>	unzip3(Function<? super T, Tuple3<? extends T1, ? extends T2, ? extends T3>> a function which converts elements of this to pairs unzipper) Implements io.vavr.collection.Seq.unzip3, io.vavr.collection.Traversable.unzip3. Unzips this elements by mapping this elements to triples which are subsequently split into three distinct sets.
public Queue<T>	update(int an index index, T an element element) Implements io.vavr.collection.LinearSeq.update. Updates the given element at the specified index.
public Queue<T>	update(int an index index, Function<? super T, ? extends T> a function transforming the previous value updater) Implements io.vavr.collection.LinearSeq.update, io.vavr.collection.LinearSeq.update. Updates the given element at the specified index using the specified function.
public <U> Queue<Tuple2<T, U>>	zip(Iterable<? extends U> The Iterable providing the second half of each result pair. that) Implements io.vavr.collection.LinearSeq.zip, io.vavr.collection.Traversable.zip. Returns a traversable formed from this traversable and another Iterable collection by combining corresponding elements in pairs.
public <U> Queue<Tuple2<T, U>>	zipAll(Iterable<? extends U> The Iterable providing the second half of each result pair. that, T The element to be used to fill up the result if this traversable is shorter than that. thisElem, U The element to be used to fill up the result if that is shorter than this traversable. thatElem) Implements io.vavr.collection.LinearSeq.zipAll, io.vavr.collection.Traversable.zipAll. Returns a traversable formed from this traversable and another Iterable by combining corresponding elements in pairs.
public <U, R> Queue<R>	zipWith(Iterable<? extends U> The Iterable providing the second parameter of the mapper. that, BiFunction<? super T, ? super U, ? extends R> a mapper. mapper) Implements io.vavr.collection.LinearSeq.zipWith, io.vavr.collection.Traversable.zipWith. Returns a traversable formed from this traversable and another Iterable collection by mapping elements.
public Queue<Tuple2<T, Integer>>	zipWithIndex() Implements io.vavr.collection.LinearSeq.zipWithIndex, io.vavr.collection.Traversable.zipWithIndex. Zips this traversable with its indices.
public <U> Queue<U>	zipWithIndex(BiFunction<? super T, ? super Integer, ? extends U> a mapper. mapper) Implements io.vavr.collection.LinearSeq.zipWithIndex, io.vavr.collection.Traversable.zipWithIndex. Zips this traversable with its indices by applying mapper provided.

Inherited from io.vavr.collection.AbstractQueue:: dequeue dequeueOption dropUntil enqueue initOption peek peek peekOption reject removeAll removeAll retainAll tailOption takeWhile toString

public final Class Queue<T>

Field Summary

Constructor Summary

Method Summary