1. JavaFX Collections.

Las colecciones de definidas para JavaFX son dos: ObservableList y ObservableMap.

En esta unidad nos centramos en la primera pues es básica para poder entender el
funcionamiento de los controles vistos en la unidad anterior.

La clase ObservableList extiende la clase List, que se implementa mediante clases

como ArrayList. Como resultado, cualquier método que se puede usar con un
ArrayList también se puede usar con un ObservableList.

Las colecciones en JavaFX están definidas por el paquete javafx.collections, que

consta de las siguientes interfaces y clases:

Interfaces

• ObservableList: Define como debe ser una “lista observable”.

• ListChangeListener: Una interfaz que recibe notificaciones de cambios a un

ObservableList.

Clases

• FXCollections: Una clase de utilidad que consiste en métodos estáticos que son
copias uno a uno de los métodos java.util.Collections, nos servirá para
implementar las observableList.

• ListChangeListener.Change: Representa un cambio realizado en un

ObservableList.

Algunos de los métodos más usados de un ObservableList son los descritos en la

siguiente tabla:
2. Breve repaso de las colecciones Java.

En concreto veremos muy rápidamente los List. Cómo los hemos usado con
anterioridad en este mismo módulo, a continuación se muestra un ejemplo que repasa
los aspectos fundamentales de los List, en concreto de los ArrayList:

import java.util.List;
import java.util.ArrayList;

public class CollectionsDemo {

public static void main(String[] args) {

// Crear una lista.

System.out.println("Creando la lista...");
List<String> list = new ArrayList<String>();
list.add("Primer elemento");
list.add("Segundo elemento");
list.add("Tercer elemento");

// Mostrar el contenido.
muestraElementos(list);

// Cambiando elemento en posición 0.

System.out.println("Cambiando un elemento...");
list.set(0, "Nuevo Elemento");
muestraElementos(list);

// Buscar el nuevo elemento.

System.out.println("Buscando...");
System.out.print("Contenido \"Nuevo Elemento\"? ");
System.out.println(list.contains("Nuevo Elemento"));
System.out.println("");

// Crear sublista.
System.out.println("creando una sublista...");
list = list.subList(1,3);
muestraElementos(list);

// Borrar todo.
System.out.println("Borrando todos los elementos...");
list.clear();
muestraElementos(list);
}

private static void muestraElementos(List<String> list) {

System.out.println("Tamaño: "+list.size());
//Recorrer los elementos de un List
for (Object o : list) {
System.out.println(o.toString());
}
System.out.println("");
 }
}

3. Usando ObservableList.

Veremos ahora diferentes ejemplos para aprender el uso de las ObservableList.

3.1. Creando ObservableList envolviendo un List.

Primero crearemos una lista estándar. Luego se envuelve con un ObservableList, que
se obtiene pasando la lista a FXCollections.observableList(list).
Después creamos un ListChangeListener que se ejecutará siempre que se realice un
cambio en el ObservableList:

public class ObservableListDemoI {

public static void main(String[] args) {
// Usamos Java Collections para crear la lista.
List<String> list = new ArrayList<String>();

// Ahora agregamos la observabilidad envolviéndola con ObservableList

ObservableList<String> observableList =
FXCollections.observableList(list);
//listener de la lista
observableList.addListener(new ListChangeListener() {
@Override
public void onChanged(ListChangeListener.Change change) {
System.out.println("Detectado un cambio!! ");
}
});

// Los cambios en la lista serán notificados

// Esta línea deberá provocar un evento
observableList.add("item uno");

// Los cambios en la lista subyaciente no serán notificados

// Esto no deberá causar un evento
list.add("item dos");

System.out.println("Tamaño: " + observableList.size());

}
}

3.2. Usando los métodos estáticos de FXCollections.

Como se ha comentado con anterioridad en FXCollections están escritos todos los

métodos Collections para usar con ObservableList, por ejemplo:
public class ObservableListDemoII {
public static void main(String[] args) {
// Usamos Java Collections para crear la lista.
List<String> list = new ArrayList<String>();

// Ahora agregamos la observabilidad envolviéndola con ObservableList

ObservableList<String> observableList =
FXCollections.observableList(list);

//Añadimos elementos a la lista

list.add("d");
list.add("b");
list.add("a");
list.add("c");

observableList.addListener(new ListChangeListener() {
@Override
public void onChanged(ListChangeListener.Change change) {
System.out.println("Detectado un cambio!! ");
}
});

// Sort usando FXCollections

FXCollections.sort(observableList);

}
}

3.3. El parámetro change del listener.

Un objeto ListChangeListener.Change puede contener varios cambios y, por lo tanto,

debe iterarse llamando a su método next () en un bucle while:
public class ObservableListDemoIII {
public static void main(String[] args) {
// Usamos Java Collections para crear la lista.
List<String> list = new ArrayList<String>();

// Ahora agregamos la observabilidad envolviéndola con ObservableList

ObservableList<String> observableList =
FXCollections.observableList(list);
list.add("d");
list.add("b");
list.add("a");
list.add("c");

observableList.addListener(new ListChangeListener() {
@Override
public void onChanged(ListChangeListener.Change change) {
System.out.println("Detectado un cambio!! ");
//usando el objeto change
while (change.next()) {
System.out.println("¿Fue añadido? " + change.wasAdded());
System.out.println("¿Fue movido? " + change.wasRemoved());
System.out.println("¿Fue remplazado? " +
change.wasReplaced());
System.out.println("¿Fue permutado? " +
change.wasPermutated());
 }
}
});

// Sort usando FXCollections

FXCollections.sort(observableList);

}
}

4. Usando ObservableList en controles JavaFX.

Las ObservableList se utilizan no sólo por la clase ChoiceBox, sino también por otros
controles , como ComboBox y List, que tienen un método getItems que devuelve un
ObservableList. Las ObservableList también son utilizadas por layouts, como HBox
y VBox, el método getChildren que es común a todas los layouts devuelve un
ObservableList.

Como consecuencia se puede borrar el contenido de un ChoiceBox de la misma

manera que se borraría el contenido de un ArrayList:

cbox.getItems().clear();

Si necesitamos saber cuántos elementos hay en un ChoiceBox, podemos llamar al

método size:

int count = cbox.getItems().size();

Puedemos insertar fácilmente elementos de una colección Java existente, como un

ArrayList, en un ChoiceBox especificando la colección en el método addAll. Por
ejemplo, supongamos que ya tenemos una lista de los elementos que deseamos
mostrar en el ChoiceBox. Podemos agregar los elementos así:

cbox.getItems().addAll(list);

Como ya sabemos no podemos usar el método addListener para responder cuando el

usuario selecciona un elemento en un control. En su lugar, se utiliza una interesante
construcción llamando al selection model para responder a los cambios en el selected
item, como vimos en la unidad anterior.
5. Ejercicio.

Modifica el ejemplo del ChoiceBox de la unidad anterior para que se pueda añadir
elementos al Chiocebox mediante un campo de texto y un botón: