Remove space and Uppercase first letter

Question

I made this program which shall turn around sentences like: User Input: Hello i´m hungry. Where is the fridge. System Output: Hungry i´m Hello. Fridge the is Where.

But there is space between the last word and "." in the reversed sentence. How can i remove? And how can i make the first word a uppercase word?

    package etzale;


public class etzale {




    public static void main(String[] args) {


        StringBuilder outputString= new StringBuilder();

        String satz;


        System.out.print("Bitte geben Sie einen String ein: ");
        String text="Hallo mir gehts gut. Wie gehts dir. mir gehts spitze.";

        while(text.indexOf(".")>=0){

            satz=text.substring(0, text.indexOf("."));
            text=text.substring(text.indexOf(".")+1);

            String []s= satz.split(" ");
            for(int i=s.length-1; i>=0; i--){

               outputString.append(s[i]);

               if(s[0]==" ");

               outputString.append(" ");

               }

          outputString.append(".");
          outputString.append(" ");

        }
        System.out.print(outputString);
}
}

How can i erase the space between the last word and "." in each sentence?

Actual Input: Mit gehts gut. Wie gehts dir. Mir gehts spitze.
Actual Output: gut gehts mir  . dir gehts Wie  . spitze gehts Mir  . 

Answer 1

I already answer another you almost similar question: Reverse all words, set "." and do the same for the next sentences, my solution covered this case also try it:

import java.util.Arrays;
import java.util.Collections;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Main {

    public static void main(String[] args) {
        final String userInput = "Hello i´m hungry. Where is the fridge.";
        final String expectedResult = "Hungry i´m Hello. Fridge the is Where.";
        String[] sentences = userInput.split("\\. ");
        String reversedSentences = Stream.of(sentences)
                .map(sentenceString -> new Sentence(sentenceString))
                .map(Sentence::reverse)
                .map(Sentence::firstLetterToUpperCase)
                .map(Sentence::removeAllDots)
                .map(Sentence::dotInTheEnd)
                .map(Sentence::toString)
                .collect(Collectors.joining(" "));
        System.out.println(reversedSentences.equals(expectedResult)); //returns true
    }


}

final class Sentence {
    private final String sentence;

    Sentence(String sentence) {
        this.sentence = sentence;
    }

    Sentence reverse() {
        String[] words = sentence.split(" ");
        Collections.reverse(Arrays.asList(words));
        return new Sentence(String.join(" ", words));
    }

    Sentence firstLetterToUpperCase() {
        String firstLetter = sentence.substring(0, 1);
        String anotherPart = sentence.substring(1);
        return new Sentence(firstLetter.toUpperCase() + anotherPart);
    }

    Sentence dotInTheEnd() {
        return new Sentence(sentence + ".");
    }

    Sentence removeAllDots() {
        return new Sentence(sentence.replaceAll("\\.", ""));
    }

    public String toString() {
        return sentence;
    }
}

Answer 2

OK, appart from your code not being very appealing, you have a typo in your code that is causing you trouble:

outputString.append(" ");

Remove that semicolon at the end and you will not have spaces before dots.

Answer 3

Here's the way I would do it. Performs at lot less inefficient string concatenation, and handles full stops, question marks, and exclamation marks.

public static void main(String[] args) {
    System.out.println("Bitte geben Sie einen String ein: ");
    String text = "Hallo mir gehts gut!! Wie gehts dir. mir gehts spitze.";

    System.out.println(reverseSentences(text));
}

/**
 * Reverse the order of the words in the sentence.
 * @param sentence the sentence to reverse.
 * @param terminal the symbol to add at the end.
 * @return the reversed sentence, with added terminal.
 */
static String reverse(String sentence, String terminal) {
    sentence = sentence.trim();
    if (sentence.isEmpty()) {
        return terminal;
    }

    // find words by splitting the sentence at spaces
    // then put the words back together in reverse order
    String[] words = sentence.split("\\s+");
    StringBuilder sb = new StringBuilder(sentence.length());

    for (int i = words.length - 1; i >= 0; i--) {
        String word = words[i];
        // capitalize the last word before placing it at the start
        if (i == words.length - 1 && !word.isEmpty()) {
            sb.append(word.substring(0, 1).toUpperCase());
            sb.append(word.substring(1));
        } else {
            sb.append(word);
        }
        if (i > 0) sb.append(' ');
    }

    // append terminal
    sb.append(terminal);
    return sb.toString();
}

/**
 * Reverse each sentence in the string.
 * @param s the string to act on.
 * @return the string, with sentences reversed.
 */
public static String reverseSentences(String s) {
    // Match each sentence, with an optional terminal
    // terminal may be one or more
    // full stops, question or exclamation marks
    Pattern p = Pattern.compile("([^.?!]+)([.?!]*)");
    Matcher m = p.matcher(s);

    // find and reverse the sentences, then recombine them
    StringBuilder sb = new StringBuilder(s.length());
    while (m.find()) {
        String sentence = m.group(1);
        String terminal = m.group(2);
        sb.append(reverse(sentence, terminal));
        sb.append(' ');
    }

    return sb.toString().trim();
}