L'API JavaFX met à disposition toute une série de classes et de classes utilitaires associées pour
afficher des graphiques de données statistiques. Ces classes sont disponibles dans le
package [Link]. Ces graphiques sont des nœuds graphiques, il est donc possible de
les modifier et de les manipuler, de leur faire subir des effets et transformations exactement comme
n'importe quel autre nœud SceneGraph. Ces graphiques sont également des Region.
Actuellement, l'API propose les graphiques suivants :
PieChart - un graphique en camembert ;
des graphiques sur deux axes qui héritent de la classe abstraite XYChart :
o ScatterChart - un graphique contenant des séries de valeurs représentées par des
nuages de points ou de symboles,
o BubbleChart - un graphique contenant des séries de valeurs représentées par des
bulles dont le diamètre varie en fonction d'une 3e dimension,
o LineChart - un graphique contenant des séries de valeurs représentées par des
lignes,
o AreaChart - un graphique contenant des séries de valeurs représentées par des
aires colorées,
o StackedAreaChart - un graphique contenant des séries de valeurs représentées par
des aires colorées superposées les unes sur les autres,
o BarChart - un graphique contenant des séries de valeurs représentées par des
colonnes classées par catégories.
o StackedBarChart - un graphique contenant des séries de valeur représentées par
des colonnes classées par catégories et superposées les unes sur les autres.
Il est également possible de créer de nouveaux types de graphiques à partir des classes de base
présentes dans l'API.
Note : les graphiques de cette API sont des agencements complexes de nœuds vectoriels. De plus,
ils sont souvent animés et peuvent mettre à jour immédiatement leur contenu en cas de modification
des séries ou des données qu'elles contiennent via un ensemble complexe d’écouteurs. Ils
contiennent donc généralement beaucoup de sous-nœuds et sont gourmands en mémoire.
Mis à jour le 18 septembre 2014 bouye
Comment créer un graphique en camembert ?
Pour créer un graphique en camembert, vous devez initialiser une instance de PieChart. Pour
peupler ce graphique, vous devez peupler sa liste observable data avec des éléments de
type [Link] contenant les valeurs à afficher.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création du graphique.
6 final PieChart chart = new PieChart();
7 [Link]("Stock de fruits");
8 [Link]().setAll(new [Link]("Pommes",
9 50), new [Link]("Oranges", 30),
10 new [Link]("Poires", 25), new
11 [Link]("Pêches", 42),
12 new [Link]("Citrons", 5), new
13 [Link]("Kiwis", 19)
14 );
15 // Montage de l'IU.
16 final StackPane root = new StackPane();
17 [Link]().add(chart);
18 final Scene scene = new Scene(root, 300, 250);
19 [Link]("Test de PieChart");
20 [Link](scene);
21 [Link]();
22 }
23
24 public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 18 septembre 2014 bouye
Comment créer un graphique avec des lignes ?
Pour créer un graphique avec des lignes, vous devez instancier un objet de type [b]LineChart[/b.
Vous devez tout d'abord créer des objets de type [Link] que vous allez peupler avec des
instances de [Link] qui contiendront les valeurs à afficher. Ces séries doivent être placées
dans la liste observable data du graphique.
Il faudra également créer deux axes qui héritent de la classe Axis. Chaque axe contient les bornes
minimale et maximale de la plage de valeurs affichables pour leur dimension respective ainsi que le
label à afficher sur cette dimension.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création des séries.
6 final List<[Link]> seriesList = new
7 LinkedList<>();
8 final int maxN = 3;
9 final int minX = 0;
10 final int maxX = 5;
11 double minY = Double.MAX_VALUE;
12 double maxY = -Double.MAX_VALUE;
13 for (int n = 0 ; n <= maxN ; n++) {
14 final [Link] series = new
15 [Link]<>();
16 [Link]([Link]("n = %d", n));
17 for (int x = minX ; x <= maxX ; x++) {
18 final double value = [Link](x, n);
19 minY = [Link](minY, value);
20 maxY = [Link](maxY, value);
21 final [Link] data = new
22 [Link](x, value);
23 [Link]().add(data);
24 }
25 [Link](series);
26 }
27
// Création du graphique.
28
final NumberAxis xAxis = new NumberAxis(minX, maxX,
29
1);
30
[Link]("x");
31
final NumberAxis yAxis = new NumberAxis(minY, maxY,
32
50);
33
[Link]("y = [Link](x, n)");
34
35 final LineChart chart = new LineChart(xAxis, yAxis);
36 [Link]("Fonction puissance");
37 [Link]().setAll(seriesList);
38 // Montage de l'IU.
39 final StackPane root = new StackPane();
40 [Link]().add(chart);
41 final Scene scene = new Scene(root, 300, 250);
42 [Link]("Test de LineChart");
43 [Link](scene);
44 [Link]();
}
public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 19 septembre 2014 bouye
Comment créer un histogramme ?
Pour créer un histogramme, vous devez instancier un objet de type BarChart. Vous devez tout
d'abord créer des objets de type [Link] que vous allez peupler avec des instances
de [Link] qui contiendront les valeurs à afficher. Ces séries doivent être placées dans la
liste observable data du graphique.
Il faudra également créer deux axes qui héritent de la classe Axis. Un de ces deux axes doit être
obligatoirement de type CategoryAxis et contenir la liste des catégories affichables. Dans
un BarChart, les catégories sont représentées par une liste de chaines de caractères. La position de
cet axe sur l'histogramme détermine si ce dernier est affiché à la verticale ou à l'horizontale.
L'autre axe contient les bornes minimale et maximale de la plage de valeurs affichables. Chaque axe
contient le label à afficher sur cette dimension.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création des séries.
6 final List<[Link]> seriesList = new
7 LinkedList<>();
8 final String[] categoriesNames = {"2012", "2013",
9 "2014"};
10 final String[] seriesNames = {"US", "Royaume-Uni",
11 "France", "Allemagne"};
12 final int[][] allValues = {
13 {50, 25, 32},
14 {80, 90, 88},
15 {24, 75, 79},
16 {15, 23, 2},};
17 final double minY = 0;
18
19 double maxY = -Double.MAX_VALUE;
20 for (int seriesIndex = 0; seriesIndex <
21 [Link]; seriesIndex++) {
22 final [Link] series = new
23 [Link]<>();
24 [Link](seriesNames[seriesIndex]);
25 final int[] values = allValues[seriesIndex];
26 for (int categoryIndex = 0; categoryIndex <
27 [Link]; categoryIndex++) {
28 final int value = values[categoryIndex];
29 final String category =
30 categoriesNames[categoryIndex];
31 maxY = [Link](maxY, value);
32 final [Link] data = new
33 [Link](category, value);
34 [Link]().add(data);
35 }
36 [Link](series);
37 }
38 // Création du graphique.
39 final CategoryAxis xAxis = new CategoryAxis();
40 [Link]().setAll(categoriesNames);
41 [Link]("Années");
42 final NumberAxis yAxis = new NumberAxis(minY, maxY,
43
50);
44
[Link]("Volumes");
45
final BarChart chart = new BarChart(xAxis, yAxis);
46
[Link]("Exportations");
47
[Link]().setAll(seriesList);
48
// Montage de l'IU.
49
final StackPane root = new StackPane();
50
[Link]().add(chart);
final Scene scene = new Scene(root, 300, 250);
[Link]("Test de BarChart");
[Link](scene);
[Link]();
}
public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 19 septembre 2014 bouye
Comment créer un histogramme empilé ?
Pour créer un histogramme empilé, vous devez instancier un objet de type StackedBarChart. Vous
devez tout d'abord créer des objets de type [Link] que vous allez peupler avec
des instances de [Link] qui contiendront les valeurs à afficher. Ces séries doivent
être placées dans la liste observable data du graphique.
Il faudra également créer deux axes qui héritent de la classe Axis. Un de ces deux axes doit être
obligatoirement de type CategoryAxis et contenir la liste des catégories affichables. Dans
un StackedBarChart, les catégories sont représentées par une liste de chaines de caractères. La
position de cet axe sur l'histogramme détermine si ce dernier est affiché à la verticale ou à
l'horizontale.
L'autre axe contient les bornes minimale et maximale de la plage de valeurs affichables. Chaque axe
contient le label à afficher sur cette dimension.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création des séries.
6 final List<[Link]> seriesList = new
7 LinkedList<>();
8 final String[] categoriesNames = {"2012", "2013",
9 "2014"};
10 final String[] seriesNames = {"US", "Royaume-Uni",
11 "France", "Allemagne"};
12 final int[][] allValues = {
13 {50, 25, 32},
14 {80, 90, 88},
15 {24, 75, 79},
16 {15, 23, 2},};
17
18 for (int seriesIndex = 0; seriesIndex <
19 [Link]; seriesIndex++) {
20 final [Link] series = new
21 [Link]<>();
22 [Link](seriesNames[seriesIndex]);
23 final int[] values = allValues[seriesIndex];
24 for (int categoryIndex = 0; categoryIndex <
25 [Link]; categoryIndex++) {
26 final int value = values[categoryIndex];
27 final String category =
28 categoriesNames[categoryIndex];
29 final [Link] data = new
30 [Link](category, value);
31 [Link]().add(data);
32 }
33 [Link](series);
34 }
35 // Création du graphique.
36 final CategoryAxis xAxis = new CategoryAxis();
37 [Link]().setAll(categoriesNames);
38 [Link]("Années");
39 final NumberAxis yAxis = new NumberAxis();
40 [Link]("Volumes");
41 [Link](true);
42
[Link](true);
43
final StackedBarChart chart = new
44
StackedBarChart(xAxis, yAxis);
45
[Link]("Exportations");
46
[Link]().setAll(seriesList);
47
// Montage de l'IU.
48
final StackPane root = new StackPane();
49
[Link]().add(chart);
final Scene scene = new Scene(root, 300, 250);
[Link]("Test de StackedBarChart");
[Link](scene);
[Link]();
}
public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 19 septembre 2014 bouye
Comment créer un graphique avec des aires ?
Pour créer un graphique avec des aires, vous devez instancier un objet de type [b]AreaChart[/b.
Vous devez tout d'abord créer des objets de type [Link] que vous allez peupler avec des
instances de [Link] qui contiendront les valeurs à afficher. Ces séries doivent être placées
dans la liste observable data du graphique.
Il faudra également créer deux axes qui héritent de la classe Axis. Chaque axe contient les bornes
minimale et maximale de la plage de valeurs affichables pour leur dimension respective ainsi que le
label à afficher sur cette dimension.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création des séries.
6 final List<[Link]> seriesList = new
7 LinkedList<>();
8 final String[] seriesNames = {"Perches", "Brochets",
9 "Truites"};
10 final int[] years = {2011, 2012, 2013, 2014};
11 final int[][] allValues = {
12 {15, 20, 19, 22},
13 {26, 24, 8, 7},
14 {5, 0, 8, 12},};
15 for (int seriesIndex = 0; seriesIndex <
16 [Link]; seriesIndex++) {
17 final [Link] series = new
18 [Link]<>();
19 [Link](seriesNames[seriesIndex]);
20 final int[] values = allValues[seriesIndex];
21 for (int yearIndex = 0; yearIndex < [Link];
22 yearIndex++) {
23 final int year = years[yearIndex];
24 final double value = values[yearIndex];
25 final [Link] data = new
26 [Link](year, value);
27 [Link]().add(data);
28 }
29 [Link](series);
30 }
31 // Création du graphique.
32 final NumberAxis xAxis = new NumberAxis();
33 [Link]("Années");
34 [Link](false);
35 [Link](years[0]);
36 [Link](years[[Link]-1]);
37 [Link](1);
38 final NumberAxis yAxis = new NumberAxis();
39 [Link]("Individus");
40 [Link](true);
41 [Link](true);
42 final AreaChart chart = new AreaChart(xAxis, yAxis);
43 [Link]("Population observée");
44 [Link]().setAll(seriesList);
45
// Montage de l'IU.
46
final StackPane root = new StackPane();
47
[Link]().add(chart);
48
final Scene scene = new Scene(root, 300, 250);
49
[Link]("Test de AreaChart");
50
[Link](scene);
51
[Link]();
}
public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 19 septembre 2014 bouye
Comment créer un graphique avec des aires empilées ?
Pour créer un graphique avec des aires empilées, vous devez instancier un objet de type
[b]StackedAreaChart[/b. Vous devez tout d'abord créer des objets de
type [Link] que vous allez peupler avec des instances
de [Link] qui contiendront les valeurs à afficher. Ces séries doivent être placées
dans la liste observable data du graphique.
Il faudra également créer deux axes qui héritent de la classe Axis. Chaque axe contient les bornes
minimale et maximale de la plage de valeurs affichables pour leur dimension respective ainsi que le
label à afficher sur cette dimension.
Par exemple :
Code Java : Sélectionner tout
1 public class Main extends Application {
2
3 @Override
4 public void start(Stage primaryStage) {
5 // Création des séries.
6 final List<[Link]> seriesList = new
7 LinkedList<>();
8 final String[] seriesNames = {"Perches", "Brochets",
9 "Truites"};
10 final int[] years = {2011, 2012, 2013, 2014};
11 final int[][] allValues = {
12 {15, 20, 19, 22},
13 {26, 24, 8, 7},
14 {5, 0, 8, 12},};
15 for (int seriesIndex = 0; seriesIndex <
16 [Link]; seriesIndex++) {
17 final [Link] series = new
18 [Link]<>();
19 [Link](seriesNames[seriesIndex]);
20 final int[] values = allValues[seriesIndex];
21 for (int yearIndex = 0; yearIndex < [Link];
22 yearIndex++) {
23 final int year = years[yearIndex];
24 final double value = values[yearIndex];
25 final [Link] data = new
26 [Link](year, value);
27 [Link]().add(data);
28 }
29 [Link](series);
30 }
31 // Création du graphique.
32 final NumberAxis xAxis = new NumberAxis();
33 [Link]("Années");
34 [Link](false);
35 [Link](years[0]);
36 [Link](years[[Link]-1]);
37 [Link](1);
38 final NumberAxis yAxis = new NumberAxis();
39 [Link]("Individus");
40 [Link](true);
41 [Link](true);
42 final StackedAreaChart chart = new
43 StackedAreaChart(xAxis, yAxis);
44
[Link]("Population observée");
45
[Link]().setAll(seriesList);
46
// Montage de l'IU.
47
final StackPane root = new StackPane();
48
[Link]().add(chart);
49
final Scene scene = new Scene(root, 300, 250);
50
[Link]("Test de StackedAreaChart");
51
[Link](scene);
[Link]();
}
public static void main(String[] args) {
launch(args);
}
}
Ce qui nous donne :
Mis à jour le 19 septembre 2014 bouye
Comment spécifier le titre du graphique ?
Pour spécifier le titre du graphique, vous devez modifier la valeur de sa propriété title.
Par exemple :
Code Java : Sélectionner tout
[Link]("Mon graphique");
Mis à jour le 19 septembre 2014 bouye
Comment changer la position du titre du graphique ?
Pour changer la position du titre du graphique, vous devez modifier la valeur de sa
propriété titleSide en lui donnant une valeur de type [Link].
Par exemple :
Code Java : Sélectionner tout
[Link]([Link]);
Ici, le titre sera placé sur le bord droit du graphique.
Note : changer cette propriété ne modifie pas l'orientation du texte.
Mis à jour le 19 septembre 2014 bouye
Comment cacher la légende du graphique ?
Pour cacher la légende du graphique, vous devez modifier la valeur de sa propriété legendVisible et
la mettre à la valeur false.
Par exemple :
Code Java : Sélectionner tout
[Link](false);
Mis à jour le 19 septembre 2014 bouye
Comment changer la position de la légende du graphique ?
Pour changer la position de la légende du graphique, vous devez modifier sa
propriété legendSide en lui donnant une valeur de type [Link].
Par exemple :
Code Java : Sélectionner tout
[Link]([Link])
Ici, la légende sera placée sur le bord gauche du graphique.
Note : le graphique peut décider de ne pas afficher la légende, s'il n'y a pas assez d'espace pour
l'inclure à sa nouvelle position.
Mis à jour le 19 septembre 2014 bouye
Comment spécifier le label sur un axe ?
Pour spécifier le label sur un axe, vous devez modifier la valeur de sa propriété label. Cela aura pour
effet de changer la chaine de caractères affichée le long de cet axe à l’écran.
Par exemple :
Code Java : Sélectionner tout
[Link]("Dates");
Mis à jour le 19 septembre 2014 bouye
Comment changer les bornes d'affichage sur un axe numérique ?
Si un de vos axes hérite de la classe ValueAxis (c'est le cas de la classe NumberAxis), il vous suffit
de modifier les valeurs de ses propriétés lowerBound ou upperBound pour modifier les bornes
minimale et maximale de cet axe. Cela aura pour impact d'afficher plus ou moins de données
provenant des séries de votre graphique.
Par exemple :
Code Java : Sélectionner tout
1 [Link](10);
2 [Link](20);
Note : si les propriétés autoRanging ou forceZeroInRange sont actives sur l'axe, il est possible que
les bornes finales ne soient pas celles que vous ayez spécifiées dans le code, car l'axe les modifiera
à nouveau avant de s'afficher.