Petit amusement programmatique avec Google Collections (1)

Google Collections est une bibliothèque fort sympathique et bien utile. Ce billet de Benjamin Wintenberg et celui-ci sur le Jayway Team Blog en présente plus en détail que le mien ce qu'offre cette nouvelle bibliothèque de Google .

Mon objectif est plus ici de m'amuser un peu avec Google Collections sur un petit cas concret. En l'occurrence ici le problème 1 du Projet Euler.
Il s'agit ici de déterminer la somme de tous les entiers naturels strictement inférieurs à 1000 qui sont multiples de 3 ou de 5.

La classe principale qui implémente une solution possible avec utilisation de l'API Google Collections :


La classe de tests (JUnit4) associée :


Regardons tout cela d'un peu plus près. La partie vraiment intéressante est la méthode solve.

Cette méthode comme son nom l'indique résout notre problème.
On crée d'abord une liste des nombres entiers de 0 à 999. Le "Lists.newArrayList();" vient de Google Collections. C'est plutôt explicite, la méthode statique newArrayList me retourne une instance de ArrayList (ici une ArrayList) que l'on se contente ensuite d'initialiser avec les nombres de 0 à 999.
Puis on crée une nouvelle liste à partir de la première liste. On utilise toujours Lists.newArrayList mais cette fois-ci avec en paramètre un Iterable. Ce paramètre Iterable correspondra concrètement à notre liste précédente filtrée pour ne garder que les multiples de 3 ou de 5. Pour se faire on utilise la méthode statique filter de la classe Iterables disponible dans Google Collection. Cette méthode filter prend en paramètre la liste à filtrer et un objet implémentant l'interface Predicat matérialisée ici par l'instanciation d'une classe anonyme implémentant une méthode apply. Cette méthode apply doit retourner un booléen et sera appliquée sur chaque élément de la liste passée en paramètre de la méthode filter : tous les éléments pour lesquels la méthode apply retournera false seront filtrés. Une fois que l'on a la liste filtrée, c'est fini. Il n'y a plus qu'à faire la somme des éléments pour trouver le résultat.

Voilà, rien de bien extraordinaire, c'est certain. L'intérêt est ici de voir un petit exemple d'utilisation de l'API Google Collections (qui - je vous rassure - propose bien d'autres choses) et les possibilités de pouvoir avoir une approche fonctionnelle en Java. D'ailleurs puisque l'on parle d'approche fonctionnelle en Java, un billet sur le blog de Xebia à propos de la sortie de Google Collections en finale 1.0 renvoyait vers 2 projets qui concernent une approche fonctionnelle en Java : Lambdaj et Functional Java. Avis aux amateurs !

Un échiquier en JavaFX

Dans ce billet, un petit programme en JavaFX qui dessine en un échiquier. Ce petit programme était l'occasion de s'essayer à utiliser un CustomNode (qui ici correspondra à l'échiquier). Et quand il y a quelques années j'enseignais la programmation en Java, le dessin d'un échiquier était un des premiers TP que je donnais aux étudiants quand nous abordions AWT/Swing, parce que c'est simple à mettre en oeuvre.

Ci-après la copie d'écran du programme :



Ce programme est composé de 2 fichiers : ChessBoardNode.fx qui contient la classe ChessBoardNode qui étend la classe CustomNode et Main.fx qui contient notre Stage et utilise le ChessBoardNode.

Tout d'abord ChessBoardNode.fx :

Tout ceci est assez simple, mais revenons sur quelques points :
- La classe CustomNode est une classe abstraite et il faut redéfinir la fonction "create" ; attention en JavaFX quand on redéfinit il faut utiliser le mot clé override.
Cette fonction create est un peu comme la méthode paint pour les composants graphiques en Java/Swing : en la redéfinissant on indique comment le composant doit être "peint". Cette méthode doit retourner un objet de type Node. Ici on créé plusieurs Rectangle (en fonction du nombre de lignes et du nombre de cases par ligne, valeurs définies dans les attributs) pour lesquels on alterne les couleurs parmi 2 et qui forment un Group, sous-classe de Node.

On remarquera qu'un certain nombre d'attributs ont été définis pour rendre l'échiquier plus facilement paramétrable.

Autre point, on notera ici l'utilisation du for et du if : il faut rappeler qu'en JavaFX, ce sont des expressions et qu'ils retournent un résultat.
A part cela, ce code ne pose pas de difficultés particulières.

Maintenant utilisons cette classe dans Main.fx :

On utilise directement un objet ChessBoardNode, en renseignant certains de ces attributs. On notera que l'abscisse et l'ordonnée de l'échiquier ne sont pas renseignées, pas plus d'ailleurs que la largeur ou la hauteur de la Scene ou du Stage : c'est JavaFX qui détermine tout cela en prenant les valeurs au plus juste.

Initialement, je voulais proposer une suite à ce billet sur JavaFX, en repartant de cet exemple et en l'améliorant un peu par la mise en oeuvre du "binding" de JavaFX pour obtenir simplement des petits effets sympathiques. Cependant je trouve que le format "billet de blog" n'est pas toujours idéal pour faire un texte comportant du code.

Entretemps j'ai donc créé un petit site sur Google Sites, dans lequel je reprends et complète ce billet.

Une cardioïde en JavaFX (bis)

Quand en 2007 j'avais regardé pour la première fois JavaFX, j'avais fait un petit programme qui affichait une cardioïde.

Entre temps, JavaFX a changé (moi aussi d'ailleurs mais c'est une autre histoire :-P) et comme je suis en train de m'essayer à nouveau à JavaFX, voici une nouvelle version d'un dessin de cardioïde avec JavaFX.


Cela donne cela :


Rien de bien extraordinaire dans le code. Le Slider permet de modifier la taille du cardioïde. Sont utilisés ici les capacités de binding de JavaFX (entre le paramètre rho de la courbe paramétrique et la valeur sélectionnée par le Slider ; pour plus d'information sur la cardioïde voir http://fr.wikipedia.org/wiki/Cardio%C3%AFde).

La fonction generatePath retourne une séquence de coordonnées x et y correspondant à la cardioïde par rapport à la valeur du paramètre rho. Cette séquence de coordonnées est utilisée par la Polyline.

Une cardioïde en JavaFX

Ci-après, un premier petit essai en JavaFX qui a pour objectif de dessiner une cardioïde...
Je doute que le code que j'ai réalisé soit optimisé ou respecte les bonnes pratiques du codage en JavaFX.

Pour faire ce petit programme, j'ai utilisé Netbeans comme il le conseil dans ce tutoriel... je sais c'est un peu lourd pour un petit programme comme cela mais je n'avais pas envie de me prendre la tête et j'utilise déjà Netbeans pour une bonne partie de mes développements Java "personnels" (sinon, c'est comme au bureau j'utilise Eclipse/RSA). D'ailleurs il existe un plugin Eclipse pour JavaFX.

Une petit explication du principe du programme : je génère un tableau de points dont les coordonnées suivent l'équation paramètrique de la cardioïde. Ce tableau de points est ensuite utilisé pour construire un objet Polyline.

J'avoue que pour l'instant je ne suis pas convaincu par JavaFX mais c'est peut-être parce que cela change mes habitudes de programmation.
Cela donne çà :



Je viens également de tomber sur ce tutoriel sur JavaFX (sur le réseau O'Reilly) mais je n'ai pas encore eu le temps de regarder de près.