IntLinkedSeq

java.lang.Object
- IntLinkedSeq

All Implemented Interfaces:

java.lang.Cloneable
```
public class IntLinkedSeq
extends java.lang.Object
implements java.lang.Cloneable
```
This class is a homework assignment; A IntLinkedSeq is a collection of int numbers. The sequence can have a special "current element," which is specified and accessed through four methods (start, getCurrent, advance, and isCurrent).

Limitations:
Beyond Int.MAX_VALUE elements, the size method does not work.
Note:
This file contains only blank implementations ("stubs") because this is a Programming Project for students.

Constructor Summary

Constructors
Constructor and Description

IntLinkedSeq()
Initialize an empty sequence.

Constructors
Constructor and Description
`IntLinkedSeq()` Initialize an empty sequence.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addAfter(int element)` Add a new element to this sequence, after the current element.
`void`	`addAll(IntLinkedSeq addend)` Place the contents of another sequence at the end of this sequence.
`void`	`addBefore(int element)` Add a new element to this sequence, before the current element.
`void`	`addFirst(int element)` Add a new element to the beginning of this sequence.
`void`	`addLast(int element)` Add a new element to the end of this sequence.
`void`	`advance()` Move forward, so that the current element is now the next element in this sequence.
`IntLinkedSeq`	`catenation(IntLinkedSeq s2)` Create a new sequence that contains all the elements from this sequence followed by another sequence.
`java.lang.Object`	`clone()` Generate a copy of this sequence.
`boolean`	`contains(int target)` Method to determine if a particular element is in this sequence.
`int`	`getCurrentValue()` Accessor method to get the value in the current element of this sequence.
`int`	`indexOf(int target)` Returns the index of the first occurrence of the specified element in this sequence, or -1 if this sequence does not contain the element.
`void`	`invalidateCurrent()` Set the state of this sequence so that it does not have a current element.
`boolean`	`isCurrent()` Accessor method to determine whether this sequence has a specified current element that can be retrieved with the getCurrent() method.
`void`	`removeCurrent()` Remove the current element from this sequence.
`void`	`removeFirst()` Remove the element at the beginning of this sequence.
`void`	`removeLast()` Remove the element at the end of this sequence.
`IntLinkedSeq`	`reverse()` Create a new sequence that contains all the elements from this sequence in the reverse order.
`void`	`setCurrent(int i)` Set the current element to be the i'th element of this sequence (starting with the 0'th element at the head).
`void`	`setCurrentValue(int element)` Mutator method to set the value in the current element of this sequence.
`int`	`size()` Determine the number of elements in this sequence.
`void`	`start()` Set the current element at the front of this sequence.
`IntLinkedSeq`	`subSeq(int fromIndex, int toIndex)` Create a new sequence that contains all the elements from this sequence that are between the indices fromIndex, inclusive, and toIndex, exclusive.
`int[]`	`toArray()` Returns an array containing all of the elements in this sequence.
`java.lang.String`	`toString()` Returns a String containing a representation of all the elements in this sequence.

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

- Constructor Detail
  - IntLinkedSeq
```
public IntLinkedSeq()
```
    Initialize an empty sequence.
    
    Parameters:
    none -
    Postcondition:
    
    This sequence is empty. It does not have a current element.
- Method Detail
  - addAfter
```
public void addAfter(int element)
```
    Add a new element to this sequence, after the current element.
    
    Parameters:
    element - the new element that is being added
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for a new node.
    Postcondition:
    
    A new copy of the element has been added to this sequence. If there was a current element, then the new element is placed after the current element. If there was no current element, then the new element is placed at the end of the sequence. In all cases, the new element becomes the new current element of this sequence.
  - addBefore
```
public void addBefore(int element)
```
    Add a new element to this sequence, before the current element.
    
    Parameters:
    element - the new element that is being added
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for a new node.
    Postcondition:
    
    A new copy of the element has been added to this sequence. If there was a current element, then the new element is placed before the current element. If there was no current element, then the new element is placed at the start of the sequence. In all cases, the new element becomes the new current element of this sequence.
  - addAll
```
public void addAll(IntLinkedSeq addend)
```
    Place the contents of another sequence at the end of this sequence.
    
    Parameters:
    addend - a sequence whose contents will be placed at the end of this sequence
    
    Throws:
    
    java.lang.NullPointerException - Indicates that addend is null.
    
    java.lang.OutOfMemoryError - Indicates insufficient memory to increase the size of this sequence.
    Precondition:
    
    The parameter, addend, is not null.
    
    Postcondition:
    
    The elements from addend have been placed at the end of this sequence. The current element of this sequence remains where it was, and the addend is also unchanged.
  - addFirst
```
public void addFirst(int element)
```
    Add a new element to the beginning of this sequence.
    
    Parameters:
    element - the new element that is being added
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for a new node.
    Postcondition:
    
    A new copy of the element has been added to the beginning of this sequence. The current element is unchanged.
  - addLast
```
public void addLast(int element)
```
    Add a new element to the end of this sequence.
    
    Parameters:
    element - the new element that is being added
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for a new node.
    Postcondition:
    
    A new copy of the element has been added to the end of this sequence. The current element is unchanged.
  - start
```
public void start()
```
    Set the current element at the front of this sequence.
    
    Parameters:
    none -
    Postcondition:
    
    The front element of this sequence is now the current element (but if this sequence has no elements at all, then there is no current element).
  - isCurrent
```
public boolean isCurrent()
```
    Accessor method to determine whether this sequence has a specified current element that can be retrieved with the getCurrent() method.
    
    Parameters:
    none -
    
    Returns:
    true (there is a current element) or false (there is no current element at the moment)
  - getCurrentValue
```
public int getCurrentValue()
```
    Accessor method to get the value in the current element of this sequence.
    
    Parameters:
    none -
    
    Returns:
    the value in the current element of this sequence
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that there is no current element, so getCurrentValue() may not be called.
    Precondition:
    
    isCurrent() returns true.
  - setCurrentValue
```
public void setCurrentValue(int element)
```
    Mutator method to set the value in the current element of this sequence.
    
    Parameters:
    element - the new value that is to be placed in the current element
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that there is no current element, so setCurrentValue() may not be called.
    Precondition:
    
    isCurrent() returns true.
  - removeCurrent
```
public void removeCurrent()
```
    Remove the current element from this sequence.
    
    Parameters:
    none -
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that there is no current element, so removeCurrent() may not be called.
    Precondition:
    
    isCurrent() returns true.
    
    Postcondition:
    
    The current element has been removed from this sequence, and the following element (if there is one) is now the new current element. If there was no following element, then there is now no current element.
  - removeFirst
```
public void removeFirst()
```
    Remove the element at the beginning of this sequence.
    
    Parameters:
    none -
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that the sequence is empty, so removeFirst() may not be called.
    Precondition:
    
    The sequence is not empty.
    
    Postcondition:
    
    The first element of the sequence is deleted from the sequence. If this was the current element, then the current element status is invalidated.
  - removeLast
```
public void removeLast()
```
    Remove the element at the end of this sequence.
    
    Parameters:
    none -
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that the sequence is empty, so removeLast() may not be called.
    Precondition:
    
    The sequence is not empty.
    
    Postcondition:
    
    The last element of the sequence is deleted from the sequence. If this was the current element, then the current element status is invalidated.
  - advance
```
public void advance()
```
    Move forward, so that the current element is now the next element in this sequence.
    
    Parameters:
    none -
    
    Throws:
    
    java.lang.IllegalStateException - Indicates that there is no current element, so advance() may not be called.
    Precondition:
    
    isCurrent() returns true.
    
    Postcondition:
    
    If the current element was already the end element of this sequence (with nothing after it), then there is no longer any current element. Otherwise, the new element is the element immediately after the original current element.
  - setCurrent
```
public void setCurrent(int i)
```
    Set the current element to be the i'th element of this sequence (starting with the 0'th element at the head).
    
    Parameters:
    i - the index of the element to make the current element
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - Indicates that i is less than 0 or greater than size-1 (i < 0 || i >= size).
    Precondition:
    
    The parameter i is greater than or equal to 0 and i is less than size (i >= 0 && i < size).
    
    Postcondition:
    
    The current element is the i'th element of the sequence (where the head element is the 0'th element)
  - invalidateCurrent
```
public void invalidateCurrent()
```
    Set the state of this sequence so that it does not have a current element.
    
    Parameters:
    none -
    Postcondition:
    
    After calling this method, calling isCurrent() returns false.
  - contains
```
public boolean contains(int target)
```
    Method to determine if a particular element is in this sequence.
    
    Parameters:
    target - the element that needs to be found in this sequence
    
    Returns:
    true if the target element is in this sequence, false otherwise
  - indexOf
```
public int indexOf(int target)
```
    Returns the index of the first occurrence of the specified element in this sequence, or -1 if this sequence does not contain the element.
    
    Parameters:
    target - the element that needs to be found in this sequence
    
    Returns:
    the index of the first occurrence of target in this sequence, or -1 if this sequence does not contain target
  - size
```
public int size()
```
    Determine the number of elements in this sequence.
    
    Parameters:
    none -
    
    Returns:
    the number of elements in this sequence
  - clone
```
public java.lang.Object clone()
```
    Generate a copy of this sequence.
    
    Overrides:
    
    clone in class java.lang.Object
    
    Parameters:
    none -
    
    Returns:
    The return value is a copy of this sequence. Subsequent changes to the copy will not affect the original, nor vice versa. The cloned copy should have its cursor set in the appropriate place within its linked list. Note that the return value must be type cast to a IntLinkedSeq before it can be used.
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for creating the clone.
  - catenation
```
public IntLinkedSeq catenation(IntLinkedSeq s2)
```
    Create a new sequence that contains all the elements from this sequence followed by another sequence. The returned sequence should not be backed by this sequence or the other sequence (so changes to the returned sequence are not reflected in this sequence or the other sequence).
    
    Parameters:
    s2 - the second sequence
    
    Returns:
    a new sequence that has the elements of this followed by the elements of s2 (with no current element)
    
    Throws:
    
    NullPointerException. - Indicates that the argument is null.
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for the new sequence.
    Precondition:
    
    s2 is not null.
  - subSeq
```
public IntLinkedSeq subSeq(int fromIndex,
                  int toIndex)
```
    Create a new sequence that contains all the elements from this sequence that are between the indices fromIndex, inclusive, and toIndex, exclusive. (If fromIndex and toIndex are equal, the returned sequence is empty.) The returned sequence should not be backed by this sequence (so changes to the returned sequence are not reflected in this sequence). The new sequence should not have a current element.
    
    Parameters:
    fromIndex - low endpoint (inclusive) of the sub sequence
    toIndex - high endpoint (exclusive) of the sub sequence
    
    Returns:
    a new sequence that contains all the elements from this sequence that are between the indices fromIndex, inclusive, and toIndex, exclusive.
    
    Throws:
    
    java.lang.IllegalArgumentException - if the endpoint indices are out of order (fromIndex > toIndex)
    
    java.lang.IndexOutOfBoundsException - endpoint index value out of range (fromIndex < 0 || toIndex > size)
    Precondition:
    
    fromIndex is less than or equal to toIndex (fromIndex <= toIndex), fromIndex is greater than or equal to zero (fromIndex >= 0), toIndex is less than or equal to size (toIndex <= size)
  - reverse
```
public IntLinkedSeq reverse()
```
    Create a new sequence that contains all the elements from this sequence in the reverse order. The returned sequence should not be backed by this sequence (so changes to the returned sequence are not reflected in this sequence). The new sequence should not have a current element.
    
    Parameters:
    none -
    
    Returns:
    a new sequence that has the elements of this in their reverse order (with no current element)
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for the new sequence.
  - toArray
```
public int[] toArray()
```
    Returns an array containing all of the elements in this sequence.
    
    Parameters:
    none -
    
    Returns:
    an array containing all the elements in this sequence
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for the new array.
  - toString
```
public java.lang.String toString()
```
    Returns a String containing a representation of all the elements in this sequence. Notice that a special symbol is used to denote the current element.
    
    Overrides:
    
    toString in class java.lang.Object
    
    Parameters:
    none -
    
    Returns:
    a String containing all the elements in this sequence
    
    Throws:
    
    java.lang.OutOfMemoryError - Indicates insufficient memory for the new String.

Class IntLinkedSeq

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

IntLinkedSeq

Method Detail

addAfter

addBefore

addAll

addFirst

addLast

start

isCurrent

getCurrentValue

setCurrentValue

removeCurrent

removeFirst

removeLast

advance

setCurrent

invalidateCurrent

contains

indexOf

size

clone

catenation

subSeq

reverse

toArray

toString