Module javafx.base
Package javafx.beans.binding

## Class Bindings

- java.lang.Object
- - javafx.beans.binding.Bindings

-     public final class Bindings
      extends Object

  Bindings is a helper class with a lot of utility functions to create simple bindings.

  Usually there are two possibilities to define the same operation: the Fluent API and the the factory methods in this class. This allows a developer to define complex expression in a way that is most easy to understand. For instance the expression `result = a*b + c*d` can be defined using only the Fluent API:

  `DoubleBinding result = a.multiply(b).add(c.multiply(d));`

  Or using only factory methods in Bindings:

  `NumberBinding result = add (multiply(a, b), multiply(c,d));`

  Or mixing both possibilities:

  `NumberBinding result = add (a.multiply(b), c.multiply(d));`

  The main difference between using the Fluent API and using the factory methods in this class is that the Fluent API requires that at least one of the operands is an Expression (see `javafx.beans.binding`). (Every Expression contains a static method that generates an Expression from an `ObservableValue`.)

  Also if you watched closely, you might have noticed that the return type of the Fluent API is different in the examples above. In a lot of cases the Fluent API allows to be more specific about the returned type (see `NumberExpression` for more details about implicit casting.

  Deploying an Application as a Module

  If any class used in a select-binding (see the various `select*` methods) is in a named module, then it must be reflectively accessible to the `javafx.base` module. A class is reflectively accessible if the module `opens` the containing package to at least the `javafx.base` module.

  For example, if `com.foo.MyClass` is in the `foo.app` module, the `module-info.java` might look like this:

      module foo.app {
          opens com.foo to javafx.base;
      }

  Alternatively, a class is reflectively accessible if the module `exports` the containing package unconditionally.

  Since:
    JavaFX 2.0
  See Also:
    `Binding`, `NumberBinding`

- - ### Method Summary

    Modifier and Type | Method | Description
    --- | --- | ---
    `static DoubleBinding` | `add​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static DoubleBinding` | `add​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `add​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the sum of the values of two instances of `ObservableNumberValue`.
    `static BooleanBinding` | `and​(ObservableBooleanValue op1, ObservableBooleanValue op2)` | Creates a `BooleanBinding` that calculates the conditional-AND operation on the value of two instance of `ObservableBooleanValue`.
    `static void` | `bindBidirectional​(Property<String> stringProperty, Property<?> otherProperty, Format format)` | Generates a bidirectional binding (or "bind with inverse") between a `String`-`Property` and another `Property` using the specified `Format` for conversion.
    `static <T> void` | `bindBidirectional​(Property<String> stringProperty, Property<T> otherProperty, StringConverter<T> converter)` | Generates a bidirectional binding (or "bind with inverse") between a `String`-`Property` and another `Property` using the specified `StringConverter` for conversion.
    `static <T> void` | `bindBidirectional​(Property<T> property1, Property<T> property2)` | Generates a bidirectional binding (or "bind with inverse") between two instances of `Property`.
    `static <E> void` | `bindContent​(List<E> list1, ObservableList<? extends E> list2)` | Generates a content binding between an `ObservableList` and a `List`.
    `static <K,​V> void` | `bindContent​(Map<K,​V> map1, ObservableMap<? extends K,​? extends V> map2)` | Generates a content binding between an `ObservableMap` and a `Map`.
    `static <E> void` | `bindContent​(Set<E> set1, ObservableSet<? extends E> set2)` | Generates a content binding between an `ObservableSet` and a `Set`.
    `static <E> void` | `bindContentBidirectional​(ObservableList<E> list1, ObservableList<E> list2)` | Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableList`.
    `static <K,​V> void` | `bindContentBidirectional​(ObservableMap<K,​V> map1, ObservableMap<K,​V> map2)` | Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableMap`.
    `static <E> void` | `bindContentBidirectional​(ObservableSet<E> set1, ObservableSet<E> set2)` | Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableSet`.
    `static BooleanBinding` | `booleanValueAt​(ObservableList<Boolean> op, int index)` | Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position.
    `static BooleanBinding` | `booleanValueAt​(ObservableList<Boolean> op, ObservableIntegerValue index)` | Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position.
    `static BooleanBinding` | `booleanValueAt​(ObservableList<Boolean> op, ObservableNumberValue index)` | Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> BooleanBinding` | `booleanValueAt​(ObservableMap<K,​Boolean> op, ObservableValue<? extends K> key)` | Creates a new `BooleanBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> BooleanBinding` | `booleanValueAt​(ObservableMap<K,​Boolean> op, K key)` | Creates a new `BooleanBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static StringExpression` | `concat​(Object... args)` | Returns a `StringExpression` that holds the value of the concatenation of multiple `Objects`.
    `static StringExpression` | `convert​(ObservableValue<?> observableValue)` | Returns a `StringExpression` that wraps a `ObservableValue`.
    `static BooleanBinding` | `createBooleanBinding​(Callable<Boolean> func, Observable... dependencies)` | Helper function to create a custom `BooleanBinding`.
    `static DoubleBinding` | `createDoubleBinding​(Callable<Double> func, Observable... dependencies)` | Helper function to create a custom `DoubleBinding`.
    `static FloatBinding` | `createFloatBinding​(Callable<Float> func, Observable... dependencies)` | Helper function to create a custom `FloatBinding`.
    `static IntegerBinding` | `createIntegerBinding​(Callable<Integer> func, Observable... dependencies)` | Helper function to create a custom `IntegerBinding`.
    `static LongBinding` | `createLongBinding​(Callable<Long> func, Observable... dependencies)` | Helper function to create a custom `LongBinding`.
    `static <T> ObjectBinding<T>` | `createObjectBinding​(Callable<T> func, Observable... dependencies)` | Helper function to create a custom `ObjectBinding`.
    `static StringBinding` | `createStringBinding​(Callable<String> func, Observable... dependencies)` | Helper function to create a custom `StringBinding`.
    `static DoubleBinding` | `divide​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `divide​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `divide​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `divide​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
    `static DoubleBinding` | `divide​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `divide​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `divide​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `divide​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `divide​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the division of the values of two instances of `ObservableNumberValue`.
    `static DoubleBinding` | `doubleValueAt​(ObservableList<? extends Number> op, int index)` | Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position.
    `static DoubleBinding` | `doubleValueAt​(ObservableList<? extends Number> op, ObservableIntegerValue index)` | Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position.
    `static DoubleBinding` | `doubleValueAt​(ObservableList<? extends Number> op, ObservableNumberValue index)` | Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> DoubleBinding` | `doubleValueAt​(ObservableMap<K,​? extends Number> op, ObservableValue<? extends K> key)` | Creates a new `DoubleBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> DoubleBinding` | `doubleValueAt​(ObservableMap<K,​? extends Number> op, K key)` | Creates a new `DoubleBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static BooleanBinding` | `equal​(double op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(float op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(int op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(long op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(Object op1, ObservableObjectValue<?> op2)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(ObservableBooleanValue op1, ObservableBooleanValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableBooleanValue` are equal.
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, double op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, float op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, int op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, long op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are equal.
    `static BooleanBinding` | `equal​(ObservableNumberValue op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are equal (with a tolerance).
    `static BooleanBinding` | `equal​(ObservableObjectValue<?> op1, Object op2)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(ObservableObjectValue<?> op1, ObservableObjectValue<?> op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableObjectValue` are equal.
    `static BooleanBinding` | `equal​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value.
    `static BooleanBinding` | `equal​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are equal.
    `static BooleanBinding` | `equalIgnoreCase​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value ignoring case.
    `static BooleanBinding` | `equalIgnoreCase​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value ignoring case.
    `static BooleanBinding` | `equalIgnoreCase​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are equal ignoring case.
    `static FloatBinding` | `floatValueAt​(ObservableFloatArray op, int index)` | Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position.
    `static FloatBinding` | `floatValueAt​(ObservableFloatArray op, ObservableIntegerValue index)` | Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position.
    `static FloatBinding` | `floatValueAt​(ObservableFloatArray op, ObservableNumberValue index)` | Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position.
    `static FloatBinding` | `floatValueAt​(ObservableList<? extends Number> op, int index)` | Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position.
    `static FloatBinding` | `floatValueAt​(ObservableList<? extends Number> op, ObservableIntegerValue index)` | Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position.
    `static FloatBinding` | `floatValueAt​(ObservableList<? extends Number> op, ObservableNumberValue index)` | Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> FloatBinding` | `floatValueAt​(ObservableMap<K,​? extends Number> op, ObservableValue<? extends K> key)` | Creates a new `FloatBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> FloatBinding` | `floatValueAt​(ObservableMap<K,​? extends Number> op, K key)` | Creates a new `FloatBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static StringExpression` | `format​(String format, Object... args)` | Creates a `StringExpression` that holds the value of multiple `Objects` formatted according to a format `String`.
    `static StringExpression` | `format​(Locale locale, String format, Object... args)` | Creates a `StringExpression` that holds the value of multiple `Objects` formatted according to a format `String` and a specified `Locale`
    `static BooleanBinding` | `greaterThan​(double op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThan​(float op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThan​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThan​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThan​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a constant value is greater than the value of a `ObservableStringValue`.
    `static BooleanBinding` | `greaterThan​(ObservableNumberValue op1, double op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
    `static BooleanBinding` | `greaterThan​(ObservableNumberValue op1, float op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
    `static BooleanBinding` | `greaterThan​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
    `static BooleanBinding` | `greaterThan​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
    `static BooleanBinding` | `greaterThan​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is greater than the value of the second.
    `static BooleanBinding` | `greaterThan​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is greater than a constant value.
    `static BooleanBinding` | `greaterThan​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is greater than the value of the second.
    `static BooleanBinding` | `greaterThanOrEqual​(double op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThanOrEqual​(float op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThanOrEqual​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThanOrEqual​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `greaterThanOrEqual​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableStringValue`.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableNumberValue op1, double op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableNumberValue op1, float op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is greater than or equal to the value of the second.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is greater than or equal to a constant value.
    `static BooleanBinding` | `greaterThanOrEqual​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is greater than or equal to the value of the second.
    `static IntegerBinding` | `integerValueAt​(ObservableIntegerArray op, int index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position.
    `static IntegerBinding` | `integerValueAt​(ObservableIntegerArray op, ObservableIntegerValue index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position.
    `static IntegerBinding` | `integerValueAt​(ObservableIntegerArray op, ObservableNumberValue index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position.
    `static IntegerBinding` | `integerValueAt​(ObservableList<? extends Number> op, int index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position.
    `static IntegerBinding` | `integerValueAt​(ObservableList<? extends Number> op, ObservableIntegerValue index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position.
    `static IntegerBinding` | `integerValueAt​(ObservableList<? extends Number> op, ObservableNumberValue index)` | Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> IntegerBinding` | `integerValueAt​(ObservableMap<K,​? extends Number> op, ObservableValue<? extends K> key)` | Creates a new `IntegerBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> IntegerBinding` | `integerValueAt​(ObservableMap<K,​? extends Number> op, K key)` | Creates a new `IntegerBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static BooleanBinding` | `isEmpty​(ObservableStringValue op)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is empty.
    `static <E> BooleanBinding` | `isEmpty​(ObservableList<E> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableList` is empty.
    `static <K,​V> BooleanBinding` | `isEmpty​(ObservableMap<K,​V> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableMap` is empty.
    `static <E> BooleanBinding` | `isEmpty​(ObservableSet<E> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableSet` is empty.
    `static BooleanBinding` | `isNotEmpty​(ObservableStringValue op)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not empty.
    `static <E> BooleanBinding` | `isNotEmpty​(ObservableList<E> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableList` is not empty.
    `static <K,​V> BooleanBinding` | `isNotEmpty​(ObservableMap<K,​V> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableMap` is not empty.
    `static <E> BooleanBinding` | `isNotEmpty​(ObservableSet<E> op)` | Creates a new `BooleanBinding` that holds `true` if a given `ObservableSet` is not empty.
    `static BooleanBinding` | `isNotNull​(ObservableObjectValue<?> op)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not `null`.
    `static BooleanBinding` | `isNull​(ObservableObjectValue<?> op)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is `null`.
    `static IntegerBinding` | `length​(ObservableStringValue op)` | Creates a new `IntegerBinding` that holds the length of a `ObservableStringValue`.
    `static BooleanBinding` | `lessThan​(double op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThan​(float op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThan​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThan​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThan​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableStringValue`.
    `static BooleanBinding` | `lessThan​(ObservableNumberValue op1, double op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
    `static BooleanBinding` | `lessThan​(ObservableNumberValue op1, float op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
    `static BooleanBinding` | `lessThan​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
    `static BooleanBinding` | `lessThan​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
    `static BooleanBinding` | `lessThan​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is less than the value of the second.
    `static BooleanBinding` | `lessThan​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is less than a constant value.
    `static BooleanBinding` | `lessThan​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is less than the value of the second.
    `static BooleanBinding` | `lessThanOrEqual​(double op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThanOrEqual​(float op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThanOrEqual​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThanOrEqual​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
    `static BooleanBinding` | `lessThanOrEqual​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableStringValue`.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableNumberValue op1, double op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableNumberValue op1, float op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is less than or equal to the value of the second.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is less than or equal to a constant value.
    `static BooleanBinding` | `lessThanOrEqual​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is less than or equal to the value of the second.
    `static LongBinding` | `longValueAt​(ObservableList<? extends Number> op, int index)` | Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position.
    `static LongBinding` | `longValueAt​(ObservableList<? extends Number> op, ObservableIntegerValue index)` | Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position.
    `static LongBinding` | `longValueAt​(ObservableList<? extends Number> op, ObservableNumberValue index)` | Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> LongBinding` | `longValueAt​(ObservableMap<K,​? extends Number> op, ObservableValue<? extends K> key)` | Creates a new `LongBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> LongBinding` | `longValueAt​(ObservableMap<K,​? extends Number> op, K key)` | Creates a new `LongBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static DoubleBinding` | `max​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static DoubleBinding` | `max​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `max​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the maximum of the values of two instances of `ObservableNumberValue`.
    `static DoubleBinding` | `min​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static DoubleBinding` | `min​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `min​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the minimum of the values of two instances of `ObservableNumberValue`.
    `static DoubleBinding` | `multiply​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static DoubleBinding` | `multiply​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `multiply​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the product of the values of two instances of `ObservableNumberValue`.
    `static NumberBinding` | `negate​(ObservableNumberValue value)` | Creates a new `NumberBinding` that calculates the negation of a `ObservableNumberValue`.
    `static BooleanBinding` | `not​(ObservableBooleanValue op)` | Creates a `BooleanBinding` that calculates the inverse of the value of a `ObservableBooleanValue`.
    `static BooleanBinding` | `notEqual​(double op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(float op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(int op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(int op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(long op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(long op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(Object op1, ObservableObjectValue<?> op2)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(ObservableBooleanValue op1, ObservableBooleanValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableBooleanValue` are not equal.
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, double op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, float op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, int op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, int op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, long op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, long op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are not equal.
    `static BooleanBinding` | `notEqual​(ObservableNumberValue op1, ObservableNumberValue op2, double epsilon)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are not equal (with a tolerance).
    `static BooleanBinding` | `notEqual​(ObservableObjectValue<?> op1, Object op2)` | Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(ObservableObjectValue<?> op1, ObservableObjectValue<?> op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableObjectValue` are not equal.
    `static BooleanBinding` | `notEqual​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value.
    `static BooleanBinding` | `notEqual​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are not equal.
    `static BooleanBinding` | `notEqualIgnoreCase​(String op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value ignoring case.
    `static BooleanBinding` | `notEqualIgnoreCase​(ObservableStringValue op1, String op2)` | Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value ignoring case.
    `static BooleanBinding` | `notEqualIgnoreCase​(ObservableStringValue op1, ObservableStringValue op2)` | Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are not equal ignoring case.
    `static BooleanBinding` | `or​(ObservableBooleanValue op1, ObservableBooleanValue op2)` | Creates a `BooleanBinding` that calculates the conditional-OR operation on the value of two instance of `ObservableBooleanValue`.
    `static <T> ObjectBinding<T>` | `select​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static <T> ObjectBinding<T>` | `select​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static BooleanBinding` | `selectBoolean​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static BooleanBinding` | `selectBoolean​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static DoubleBinding` | `selectDouble​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static DoubleBinding` | `selectDouble​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static FloatBinding` | `selectFloat​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static FloatBinding` | `selectFloat​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static IntegerBinding` | `selectInteger​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static IntegerBinding` | `selectInteger​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static LongBinding` | `selectLong​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static LongBinding` | `selectLong​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static StringBinding` | `selectString​(Object root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static StringBinding` | `selectString​(ObservableValue<?> root, String... steps)` | Creates a binding used to get a member, such as `a.b.c`.
    `static IntegerBinding` | `size​(ObservableArray op)` | Creates a new `IntegerBinding` that contains the size of an `ObservableArray`.
    `static <E> IntegerBinding` | `size​(ObservableList<E> op)` | Creates a new `IntegerBinding` that contains the size of an `ObservableList`.
    `static <K,​V> IntegerBinding` | `size​(ObservableMap<K,​V> op)` | Creates a new `IntegerBinding` that contains the size of an `ObservableMap`.
    `static <E> IntegerBinding` | `size​(ObservableSet<E> op)` | Creates a new `IntegerBinding` that contains the size of an `ObservableSet`.
    `static StringBinding` | `stringValueAt​(ObservableList<String> op, int index)` | Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position.
    `static StringBinding` | `stringValueAt​(ObservableList<String> op, ObservableIntegerValue index)` | Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position.
    `static StringBinding` | `stringValueAt​(ObservableList<String> op, ObservableNumberValue index)` | Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K> StringBinding` | `stringValueAt​(ObservableMap<K,​String> op, ObservableValue<? extends K> key)` | Creates a new `StringBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K> StringBinding` | `stringValueAt​(ObservableMap<K,​String> op, K key)` | Creates a new `StringBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static DoubleBinding` | `subtract​(double op1, ObservableNumberValue op2)` | Creates a new `DoubleBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `subtract​(float op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `subtract​(int op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
    `static NumberBinding` | `subtract​(long op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
    `static DoubleBinding` | `subtract​(ObservableNumberValue op1, double op2)` | Creates a new `DoubleBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `subtract​(ObservableNumberValue op1, float op2)` | Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `subtract​(ObservableNumberValue op1, int op2)` | Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `subtract​(ObservableNumberValue op1, long op2)` | Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
    `static NumberBinding` | `subtract​(ObservableNumberValue op1, ObservableNumberValue op2)` | Creates a new `NumberBinding` that calculates the difference of the values of two instances of `ObservableNumberValue`.
    `static void` | `unbindBidirectional​(Object property1, Object property2)` | Delete a bidirectional binding that was previously defined with `bindBidirectional(Property, Property)` or `bindBidirectional(javafx.beans.property.Property, javafx.beans.property.Property, java.text.Format)`.
    `static <T> void` | `unbindBidirectional​(Property<T> property1, Property<T> property2)` | Delete a bidirectional binding that was previously defined with `bindBidirectional(Property, Property)`.
    `static void` | `unbindContent​(Object obj1, Object obj2)` | Remove a content binding.
    `static void` | `unbindContentBidirectional​(Object obj1, Object obj2)` | Remove a bidirectional content binding.
    `static <E> ObjectBinding<E>` | `valueAt​(ObservableList<E> op, int index)` | Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position.
    `static <E> ObjectBinding<E>` | `valueAt​(ObservableList<E> op, ObservableIntegerValue index)` | Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position.
    `static <E> ObjectBinding<E>` | `valueAt​(ObservableList<E> op, ObservableNumberValue index)` | Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position.
    `static <K,​V> ObjectBinding<V>` | `valueAt​(ObservableMap<K,​V> op, ObservableValue<? extends K> key)` | Creates a new `ObjectBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static <K,​V> ObjectBinding<V>` | `valueAt​(ObservableMap<K,​V> op, K key)` | Creates a new `ObjectBinding` that contains the mapping of a specific key in an `ObservableMap`.
    `static When` | `when​(ObservableBooleanValue condition)` | Creates a binding that calculates the result of a ternary expression.

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

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

- - ### Method Detail

    - #### createBooleanBinding

          public static BooleanBinding createBooleanBinding​(Callable<Boolean> func,
                                                            Observable... dependencies)

      Helper function to create a custom `BooleanBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createDoubleBinding

          public static DoubleBinding createDoubleBinding​(Callable<Double> func,
                                                          Observable... dependencies)

      Helper function to create a custom `DoubleBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createFloatBinding

          public static FloatBinding createFloatBinding​(Callable<Float> func,
                                                        Observable... dependencies)

      Helper function to create a custom `FloatBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createIntegerBinding

          public static IntegerBinding createIntegerBinding​(Callable<Integer> func,
                                                            Observable... dependencies)

      Helper function to create a custom `IntegerBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createLongBinding

          public static LongBinding createLongBinding​(Callable<Long> func,
                                                      Observable... dependencies)

      Helper function to create a custom `LongBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createObjectBinding

          public static <T> ObjectBinding<T> createObjectBinding​(Callable<T> func,
                                                                 Observable... dependencies)

      Helper function to create a custom `ObjectBinding`.
      Type Parameters:
        `T` - the type of the bound `Object`
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### createStringBinding

          public static StringBinding createStringBinding​(Callable<String> func,
                                                          Observable... dependencies)

      Helper function to create a custom `StringBinding`.
      Parameters:
        `func` - The function that calculates the value of this binding
        `dependencies` - The dependencies of this binding
      Returns:
        The generated binding
      Since:
        JavaFX 2.1

    - #### select

          public static <T> ObjectBinding<T> select​(ObservableValue<?> root,
                                                    String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `null` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being the right type etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Type Parameters:
        `T` - the type of the wrapped `Object`
      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `ObjectBinding`

    - #### selectDouble

          public static DoubleBinding selectDouble​(ObservableValue<?> root,
                                                   String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0.0` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `DoubleBinding`

    - #### selectFloat

          public static FloatBinding selectFloat​(ObservableValue<?> root,
                                                 String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0.0f` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `FloatBinding`

    - #### selectInteger

          public static IntegerBinding selectInteger​(ObservableValue<?> root,
                                                     String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `IntegerBinding`

    - #### selectLong

          public static LongBinding selectLong​(ObservableValue<?> root,
                                               String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0L` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `LongBinding`

    - #### selectBoolean

          public static BooleanBinding selectBoolean​(ObservableValue<?> root,
                                                     String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `false` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `boolean` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `ObjectBinding`

    - #### selectString

          public static StringBinding selectString​(ObservableValue<?> root,
                                                   String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `""` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `String` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      Note: since 8.0, JavaBeans properties are supported and might be in the chain.

      Parameters:
        `root` - The root `ObservableValue`
        `steps` - The property names to reach the final property
      Returns:
        the created `ObjectBinding`

    - #### select

          public static <T> ObjectBinding<T> select​(Object root,
                                                    String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `null` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being the right type etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `select(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Type Parameters:
        `T` - the type of the wrapped `Object`
      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `ObjectBinding`
      Since:
        JavaFX 8.0

    - #### selectDouble

          public static DoubleBinding selectDouble​(Object root,
                                                   String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0.0` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectDouble(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `DoubleBinding`
      Since:
        JavaFX 8.0

    - #### selectFloat

          public static FloatBinding selectFloat​(Object root,
                                                 String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0.0f` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectFloat(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `FloatBinding`
      Since:
        JavaFX 8.0

    - #### selectInteger

          public static IntegerBinding selectInteger​(Object root,
                                                     String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectInteger(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `IntegerBinding`
      Since:
        JavaFX 8.0

    - #### selectLong

          public static LongBinding selectLong​(Object root,
                                               String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `0L` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `Number` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectLong(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `LongBinding`
      Since:
        JavaFX 8.0

    - #### selectBoolean

          public static BooleanBinding selectBoolean​(Object root,
                                                     String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `false` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `boolean` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectBoolean(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `ObjectBinding`
      Since:
        JavaFX 8.0

    - #### selectString

          public static StringBinding selectString​(Object root,
                                                   String... steps)

      Creates a binding used to get a member, such as `a.b.c`. The value of the binding will be `c`, or `""` if `c` could not be reached (due to `b` not having a `c` property, `b` being `null`, or `c` not being a `String` etc.).

      All classes and properties used in a select-binding have to be declared public. Additionally, if any class is in a named module, then it must be reflectively accessible to the `javafx.base` module (see Deploying an Application as a Module).

      If root has JavaFX properties, this call is equivalent to `selectString(javafx.beans.value.ObservableValue, java.lang.String[])`, with the `root` and `step[0]` being substituted with the relevant property object.

      Parameters:
        `root` - The root bean.
        `steps` - The property names to reach the final property. The first step must be specified as it marks the property of the root bean.
      Returns:
        the created `ObjectBinding`
      Since:
        JavaFX 8.0

    - #### when

          public static When when​(ObservableBooleanValue condition)

      Creates a binding that calculates the result of a ternary expression. See the description of class `When` for details.
      Parameters:
        `condition` - the condition of the ternary expression
      Returns:
        an intermediate class to build the complete binding
      See Also:
        `When`

    - #### bindBidirectional

          public static <T> void bindBidirectional​(Property<T> property1,
                                                   Property<T> property2)

      Generates a bidirectional binding (or "bind with inverse") between two instances of `Property`.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      A bidirectional binding can be removed with `unbindBidirectional(Property, Property)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Type Parameters:
        `T` - the types of the properties
      Parameters:
        `property1` - the first `Property<T>`
        `property2` - the second `Property<T>`
      Throws:
        `NullPointerException` - if one of the properties is `null`
        `IllegalArgumentException` - if both properties are equal

    - #### unbindBidirectional

          public static <T> void unbindBidirectional​(Property<T> property1,
                                                     Property<T> property2)

      Delete a bidirectional binding that was previously defined with `bindBidirectional(Property, Property)`.
      Type Parameters:
        `T` - the types of the properties
      Parameters:
        `property1` - the first `Property<T>`
        `property2` - the second `Property<T>`
      Throws:
        `NullPointerException` - if one of the properties is `null`
        `IllegalArgumentException` - if both properties are equal

    - #### unbindBidirectional

          public static void unbindBidirectional​(Object property1,
                                                 Object property2)

      Delete a bidirectional binding that was previously defined with `bindBidirectional(Property, Property)` or `bindBidirectional(javafx.beans.property.Property, javafx.beans.property.Property, java.text.Format)`.
      Parameters:
        `property1` - the first `Property<T>`
        `property2` - the second `Property<T>`
      Throws:
        `NullPointerException` - if one of the properties is `null`
        `IllegalArgumentException` - if both properties are equal
      Since:
        JavaFX 2.1

    - #### bindBidirectional

          public static void bindBidirectional​(Property<String> stringProperty,
                                               Property<?> otherProperty,
                                               Format format)

      Generates a bidirectional binding (or "bind with inverse") between a `String`-`Property` and another `Property` using the specified `Format` for conversion.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      A bidirectional binding can be removed with `unbindBidirectional(Object, Object)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Parameters:
        `stringProperty` - the `String` `Property`
        `otherProperty` - the other (non-`String`) `Property`
        `format` - the `Format` used to convert between the properties
      Throws:
        `NullPointerException` - if one of the properties or the `format` is `null`
        `IllegalArgumentException` - if both properties are equal
      Since:
        JavaFX 2.1

    - #### bindBidirectional

          public static <T> void bindBidirectional​(Property<String> stringProperty,
                                                   Property<T> otherProperty,
                                                   StringConverter<T> converter)

      Generates a bidirectional binding (or "bind with inverse") between a `String`-`Property` and another `Property` using the specified `StringConverter` for conversion.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      A bidirectional binding can be removed with `unbindBidirectional(Object, Object)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Type Parameters:
        `T` - the type of the wrapped `Object`
      Parameters:
        `stringProperty` - the `String` `Property`
        `otherProperty` - the other (non-`String`) `Property`
        `converter` - the `StringConverter` used to convert between the properties
      Throws:
        `NullPointerException` - if one of the properties or the `converter` is `null`
        `IllegalArgumentException` - if both properties are equal
      Since:
        JavaFX 2.1

    - #### bindContentBidirectional

          public static <E> void bindContentBidirectional​(ObservableList<E> list1,
                                                          ObservableList<E> list2)

      Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableList`.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      Only the content of the two lists is synchronized, which means that both lists are different, but they contain the same elements.

      A bidirectional content-binding can be removed with `unbindContentBidirectional(Object, Object)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Type Parameters:
        `E` - the type of the list elements
      Parameters:
        `list1` - the first `ObservableList<E>`
        `list2` - the second `ObservableList<E>`
      Throws:
        `NullPointerException` - if one of the lists is `null`
        `IllegalArgumentException` - if `list1` == `list2`
      Since:
        JavaFX 2.1

    - #### bindContentBidirectional

          public static <E> void bindContentBidirectional​(ObservableSet<E> set1,
                                                          ObservableSet<E> set2)

      Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableSet`.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      Only the content of the two sets is synchronized, which means that both sets are different, but they contain the same elements.

      A bidirectional content-binding can be removed with `unbindContentBidirectional(Object, Object)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Type Parameters:
        `E` - the type of the set elements
      Parameters:
        `set1` - the first `ObservableSet<E>`
        `set2` - the second `ObservableSet<E>`
      Throws:
        `NullPointerException` - if one of the sets is `null`
        `IllegalArgumentException` - if `set1` == `set2`
      Since:
        JavaFX 2.1

    - #### bindContentBidirectional

          public static <K,​V> void bindContentBidirectional​(ObservableMap<K,​V> map1,
                                                                  ObservableMap<K,​V> map2)

      Generates a bidirectional binding (or "bind with inverse") between two instances of `ObservableMap`.

      A bidirectional binding is a binding that works in both directions. If two properties `a` and `b` are linked with a bidirectional binding and the value of `a` changes, `b` is set to the same value automatically. And vice versa, if `b` changes, `a` is set to the same value.

      Only the content of the two maps is synchronized, which means that both maps are different, but they contain the same elements.

      A bidirectional content-binding can be removed with `unbindContentBidirectional(Object, Object)`.

      Note: this implementation of a bidirectional binding behaves differently from all other bindings here in two important aspects. A property that is linked to another property with a bidirectional binding can still be set (usually bindings would throw an exception). Secondly bidirectional bindings are calculated eagerly, i.e. a bound property is updated immediately.

      Type Parameters:
        `K` - the type of the key elements
        `V` - the type of the value elements
      Parameters:
        `map1` - the first `ObservableMap<K, V>`
        `map2` - the second `ObservableMap<K, V>`
      Since:
        JavaFX 2.1

    - #### unbindContentBidirectional

          public static void unbindContentBidirectional​(Object obj1,
                                                        Object obj2)

      Remove a bidirectional content binding.
      Parameters:
        `obj1` - the first `Object`
        `obj2` - the second `Object`
      Since:
        JavaFX 2.1

    - #### bindContent

          public static <E> void bindContent​(List<E> list1,
                                             ObservableList<? extends E> list2)

      Generates a content binding between an `ObservableList` and a `List`.

      A content binding ensures that the `List` contains the same elements as the `ObservableList`. If the content of the `ObservableList` changes, the `List` will be updated automatically.

      Once a `List` is bound to an `ObservableList`, the `List` must not be changed directly anymore. Doing so would lead to unexpected results.

      A content-binding can be removed with `unbindContent(Object, Object)`.

      Type Parameters:
        `E` - the type of the `List` elements
      Parameters:
        `list1` - the `List`
        `list2` - the `ObservableList`
      Since:
        JavaFX 2.1

    - #### bindContent

          public static <E> void bindContent​(Set<E> set1,
                                             ObservableSet<? extends E> set2)

      Generates a content binding between an `ObservableSet` and a `Set`.

      A content binding ensures that the `Set` contains the same elements as the `ObservableSet`. If the content of the `ObservableSet` changes, the `Set` will be updated automatically.

      Once a `Set` is bound to an `ObservableSet`, the `Set` must not be changed directly anymore. Doing so would lead to unexpected results.

      A content-binding can be removed with `unbindContent(Object, Object)`.

      Type Parameters:
        `E` - the type of the `Set` elements
      Parameters:
        `set1` - the `Set`
        `set2` - the `ObservableSet`
      Throws:
        `NullPointerException` - if one of the sets is `null`
        `IllegalArgumentException` - if `set1` == `set2`
      Since:
        JavaFX 2.1

    - #### bindContent

          public static <K,​V> void bindContent​(Map<K,​V> map1,
                                                     ObservableMap<? extends K,​? extends V> map2)

      Generates a content binding between an `ObservableMap` and a `Map`.

      A content binding ensures that the `Map` contains the same elements as the `ObservableMap`. If the content of the `ObservableMap` changes, the `Map` will be updated automatically.

      Once a `Map` is bound to an `ObservableMap`, the `Map` must not be changed directly anymore. Doing so would lead to unexpected results.

      A content-binding can be removed with `unbindContent(Object, Object)`.

      Type Parameters:
        `K` - the type of the key elements of the `Map`
        `V` - the type of the value elements of the `Map`
      Parameters:
        `map1` - the `Map`
        `map2` - the `ObservableMap`
      Throws:
        `NullPointerException` - if one of the maps is `null`
        `IllegalArgumentException` - if `map1` == `map2`
      Since:
        JavaFX 2.1

    - #### unbindContent

          public static void unbindContent​(Object obj1,
                                           Object obj2)

      Remove a content binding.
      Parameters:
        `obj1` - the first `Object`
        `obj2` - the second `Object`
      Throws:
        `NullPointerException` - if one of the `Objects` is `null`
        `IllegalArgumentException` - if `obj1` == `obj2`
      Since:
        JavaFX 2.1

    - #### negate

          public static NumberBinding negate​(ObservableNumberValue value)

      Creates a new `NumberBinding` that calculates the negation of a `ObservableNumberValue`.
      Parameters:
        `value` - the operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the value is `null`

    - #### add

          public static NumberBinding add​(ObservableNumberValue op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the sum of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### add

          public static DoubleBinding add​(ObservableNumberValue op1,
                                          double op2)

      Creates a new `DoubleBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static DoubleBinding add​(double op1,
                                          ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(ObservableNumberValue op1,
                                          float op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(float op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(ObservableNumberValue op1,
                                          long op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(long op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(ObservableNumberValue op1,
                                          int op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### add

          public static NumberBinding add​(int op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the sum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(ObservableNumberValue op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the difference of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### subtract

          public static DoubleBinding subtract​(ObservableNumberValue op1,
                                               double op2)

      Creates a new `DoubleBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static DoubleBinding subtract​(double op1,
                                               ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(ObservableNumberValue op1,
                                               float op2)

      Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(float op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(ObservableNumberValue op1,
                                               long op2)

      Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(long op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(ObservableNumberValue op1,
                                               int op2)

      Creates a new `NumberBinding` that calculates the difference of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### subtract

          public static NumberBinding subtract​(int op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the difference of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(ObservableNumberValue op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the product of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### multiply

          public static DoubleBinding multiply​(ObservableNumberValue op1,
                                               double op2)

      Creates a new `DoubleBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static DoubleBinding multiply​(double op1,
                                               ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(ObservableNumberValue op1,
                                               float op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(float op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(ObservableNumberValue op1,
                                               long op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(long op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(ObservableNumberValue op1,
                                               int op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### multiply

          public static NumberBinding multiply​(int op1,
                                               ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the product of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(ObservableNumberValue op1,
                                             ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the division of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### divide

          public static DoubleBinding divide​(ObservableNumberValue op1,
                                             double op2)

      Creates a new `DoubleBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static DoubleBinding divide​(double op1,
                                             ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(ObservableNumberValue op1,
                                             float op2)

      Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(float op1,
                                             ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(ObservableNumberValue op1,
                                             long op2)

      Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(long op1,
                                             ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(ObservableNumberValue op1,
                                             int op2)

      Creates a new `NumberBinding` that calculates the division of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### divide

          public static NumberBinding divide​(int op1,
                                             ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the division of a constant value and the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             ObservableNumberValue op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are equal (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are equal.

      When comparing floating-point numbers it is recommended to use the `equal()` method that allows a small tolerance.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             double op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(double op1,
                                             ObservableNumberValue op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             float op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(float op1,
                                             ObservableNumberValue op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             long op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `equal()` method that allows a small tolerance.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(long op1,
                                             ObservableNumberValue op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(long op1,
                                             ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `equal()` method that allows a small tolerance.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             int op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableNumberValue op1,
                                             int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `equal()` method that allows a small tolerance.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(int op1,
                                             ObservableNumberValue op2,
                                             double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### equal

          public static BooleanBinding equal​(int op1,
                                             ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `equal()` method that allows a small tolerance.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                ObservableNumberValue op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are not equal (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableNumberValue` are not equal.

      When comparing floating-point numbers it is recommended to use the `notEqual()` method that allows a small tolerance.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                double op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(double op1,
                                                ObservableNumberValue op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                float op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(float op1,
                                                ObservableNumberValue op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                long op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `notEqual()` method that allows a small tolerance.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(long op1,
                                                ObservableNumberValue op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(long op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `notEqual()` method that allows a small tolerance.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                int op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableNumberValue op1,
                                                int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `notEqual()` method that allows a small tolerance.

      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(int op1,
                                                ObservableNumberValue op2,
                                                double epsilon)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value (with a tolerance).

      Two operands `a` and `b` are considered equal if `Math.abs(a-b) <= epsilon`.

      Allowing a small tolerance is recommended when comparing floating-point numbers because of rounding-errors.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
        `epsilon` - the permitted tolerance
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(int op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is not equal to a constant value.

      When comparing floating-point numbers it is recommended to use the `notEqual()` method that allows a small tolerance.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableNumberValue op1,
                                                   ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is greater than the value of the second.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableNumberValue op1,
                                                   double op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(double op1,
                                                   ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableNumberValue op1,
                                                   float op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(float op1,
                                                   ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableNumberValue op1,
                                                   long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(long op1,
                                                   ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableNumberValue op1,
                                                   int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(int op1,
                                                   ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableNumberValue op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is less than the value of the second.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableNumberValue op1,
                                                double op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(double op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableNumberValue op1,
                                                float op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(float op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableNumberValue op1,
                                                long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(long op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableNumberValue op1,
                                                int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(int op1,
                                                ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableNumberValue op1,
                                                          ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is greater than or equal to the value of the second.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableNumberValue op1,
                                                          double op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(double op1,
                                                          ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableNumberValue op1,
                                                          float op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(float op1,
                                                          ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableNumberValue op1,
                                                          long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(long op1,
                                                          ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableNumberValue op1,
                                                          int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is greater than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(int op1,
                                                          ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableNumberValue op1,
                                                       ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableNumberValue` is less than or equal to the value of the second.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableNumberValue op1,
                                                       double op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(double op1,
                                                       ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableNumberValue op1,
                                                       float op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(float op1,
                                                       ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableNumberValue op1,
                                                       long op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(long op1,
                                                       ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableNumberValue op1,
                                                       int op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableNumberValue` is less than or equal to a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(int op1,
                                                       ObservableNumberValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableNumberValue`.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(ObservableNumberValue op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the minimum of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### min

          public static DoubleBinding min​(ObservableNumberValue op1,
                                          double op2)

      Creates a new `DoubleBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static DoubleBinding min​(double op1,
                                          ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(ObservableNumberValue op1,
                                          float op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(float op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(ObservableNumberValue op1,
                                          long op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(long op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(ObservableNumberValue op1,
                                          int op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### min

          public static NumberBinding min​(int op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the minimum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(ObservableNumberValue op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the maximum of the values of two instances of `ObservableNumberValue`.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### max

          public static DoubleBinding max​(ObservableNumberValue op1,
                                          double op2)

      Creates a new `DoubleBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static DoubleBinding max​(double op1,
                                          ObservableNumberValue op2)

      Creates a new `DoubleBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(ObservableNumberValue op1,
                                          float op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(float op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(ObservableNumberValue op1,
                                          long op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(long op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(ObservableNumberValue op1,
                                          int op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the `ObservableNumberValue`
        `op2` - the constant value
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### max

          public static NumberBinding max​(int op1,
                                          ObservableNumberValue op2)

      Creates a new `NumberBinding` that calculates the maximum of the value of a `ObservableNumberValue` and a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableNumberValue`
      Returns:
        the new `NumberBinding`
      Throws:
        `NullPointerException` - if the `ObservableNumberValue` is `null`

    - #### and

          public static BooleanBinding and​(ObservableBooleanValue op1,
                                           ObservableBooleanValue op2)

      Creates a `BooleanBinding` that calculates the conditional-AND operation on the value of two instance of `ObservableBooleanValue`.
      Parameters:
        `op1` - first `ObservableBooleanValue`
        `op2` - second `ObservableBooleanValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### or

          public static BooleanBinding or​(ObservableBooleanValue op1,
                                          ObservableBooleanValue op2)

      Creates a `BooleanBinding` that calculates the conditional-OR operation on the value of two instance of `ObservableBooleanValue`.
      Parameters:
        `op1` - first `ObservableBooleanValue`
        `op2` - second `ObservableBooleanValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### not

          public static BooleanBinding not​(ObservableBooleanValue op)

      Creates a `BooleanBinding` that calculates the inverse of the value of a `ObservableBooleanValue`.
      Parameters:
        `op` - the `ObservableBooleanValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the operand is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableBooleanValue op1,
                                             ObservableBooleanValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableBooleanValue` are equal.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableBooleanValue op1,
                                                ObservableBooleanValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableBooleanValue` are not equal.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### convert

          public static StringExpression convert​(ObservableValue<?> observableValue)

      Returns a `StringExpression` that wraps a `ObservableValue`. If the `ObservableValue` is already a `StringExpression`, it will be returned. Otherwise a new `StringBinding` is created that holds the value of the `ObservableValue` converted to a `String`.
      Parameters:
        `observableValue` - The source `ObservableValue`
      Returns:
        A `StringExpression` that wraps the `ObservableValue` if necessary
      Throws:
        `NullPointerException` - if `observableValue` is `null`

    - #### concat

          public static StringExpression concat​(Object... args)

      Returns a `StringExpression` that holds the value of the concatenation of multiple `Objects`.

      If one of the arguments implements `ObservableValue` and the value of this `ObservableValue` changes, the change is automatically reflected in the `StringExpression`.

      If `null` or an empty array is passed to this method, a `StringExpression` that contains an empty `String` is returned

      Parameters:
        `args` - the `Objects` that should be concatenated
      Returns:
        the new `StringExpression`

    - #### format

          public static StringExpression format​(String format,
                                                Object... args)

      Creates a `StringExpression` that holds the value of multiple `Objects` formatted according to a format `String`.

      If one of the arguments implements `ObservableValue` and the value of this `ObservableValue` changes, the change is automatically reflected in the `StringExpression`.

      See `java.util.Formatter` for formatting rules.

      Parameters:
        `format` - the formatting `String`
        `args` - the `Objects` that should be inserted in the formatting `String`
      Returns:
        the new `StringExpression`

    - #### format

          public static StringExpression format​(Locale locale,
                                                String format,
                                                Object... args)

      Creates a `StringExpression` that holds the value of multiple `Objects` formatted according to a format `String` and a specified `Locale`

      If one of the arguments implements `ObservableValue` and the value of this `ObservableValue` changes, the change is automatically reflected in the `StringExpression`.

      See `java.util.Formatter` for formatting rules. See `java.util.Locale` for details on `Locale`.

      Parameters:
        `locale` - the `Locale` to use during formatting
        `format` - the formatting `String`
        `args` - the `Objects` that should be inserted in the formatting `String`
      Returns:
        the new `StringExpression`

    - #### equal

          public static BooleanBinding equal​(ObservableStringValue op1,
                                             ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are equal.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableStringValue op1,
                                             String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### equal

          public static BooleanBinding equal​(String op1,
                                             ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableStringValue op1,
                                                ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are not equal.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableStringValue op1,
                                                String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(String op1,
                                                ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### equalIgnoreCase

          public static BooleanBinding equalIgnoreCase​(ObservableStringValue op1,
                                                       ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are equal ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### equalIgnoreCase

          public static BooleanBinding equalIgnoreCase​(ObservableStringValue op1,
                                                       String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### equalIgnoreCase

          public static BooleanBinding equalIgnoreCase​(String op1,
                                                       ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is equal to a constant value ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### notEqualIgnoreCase

          public static BooleanBinding notEqualIgnoreCase​(ObservableStringValue op1,
                                                          ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableStringValue` are not equal ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqualIgnoreCase

          public static BooleanBinding notEqualIgnoreCase​(ObservableStringValue op1,
                                                          String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### notEqualIgnoreCase

          public static BooleanBinding notEqualIgnoreCase​(String op1,
                                                          ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not equal to a constant value ignoring case.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableStringValue op1,
                                                   ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is greater than the value of the second.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(ObservableStringValue op1,
                                                   String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is greater than a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### greaterThan

          public static BooleanBinding greaterThan​(String op1,
                                                   ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a constant value is greater than the value of a `ObservableStringValue`.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableStringValue op1,
                                                ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is less than the value of the second.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(ObservableStringValue op1,
                                                String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is less than a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### lessThan

          public static BooleanBinding lessThan​(String op1,
                                                ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than the value of a `ObservableStringValue`.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableStringValue op1,
                                                          ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is greater than or equal to the value of the second.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(ObservableStringValue op1,
                                                          String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is greater than or equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### greaterThanOrEqual

          public static BooleanBinding greaterThanOrEqual​(String op1,
                                                          ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is greater than or equal to the value of a `ObservableStringValue`.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableStringValue op1,
                                                       ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if the value of the first `ObservableStringValue` is less than or equal to the value of the second.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(ObservableStringValue op1,
                                                       String op2)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is less than or equal to a constant value.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the `ObservableStringValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### lessThanOrEqual

          public static BooleanBinding lessThanOrEqual​(String op1,
                                                       ObservableStringValue op2)

      Creates a new `BooleanBinding` that holds `true` if a constant value is less than or equal to the value of a `ObservableStringValue`.

      Note: In this comparison a `String` that is `null` is considered equal to an empty `String`.

      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`

    - #### length

          public static IntegerBinding length​(ObservableStringValue op)

      Creates a new `IntegerBinding` that holds the length of a `ObservableStringValue`.

      Note: In this comparison a `String` that is `null` is considered to have a length of `0`.

      Parameters:
        `op` - the `ObservableStringValue`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`
      Since:
        JavaFX 8.0

    - #### isEmpty

          public static BooleanBinding isEmpty​(ObservableStringValue op)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is empty.

      Note: In this comparison a `String` that is `null` is considered to be empty.

      Parameters:
        `op` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`
      Since:
        JavaFX 8.0

    - #### isNotEmpty

          public static BooleanBinding isNotEmpty​(ObservableStringValue op)

      Creates a new `BooleanBinding` that holds `true` if the value of a `ObservableStringValue` is not empty.

      Note: In this comparison a `String` that is `null` is considered to be empty.

      Parameters:
        `op` - the `ObservableStringValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableStringValue` is `null`
      Since:
        JavaFX 8.0

    - #### equal

          public static BooleanBinding equal​(ObservableObjectValue<?> op1,
                                             ObservableObjectValue<?> op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableObjectValue` are equal.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### equal

          public static BooleanBinding equal​(ObservableObjectValue<?> op1,
                                             Object op2)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is equal to a constant value.
      Parameters:
        `op1` - the `ObservableObjectValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### equal

          public static BooleanBinding equal​(Object op1,
                                             ObservableObjectValue<?> op2)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is equal to a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableObjectValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableObjectValue<?> op1,
                                                ObservableObjectValue<?> op2)

      Creates a new `BooleanBinding` that holds `true` if the values of two instances of `ObservableObjectValue` are not equal.
      Parameters:
        `op1` - the first operand
        `op2` - the second operand
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if one of the operands is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(ObservableObjectValue<?> op1,
                                                Object op2)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not equal to a constant value.
      Parameters:
        `op1` - the `ObservableObjectValue`
        `op2` - the constant value
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### notEqual

          public static BooleanBinding notEqual​(Object op1,
                                                ObservableObjectValue<?> op2)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not equal to a constant value.
      Parameters:
        `op1` - the constant value
        `op2` - the `ObservableObjectValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### isNull

          public static BooleanBinding isNull​(ObservableObjectValue<?> op)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is `null`.
      Parameters:
        `op` - the `ObservableObjectValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### isNotNull

          public static BooleanBinding isNotNull​(ObservableObjectValue<?> op)

      Creates a new `BooleanBinding` that holds `true` if the value of an `ObservableObjectValue` is not `null`.
      Parameters:
        `op` - the `ObservableObjectValue`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableObjectValue` is `null`

    - #### size

          public static <E> IntegerBinding size​(ObservableList<E> op)

      Creates a new `IntegerBinding` that contains the size of an `ObservableList`.
      Type Parameters:
        `E` - type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
      Since:
        JavaFX 2.1

    - #### isEmpty

          public static <E> BooleanBinding isEmpty​(ObservableList<E> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableList` is empty.
      Type Parameters:
        `E` - type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
      Since:
        JavaFX 2.1

    - #### isNotEmpty

          public static <E> BooleanBinding isNotEmpty​(ObservableList<E> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableList` is not empty.
      Type Parameters:
        `E` - type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
      Since:
        JavaFX 8.0

    - #### valueAt

          public static <E> ObjectBinding<E> valueAt​(ObservableList<E> op,
                                                     int index)

      Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position. The `ObjectBinding` will contain `null` if the `index` points behind the `ObservableList`.
      Type Parameters:
        `E` - the type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `ObjectBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### valueAt

          public static <E> ObjectBinding<E> valueAt​(ObservableList<E> op,
                                                     ObservableIntegerValue index)

      Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position. The `ObjectBinding` will contain `null` if the `index` is outside of the `ObservableList`.
      Type Parameters:
        `E` - the type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `ObjectBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### valueAt

          public static <E> ObjectBinding<E> valueAt​(ObservableList<E> op,
                                                     ObservableNumberValue index)

      Creates a new `ObjectBinding` that contains the element of an `ObservableList` at the specified position. The `ObjectBinding` will contain `null` if the `index` is outside of the `ObservableList`.
      Type Parameters:
        `E` - the type of the `List` elements
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `ObjectBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### booleanValueAt

          public static BooleanBinding booleanValueAt​(ObservableList<Boolean> op,
                                                      int index)

      Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position. The `BooleanBinding` will hold `false` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### booleanValueAt

          public static BooleanBinding booleanValueAt​(ObservableList<Boolean> op,
                                                      ObservableIntegerValue index)

      Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position. The `BooleanBinding` will hold `false` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### booleanValueAt

          public static BooleanBinding booleanValueAt​(ObservableList<Boolean> op,
                                                      ObservableNumberValue index)

      Creates a new `BooleanBinding` that contains the element of an `ObservableList` at the specified position. The `BooleanBinding` will hold `false` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### doubleValueAt

          public static DoubleBinding doubleValueAt​(ObservableList<? extends Number> op,
                                                    int index)

      Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position. The `DoubleBinding` will hold `0.0` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### doubleValueAt

          public static DoubleBinding doubleValueAt​(ObservableList<? extends Number> op,
                                                    ObservableIntegerValue index)

      Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position. The `DoubleBinding` will hold `0.0` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### doubleValueAt

          public static DoubleBinding doubleValueAt​(ObservableList<? extends Number> op,
                                                    ObservableNumberValue index)

      Creates a new `DoubleBinding` that contains the element of an `ObservableList` at the specified position. The `DoubleBinding` will hold `0.0` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableList<? extends Number> op,
                                                  int index)

      Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableList<? extends Number> op,
                                                  ObservableIntegerValue index)

      Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableList<? extends Number> op,
                                                  ObservableNumberValue index)

      Creates a new `FloatBinding` that contains the element of an `ObservableList` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableList<? extends Number> op,
                                                      int index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position. The `IntegerBinding` will hold `0` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableList<? extends Number> op,
                                                      ObservableIntegerValue index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position. The `IntegerBinding` will hold `0` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableList<? extends Number> op,
                                                      ObservableNumberValue index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableList` at the specified position. The `IntegerBinding` will hold `0` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### longValueAt

          public static LongBinding longValueAt​(ObservableList<? extends Number> op,
                                                int index)

      Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position. The `LongBinding` will hold `0L` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `LongBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### longValueAt

          public static LongBinding longValueAt​(ObservableList<? extends Number> op,
                                                ObservableIntegerValue index)

      Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position. The `LongBinding` will hold `0L` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `LongBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### longValueAt

          public static LongBinding longValueAt​(ObservableList<? extends Number> op,
                                                ObservableNumberValue index)

      Creates a new `LongBinding` that contains the element of an `ObservableList` at the specified position. The `LongBinding` will hold `0L` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `LongBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### stringValueAt

          public static StringBinding stringValueAt​(ObservableList<String> op,
                                                    int index)

      Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position. The `StringBinding` will hold `null` if the `index` points behind the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `StringBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 2.1

    - #### stringValueAt

          public static StringBinding stringValueAt​(ObservableList<String> op,
                                                    ObservableIntegerValue index)

      Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position. The `StringBinding` will hold `""` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`
      Returns:
        the new `StringBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 2.1

    - #### stringValueAt

          public static StringBinding stringValueAt​(ObservableList<String> op,
                                                    ObservableNumberValue index)

      Creates a new `StringBinding` that contains the element of an `ObservableList` at the specified position. The `StringBinding` will hold `""` if the `index` is outside of the `ObservableList`.
      Parameters:
        `op` - the `ObservableList`
        `index` - the position in the `List`, converted to int
      Returns:
        the new `StringBinding`
      Throws:
        `NullPointerException` - if the `ObservableList` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### size

          public static <E> IntegerBinding size​(ObservableSet<E> op)

      Creates a new `IntegerBinding` that contains the size of an `ObservableSet`.
      Type Parameters:
        `E` - the type of the `Set` elements
      Parameters:
        `op` - the `ObservableSet`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableSet` is `null`
      Since:
        JavaFX 2.1

    - #### isEmpty

          public static <E> BooleanBinding isEmpty​(ObservableSet<E> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableSet` is empty.
      Type Parameters:
        `E` - the type of the `Set` elements
      Parameters:
        `op` - the `ObservableSet`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableSet` is `null`
      Since:
        JavaFX 2.1

    - #### isNotEmpty

          public static <E> BooleanBinding isNotEmpty​(ObservableSet<E> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableSet` is not empty.
      Type Parameters:
        `E` - the type of the `Set` elements
      Parameters:
        `op` - the `ObservableSet`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableSet` is `null`
      Since:
        JavaFX 8.0

    - #### size

          public static IntegerBinding size​(ObservableArray op)

      Creates a new `IntegerBinding` that contains the size of an `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` is `null`
      Since:
        JavaFX 8.0

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableFloatArray op,
                                                  int index)

      Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` points behind the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 8.0

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableFloatArray op,
                                                  ObservableIntegerValue index)

      Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` is outside of the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### floatValueAt

          public static FloatBinding floatValueAt​(ObservableFloatArray op,
                                                  ObservableNumberValue index)

      Creates a new `FloatBinding` that contains the element of an `ObservableArray` at the specified position. The `FloatBinding` will hold `0.0f` if the `index` is outside of the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`, converted to int
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableIntegerArray op,
                                                      int index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position. The `IntegerBinding` will hold `0` if the `index` points behind the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` is `null`
        `IllegalArgumentException` - if (@code index < 0)
      Since:
        JavaFX 8.0

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableIntegerArray op,
                                                      ObservableIntegerValue index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position. The `IntegerBinding` will hold `0` if the `index` is outside of the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### integerValueAt

          public static IntegerBinding integerValueAt​(ObservableIntegerArray op,
                                                      ObservableNumberValue index)

      Creates a new `IntegerBinding` that contains the element of an `ObservableArray` at the specified position. The `IntegerBinding` will hold `0` if the `index` is outside of the `ObservableArray`.
      Parameters:
        `op` - the `ObservableArray`
        `index` - the position in the `ObservableArray`, converted to int
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableArray` or `index` is `null`
      Since:
        JavaFX 8.0

    - #### size

          public static <K,​V> IntegerBinding size​(ObservableMap<K,​V> op)

      Creates a new `IntegerBinding` that contains the size of an `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
        `V` - type of the value elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### isEmpty

          public static <K,​V> BooleanBinding isEmpty​(ObservableMap<K,​V> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableMap` is empty.
      Type Parameters:
        `K` - type of the key elements of the `Map`
        `V` - type of the value elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### isNotEmpty

          public static <K,​V> BooleanBinding isNotEmpty​(ObservableMap<K,​V> op)

      Creates a new `BooleanBinding` that holds `true` if a given `ObservableMap` is not empty.
      Type Parameters:
        `K` - type of the key elements of the `Map`
        `V` - type of the value elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 8.0

    - #### valueAt

          public static <K,​V> ObjectBinding<V> valueAt​(ObservableMap<K,​V> op,
                                                             K key)

      Creates a new `ObjectBinding` that contains the mapping of a specific key in an `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
        `V` - type of the value elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `ObjectBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### valueAt

          public static <K,​V> ObjectBinding<V> valueAt​(ObservableMap<K,​V> op,
                                                             ObservableValue<? extends K> key)

      Creates a new `ObjectBinding` that contains the mapping of a specific key in an `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
        `V` - type of the value elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `ObjectBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### booleanValueAt

          public static <K> BooleanBinding booleanValueAt​(ObservableMap<K,​Boolean> op,
                                                          K key)

      Creates a new `BooleanBinding` that contains the mapping of a specific key in an `ObservableMap`. The `BooleanBinding` will hold `false` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### booleanValueAt

          public static <K> BooleanBinding booleanValueAt​(ObservableMap<K,​Boolean> op,
                                                          ObservableValue<? extends K> key)

      Creates a new `BooleanBinding` that contains the mapping of a specific key in an `ObservableMap`. The `BooleanBinding` will hold `false` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `BooleanBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### doubleValueAt

          public static <K> DoubleBinding doubleValueAt​(ObservableMap<K,​? extends Number> op,
                                                        K key)

      Creates a new `DoubleBinding` that contains the mapping of a specific key in an `ObservableMap`. The `DoubleBinding` will hold `0.0` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### doubleValueAt

          public static <K> DoubleBinding doubleValueAt​(ObservableMap<K,​? extends Number> op,
                                                        ObservableValue<? extends K> key)

      Creates a new `DoubleBinding` that contains the mapping of a specific key in an `ObservableMap`. The `DoubleBinding` will hold `0.0` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `DoubleBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### floatValueAt

          public static <K> FloatBinding floatValueAt​(ObservableMap<K,​? extends Number> op,
                                                      K key)

      Creates a new `FloatBinding` that contains the mapping of a specific key in an `ObservableMap`. The `FloatBinding` will hold `0.0f` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### floatValueAt

          public static <K> FloatBinding floatValueAt​(ObservableMap<K,​? extends Number> op,
                                                      ObservableValue<? extends K> key)

      Creates a new `FloatBinding` that contains the mapping of a specific key in an `ObservableMap`. The `FloatBinding` will hold `0.0f` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `FloatBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### integerValueAt

          public static <K> IntegerBinding integerValueAt​(ObservableMap<K,​? extends Number> op,
                                                          K key)

      Creates a new `IntegerBinding` that contains the mapping of a specific key in an `ObservableMap`. The `IntegerBinding` will hold `0` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### integerValueAt

          public static <K> IntegerBinding integerValueAt​(ObservableMap<K,​? extends Number> op,
                                                          ObservableValue<? extends K> key)

      Creates a new `IntegerBinding` that contains the mapping of a specific key in an `ObservableMap`. The `IntegerBinding` will hold `0` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `IntegerBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### longValueAt

          public static <K> LongBinding longValueAt​(ObservableMap<K,​? extends Number> op,
                                                    K key)

      Creates a new `LongBinding` that contains the mapping of a specific key in an `ObservableMap`. The `LongBinding` will hold `0L` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `LongBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### longValueAt

          public static <K> LongBinding longValueAt​(ObservableMap<K,​? extends Number> op,
                                                    ObservableValue<? extends K> key)

      Creates a new `LongBinding` that contains the mapping of a specific key in an `ObservableMap`. The `LongBinding` will hold `0L` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `LongBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1

    - #### stringValueAt

          public static <K> StringBinding stringValueAt​(ObservableMap<K,​String> op,
                                                        K key)

      Creates a new `StringBinding` that contains the mapping of a specific key in an `ObservableMap`. The `StringBinding` will hold `null` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `StringBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` is `null`
      Since:
        JavaFX 2.1

    - #### stringValueAt

          public static <K> StringBinding stringValueAt​(ObservableMap<K,​String> op,
                                                        ObservableValue<? extends K> key)

      Creates a new `StringBinding` that contains the mapping of a specific key in an `ObservableMap`. The `StringBinding` will hold `""` if the `key` cannot be found in the `ObservableMap`.
      Type Parameters:
        `K` - type of the key elements of the `Map`
      Parameters:
        `op` - the `ObservableMap`
        `key` - the key in the `Map`
      Returns:
        the new `StringBinding`
      Throws:
        `NullPointerException` - if the `ObservableMap` or `key` is `null`
      Since:
        JavaFX 2.1