Java program that does simple string manipulation is not working correctly

Here's a better algorithm:

1. split the input into an array of words
2. iterate over each word
3. if the word begins with a vowel, append it to the output

The easiest way to split the input would be to use String.split().

Here's a simple implementation:

public static void main(String[] args) {
    Scanner console = new Scanner(System.in);
    String input = console.nextLine();
    String[] words = input.split(" ");
    StringBuilder output = new StringBuilder();
    for (String s : words) {
        if (startsWithVowel(s)) {
            output.append(s);
        }
        else {
            output.append(getPunc(s));
        }
    }
    System.out.println(output.toString());
}

public static boolean startsWithVowel(String s) {
     char[] vowels = { 'a', 'e', 'i', 'o', 'u' };
     char firstChar = s.toLowerCase().charAt(0);
     for (char v : vowels) {
         if (v == firstChar) {
             return true;
         }
     }
     return false;
 }

public static String getPunc(String s) {
    if (s.matches(".*[.,:;!?]$")) {
        int len = s.length();
        return s.substring(len - 1, len);
    }
    return "";
}

Normally i would suggest you where to fix your code, but it's seems there is a lot of bad code practice in here.

• Mass Concatenation should be apply be StringBuilder.
• Never call a class Class
• Conditions are too long and can be shorten by a static string of Vowels and apply .contains(Your-Char)
• Spaces, Indentations required for readability purposes.
• A different way of attacking this problem, may probably accelerate your efficiency.

Another approch will be Split the code by spaces and loop through the resulted array for starting vowels letters and then Append them to the result string.

A better readable and more maintainable version doing what you want:

public static String buildWeirdSentence(String input) {
    Pattern vowels = Pattern.compile("A|E|I|O|U|a|e|i|o|u");
    Pattern signs = Pattern.compile("!|\\.|,|:|;|\\?");
    StringBuilder builder = new StringBuilder();

    for (String word : input.split(" ")) {
        String firstCharacter = word.substring(0, 1);
        Matcher vowelMatcher = vowels.matcher(firstCharacter);
        if (vowelMatcher.matches()) {
            builder.append(word);
        } else {
            // we still might want the last character because it might be a sign
            int wordLength = word.length();
            String lastCharacter = word.substring(wordLength - 1, wordLength);
            Matcher signMatcher = signs.matcher(lastCharacter);
            if (signMatcher.matches()) {
                builder.append(lastCharacter);
            }
        }
    }

    return builder.toString();
}

In use:

public static void main(String[] args) {
    System.out.println(buildWeirdSentence("It is a hot and humid day.")); // Itisaand.
}

I think best approach is to split input and then check each word if it starts with vowel.

public static void main(String[] args)
{

  Scanner console = new Scanner(System.in);
  System.out.print("Input: ");
  String str = console.next();

  String[] input = str.split(" ");

  StringBuilder s = new StringBuilder();

  String test;

  for (int i = 0; i < input.length; i++)
  {
      test = input[i];

      if (test.charAt(0) == 'U' || test.charAt(0) == 'O'
          || test.charAt(0) == 'I' || test.charAt(0) == 'E'
          || test.charAt(0) == 'A' || test.charAt(0) == 'a'
          || test.charAt(0) == 'e' || test.charAt(0) == 'i'
          || test.charAt(0) == 'o' || test.charAt(0) == 'u')
     {
           s.append(input[i]);

     }

   }
   System.out.println(s);

}

The problem with your code is that you override the first beg when a word has more that vowel. for example with Apples beg goes to 0 and before you could call findWord to catch it, it gets overridden with 4 which is the index of e. And this is what screws up your algorithm.

You need to note that you have already found a vowel until you have called finWord, for that you can add a boolean variable haveFirstVowel and set it the first time you have found one to true and only enter the branch for setting that variable to true if you haven't already set it. After you have called findWord set it back to false.

Next you need to detect the start of a word, otherwise for example the o of hot could wrongly signal a first vowel.

Class strings = new Class(input);
int beg = 0;
boolean haveFirstVowel = false;
for (int j = 0; j < input.length(); j++) {
    boolean startOfWord = (beg == 0 || input.charAt(j - 1) == ' ');
    if (startOfWord && ! haveFirstVowel && strings.isVowel(j)) {
        beg = j;
        haveFirstVowel = true;
    }
    else if (strings.endWord(j) && haveFirstVowel) {
        strings.findWord(beg, j);
        haveFirstVowel = false;
    }
}
System.out.print("Output: ");
strings.printAnswer();

I think overall the algorithm is not bad. It's just that the implementation can definitely be better.

Regarding to the problem, you only need to call findWord() when:

1. You have found a vowel, and
2. You have reached the end of a word.

Your code forgot the rule (1), therefore the main() can be modified as followed:

Scanner console = new Scanner(System.in);
System.out.print("Input: ");
String input = console.nextLine();
Class strings = new Class(input);
int beg = 0;
boolean foundVowel = false; // added a flag indicating whether a vowel has been found or not
for (int j = 0; j < input.length(); j++) {
    if (strings.isVowel(j) && (j == 0 || input.charAt(j - 1) == ' ')) {
        beg = j;
        foundVowel = true;
    } else if (strings.endWord(j) && (beg == 0 || input.charAt(beg - 1) == ' ')) {
        if (foundVowel) { // only call findWord() when you have found a vowel and reached the end of a word
            strings.findWord(beg, j);
            foundVowel = false; // remember to reset the flag
        }
    }
}
System.out.print("Output: ");
strings.printAnswer();