javafx.collections

Class FXCollections

java.lang.Object

javafx.collections.FXCollections

public class FXCollections
extends java.lang.Object

Utility class that consists of static methods that are 1:1 copies of java.util.Collections methods.

The wrapper methods (like synchronizedObservableList or emptyObservableList) has exactly the same functionality as the methods in Collections, with exception that they return ObservableList and are therefore suitable for methods that require ObservableList on input.

The utility methods are here mainly for performance reasons. All methods are optimized in a way that they yield only limited number of notifications. On the other hand, java.util.Collections methods might call "modification methods" on an ObservableList multiple times, resulting in a number of notifications.

Method Summary

Methods

Modifier and Type	Method and Description
static <E> ObservableList<E>	checkedObservableList(ObservableList<E> list, java.lang.Class<E> type) Creates and returns a typesafe wrapper on top of provided observable list.
static <E> ObservableList<E>	concat(ObservableList<E>... lists) Concatenates more observable lists into one.
static <T> void	copy(ObservableList<? super T> dest, java.util.List<? extends T> src) Copies elements from src to dest.
static <E> ObservableList<E>	emptyObservableList() Creates and empty unmodifiable observable list.
static <T> void	fill(ObservableList<? super T> list, T obj) Fills the provided list with obj.
static <E> ObservableList<E>	observableArrayList() Creates a new empty observable list that is backed by an arraylist.
static <E> ObservableList<E>	observableArrayList(Callback<E,Observable[]> extractor) Creates a new empty observable list backed by an arraylist.
static <E> ObservableList<E>	observableArrayList(java.util.Collection<? extends E> col) Creates a new observable array list and adds a content of collection col to it.
static <E> ObservableList<E>	observableArrayList(E... items) Creates a new observable array list with items added to it.
static <K,V> ObservableMap<K,V>	observableHashMap() Creates a new empty observable map that is backed by a HashMap.
static <E> ObservableList<E>	observableList(java.util.List<E> list) Constructs an ObservableList that is backed by the specified list.
static <E> ObservableList<E>	observableList(java.util.List<E> list, Callback<E,Observable[]> extractor) Constructs an ObservableList that is backed by the specified list.
static <K,V> ObservableMap<K,V>	observableMap(java.util.Map<K,V> map) Constructs an ObservableMap that is backed by the specified map.
static <E> ObservableSet<E>	observableSet(E... elements) Constructs an ObservableSet that contains all the specified elements.
static <E> ObservableSet<E>	observableSet(java.util.Set<E> set) Constructs an ObservableSet that is backed by the specified set.
static <T> boolean	replaceAll(ObservableList<T> list, T oldVal, T newVal) Replace all oldVal elements in the list with newVal element.
static void	reverse(ObservableList list) Reverse the order in the list Fires only one change notification on the list.
static void	rotate(ObservableList list, int distance) Rotates the list by distance.
static void	shuffle(ObservableList<?> list) Shuffles all elements in the observable list.
static void	shuffle(ObservableList list, java.util.Random rnd) Shuffles all elements in the observable list.
static <E> ObservableList<E>	singletonObservableList(E e) Creates an unmodifiable observable list with single element.
static <T extends java.lang.Comparable<? super T>> void	sort(ObservableList<T> list) Sorts the provided observable list.
static <T> void	sort(ObservableList<T> list, java.util.Comparator<? super T> c) Sorts the provided observable list using the c comparator.
static <E> ObservableList<E>	synchronizedObservableList(ObservableList<E> list) Creates and returns a synchronized wrapper on top of provided observable list.
static <E> ObservableList<E>	unmodifiableObservableList(ObservableList<E> list) Creates and returns unmodifiable wrapper list on top of provided observable list.
static <K,V> ObservableMap<K,V>	unmodifiableObservableMap(ObservableMap<K,V> map) Constructs a read-only interface to the specified ObservableMap.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

observableList

public static <E> ObservableList<E> observableList(java.util.List<E> list)

Constructs an ObservableList that is backed by the specified list. Mutation operations on the ObservableList instance will be reported to observers that have registered on that instance.
Note that mutation operations made directly to the underlying list are not reported to observers of any ObservableList that wraps it.

Parameters:

list - a concrete List that backs this ObservableList

Returns:

a newly created ObservableList

observableList

public static <E> ObservableList<E> observableList(java.util.List<E> list,
                                   Callback<E,Observable[]> extractor)

Constructs an ObservableList that is backed by the specified list. Mutation operations on the ObservableList instance will be reported to observers that have registered on that instance.
Note that mutation operations made directly to the underlying list are not reported to observers of any ObservableList that wraps it.
This list also reports mutations of the elements in it by using extractor. Observable objects returned by extractor (applied to each list element) are listened for changes and transformed into "update" change of ListChangeListener.

Parameters:

list - a concrete List that backs this ObservableList

extractor - element to Observable[] convertor

Returns:

a newly created ObservableList

Since:

2.1

observableMap

public static <K,V> ObservableMap<K,V> observableMap(java.util.Map<K,V> map)

Constructs an ObservableMap that is backed by the specified map. Mutation operations on the ObservableMap instance will be reported to observers that have registered on that instance.
Note that mutation operations made directly to the underlying map are not reported to observers of any ObservableMap that wraps it.

Parameters:

map - a Map that backs this ObservableMap

Returns:

a newly created ObservableMap

observableSet

public static <E> ObservableSet<E> observableSet(java.util.Set<E> set)

Constructs an ObservableSet that is backed by the specified set. Mutation operations on the ObservableSet instance will be reported to observers that have registered on that instance.
Note that mutation operations made directly to the underlying set are not reported to observers of any ObservableSet that wraps it.

Parameters:

set - a Set that backs this ObservableSet

Returns:

a newly created ObservableSet

observableSet

public static <E> ObservableSet<E> observableSet(E... elements)

Constructs an ObservableSet that contains all the specified elements.

Parameters:

elements - elements that will be added into returned ObservableSet

Returns:

a newly created ObservableSet

unmodifiableObservableMap

public static <K,V> ObservableMap<K,V> unmodifiableObservableMap(ObservableMap<K,V> map)

Constructs a read-only interface to the specified ObservableMap. Only mutation operations made to the underlying ObservableMap will be reported to observers that have registered on the unmodifiable instance. This allows clients to track changes in a Map but disallows the ability to modify it.

Parameters:

map - an ObservableMap that is to be monitored by this interface

Returns:

a newly created UnmodifiableObservableMap

observableArrayList

public static <E> ObservableList<E> observableArrayList()

Creates a new empty observable list that is backed by an arraylist.

Returns:

a newly created ObservableList

See Also:

observableList(java.util.List)

observableArrayList

public static <E> ObservableList<E> observableArrayList(Callback<E,Observable[]> extractor)

Creates a new empty observable list backed by an arraylist. This list reports element updates.

Parameters:

extractor - element to Observable[] convertor. Observable objects are listened for changes on the element.

Returns:

a newly created ObservableList

Since:

2.1

See Also:

observableList(java.util.List, javafx.util.Callback)

observableArrayList

public static <E> ObservableList<E> observableArrayList(E... items)

Creates a new observable array list with items added to it.

Parameters:

items - the items that will be in the new observable ArrayList

Returns:

a newly created observableArrayList

See Also:

observableArrayList()

observableArrayList

public static <E> ObservableList<E> observableArrayList(java.util.Collection<? extends E> col)

Creates a new observable array list and adds a content of collection col to it.

Parameters:

col - a collection which content should be added to the observableArrayList

Returns:

a newly created observableArrayList

observableHashMap

public static <K,V> ObservableMap<K,V> observableHashMap()

Creates a new empty observable map that is backed by a HashMap.

Type Parameters:

K - the type of keys

V - the type of values

Returns:

a newly created observable HashMap

concat

public static <E> ObservableList<E> concat(ObservableList<E>... lists)

Concatenates more observable lists into one. The resulting list would be backed by an arraylist.

Parameters:

lists - lists to concatenate

Returns:

new observable array list concatenated from the arguments

unmodifiableObservableList

public static <E> ObservableList<E> unmodifiableObservableList(ObservableList<E> list)

Creates and returns unmodifiable wrapper list on top of provided observable list. For more information.

Parameters:

list - an ObservableList that is to be wrapped

Returns:

an ObserableList wrapper that is unmodifiable

See Also:

Collections.unmodifiableList(java.util.List)

checkedObservableList

public static <E> ObservableList<E> checkedObservableList(ObservableList<E> list,
                                          java.lang.Class<E> type)

Creates and returns a typesafe wrapper on top of provided observable list.

Parameters:

list - an Observable list to be wrapped

type - the type of element that list is permitted to hold

Returns:

a dynamically typesafe view of the specified list

See Also:

Collections.checkedList(java.util.List, java.lang.Class)

synchronizedObservableList

public static <E> ObservableList<E> synchronizedObservableList(ObservableList<E> list)

Creates and returns a synchronized wrapper on top of provided observable list.

Parameters:

list - the list to be "wrapped" in a synchronized list.

Returns:

A synchronized version of the observable list

See Also:

Collections.synchronizedList(java.util.List)

emptyObservableList

public static <E> ObservableList<E> emptyObservableList()

Creates and empty unmodifiable observable list.

Returns:

An empty unmodifiable observable list

See Also:

Collections.emptyList()

singletonObservableList

public static <E> ObservableList<E> singletonObservableList(E e)

Creates an unmodifiable observable list with single element.

Parameters:

e - the only elements that will be contained in this singleton observable list

Returns:

a singleton observable list

See Also:

Collections.singletonList(java.lang.Object)

copy

public static <T> void copy(ObservableList<? super T> dest,
            java.util.List<? extends T> src)

Copies elements from src to dest. Fires only one change notification on dest.

Parameters:

dest - the destination observable list

src - the source list

See Also:

Collections.copy(java.util.List, java.util.List)

fill

public static <T> void fill(ObservableList<? super T> list,
            T obj)

Fills the provided list with obj. Fires only one change notification on the list.

Parameters:

list - the list to fill

obj - the object to fill the list with

See Also:

Collections.fill(java.util.List, java.lang.Object)

replaceAll

public static <T> boolean replaceAll(ObservableList<T> list,
                     T oldVal,
                     T newVal)

Replace all oldVal elements in the list with newVal element. Fires only one change notification on the list.

Parameters:

list - the list which will have it's elements replaced

oldVal - the element that is going to be replace

newVal - the replacement

Returns:

true if the list was modified

See Also:

Collections.replaceAll(java.util.List, java.lang.Object, java.lang.Object)

reverse

public static void reverse(ObservableList list)

Reverse the order in the list Fires only one change notification on the list.

Parameters:

list - the list to be reversed

See Also:

Collections.reverse(java.util.List)

rotate

public static void rotate(ObservableList list,
          int distance)

Rotates the list by distance. Fires only one change notification on the list.

Parameters:

list - the list to be rotated

distance - the distance of rotation

See Also:

Collections.rotate(java.util.List, int)

shuffle

public static void shuffle(ObservableList<?> list)

Shuffles all elements in the observable list. Fires only one change notification on the list.

Parameters:

list - the list to shuffle

See Also:

Collections.shuffle(java.util.List)

shuffle

public static void shuffle(ObservableList list,
           java.util.Random rnd)

Shuffles all elements in the observable list. Fires only one change notification on the list.

Parameters:

list - the list to be shuffled

rnd - the random generator used for shuffling

See Also:

Collections.shuffle(java.util.List, java.util.Random)

sort

public static <T extends java.lang.Comparable<? super T>> void sort(ObservableList<T> list)

Sorts the provided observable list. Fires only one change notification on the list.

See Also:

Collections.sort(java.util.List)

sort

public static <T> void sort(ObservableList<T> list,
            java.util.Comparator<? super T> c)

Sorts the provided observable list using the c comparator. Fires only one change notification on the list.

Parameters:

list - the list to sort

c - comparator used for sorting. Null if natural ordering is required.

See Also:

Collections.sort(java.util.List, java.util.Comparator)