面试编码测试：Fizz Buzz

package com.engineerdollery;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.util.stream.Collectors.*;

public class FizzBuzz {
    private static final String NUMBER = "\d+";

    public String basic() {
        return IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(joining(" "));
    }

    public String lucky() {
        return IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> Integer.toString(i).contains("3") ? "lucky" // this is the only change from basic()
                        : i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(joining(" "));
    }

    public String counter() {
        List<String> fizzBuzzList = IntStream.rangeClosed(1, 20)
                .parallel()
                .mapToObj(i -> Integer.toString(i).contains("3") ? "lucky"
                        : i % 15 == 0 ? "fizzbuzz"
                        : i % 3 == 0 ? "fizz"
                        : i % 5 == 0 ? "buzz"
                        : Integer.toString(i))
                .collect(Collectors.toList());

        Map<String, Long> countMap = fizzBuzzList
                .parallelStream()
                .collect(groupingBy(s -> s.matches(NUMBER) ? "integer" : s, counting()));

        // reports

        String fizzbuzz = fizzBuzzList.parallelStream().collect(joining(" "));

        String counts = countMap.entrySet().parallelStream()
                .map(e -> e.getKey() + ": " + e.getValue())
                .collect(joining("\n"));

        return fizzbuzz + "\n" + counts;
    }
}

package com.engineerdollery;

import org.junit.Test;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

public class FizzBuzzTest {
    public static void main(String[] args) {
        System.out.println(new FizzBuzz().counter());
    }

    @Test
    public void basic() {
        FizzBuzz fizzBuzz = new FizzBuzz();
        String actual = fizzBuzz.basic();
        assertEquals("1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizzbuzz 16 17 fizz 19 buzz", actual);
    }

    @Test
    public void lucky() {
        FizzBuzz fizzBuzz = new FizzBuzz();
        String actual = fizzBuzz.lucky();
        assertEquals("1 2 lucky 4 buzz fizz 7 8 fizz buzz 11 fizz lucky 14 fizzbuzz 16 17 fizz 19 buzz", actual);
    }

    @Test
    public void counter() {
        FizzBuzz fizzBuzz = new FizzBuzz();
        String actual = fizzBuzz.counter();
        assertTrue(actual.contains("1 2 lucky 4 buzz fizz 7 8 fizz buzz 11 fizz lucky 14 fizzbuzz 16 17 fizz 19 buzz"));
        assertTrue(actual.contains("fizz: 4"));
        assertTrue(actual.contains("buzz: 3"));
        assertTrue(actual.contains("fizzbuzz: 1"));
        assertTrue(actual.contains("lucky: 2"));
        assertTrue(actual.contains("integer: 10"));
    }
}

public String lucky() {
    return IntStream.rangeClosed(1, 20)
            .parallel().mapToObj(i -> 
                Integer.toString(i).contains("3") 
                    ? "lucky" // this is the only change from basic()
                    : i % 15 == 0 
                        ? "fizzbuzz"
                        : i % 3 == 0 
                            ? "fizz"
                            : i % 5 == 0 
                                ? "buzz"
                                : Integer.toString(i))
            .collect(joining(" "));
}

return condition.boolExpression()
       ? true
       : condition.boolExpression()
           ? true
           : false;

public String lucky() {
    return IntStream.rangeClosed(1, 20)
            .parallel().mapToObj(i -> fizzbuzz(i))
            .collect(joining(" "));
}

public String lucky() {
    return IntStream.rangeClosed(1, 20)
            .parallel().mapToObj(fizzbuzz)
            .collect(joining(" "));
}

public String basic(int max) {
    return IntStream.rangeClosed(1, max) //...
}

i -> i % 15 == 0 ? "fizzbuzz"
    : i % 3 == 0 ? "fizz"
    : i % 5 == 0 ? "buzz"
    : Integer.toString(i)

IntStream.rangeClosed(1, 20).parallel() //...

public class FizzBuzz {

    enum Special {

        Fizz {
            @Override
            boolean special(int n) {
                return (n % 3) == 0;
            }
        },
        Buzz {
            @Override
            boolean special(int n) {
                return (n % 5) == 0;
            }
        };

        abstract boolean special(int n);
    }

    static CharSequence encode(int n) {
        StringBuilder s = new StringBuilder();
        boolean normal = true;
        for (Special fb : Special.values()) {

            if (fb.special(n)) {
                s.append(fb.name()).append(" ");
                normal = false;
            }
        }
        if (normal) {
            s.append(n).append(" ");
        }
        return s;
    }

    private void fizzBuzz() {
        for (int i = 1; i < 20; i++) {
            System.out.println("" + i + " -> " + s);
        }
    }

    public static void main(String args[]) {
        try {
            new FizzBuzz().fizzBuzz();
        } catch (Throwable t) {
            t.printStackTrace(System.err);
        }
    }
}

        Lucky {
            @Override
            boolean special(int n) {
                return Integer.toString(n).contains("3");
            }
        }