在JAVA中用分隔符反转字符串

Question

输入的字符串是 String sentence =“comp！ex，ex.amp！e”;输出应为 String output =“pmoc！xe，xe.pma！e”;

尝试这样做：在输入

static void reverseEachWordOfString(String inputString) 
{ 
      String[] words = inputString.split("[\\s,!.]"); 

      String reverseString = ""; 

      for (int i = 0; i < words.length; i++) 
      { 
       String word = words[i]; 

       String reverseWord = ""; 

       for (int j = word.length()-1; j >= 0; j--) 
       { 
        reverseWord = reverseWord + word.charAt(j); 
       } 

       reverseString = reverseString + reverseWord + " "; 
      } 
} 

Answer 1

下面的示例迭代。它停止，直到当前字符与regualr表达式匹配。表达式在代码中进行了解释。它可以通过应该分割输入的更多特殊字符来扩展。特殊字符的

• 输入开始和指数之间的subtring
• 或最后一站和当前特殊字符
• 或最后一站，并输入结束

将得到扭转，并追加到输出字符串。如果这不符合要求，请编辑您的问题并提供更多信息。

public static void main(String[] args) 
{ 
    String reversed = reverse("comp!ex, ex.amp!e"); 

    // 
    // Just to test... 
    // 
    String expectedOutput = "pmoc!xe, xe.pma!e"; 

    if(expectedOutput.equals(reversed) == false) 
    { 
     throw new IllegalStateException(reversed); 
    } 
} 

public static String reverse(String input) 
{ 
    // 
    // Regular expression to match characters that should split the string. 
    // ! or . or , or 'a sequence of whitespace' 
    // 
    String specialCharExpression = "!|\\.|,| *"; 

    StringBuilder result = new StringBuilder(); 

    int fragmentStart = 0; 

    for(int i = 0; i < input.length(); i++) 
    { 
     String currentChar = input.charAt(i) + ""; 

     if(currentChar.matches(specialCharExpression) 
      || i == input.length() - 1) 
     { 
      result 
       .append(new StringBuilder(input.substring(fragmentStart, i)) 
        .reverse().toString()); 
      result.append(currentChar); 

      fragmentStart = i + 1; 
     } 
    } 

    return result.toString(); 
} 

Answer 2

从中找到你可以开始一个片段下方。在代码中是解释所做的事情的附加评论。

String sentence = "comp!ex, ex.amp!e"; 
String[] split = sentence.split("[\\s,!.]"); 
StringBuilder out = new StringBuilder(sentence.length()); 
StringBuilder tmp = new StringBuilder(sentence.length()); 
for (String s : split) { 
    // reset the length and reuse the tmp StringBuilder 
    tmp.setLength(0); 
    // append the part the the temporary StringBuilder 
    tmp.append(s); 
    // append the reversed part to the output StringBuilder 
    out.append(tmp.reverse()); 
    // if the length of the input is longer then the output 
    // we need to add the separator char from the input 
    if (sentence.length() > out.length()) { 
     out.append(sentence.charAt(out.length())); 
    } 
} 
System.out.println("input : " + sentence); 
System.out.println("reversed: " + out); 

输出

input : comp!ex, ex.amp!e 
reversed: pmoc!xe, xe.pma!e 

Answer 3

这是另一种方式来扭转特殊字符的字符串，不要把字符串。

• 将String转换为char数组。
• 编写一个参数char[]并在char[]上循环的方法。
• 编写一个方法来检查char[index]是否是一个字母表。
• 当char[index]不是字母表时，存储起始索引和结束索引，并将char[]中的元素与开始索引和 结束索引进行交换。

这里是工作code：

public static boolean isAlphabet(char x) { 
     return ((x >= 'A' && x <= 'Z') || (x >= 'a' && x <= 'z')); 
    } 

public static void reverse(char ch[]) { 
    int l = 0; 
    int startIndex = 0; 
    int endIndex = 0; 
    while (l < ch.length - 1) { 
     if (isAlphabet(ch[l])) { 
      l++; 
     } else { 
      endIndex = l - 1; 
      while (startIndex < endIndex){ 
       char temp = ch[startIndex]; 
       ch[startIndex] = ch[endIndex]; 
       ch[endIndex] = temp; 
       endIndex--; 
       startIndex++; 
      } 
      l++; 
      startIndex = l; 
      } 
     } 
    } 

    public static void main(String[] args) throws java.lang.Exception { 
     String inputString = "comp!ex, ex.amp!e"; 
     char[] ch = inputString.toCharArray(); 
     reverse(ch); 
     String reverseString = new String(ch); 
     System.out.println(reverseString); 
    } 

输入：comp!ex, ex.amp!e输出：pmoc!xe, xe.pma!e

通过与whitespace分裂String，您可以使用相同的isAlphabet和reverse方法。

Code：

String inputString = "comp!ex, ex.amp!e"; 
String[] splitArray = inputString.split("\\s"); 
char[] ch1 = splitArray[0].toCharArray(); 
reverse(ch1); 
char[] ch2 = splitArray[1].toCharArray(); 
reverse(ch2); 
StringBuilder reverseString = new StringBuilder(); 
reverseString.append(ch1); 
reverseString.append(" "); 
reverseString.append(ch2); 
System.out.println(reverseString.toString()); 

输出：

Input : comp!ex, ex.amp!e 
Output: pmoc!ex, xe.pma!e 

Answer 4

的溶液，使得使用堆栈

的也有一个方法isDelimiter()它允许你添加任何数量的分隔符。

static String reverseEachWordOfString(String inputString) { 

    StringBuffer reversedString = new StringBuffer(); 
    Stack<Character> stack = new Stack<Character>(); 

    for(int i=0;i<inputString.length();i++){ 
               // Get each character 
     char character = inputString.charAt(i); 
     if(isDelimiter(character)) {    // If character is delimiter 
      popInto(stack, reversedString);  // Then pop stack into output string 
      reversedString.append(character); // And append the delimiter 
     } else 
      stack.push(character);    // Else push character onto the stack 
    } 
    popInto(stack, reversedString);    // In the end pop stack into output string 

    return reversedString.toString(); 
} 

private static void popInto(Stack<Character> stack, StringBuffer str) { 
    while(!stack.empty()) { 
     str.append(stack.pop()); 
    } 
} 

private static boolean isDelimiter(char character) { 
    return character == ' ' || character == '.' || character == ',' || character == '!'; 
}