Diamond kata

DiamondTest.java

import org.junit.Test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;

import static org.assertj.core.api.Assertions.assertThat;

public class DiamondTest {

    private static final List<String> CHARS = Arrays.asList("abcdefghijklmnopqrstuvwxyz".split(""));

    @Test
    public void all_in_one() {
        List<String> letters = lettersUpTo('c');
        assertThat(letters).containsExactly("a", "b", "c");

        List<String> baseLetters = symetryOf(letters);
        assertThat(baseLetters).containsExactly("a", "b", "c", "b", "a");

        String base = baseLetters.stream().collect(Collectors.joining(""));
        assertThat(base).isEqualTo("abcba");

        List<String> mainLettersByLine = mainLettersByLine(letters);
        assertThat(mainLettersByLine).containsExactly("c", "b", "a", "b", "c");

        List<String> diamond = mainLettersByLine
                .stream()
                .map(c -> removeAllLettersExcept(base, c))
                .collect(Collectors.toList());
        assertThat(diamond.get(0)).isEqualTo("..c..");
        assertThat(diamond.get(1)).isEqualTo(".b.b.");
        assertThat(diamond.get(2)).isEqualTo("a...a");
        assertThat(diamond.get(3)).isEqualTo(".b.b.");
        assertThat(diamond.get(4)).isEqualTo("..c..");
    }

    private static List<String> lettersUpTo(char c) {
        int indexOf = CHARS.indexOf(String.valueOf(c));
        return CHARS.subList(0, indexOf+1);
    }

    private static <T> List<T> mainLettersByLine(List<T> letters) {
        return symetryOf(reverse(letters));
    }

    private static String removeAllLettersExcept(String base, String c) {
        return base.replaceAll("[^" + c + "]", ".");
    }

    //
    // GENERIC Collections functions...
    //

    private static <T> List<T> reverse(List<T> elements) {
        List<T> xs = new ArrayList<>(elements);
        Collections.reverse(xs);
        return xs;
    }

    private static <T> List<T> join(List<T> xs, List<T> ys) {
        List<T> joined = new ArrayList<>(xs.size() + ys.size());
        joined.addAll(xs);
        joined.addAll(ys);
        return joined;
    }

    private static <T> List<T> symetryOf(List<T> values) {
        List<T> symetry = removeLast(values);
        return join(values, reverse(symetry));
    }

    private static <T> List<T> removeLast(List<T> values) {
        List<T> xs = new ArrayList<>(values);
        xs.remove(xs.size() - 1);
        return xs;
    }
 }