Module javafx.base
Package javafx.collections

# Class ModifiableObservableListBase<E>

java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
javafx.collections.ObservableListBase<E>
javafx.collections.ModifiableObservableListBase<E>

Type Parameters:
  `E` - the type of the elements contained in the List

All Implemented Interfaces:
  `Iterable<E>`, `Collection<E>`, `List<E>`, `SequencedCollection<E>`, `Observable`, `ObservableList<E>`

public abstract class ModifiableObservableListBase<E> extends ObservableListBase<E>
Abstract class that serves as a base class for `ObservableList` implementations that are modifiable. To implement a modifiable `ObservableList` class, you just need to implement the following set of methods:

- `get(int)`
- `size()`
- `doAdd(int, Object)`
- `doRemove(int)`
- `doSet(int, Object)`

and the notifications and built and fired automatically for you.

Example of a simple `ObservableList` delegating to another `List` would look like this:

       public class ArrayObservableList<E> extends ModifiableObservableList<E> {

       private final List<E> delegate = new ArrayList<>();

       public E get(int index) {
           return delegate.get(index);
       }

       public int size() {
           return delegate.size();
       }

       protected void doAdd(int index, E element) {
           delegate.add(index, element);
       }

       protected E doSet(int index, E element) {
           return delegate.set(index, element);
       }

       protected E doRemove(int index) {
           return delegate.remove(index);
       }

Since:
  JavaFX 8.0
See Also:
  - `ObservableListBase`

## Field Summary

### Fields inherited from class java.util.AbstractList

`modCount`

## Constructor Summary

Constructors
Constructor
Description
`ModifiableObservableListBase()`

## Method Summary

Modifier and Type
Method
Description
`void`
`add(int index, E element)`
`boolean`
`addAll(int index, Collection<? extends E> c)`
`boolean`
`addAll(Collection<? extends E> c)`
`protected abstract void`
`doAdd(int index, E element)`
Adds the `element` to the List at the position of `index`.
`protected abstract E`
`doRemove(int index)`
Removes the element at position of `index`.
`protected abstract E`
`doSet(int index, E element)`
Sets the `element` in the List at the position of `index`.
`abstract E`
`get(int index)`
`E`
`remove(int index)`
`boolean`
`remove(Object o)`
`boolean`
`removeAll(Collection<?> c)`
`protected void`
`removeRange(int fromIndex, int toIndex)`
`boolean`
`retainAll(Collection<?> c)`
`E`
`set(int index, E element)`
`boolean`
`setAll(Collection<? extends E> col)`
Clears the ObservableList and adds all elements from the collection.
`abstract int`
`size()`
`List<E>`
`subList(int fromIndex, int toIndex)`

### Methods inherited from class javafx.collections.ObservableListBase

`addAll, addListener, addListener, beginChange, endChange, fireChange, hasListeners, nextAdd, nextPermutation, nextRemove, nextRemove, nextReplace, nextSet, nextUpdate, remove, removeAll, removeListener, removeListener, retainAll, setAll`

### Methods inherited from class java.util.AbstractList

`add, clear, equals, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator`

### Methods inherited from class java.util.AbstractCollection

`contains, containsAll, isEmpty, toArray, toArray, toString`

### Methods inherited from class java.lang.Object

`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

### Methods inherited from interface java.util.Collection

`parallelStream, removeIf, stream, toArray`

### Methods inherited from interface java.lang.Iterable

`forEach`

### Methods inherited from interface java.util.List

`add, addFirst, addLast, clear, contains, containsAll, equals, getFirst, getLast, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, removeFirst, removeLast, replaceAll, reversed, sort, spliterator, toArray, toArray`

### Methods inherited from interface javafx.collections.ObservableList

`filtered, sorted, sorted`

## Constructor Details

### ModifiableObservableListBase

public ModifiableObservableListBase()

## Method Details

### setAll

public boolean setAll(Collection<? extends E> col)
Description copied from interface: `ObservableList`
Clears the ObservableList and adds all elements from the collection.

Specified by:
  `setAll` in interface `ObservableList<E>`
Overrides:
  `setAll` in class `ObservableListBase<E>`
Parameters:
  `col` - the collection with elements that will be added to this observableArrayList
Returns:
  true (as specified by Collection.add(E))

### addAll

public boolean addAll(Collection<? extends E> c)

Specified by:
  `addAll` in interface `Collection<E>`
Specified by:
  `addAll` in interface `List<E>`
Overrides:
  `addAll` in class `AbstractCollection<E>`

### addAll

public boolean addAll(int index, Collection<? extends E> c)

Specified by:
  `addAll` in interface `List<E>`
Overrides:
  `addAll` in class `AbstractList<E>`

### removeRange

protected void removeRange(int fromIndex, int toIndex)

Overrides:
  `removeRange` in class `AbstractList<E>`

### removeAll

public boolean removeAll(Collection<?> c)

Specified by:
  `removeAll` in interface `Collection<E>`
Specified by:
  `removeAll` in interface `List<E>`
Overrides:
  `removeAll` in class `AbstractCollection<E>`

### retainAll

public boolean retainAll(Collection<?> c)

Specified by:
  `retainAll` in interface `Collection<E>`
Specified by:
  `retainAll` in interface `List<E>`
Overrides:
  `retainAll` in class `AbstractCollection<E>`

### add

public void add(int index, E element)

Specified by:
  `add` in interface `List<E>`
Overrides:
  `add` in class `AbstractList<E>`

### set

public E set(int index, E element)

Specified by:
  `set` in interface `List<E>`
Overrides:
  `set` in class `AbstractList<E>`

### remove

public boolean remove(Object o)

Specified by:
  `remove` in interface `Collection<E>`
Specified by:
  `remove` in interface `List<E>`
Overrides:
  `remove` in class `AbstractCollection<E>`

### remove

public E remove(int index)

Specified by:
  `remove` in interface `List<E>`
Overrides:
  `remove` in class `AbstractList<E>`

### subList

public List<E> subList(int fromIndex, int toIndex)

Specified by:
  `subList` in interface `List<E>`
Overrides:
  `subList` in class `AbstractList<E>`

### get

public abstract E get(int index)

Specified by:
  `get` in interface `List<E>`
Specified by:
  `get` in class `AbstractList<E>`

### size

public abstract int size()

Specified by:
  `size` in interface `Collection<E>`
Specified by:
  `size` in interface `List<E>`
Specified by:
  `size` in class `AbstractCollection<E>`

### doAdd

protected abstract void doAdd(int index, E element)
Adds the `element` to the List at the position of `index`.

For the description of possible exceptions, please refer to the documentation of `AbstractList.add(java.lang.Object)` method.

Parameters:
  `index` - the position where to add the element
  `element` - the element that will be added
Throws:
  `ClassCastException` - if the type of the specified element is incompatible with this list
  `NullPointerException` - if the specified arguments contain one or more null elements
  `IllegalArgumentException` - if some property of this element prevents it from being added to this list
  `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index > size())`

### doSet

protected abstract E doSet(int index, E element)
Sets the `element` in the List at the position of `index`.

For the description of possible exceptions, please refer to the documentation of `set(int, java.lang.Object)` method.

Parameters:
  `index` - the position where to set the element
  `element` - the element that will be set at the specified position
Returns:
  the old element at the specified position
Throws:
  `ClassCastException` - if the type of the specified element is incompatible with this list
  `NullPointerException` - if the specified arguments contain one or more null elements
  `IllegalArgumentException` - if some property of this element prevents it from being added to this list
  `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index >= size())`

### doRemove

protected abstract E doRemove(int index)
Removes the element at position of `index`.

Parameters:
  `index` - the index of the removed element
Returns:
  the removed element
Throws:
  `IndexOutOfBoundsException` - if the index is out of range `(index < 0 || index >= size())`