Generate String with Random Consonants and Vowels Purpose

This problem comes from this dailyProgrammer subreddit challenge.

The task is to take an input of C / cs and V / vs and to replace Cs with random consonants and Vs with random vowels (English alphabet) while keeping the case the same. Y is not considered a vowel in this case.

Example:


CcVvv => BgAoi
ccVVV => zqUUE


Implementation

For this case, I've put all methods in the same class - in reality, I might split these methods out into different classes.

Edit: I forgot to throw an exception in generateRandomString when the isValidCharacter method is called and returns false.

public class RandomCharacterReplacer {
  public static final char C = 'C';
  public static final char V = 'V';
  public static final List&lt;Character&gt; CONSONANTS = new ArrayList&lt;&gt;(
      Arrays.asList('B', 'C', 'D', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'V', 'W', 'X', 'Y', 'Z')
  );
  public static final List&lt;Character&gt; VOWELS = new ArrayList&lt;&gt;(
      Arrays.asList(
          'A', 'E', 'I', 'O', 'U'
      )
  );

  private static boolean isValidCharacter(final char c) {
    final char upperCaseChar = Character.toUpperCase(c);
    return upperCaseChar == C || upperCaseChar == V;
  }

  public static AlphabetCharacterCase returnAlphabetCharacterCase(final char c) {
    if (!Character.isAlphabetic(c)) {
      throw new RuntimeException("character is non-alphabetic");
    }

    if (Character.isUpperCase(c)) {
      return AlphabetCharacterCase.UPPER;
    }

    if (Character.isLowerCase(c)) {
      return AlphabetCharacterCase.LOWER;
    }

    throw new RuntimeException("unexpected character case");
  }

  public static AlphabetCharacterType returnAlphabetCharacterType(final char c) {
    if (!Character.isAlphabetic(c)) {
      throw new RuntimeException("character is non-alphabetic");
    }

    final char upperCaseChar = Character.toUpperCase(c);
    if (upperCaseChar == C) {
      return AlphabetCharacterType.CONSONANT;
    }

    if (upperCaseChar == V) {
      return AlphabetCharacterType.VOWEL;
    }

    throw new RuntimeException("unexpected character type");
  }

  public static char returnRandomCharacter(final List&lt;Character&gt; characterList) {
    if (characterList.isEmpty()) {
      throw new IllegalArgumentException("character list must be non-empty");
    }
    final Random random = new Random();
    return characterList.get(random.nextInt(characterList.size() - 1));
  }

  public static List&lt;Character&gt; returnAlphabetCharacterTypeList(final AlphabetCharacterType characterType) {
    switch (characterType) {
      case CONSONANT: {
        return CONSONANTS;
      }

      case VOWEL: {
        return VOWELS;
      }

      default: {
        throw new RuntimeException("unexpected character type");
      }
    }
  }


  public static char generateRandomCharacter(final AlphabetCharacterCase alphabetCharacterCase, final AlphabetCharacterType characterType) {
    final List&lt;Character&gt; characters = returnAlphabetCharacterTypeList(characterType);
    switch (alphabetCharacterCase) {
      case UPPER: {
        return returnRandomCharacter(characters);
      }

      case LOWER: {
        return Character.toLowerCase(returnRandomCharacter(characters));
      }

      default: {
        throw new RuntimeException("unexpected character case");
      }
    }
  }

  public static String generateRandomString(final String input) {
    final char[] chars = input.toCharArray();
    final StringBuilder stringBuilder = new StringBuilder();
    for (final char c : chars) {
      if (isValidCharacter(c)) {
        final AlphabetCharacterCase alphabetCharacterCase = returnAlphabetCharacterCase(c);
        final AlphabetCharacterType alphabetCharacterType = returnAlphabetCharacterType(c);
        stringBuilder.append(generateRandomCharacter(alphabetCharacterCase, alphabetCharacterType));
      }
    }

    return stringBuilder.toString();
  }
}
I think if I were doing this, I'd do it...somewhat (a lot?) differently. My immediate reaction would be to do something on this general order (using C++ syntax instead of Java, but I'm pretty sure the same basic idea should work in Java about the same way):

char gen_rand(std::string const &amp;input) { 
    // A quick and dirty method, for now.
    return input[rand() % input.size()];
}    

static const string lower_c = "bcdfghjklmnpqrstvwxyz";
static const string upper_c = "BCDFGHJKLMNPQRSTVWXYZ";
static const string lower_v = "aeiou";
static const string upper_v = "AEIOU";

string genRandomString(std::string const &amp;input) { 
    string output; // I suppose needs to be a StringBuilder in Java

    for (char ch : input)
        switch (ch) {
        case 'c': output.push_back(gen_rand(lower_c));    break;
        case 'C': output.push_back(gen_rand(upper_c));    break;
        case 'v': output.push_back(gen_rand(lower_v));    break;
        case 'V': output.push_back(gen_rand(upper_v));    break;
        default: throw std::runtime_error("Unexpected character in input");
        }
     return output;
 }


If I'm allowed to speak in generalities, your code seems (to me) to spend a lot of effort on issues that are almost incidental to the question at hand (e.g., 37 lines just to decide that c, C, v and V refer to lower- and upper-case consonants and vowels). At least as I see things, the fact that the case of the input corresponds to the case of the output is really mostly incidental--they could just as well be a, b, c and d instead.

Another option that seems obvious to me, would be to use a map to take an input character and retrieve the collection of characters to choose from for that input. This is probably more work than it's worth for only 4 fixed inputs, but if you might have a lot of inputs, or (especially) if you want to support those inputs being specified at run time (e.g., reading them from a configuration file) a map becomes much more attractive.

Bottom line: it's a lot simpler and more flexible to just treat the mapping from input character to action as entirely arbitrary rather than go to a lot of work to classify the inputs as upper/lower case.