Seq (core 4.6 API)

java.lang.Object
- fj.data.Seq<A>

All Implemented Interfaces:

java.lang.Iterable<A>
```
public final class Seq<A>
extends java.lang.Object
implements java.lang.Iterable<A>
```
Provides an immutable finite sequence, implemented as a finger tree. This structure gives O(1) access to the head and tail, as well as O(log n) random access and concatenation of sequences.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Seq<A>`	`append(Seq<A> as)` Appends the given sequence to this sequence.
`static <A> Seq<A>`	`arraySeq(A... as)` Constructs a sequence from the array.
`Seq<A>`	`cons(A a)` Inserts the given element at the front of this sequence.
`Seq<A>`	`delete(int i)` Delete the element at the given index.
`Seq<A>`	`drop(int n)` Drops the given number of elements from the head of this sequence if they are available.
`static <A> Seq<A>`	`empty()` The empty sequence.
`boolean`	`equals(java.lang.Object other)`
`<B> B`	`foldLeft(F2<B,A,B> f, B z)`
`<B> B`	`foldRight(F2<A,B,B> f, B z)`
`static <A> Seq<A>`	`fromJavaList(java.util.List<A> list)` Constructs a sequence from the given list.
`int`	`hashCode()`
`A`	`head()` The first element of this sequence.
`Option<A>`	`headOption()`
`A`	`index(int i)` Returns the element at the given index.
`Seq<A>`	`init()` The sequence without the last element.
`boolean`	`isEmpty()` Checks if this is the empty sequence.
`boolean`	`isNotEmpty()` Checks if this sequence is not empty.
`static <A> Seq<A>`	`iterableSeq(java.lang.Iterable<A> i)` Constructs a sequence from the iterable.
`java.util.Iterator<A>`	`iterator()` Returns an iterator for this seq.
`static <A> Seq<A>`	`iteratorSeq(java.util.Iterator<A> i)` Constructs a sequence from the iterator.
`A`	`last()` The last element of this sequence.
`int`	`length()` Returns the number of elements in this sequence.
`static <A> Seq<A>`	`listSeq(List<A> list)` Deprecated. As of release 4.5, use `iterableSeq(java.lang.Iterable<A>)`
`<B> Seq<B>`	`map(F<A,B> f)`
`static <A> Seq<A>`	`seq(A... as)` Constructs a sequence from the given elements.
`static <A> Seq<A>`	`seq(List<A> list)` Deprecated. As of release 4.5, use `listSeq(List)`
`static <A> Seq<A>`	`single(A a)` A singleton sequence.
`Seq<A>`	`snoc(A a)` Inserts the given element at the end of this sequence.
`P2<Seq<A>,Seq<A>>`	`split(int i)` Splits this sequence into a pair of sequences at the given position.
`Seq<A>`	`tail()` The sequence without the first element.
`Seq<A>`	`take(int n)` Takes the given number of elements from the head of this sequence if they are available.
`java.util.List<A>`	`toJavaList()` Converts the sequence to a java.util.List
`List<A>`	`toList()` Converts this sequence to a List
`Stream<A>`	`toStream()` Converts this sequence to a Stream
`java.lang.String`	`toString()`
`Seq<A>`	`update(int i, A a)` Replace the element at the given index with the supplied value.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Method Detail
  - empty
```
public static <A> Seq<A> empty()
```
    The empty sequence.
    
    Returns:
    
    A sequence with no elements.
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
  - single
```
public static <A> Seq<A> single(A a)
```
    A singleton sequence.
    
    Parameters:
    
    a - The single element in the sequence.
    
    Returns:
    
    A new sequence with the given element in it.
  - seq
```
@SafeVarargs
public static <A> Seq<A> seq(A... as)
```
    Constructs a sequence from the given elements.
    
    Parameters:
    
    as - The elements to create the sequence from.
    
    Returns:
    
    A sequence with the given elements.
  - seq
```
@Deprecated
public static <A> Seq<A> seq(List<A> list)
```
    Deprecated. As of release 4.5, use listSeq(List)
    
    Constructs a sequence from the given list.
    
    Parameters:
    
    list - The list to create the sequence from.
    
    Returns:
    
    A sequence with the given elements in the list.
  - listSeq
```
@Deprecated
public static <A> Seq<A> listSeq(List<A> list)
```
    Deprecated. As of release 4.5, use iterableSeq(java.lang.Iterable<A>)
    
    Constructs a sequence from the given list.
    
    Parameters:
    
    list - The list to create the sequence from.
    
    Returns:
    
    A sequence with the elements of the list.
  - iterableSeq
```
public static <A> Seq<A> iterableSeq(java.lang.Iterable<A> i)
```
    Constructs a sequence from the iterable.
    
    Parameters:
    
    i - The iterable to create the sequence from.
    
    Returns:
    
    A sequence with the elements of the iterable.
  - iteratorSeq
```
public static <A> Seq<A> iteratorSeq(java.util.Iterator<A> i)
```
    Constructs a sequence from the iterator.
    
    Parameters:
    
    i - The iterator to create the sequence from.
    
    Returns:
    
    A sequence with the elements of the iterator.
  - arraySeq
```
@SafeVarargs
public static <A> Seq<A> arraySeq(A... as)
```
    Constructs a sequence from the array.
  - fromJavaList
```
public static <A> Seq<A> fromJavaList(java.util.List<A> list)
```
    Constructs a sequence from the given list.
    
    Parameters:
    
    list - The list to create the sequence from.
    
    Returns:
    
    A sequence with the elements of the list.
  - cons
```
public Seq<A> cons(A a)
```
    Inserts the given element at the front of this sequence.
    
    Parameters:
    
    a - An element to insert at the front of this sequence.
    
    Returns:
    
    A new sequence with the given element at the front.
  - snoc
```
public Seq<A> snoc(A a)
```
    Inserts the given element at the end of this sequence.
    
    Parameters:
    
    a - An element to insert at the end of this sequence.
    
    Returns:
    
    A new sequence with the given element at the end.
  - head
```
public A head()
```
    The first element of this sequence. This is an O(1) operation.
    
    Returns:
    
    The first element if this sequence is nonempty, otherwise throws an error.
  - headOption
```
public Option<A> headOption()
```
  - last
```
public A last()
```
    The last element of this sequence. This is an O(1) operation.
    
    Returns:
    
    The last element if this sequence is nonempty, otherwise throws an error.
  - tail
```
public Seq<A> tail()
```
    The sequence without the first element. This is an O(1) operation.
    
    Returns:
    
    The sequence without the first element if this sequence is nonempty, otherwise throws an error.
  - init
```
public Seq<A> init()
```
    The sequence without the last element. This is an O(1) operation.
    
    Returns:
    
    The sequence without the last element if this sequence is nonempty, otherwise throws an error.
  - toStream
```
public Stream<A> toStream()
```
    Converts this sequence to a Stream
  - toList
```
public List<A> toList()
```
    Converts this sequence to a List
  - toJavaList
```
public java.util.List<A> toJavaList()
```
    Converts the sequence to a java.util.List
  - iterator
```
public java.util.Iterator<A> iterator()
```
    Returns an iterator for this seq. This method exists to permit the use in a for-each loop.
    
    Specified by:
    
    iterator in interface java.lang.Iterable<A>
    
    Returns:
    
    A iterator for this seq.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - append
```
public Seq<A> append(Seq<A> as)
```
    Appends the given sequence to this sequence.
    
    Parameters:
    
    as - A sequence to append to this one.
    
    Returns:
    
    A new sequence with the given sequence appended to this one.
  - isEmpty
```
public boolean isEmpty()
```
    Checks if this is the empty sequence.
    
    Returns:
    
    True if this sequence is empty, otherwise false.
  - isNotEmpty
```
public boolean isNotEmpty()
```
    Checks if this sequence is not empty.
    
    Returns:
    
    True if this sequence is not empty, otherwise false.
  - length
```
public int length()
```
    Returns the number of elements in this sequence.
    
    Returns:
    
    the number of elements in this sequence.
  - split
```
public P2<Seq<A>,Seq<A>> split(int i)
```
    Splits this sequence into a pair of sequences at the given position. This is a O(log(n)) operation.
    
    Returns:
    
    Pair: the subsequence containing elements with indices less than i and the subsequence containing elements with indices greater than or equal to i.
  - index
```
public A index(int i)
```
    Returns the element at the given index. This is an O(log(n)) operation.
    
    Parameters:
    
    i - The index of the element to return.
    
    Returns:
    
    The element at the given index, or throws an error if the index is out of bounds.
  - update
```
public Seq<A> update(int i,
                     A a)
```
    Replace the element at the given index with the supplied value. This is an O(log(n)) operation.
    
    Parameters:
    
    i - The index of the element to update.
    
    a - The new value.
    
    Returns:
    
    The updated sequence, or throws an error if the index is out of bounds.
  - delete
```
public Seq<A> delete(int i)
```
    Delete the element at the given index. This is an O(log(n)) operation.
    
    Parameters:
    
    i - The index of the element to update.
    
    Returns:
    
    The updated sequence, or throws an error if the index is out of bounds.
  - take
```
public Seq<A> take(int n)
```
    Takes the given number of elements from the head of this sequence if they are available.
    
    Parameters:
    
    n - The maximum number of elements to take from this sequence.
    
    Returns:
    
    A sequence consisting only of the first n elements of this sequence, or else the whole sequence, if it has less than n elements.
  - drop
```
public Seq<A> drop(int n)
```
    Drops the given number of elements from the head of this sequence if they are available.
    
    Parameters:
    
    n - The number of elements to drop from this sequence.
    
    Returns:
    
    A sequence consisting of all elements of this sequence except the first n ones, or else the empty sequence, if this sequence has less than n elements.
  - foldLeft
```
public <B> B foldLeft(F2<B,A,B> f,
                      B z)
```
  - foldRight
```
public <B> B foldRight(F2<A,B,B> f,
                       B z)
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - map
```
public <B> Seq<B> map(F<A,B> f)
```

Class Seq<A>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Method Detail

empty

equals

single

seq

seq

listSeq

iterableSeq

iteratorSeq

arraySeq

fromJavaList

cons

snoc

head

headOption

last

tail

init

toStream

toList

toJavaList

iterator

toString

append

isEmpty

isNotEmpty

length

split

index

update

delete

take

drop

foldLeft

foldRight

hashCode

map