Java中的功能性FizzBu​​zz Kata

最新推荐文章于 2024-09-15 19:46:31 发布
最新推荐文章于 2024-09-15 19:46:31 发布
阅读量88 收藏
点赞数
文章标签： java php stream lambda filter

不久前，我使用Java 8流和lambda解决了FizzBu​​zz kata问题。 尽管最终结果是可行的，但中间步骤却没有。 我当然可以做得更好。

与往常一样，让我们​​从失败的测试开始： 

package remonsinnema.blog.fizzbuzz;
+
+ import static org.junit.Assert.assertEquals;
+
+ import org.junit.Test;
+
+
+ public class WhenFunctionallyFuzzingAndBuzzing {
+
+   private final FizzBuzzer fizzBuzzer = new FizzBuzzer();
+
+   @Test
+   public void shouldReplaceMultiplesOfThreeWithFizzAndMultiplesOfFiveWithBuzz() {
+     assertEquals(“1”, “1”, fizzBuzzer.apply(1));
+   }
+
+ }
package remonsinnema.blog.fizzbuzz;
+
+ import java.util.function.Function;
+
+
+ public class FizzBuzzer implements Function<Integer, String> {
+
+   @Override
+   public String apply(Integer n) {
+     return null;
+   }
+
+ }

请注意，我马上就开始使用Java的Function进行功能课程。

我伪造实现以使测试通过： 

public class FizzBuzzer implements Function<Integer, String> {
    @Override
    public String apply(Integer n) {
–     return null;
+     return “1”;
    }
  }

并重构测试以消除重复： 

public class WhenFunctionallyFuzzingAndBuzzing {
    @Test
    public void shouldReplaceMultiplesOfThreeWithFizzAndMultiplesOfFiveWithBuzz() {
–     assertEquals(“1”, “1”, fizzBuzzer.apply(1));
+     assertFizzBuzz(“1”, 1);
+   }
+
+   private void assertFizzBuzz(String expected, int value) {
+     assertEquals(Integer.toString(value), expected, fizzBuzzer.apply(value));
    }
  }

然后，我添加另一个测试以概括实现： 

public class WhenFunctionallyFuzzingAndBuzzing {
    @Test
    public void shouldReplaceMultiplesOfThreeWithFizzAndMultiplesOfFiveWithBuzz() {
      assertFizzBuzz(“1”, 1);
+     assertFizzBuzz(“2”, 2);
    }
    private void assertFizzBuzz(String expected, int value) {
  public class FizzBuzzer implements Function<Integer, String> {
    @Override
    public String apply(Integer n) {
–     return “1”;
+     return Integer.toString(n);
    }
  }

好的，到目前为止，非常标准的东西。 接下来，我需要将3替换为“ Fizz”： 

public class WhenFunctionallyFuzzingAndBuzzing {
    public void shouldReplaceMultiplesOfThreeWithFizzAndMultiplesOfFiveWithBuzz() {
      assertFizzBuzz(“1”, 1);
      assertFizzBuzz(“2”, 2);
+     assertFizzBuzz(“Fizz”, 3);
    }
  nbsp;
    private void assertFizzBuzz(String expected, int value) {
  public class FizzBuzzer implements Function<Integer, String> {
    @Override
    public String apply(Integer n) {
–     return Integer.toString(n);
+     return numberReplacerFor(n).apply(n);
+   }
+
+   private Function<Integer, String> numberReplacerFor(Integer n) {
+     return n == 3
+         ? i -> “Fizz”
+         : i -> Integer.toString(i);
    }
  }

在这里，我认识到我需要根据输入应用两个函数之一。 该代码有效，但需要进行一些清理。 首先，作为垫脚石，我将lambda提取到各个字段中： 

import java.util.function.Function;
  public class FizzBuzzer implements Function<Integer, String> {
+   private final Function<Integer, String> replaceNumberWithStringRepresentation
+       = n -> Integer.toString(n);
+   private final Function<Integer, String> replaceNumberWithFizz
+       = n -> “Fizz”;
+
    @Override
    public String apply(Integer n) {
      return numberReplacerFor(n).apply(n);
    private Function<Integer, String> numberReplacerFor(Integer n) {
      return n == 3
–         ? i -> “Fizz”
–         : i -> Integer.toString(i);
+         ? replaceNumberWithFizz
+         : replaceNumberWithStringRepresentation;
    }
  }

接下来，我强​​调通过提取一个类将“ 3”和“ Fizz”结合在一起： 

public class FizzBuzzer implements Function<Integer, String> {
    private final Function<Integer, String> replaceNumberWithStringRepresentation
        = n -> Integer.toString(n);
–   private final Function<Integer, String> replaceNumberWithFizz
–       = n -> “Fizz”;
+   private final Fizzer replaceNumberWithFizz = new Fizzer();
    @Override
    public String apply(Integer n) {
    }
    private Function<Integer, String> numberReplacerFor(Integer n) {
–     return n == 3
+     return replaceNumberWithFizz.test(n)
          ? replaceNumberWithFizz
          : replaceNumberWithStringRepresentation;
    }
+ package remonsinnema.blog.fizzbuzz;
+
+ import java.util.function.Function;
+ import java.util.function.Predicate;
+
+
+ public class Fizzer implements Function<Integer, String>, Predicate<Integer> {
+
+   @Override
+   public boolean test(Integer n) {
+     return n == 3;
+   }
+
+   @Override
+   public String apply(Integer n) {
+     return “Fizz”;
+   }
+
+ }

在这里，我使用标准的Java Predicate功能接口。

要添加“ Buzz”，我需要将代码从单个if （隐藏为三元运算符）推广到循环： 

public class WhenFunctionallyFuzzingAndBuzzing {
      assertFizzBuzz(“1”, 1);
      assertFizzBuzz(“2”, 2);
      assertFizzBuzz(“Fizz”, 3);
+     assertFizzBuzz(“4”, 4);
+     assertFizzBuzz(“Buzz”, 5);
    }
    private void assertFizzBuzz(String expected, int value) {
  package remonsinnema.blog.fizzbuzz;
+ import java.util.Arrays;
+ import java.util.Collection;
  import java.util.function.Function;
    private final Function<Integer, String> replaceNumberWithStringRepresentation
        = n -> Integer.toString(n);
–   private final Fizzer replaceNumberWithFizz = new Fizzer();
+   private final Collection<ReplaceNumberWithFixedText> replacers = Arrays.asList(
+       new ReplaceNumberWithFixedText(3, “Fizz”),
+       new ReplaceNumberWithFixedText(5, “Buzz”)
+   );
    @Override
    public String apply(Integer n) {
    }
    private Function<Integer, String> numberReplacerFor(Integer n) {
–     return replaceNumberWithFizz.test(n)
–         ? replaceNumberWithFizz
–         : replaceNumberWithStringRepresentation;
+     for (ReplaceNumberWithFixedText replacer : replacers) {
+       if (replacer.test(n)) {
+         return replacer;
+       }
+     }
+     return replaceNumberWithStringRepresentation;
    }
  }
package remonsinnema.blog.fizzbuzz;
–
– import java.util.function.Function;
– import java.util.function.Predicate;
–
–
– public class Fizzer implements Function<Integer, String>, Predicate<Integer> {
–
–   @Override
–   public boolean test(Integer n) {
–     return n == 3;
–   }
–
–   @Override
–   public String apply(Integer n) {
–     return “Fizz”;
–   }
–
– }
package remonsinnema.blog.fizzbuzz;
+
+ import java.util.function.Function;
+ import java.util.function.Predicate;
+
+
+ public class ReplaceNumberWithFixedText implements Function<Integer, String>,
+     Predicate<Integer> {
+
+   private final int target;
+   private final String replacement;
+
+   public ReplaceNumberWithFixedText(int target, String replacement) {
+     this.target = target;
+     this.replacement = replacement;
+   }
+
+   @Override
+   public boolean test(Integer n) {
+     return n == target;
+   }
+
+   @Override
+   public String apply(Integer n) {
+     return replacement;
+   }
+
+ }

糟糕，旧习惯……那应该是一个循环而不是循环： 

import java.util.function.Function;
  public class FizzBuzzer implements Function<Integer, String> {
–   private final Function<Integer, String> replaceNumberWithStringRepresentation
+   private final Function<Integer, String> defaultReplacer
        = n -> Integer.toString(n);
    private final Collection<ReplaceNumberWithFixedText> replacers = Arrays.asList(
        new ReplaceNumberWithFixedText(3, “Fizz”),
    }
    private Function<Integer, String> numberReplacerFor(Integer n) {
–     for (ReplaceNumberWithFixedText replacer : replacers) {
–       if (replacer.test(n)) {
–         return replacer;
–       }
–     }
–     return replaceNumberWithStringRepresentation;
+     return replacers.stream()
+         .filter(replacer -> replacer.test(n))
+         .map(replacer -> (Function<Integer, String>) replacer)
+         .findFirst()
+         .orElse(defaultReplacer);
    }
  }

好多了。 下一个测试是用于倍数的： 

public class WhenFunctionallyFuzzingAndBuzzing {
      assertFizzBuzz(“Fizz”, 3);
      assertFizzBuzz(“4”, 4);
      assertFizzBuzz(“Buzz”, 5);
+     assertFizzBuzz(“Fizz”, 6);
    }
    private void assertFizzBuzz(String expected, int value) {
  public class FizzBuzzer implements Function<Integer, String> {
    private final Function<Integer, String> defaultReplacer
        = n -> Integer.toString(n);
–   private final Collection<ReplaceNumberWithFixedText> replacers = Arrays.asList(
–       new ReplaceNumberWithFixedText(3, “Fizz”),
–       new ReplaceNumberWithFixedText(5, “Buzz”)
+   private final Collection<ReplaceMultipleWithFixedText> replacers = Arrays.asList(
+       new ReplaceMultipleWithFixedText(3, “Fizz”),
+       new ReplaceMultipleWithFixedText(5, “Buzz”)
    );
    @Override
+ package remonsinnema.blog.fizzbuzz;
+
+ import java.util.function.Function;
+ import java.util.function.Predicate;
+
+
+ public class ReplaceNumberWithFixedText implements Function<Integer, String>,
+     Predicate<Integer> {
+
+   private final int target;
+   private final String replacement;
+
+   public ReplaceNumberWithFixedText(int target, String replacement) {
+     this.target = target;
+     this.replacement = replacement;
+   }
+
+   @Override
+   public boolean test(Integer n) {
+     return n % target == 0;
+   }
+
+   @Override
+   public String apply(Integer n) {
+     return replacement;
+   }
+
+ }
– package remonsinnema.blog.fizzbuzz;
–
– import java.util.function.Function;
– import java.util.function.Predicate;
–
–
– public class ReplaceNumberWithFixedText implements Function<Integer, String>, Predicate<Integer> {
–
–   private final int target;
–   private final String replacement;
–
–   public ReplaceNumberWithFixedText(int target, String replacement) {
–     this.target = target;
–     this.replacement = replacement;
–   }
–
–   @Override
–   public boolean test(Integer n) {
–     return n == target;
–   }
–
–   @Override
–   public String apply(Integer n) {
–     return replacement;
–   }
–
– }

最后一个测试是结合Fizz和Buzz： 

public class WhenFunctionallyFuzzingAndBuzzing {
      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 value) {
  package remonsinnema.blog.fizzbuzz;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.function.Function;
+ import java.util.stream.Collectors;
+ import java.util.stream.Stream;
  public class FizzBuzzer implements Function<Integer, String> {
    @Override
    public String apply(Integer n) {
–     return numberReplacerFor(n).apply(n);
+     return numberReplacersFor(n)
+         .map(function -> function.apply(n))
+         .collect(Collectors.joining());
    }
–   private Function<Integer, String> numberReplacerFor(Integer n) {
–     return replacers.stream()
+   private Stream<Function<Integer, String>> numberReplacersFor(Integer n) {
+     return Stream.of(replacers.stream()
          .filter(replacer -> replacer.test(n))
          .map(replacer -> (Function<Integer, String>) replacer)
          .findFirst()
–         .orElse(defaultReplacer);
+         .orElse(defaultReplacer));
    }
  }

我概括了单一Function到一个Stream的Function S，而我应用的map-reduce模式。 我本可以使用.reduce("", (a, b) -> a + b)类的东西来拼写Reduce的部分，但我认为Collectors.joining()更具表现力。

这还没有通过测试，因为我返回了单个函数的流。 该修复有些棘手，因为我需要知道是否找到了任何适用的替换器函数，并且您必须在不终止流的情况下才能做到这一点 。 所以我需要使用StreamSupport创建一个新的流： 

package remonsinnema.blog.fizzbuzz;
  import java.util.Arrays;
  import java.util.Collection;
+ import java.util.Iterator;
+ import java.util.Spliterators;
  import java.util.function.Function;
  import java.util.stream.Collectors;
  import java.util.stream.Stream;
+ import java.util.stream.StreamSupport;
  public class FizzBuzzer implements Function<Integer, String> {
    }
    private Stream<Function<Integer, String>> numberReplacersFor(Integer n) {
–     return Stream.of(replacers.stream()
+     Iterator<Function<Integer, String>> result = replacers.stream()
          .filter(replacer -> replacer.test(n))
          .map(replacer -> (Function<Integer, String>) replacer)
–         .findFirst()
–         .orElse(defaultReplacer));
+         .iterator();
+     return result.hasNext()
+         ? StreamSupport.stream(Spliterators.spliteratorUnknownSize(result, 0), false)
+         : Stream.of(defaultReplacer);
    }
  }

就是这样。 完整代码在GitHub上 。

我从这个小练习中学到了两个教训：

  1. Java附带了一堆功能接口，例如Function和Predicate ，可以很容易地与流结合以解决各种问题。
  2. 在功能世界中， if → while 转换成为if → stream的标准。

翻译自: https://www.javacodegeeks.com/2016/08/functional-fizzbuzz-kata-java.html

dnc8371
关注
java发版工具fizz,微服务最强开源API网关Fizz Gateway
weixin_34832150的博客
03-21 949
Fizz Gateway 1.1.1版本发布！支持更多方便的后台管理功能特性：(Java 语言中最好的API网关)1、禁止default网关分组的编辑删除；2、修改插件配置时同时向网关推送数据；3、限制插件名称唯一，网关分组、插件名称、增加appID字段长度限制；4、修复插件管理校验bug，插件表单定义可为空；5、增加路由管理详情字段必填标记；6、修复管理后台路由配置的app为空时, 授权插件无法...
Java实现FizzBuzz问题
cunane的博客
12-30 1454
参考：简单却又复杂的FizzBuzz面试编程问题 在CodingBat网站上偶然看到，觉得有点意思。简单来说，依次输出1~100之间的整数，是3的倍数就改为输出“FIzz”，是5的倍数就输出“Buzz”，是15的倍数就输出“FizzBuzz”。 自己先凭直觉写了个最笨的Java代码： public class FizzBuzz { /*判断x是否为3、5、15的倍数*/ public ...
LeetCode ---- Fizz Buzz (Java/Lua 实现)
wenniuwuren
10-20 2976
题目： Write a program that outputs the string representation of numbers from 1 to n. But for multiples of three it should output “Fizz” instead of the number and for the multiples of five outp
kata_Java中的功能性FizzBu​​zz Kata
最佳 Java 编程
06-26 149
kata 不久前，我使用Java 8流和lambda解决了FizzBu​​zz kata问题。 尽管最终结果是可行的，但中间步骤却没有。 我当然可以做得更好。 与往常一样，让我们​​从失败的测试开始： package remonsinnema.blog.fizzbuzz; + + import static org.junit.Assert.assertEquals; + + impor...
FizzBu​​zz Kata与Java流
最佳 Java 编程
06-03 65
在柔道练习仅几周之后，我的儿子感到无聊。 他抱怨说自己没有学任何东西，因为他一遍又一遍地做着同样的事情。 混淆学习和做新事物的不仅仅是幼儿。 例如，有多少软件开发人员通过执行kata或参加dojos来进行刻意练习的麻烦？ 重复您已经做过很多次的练习似乎很愚蠢，但事实并非如此。 这是在您的领域成为黑带的唯一方法。 并且请记住，精通是三个内在动机之一 （其他是自主性和目的性）。 练习...
kata_FizzBu​​zz Kata与Java流
最佳 Java 编程
06-25 71
kata 在柔道练习仅几周之后，我的儿子感到无聊。 他抱怨说自己没有学任何东西，因为他一遍又一遍地做着同样的事情。 混淆学习和做新事物的不仅是幼儿。 例如，有多少软件开发人员通过执行kata或参加dojos来进行刻意练习的麻烦？ 重复您已经做过很多次的练习似乎很愚蠢，但事实并非如此。 这是在您的领域成为黑带的唯一方法。 记住，掌握是三个内在动机之一 （其他是自主性和目的性）。 实践...
mockito_使用FizzBu​​zz和Mockito进行单元测试
cunfeng7797的博客
12-18 74
mockito 我有时使用FizzBu​​zz向新手演示单元测试的基础。 尽管FizzBu​​zz确实是一个简单的问题，但是它也可以用于演示更高级的单元测试技术，例如模拟。 FizzBu​​zz Kata： “编写一个程序，打印从1到100的数字。但是，对于三个数字的倍数，请打印“ Fizz”，而不是数字；对于五个数字的倍数，请打印“ Buzz”。 对于三和五的倍数的数字，请打印“ Fizz...
mockito 单元测试_使用FizzBu​​zz和Mockito进行单元测试
最佳 Java 编程
06-18 115
mockito 单元测试 我有时使用FizzBu​​zz向新手演示单元测试的基础。 尽管FizzBu​​zz确实是一个简单的问题，但它也可以用于演示更高级的单元测试技术，例如模拟 。 FizzBu​​zz Kata： “ 编写一个程序，打印一个从1到100的数字。但是，对于三个打印倍数的“ Fizz”（而不是数字），对于五个打印倍数的“ Buzz”。 对于三和五的倍数的数字，请打印“ ...
fizzbuzz_java:Java 中的 FizzBu​​zz Kata (TDD)
07-07
在编程领域，Kata 是一种常见的练习方式，用于提高编程技能和...它强调了测试先行的重要性，有助于提升开发者对Java语言的理解和对TDD流程的掌握。通过这样的练习，开发者可以更好地学习如何写出高质量、可维护的代码。
FizzBuzz-Kata:C# 中的 FizzBu​​zz 卡塔
06-08
FizzBu​​zz-卡塔 规则：任何能被 3 整除的数都用 fizz 代替，任何能被 5 整除的数用 buzz 代替。 可以被两者整除的数字变得嘶嘶声。 犯错的球员必须喝一杯。 爱因斯坦会选择一个随机数作为开头——例如：4, buzz, ...
FizzBuzz-ObjectCalisthenics-Kata:使用对象健美操规则完成FizzBu​​zz kata
05-01
卡塔物镜 主要目标是实践Jeff Bay在提出的对象健美操规则。 对象健美操规则 每种方法只有一个缩进级别 不要使用else关键字 包装所有原语和字符串 一流的收藏 每行一个点 不要缩写 保持所有实体较小 ...
TDDFizzBuzz:PA代码kata挑战＃1-使用FizzBu​​zz控制台应用程序，但要使用TDD
03-18
标题中的"TDDFizzBuzz"是一个编程挑战，它结合了经典的FizzBuzz问题与测试驱动开发（TDD）的方法。这个挑战的目的是通过编写一个基于C#的控制台应用程序来解决FizzBuzz问题，同时遵循TDD的原则。 **测试驱动开发...
roman-numeral-kata:在 Java 中通过罗马数字 Kata 练习 TDDing
07-05
在 Java 中实现这个 kata，我们需要创建一个方法，接受一个整数作为输入，并返回对应的罗马数字字符串。TDD 方法要求我们首先编写测试，然后根据测试失败的情况编写最小的代码以使测试通过。这个过程通常包括以下...
Java企业面试题3
最新发布
m0_74972727的博客
09-15 469
1. break和continue的作用(智*图) break：用于完全退出一个循环（如 for, while）或一个 switch 语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。 continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在 for 循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。 2. if分支语句和switch分支语句的异同之处(智*图) 相同点：都是用来根据不同的条件执行不同的代码块。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1099
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 141
");
笔记：Centos Jdk Nginx 安装包安装命令
贰十六的博客
09-12 619
进入到usr中的src，把刚才下载的安装包拉进去。# ./configure 报错。# 将下面填写到配置最下方。# JDK 解压版 配置。# 进入环境变量配置。
Kata Containers与gVisor：性能对比与技术解析
"kata containers 和 gvisor 是两种在云原生环境中提供增强安全性和隔离性的容器技术。本文将对它们进行性能对比分析，并探讨它们的架构和未来发展趋势。" Kata Containers 和 gVisor 都是针对容器安全性的解决方案...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值