javafx.collections

Class ObservableListBase<E>

java.lang.Object

java.util.AbstractCollection<E>
- java.util.AbstractList<E>
- - javafx.collections.ObservableListBase<E>

Type Parameters:

E - the type of the elements contained in the List

All Implemented Interfaces:

Iterable<E>, Collection<E>, List<E>, Observable, ObservableList<E>

Direct Known Subclasses:

ModifiableObservableListBase, TransformationList

public abstract class ObservableListBase<E>
extends AbstractList<E>
implements ObservableList<E>

Abstract class that serves as a base class for ObservableList implementations. The base class provides two functionalities for the implementing classes.

Listener handling by implementing addListener and removeListener methods. fireChange(javafx.collections.ListChangeListener.Change) method is provided for notifying the listeners with a Change object.
Methods for building up a ListChangeListener.Change object. There are various methods called next*, like nextAdd(int, int) for new items in the lists or nextRemove(int, java.lang.Object) for an item being removed from the list.
These methods must be always enclosed in beginChange() and endChange() block.

See the example below.

The following example shows how the Change build-up works:

public void removeOddIndexes() {
      beginChange();
      try {
          for (int i = 1; i < size(); ++i) {
              remove(i);
          }
      } finally {
          endChange();
      }
  }

  public void remove(int i) {
      beginChange();
      try {
          E removed = ... //do some stuff that will actually remove the element at index i
          nextRemove(i, removed);
      } finally {
          endChange();
      }
  }

The try/finally blocks in the example are needed only if there's a possibility for an exception to occur inside a beginChange() / endChange() block

Note: If you want to create modifiable ObservableList implementation, consider using ModifiableObservableListBase as a superclass.

Note: In order to create list with sequential access, you should override AbstractList.listIterator(), AbstractList.iterator() methods and use them in AbstractList.get(int), AbstractCollection.size() and other methods accordingly.

Since:

JavaFX 8.0

Constructors
Constructor and Description
`ObservableListBase()`

Method Summary

All MethodsInstance MethodsConcrete Methods
Modifier and Type	Method and Description
`boolean`	`addAll(E... elements)` A convenient method for var-arg adding of elements.
`void`	`addListener(InvalidationListener listener)` Adds an `InvalidationListener` which will be notified whenever the `Observable` becomes invalid.
`void`	`addListener(ListChangeListener<? super E> listener)` Add a listener to this observable list.
`protected void`	`beginChange()` Begins a change block.
`protected void`	`endChange()` Ends the change block.
`protected void`	`fireChange(ListChangeListener.Change<? extends E> change)` Notifies all listeners of a change
`protected boolean`	`hasListeners()` Returns true if there are some listeners registered for this list.
`protected void`	`nextAdd(int from, int to)` Adds a new add operation to the change.
`protected void`	`nextPermutation(int from, int to, int[] perm)` Adds a new permutation operation to the change.
`protected void`	`nextRemove(int idx, E removed)` Adds a new remove operation to the change with single item removed.
`protected void`	`nextRemove(int idx, List<? extends E> removed)` Adds a new remove operation to the change with multiple items removed.
`protected void`	`nextReplace(int from, int to, List<? extends E> removed)` Adds a new replace operation to the change.
`protected void`	`nextSet(int idx, E old)` Adds a new set operation to the change.
`protected void`	`nextUpdate(int pos)` Adds a new update operation to the change.
`void`	`remove(int from, int to)` Basically a shortcut to sublist(from, to).clear() As this is a common operation, ObservableList has this method for convenient usage.
`boolean`	`removeAll(E... elements)` A convenient method for var-arg usage of removaAll method.
`void`	`removeListener(InvalidationListener listener)` Removes the given listener from the list of listeners, that are notified whenever the value of the `Observable` becomes invalid.
`void`	`removeListener(ListChangeListener<? super E> listener)` Tries to removed a listener from this observable list.
`boolean`	`retainAll(E... elements)` A convenient method for var-arg usage of retain method.
`boolean`	`setAll(Collection<? extends E> col)` Clears the ObservableList and add all elements from the collection.
`boolean`	`setAll(E... elements)` Clears the ObservableList and add all the elements passed as var-args.

Methods inherited from class java.util.AbstractList
add, add, addAll, clear, equals, get, hashCode, indexOf, iterator, lastIndexOf, listIterator, listIterator, remove, removeRange, set, subList

Methods inherited from class java.util.AbstractCollection
addAll, contains, containsAll, isEmpty, remove, removeAll, retainAll, size, toArray, toArray, toString

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

Methods inherited from interface javafx.collections.ObservableList
filtered, sorted, sorted

Methods inherited from interface java.util.List
add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, replaceAll, retainAll, set, size, sort, spliterator, subList, toArray, toArray

Methods inherited from interface java.util.Collection
parallelStream, removeIf, stream

Methods inherited from interface java.lang.Iterable
forEach

Constructor Detail
- ObservableListBase
```
public ObservableListBase()
```

Method Detail
- nextUpdate
```
protected final void nextUpdate(int pos)
```
  Adds a new update operation to the change.
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  pos - the position in the list where the updated element resides.
- nextSet
```
protected final void nextSet(int idx,
                             E old)
```
  Adds a new set operation to the change. Equivalent to nextRemove(idx); nextAdd(idx, idx + 1); .
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  idx - the index of the item that was set
- nextReplace
```
protected final void nextReplace(int from,
                                 int to,
                                 List<? extends E> removed)
```
  Adds a new replace operation to the change. Equivalent to nextRemove(from, removed); nextAdd(from, to);
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  from - the index where the items were replaced
- nextRemove
```
protected final void nextRemove(int idx,
                                List<? extends E> removed)
```
  Adds a new remove operation to the change with multiple items removed.
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  idx - the index where the items were removed
- nextRemove
```
protected final void nextRemove(int idx,
                                E removed)
```
  Adds a new remove operation to the change with single item removed.
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  idx - the index where the item was removed
- nextPermutation
```
protected final void nextPermutation(int from,
                                     int to,
                                     int[] perm)
```
  Adds a new permutation operation to the change. The permutation on index "i" contains the index, where the item from the index "i" was moved.
  It's not necessary to provide the smallest permutation possible. It's correct to always call this method with nextPermutation(0, size(), permutation);
  
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  from - marks the beginning (inclusive) of the range that was permutated
- nextAdd
```
protected final void nextAdd(int from,
                             int to)
```
  Adds a new add operation to the change. There's no need to provide the list of added items as they can be found directly in the list under the specified indexes.
  Note: needs to be called inside beginChange() / endChange() block.
  
  Note: needs to reflect the current state of the list.
  
  Parameters:
  
  from - marks the beginning (inclusive) of the range that was added
- beginChange
```
protected final void beginChange()
```
  Begins a change block. Must be called before any of the next* methods is called. For every beginChange(), there must be a corresponding endChange() call.
  beginChange() calls can be nested in a beginChange()/endChange() block.
  
  See Also:
  
  endChange()
- endChange
```
protected final void endChange()
```
  Ends the change block. If the block is the outer-most block for the ObservableList, the Change is constructed and all listeners are notified.
  Ending a nested block doesn't fire a notification.
  
  See Also:
  
  beginChange()
- addListener
```
public final void addListener(InvalidationListener listener)
```
  Description copied from interface: Observable
  
  Adds an InvalidationListener which will be notified whenever the Observable becomes invalid. If the same listener is added more than once, then it will be notified more than once. That is, no check is made to ensure uniqueness.
  Note that the same actual InvalidationListener instance may be safely registered for different Observables.
  
  The Observable stores a strong reference to the listener which will prevent the listener from being garbage collected and may result in a memory leak. It is recommended to either unregister a listener by calling removeListener after use or to use an instance of WeakInvalidationListener avoid this situation.
  
  Specified by:
  
  addListener in interface Observable
  
  Parameters:
  
  listener - The listener to register
  
  See Also:
  
  Observable.removeListener(InvalidationListener)
- removeListener
```
public final void removeListener(InvalidationListener listener)
```
  Description copied from interface: Observable
  
  Removes the given listener from the list of listeners, that are notified whenever the value of the Observable becomes invalid.
  If the given listener has not been previously registered (i.e. it was never added) then this method call is a no-op. If it had been previously added then it will be removed. If it had been added more than once, then only the first occurrence will be removed.
  
  Specified by:
  
  removeListener in interface Observable
  
  Parameters:
  
  listener - The listener to remove
  
  See Also:
  
  Observable.addListener(InvalidationListener)
- addListener
```
public final void addListener(ListChangeListener<? super E> listener)
```
  Description copied from interface: ObservableList
  
  Add a listener to this observable list.
  
  Specified by:
  
  addListener in interface ObservableList<E>
  
  Parameters:
  
  listener - the listener for listening to the list changes
- removeListener
```
public final void removeListener(ListChangeListener<? super E> listener)
```
  Description copied from interface: ObservableList
  
  Tries to removed a listener from this observable list. If the listener is not attached to this list, nothing happens.
  
  Specified by:
  
  removeListener in interface ObservableList<E>
  
  Parameters:
  
  listener - a listener to remove
- fireChange
```
protected final void fireChange(ListChangeListener.Change<? extends E> change)
```
  Notifies all listeners of a change
  
  Parameters:
  
  change -
- hasListeners
```
protected final boolean hasListeners()
```
  Returns true if there are some listeners registered for this list.
- addAll
```
public boolean addAll(E... elements)
```
  Description copied from interface: ObservableList
  
  A convenient method for var-arg adding of elements.
  
  Specified by:
  
  addAll in interface ObservableList<E>
  
  Parameters:
  
  elements - the elements to add
  
  Returns:
  
  true (as specified by Collection.add(E))
- setAll
```
public boolean setAll(E... elements)
```
  Description copied from interface: ObservableList
  
  Clears the ObservableList and add all the elements passed as var-args.
  
  Specified by:
  
  setAll in interface ObservableList<E>
  
  Parameters:
  
  elements - the elements to set
  
  Returns:
  
  true (as specified by Collection.add(E))
- setAll
```
public boolean setAll(Collection<? extends E> col)
```
  Description copied from interface: ObservableList
  
  Clears the ObservableList and add all elements from the collection.
  
  Specified by:
  
  setAll in interface ObservableList<E>
  
  Parameters:
  
  col - the collection with elements that will be added to this observableArrayList
  
  Returns:
  
  true (as specified by Collection.add(E))
- removeAll
```
public boolean removeAll(E... elements)
```
  Description copied from interface: ObservableList
  
  A convenient method for var-arg usage of removaAll method.
  
  Specified by:
  
  removeAll in interface ObservableList<E>
  
  Parameters:
  
  elements - the elements to be removed
  
  Returns:
  
  true if list changed as a result of this call
- retainAll
```
public boolean retainAll(E... elements)
```
  Description copied from interface: ObservableList
  
  A convenient method for var-arg usage of retain method.
  
  Specified by:
  
  retainAll in interface ObservableList<E>
  
  Parameters:
  
  elements - the elements to be retained
  
  Returns:
  
  true if list changed as a result of this call
- remove
```
public void remove(int from,
                   int to)
```
  Description copied from interface: ObservableList
  
  Basically a shortcut to sublist(from, to).clear() As this is a common operation, ObservableList has this method for convenient usage.
  
  Specified by:
  
  remove in interface ObservableList<E>
  
  Parameters:
  
  from - the start of the range to remove (inclusive)

© 2008, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from JavaFX API Documentation.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Java, JavaFX and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.

Class ObservableListBase<E>

Field Summary

Fields inherited from class java.util.AbstractList

Constructor Summary

Method Summary

Methods inherited from class java.util.AbstractList

Methods inherited from class java.util.AbstractCollection

Methods inherited from class java.lang.Object

Methods inherited from interface javafx.collections.ObservableList

Methods inherited from interface java.util.List

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Constructor Detail

ObservableListBase

Method Detail

nextUpdate

nextSet

nextReplace

nextRemove

nextRemove

nextPermutation

nextAdd

beginChange

endChange

addListener

removeListener

addListener

removeListener

fireChange

hasListeners

addAll

setAll

setAll

removeAll

retainAll

remove