IList

All Superinterfaces:

Iterable<E>

All Known Implementing Classes:

LinkedList
```
public interface IList<E>
extends Iterable<E>
```
Interface for a simple List. Random access to all items in the list is provided. The numbering of elements in the list begins at 0.

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(E item)` Add an item to the end of this list.
`boolean`	`equals(Object other)` Determine if this IList is equal to other.
`E`	`get(int pos)` Get an element from the list.
`IList<E>`	`getSubList(int start, int stop)` Return a sublist of elements in this list from `start` inclusive to `stop` exclusive.
`int`	`indexOf(E item)` Find the position of an element in the list.
`int`	`indexOf(E item, int pos)` find the position of an element in the list starting at a specified position.
`void`	`insert(int pos, E item)` Insert an item at a specified position in the list.
`Iterator<E>`	`iterator()` return an Iterator for this list.
`void`	`makeEmpty()` return the list to an empty state.
`boolean`	`remove(E obj)` Remove the first occurrence of obj in this list.
`E`	`remove(int pos)` Remove an element in the list based on position.
`void`	`removeRange(int start, int stop)` Remove all elements in this list from `start` inclusive to `stop` exclusive.
`E`	`set(int pos, E item)` Change the data at the specified position in the list.
`int`	`size()` Return the size of this list.
`String`	`toString()` Return a String version of this list enclosed in square brackets, [].

- Method Detail
  - add
```
void add(E item)
```
    Add an item to the end of this list.
    pre: item != null
    post: size() = old size() + 1, get(size() - 1) = item
    
    Parameters:
    item - the data to be added to the end of this list
  - insert
```
void insert(int pos,
          E item)
```
    Insert an item at a specified position in the list.
    pre: 0 <= pos <= size(), item != null
    post: size() = old size() + 1, get(pos) = item, all elements in the list with a positon >= pos have a position = old position + 1
    
    Parameters:
    pos - the position to insert the data at in the list
    item - the data to add to the list
  - set
```
E set(int pos,
    E item)
```
    Change the data at the specified position in the list. the old data at that position is returned.
    pre: 0 <= pos < size(), item != null
    post: get(pos) = item, return the old get(pos)
    
    Parameters:
    pos - the position in the list to overwrite
    item - the new item that will overwrite the old item
    
    Returns:
    the old data at the specified position
  - get
```
E get(int pos)
```
    Get an element from the list.
    pre: 0 <= pos < size()
    post: return the item at pos
    
    Parameters:
    pos - specifies which element to get
    
    Returns:
    the element at the specified position in the list
  - remove
```
E remove(int pos)
```
    Remove an element in the list based on position.
    pre: 0 <= pos < size()
    post: size() = old size() - 1, all elements of list with a positon > pos have a position = old position - 1
    
    Parameters:
    pos - the position of the element to remove from the list
    
    Returns:
    the data at position pos
  - remove
```
boolean remove(E obj)
```
    Remove the first occurrence of obj in this list. Return true if this list changed as a result of this call, false otherwise.
    pre: obj != null
    post: if obj is in this list the first occurence has been removed and size() = old size() - 1. If obj is not present the list is not altered in any way.
    
    Parameters:
    obj - The item to remove from this list.
    
    Returns:
    Return true if this list changed as a result of this call, false otherwise.
  - getSubList
```
IList<E> getSubList(int start,
                  int stop)
```
    Return a sublist of elements in this list from start inclusive to stop exclusive. This list is not changed as a result of this call.
    pre: 0 <= start < size(), start <= stop <= size()
    post: return a list whose size is stop - start and contains the elements at positions start through stop - 1 in this list.
    
    Parameters:
    start - index of the first element of the sublist.
    stop - stop - 1 is the index of the last element of the sublist.
    
    Returns:
    a list with stop - start elements, The elements are from positions start inclusive to stop exclusive in this list.
  - size
```
int size()
```
    Return the size of this list. In other words the number of elements in this list.
    pre: none
    post: return the number of items in this list
    
    Returns:
    the number of items in this list
  - indexOf
```
int indexOf(E item)
```
    Find the position of an element in the list.
    pre: item != null
    post: return the index of the first element equal to item or -1 if item is not present
    
    Parameters:
    item - the element to search for in the list
    
    Returns:
    return the index of the first element equal to item or a -1 if item is not present
  - indexOf
```
int indexOf(E item,
          int pos)
```
    find the position of an element in the list starting at a specified position.
    pre: 0 <= pos < size(), item != null
    post: return the index of the first element equal to item starting at pos or -1 if item is not present from position pos onward
    
    Parameters:
    item - the element to search for in the list
    pos - the position in the list to start searching from
    
    Returns:
    starting from the specified position return the index of the first element equal to item or a -1 if item is not present between pos and the end of the list
  - makeEmpty
```
void makeEmpty()
```
    return the list to an empty state.
    pre: none
    post: size() = 0
  - iterator
```
Iterator<E> iterator()
```
    return an Iterator for this list.
    pre: none
    post: return an Iterator object for this List
    
    Specified by:
    
    iterator in interface Iterable<E>
  - removeRange
```
void removeRange(int start,
               int stop)
```
    Remove all elements in this list from start inclusive to stop exclusive.
    pre: 0 <= start < size(), start <= stop <= size()
    post: size() = old size() - (stop - start)
    
    Parameters:
    start - position at beginning of range of elements to be removed
    stop - stop - 1 is the position at the end of the range of elements to be removed
  - toString
```
String toString()
```
    Return a String version of this list enclosed in square brackets, []. Elements are in are in order based on position in the list with the first element first. Adjacent elements are seperated by comma's
    
    Overrides:
    
    toString in class Object
    
    Returns:
    a String representation of this IList
  - equals
```
boolean equals(Object other)
```
    Determine if this IList is equal to other. Two ILists are equal if they contain the same elements in the same order.
    pre: none
    
    Overrides:
    
    equals in class Object
    
    Returns:
    true if this IList is equal to other, false otherwise

Interface IList<E>

Method Summary

Method Detail

add

insert

set

get

remove

remove

getSubList

size

indexOf

indexOf

makeEmpty

iterator

removeRange

toString

equals