Kata FizzBuzz avec flux Java
Après seulement quelques semaines de pratique du judo, mon fils s'est ennuyé. Il s'est plaint de ne rien apprendre, parce qu'il continuait à faire la même chose encore et encore.
Il n'y a pas que les jeunes enfants qui confondent apprendre et faire de nouvelles choses. Par exemple, combien de développeurs de logiciels se donnent la peine de s'entraîner délibérément en exécutant des katas ou en fréquentant des dojos ?
Il peut sembler idiot de répéter des exercices que vous avez déjà fait plusieurs fois, mais ce n'est pas le cas. C'est la seule façon de devenir une ceinture noire dans votre domaine. Et rappelez-vous que la maîtrise est l'un des trois motivateurs intrinsèques (les autres étant l'autonomie et le but).
Pratiquer signifie ralentir et déplacer l'attention du résultat vers le processus. Il est préférable d'utiliser des exercices simples que vous pouvez effectuer en un temps limité, afin de pouvoir refaire le même exercice plusieurs fois.
J'ai découvert que j'apprends pratiquement toujours quelque chose de nouveau lorsque je pratique. Ce n'est pas parce que j'ai oublié comment résoudre le problème depuis la dernière fois, mais parce que j'ai appris de nouvelles choses depuis et donc voir le monde avec de nouveaux yeux.
Par exemple, depuis la sortie de Java 8, j'ai essayé d'utiliser les nouvelles classes de flux pour passer à un style de programmation plus fonctionnel. Cela a changé ma façon de voir les vieux problèmes, comme FizzBuzz.
Voyons cela en action. Bien sûr, je commence par ajouter un test :
+ package remonsinnema.blog.fizzbuzz;
+
+ import static org.junit.Assert.assertEquals;
+
+ import org.junit.Test;
+
+
+ public class WhenFizzingAndBuzzing {
+
+ private final FizzBuzz fizzbuzz = new FizzBuzz();
+
+ @Test
+ public void shouldReplaceWithFizzAndBuzz() {
+ assertEquals(“1”, “1”, fizzbuzz.get(1));
+ }
+
+ } Ce test utilise la forme de test unitaire When…Should qui permet de se concentrer sur le comportement plutôt que sur les détails de mise en œuvre. Je laisse Eclipse générer le code requis pour effectuer cette compilation :
+ package remonsinnema.blog.fizzbuzz;
+
+
+ public class FizzBuzz {
+
+ public String get(int i) {
+ return null;
+ }
+
+ } Le code le plus simple pour réussir le test est de le simuler :
package remonsinnema.blog.fizzbuzz;
public class FizzBuzz {
public String get(int i) {
– return null;
+ return “1”;
}
} Maintenant que le test a réussi, il est temps de refactoriser. Je supprime la duplication du test :
public class WhenFizzingAndBuzzing {
@Test
public void shouldReplaceWithFizzAndBuzz() {
– assertEquals(“1”, “1”, fizzbuzz.get(1));
+ assertFizzBuzz(“1”, 1);
+ }
+
+ private void assertFizzBuzz(String expected, int n) {
+ assertEquals(Integer.toString(n), expected, fizzbuzz.get(n));
}
} Ensuite, j'ajoute un test pour forcer l'implémentation réelle :
public class WhenFizzingAndBuzzing {
@Test
public void shouldReplaceWithFizzAndBuzz() {
assertFizzBuzz(“1”, 1);
+ assertFizzBuzz(“2”, 2);
}
private void assertFizzBuzz(String expected, int n) {
package remonsinnema.blog.fizzbuzz;
public class FizzBuzz {
– public String get(int i) {
– return “1”;
+ public String get(int n) {
+ return Integer.toString(n);
}
} OK, maintenant passons aux choses sérieuses avec un test pour Fizz :
public class WhenFizzingAndBuzzing {
public void shouldReplaceWithFizzAndBuzz() {
assertFizzBuzz(“1”, 1);
assertFizzBuzz(“2”, 2);
+ assertFizzBuzz(“Fizz”, 3);
}
private void assertFizzBuzz(String expected, int n) {
package remonsinnema.blog.fizzbuzz;
public class FizzBuzz {
public String get(int n) {
+ if (n == 3) {
+ return “Fizz”;
+ }
return Integer.toString(n);
} Similaire pour Buzz :
public class WhenFizzingAndBuzzing {
assertFizzBuzz(“Fizz”, 3);
+ assertFizzBuzz(“4”, 4);
+ assertFizzBuzz(“Buzz”, 5);
}
private void assertFizzBuzz(String expected, int n) {
public class FizzBuzz {
if (n == 3) {
return “Fizz”;
}
+ if (n == 5) {
+ return “Buzz”;
+ }
return Integer.toString(n);
}
Ici, je viens de copier et coller le if déclaration pour le faire fonctionner rapidement . Il ne faut pas s'arrêter là, bien sûr, mais se débarrasser du sale des trucs. Dans ce cas, c'est un doublon.
Tout d'abord, mettons à jour le code pour rendre la duplication plus apparente :
package remonsinnema.blog.fizzbuzz;
public class FizzBuzz {
public String get(int n) {
– if (n == 3) {
– return “Fizz”;
+ MultipleReplacer replacer = new MultipleReplacer(3, “Fizz”);
+ if (n == replacer.getValue()) {
+ return replacer.getText();
}
– if (n == 5) {
– return “Buzz”;
+ replacer = new MultipleReplacer(5, “Buzz”);
+ if (n == replacer.getValue()) {
+ return replacer.getText();
}
return Integer.toString(n);
} + package remonsinnema.blog.fizzbuzz;
+
+
+ public class MultipleReplacer {
+
+ private final int value;
+ private final String text;
+
+ public MultipleReplacer(int value, String text) {
+ this.value = value;
+ this.text = text;
+ }
+
+ public int getValue() {
+ return value;
+ }
+
+ public String getText() {
+ return text;
+ }
+
+ } Je viens de créer un nouvel objet de valeur pour contenir les deux valeurs que j'ai dû modifier après le copier/coller.
Maintenant que la duplication est plus claire, elle est facile à supprimer :
package remonsinnema.blog.fizzbuzz;
+ import java.util.Arrays;
+ import java.util.Collection;
+
public class FizzBuzz {
+ private final Collection replacers = Arrays.asList(
+ new MultipleReplacer(3, “Fizz”), new MultipleReplacer(5, “Buzz”));
+
public String get(int n) {
– MultipleReplacer replacer = new MultipleReplacer(3, “Fizz”);
– if (n == replacer.getValue()) {
– return replacer.getText();
– }
– replacer = new MultipleReplacer(5, “Buzz”);
– if (n == replacer.getValue()) {
– return replacer.getText();
+ for (MultipleReplacer replacer : replacers) {
+ if (n == replacer.getValue()) {
+ return replacer.getText();
+ }
}
return Integer.toString(n);
} Cependant, je n'ai pas fini de nettoyer. Le code actuel souffre d'envie de fonctionnalités, que je résous en déplaçant le comportement dans l'objet de valeur :
package remonsinnema.blog.fizzbuzz;
import java.util.Arrays;
import java.util.Collection;
+ import java.util.Optional;
public class FizzBuzz {
public String get(int n) {
for (MultipleReplacer replacer : replacers) {
– if (n == replacer.getValue()) {
– return replacer.getText();
+ Optional result = replacer.textFor(n);
+ if (result.isPresent()) {
+ return result.get();
}
}
return Integer.toString(n); package remonsinnema.blog.fizzbuzz;
+ import java.util.Optional;
+
public class MultipleReplacer {
this.text = text;
}
– public int getValue() {
– return value;
– }
–
– public String getText() {
– return text;
+ public Optional<String> textFor(int n) {
+ if (n == value) {
+ return Optional.of(text);
+ }
+ return Optional.empty();
}
} Maintenant que j'ai terminé la refactorisation, je peux continuer avec des multiples :
public class WhenFizzingAndBuzzing {
assertFizzBuzz(“Fizz”, 3);
assertFizzBuzz(“4”, 4);
assertFizzBuzz(“Buzz”, 5);
+ assertFizzBuzz(“Fizz”, 6);
}
private void assertFizzBuzz(String expected, int n) {
public class MultipleReplacer {
}
public Optional<String> textFor(int n) {
– if (n == value) {
+ if (n % value == 0) {
return Optional.of(text);
}
return Optional.empty(); Le test final est pour "Fizz" et "Buzz" simultanés :
public class WhenFizzingAndBuzzing {
assertFizzBuzz(“4”, 4);
assertFizzBuzz(“Buzz”, 5);
assertFizzBuzz(“Fizz”, 6);
+ assertFizzBuzz(“7”, 7);
+ assertFizzBuzz(“8”, 8);
+ assertFizzBuzz(“Fizz”, 9);
+ assertFizzBuzz(“Buzz”, 10);
+ assertFizzBuzz(“11”, 11);
+ assertFizzBuzz(“Fizz”, 12);
+ assertFizzBuzz(“13”, 13);
+ assertFizzBuzz(“14”, 14);
+ assertFizzBuzz(“FizzBuzz”, 15);
}
private void assertFizzBuzz(String expected, int n) { public class FizzBuzz {
public class FizzBuzz {
new MultipleReplacer(3, “Fizz”), new MultipleReplacer(5, “Buzz”));
public String get(int n) {
+ StringBuilder result = new StringBuilder();
for (MultipleReplacer replacer : replacers) {
– Optional<String> result = replacer.textFor(n);
– if (result.isPresent()) {
– return result.get();
+ Optional<String> replacement = replacer.textFor(n);
+ if (replacement.isPresent()) {
+ result.append(replacement.get());
}
}
+ if (result.length() > 0) {
+ return result.toString();
+ }
return Integer.toString(n);
}
} Ce code est plutôt complexe, mais c'est là que les flux viennent à la rescousse :
public class FizzBuzz {
new MultipleReplacer(3, “Fizz”), new MultipleReplacer(5, “Buzz”));
public String get(int n) {
– StringBuilder result = new StringBuilder();
– for (MultipleReplacer replacer : replacers) {
– Optional<String> replacement = replacer.textFor(n);
– if (replacement.isPresent()) {
– result.append(replacement.get());
– }
– }
– if (result.length() > 0) {
– return result.toString();
– }
– return Integer.toString(n);
+ return replacers.stream()
+ .map(replacer -> replacer.textFor(n))
+ .filter(Optional::isPresent)
+ .map(optional -> optional.get())
+ .reduce((a, b) -> a + b)
+ .orElse(Integer.toString(n));
}
}
Notez comment le for et if les déclarations disparaissent. Plutôt que d'expliquer comment quelque chose doit être fait, nous disons quoi nous voulons atteindre.
On peut appliquer la même astuce pour se débarrasser des if restants déclaration dans notre base d'ode :
public class MultipleReplacer {
}
public Optional<String> textFor(int n) {
– if (n % value == 0) {
– return Optional.of(text);
– }
– return Optional.empty();
+ return Optional.of(text)
+ .filter(ignored -> n % value == 0);
}
}
Le code est sur GitHub.
