Odwróć ciąg słowo po słowie w Javie

Question

Mam następujący kod, aby odwrócić ciąg słowo po słowie, mam pytanie jednak, po pierwsze może ktoś wskazać, jak zrobić lepszy kod? i po drugie, jak mogę usunąć przestrzeń, którą kończę na początku nowego łańcucha.

String str = "hello brave new world"; 
tStr.reverseWordByWord(str) 

public String reverseWordByWord(String str){ 
     int strLeng = str.length()-1; 
     String reverse = "", temp = ""; 

     for(int i = 0; i <= strLeng; i++){ 
      temp += str.charAt(i); 
      if((str.charAt(i) == ' ') || (i == strLeng)){ 
       for(int j = temp.length()-1; j >= 0; j--){ 
        reverse += temp.charAt(j); 
        if((j == 0) && (i != strLeng)) 
         reverse += " "; 
       } 
       temp = ""; 
      } 
     } 

     return reverse; 
    } 

zdanie w tej chwili staje się:

olleh evarb Wen dlrow

Zawiadomienie przestrzeń na początku nowego łańcucha.

Answer 1

Pierwszą rzeczą, jaką zrobiłbym, to oddzielenie kodu odwracającego słowa z kodu odwracającego każde słowo osobno. Ta wewnętrzna pętla:

for(int j = temp.length()-1; j >= 0; j--) 
{ 
    reverse += temp.charAt(j); 
    if((j == 0) && (i != strLeng)) 
     reverse += " "; 
} 

Będzie to wywołanie funkcji/metody.

Ponadto, aby uczynić twój kod bardziej wydajnym, zamiast łączenia łańcuchów z operatorem +, używałbym klasy bufora ciągowego. Takich jak StringBuffer lub StringBuilder.

Answer 2

Przede wszystkim należy rozdzielić go na trzy funkcje. Pierwsze zerwanie dużego ciągu na liście ciągów za pomocą spacji jako separatora, drugie odwrócenie jednego ciągu bez spacji i ostatnie ciągi łączące.

Po wykonaniu tej czynności łatwiej będzie zlokalizować przyczynę spacji. Widać to już w bieżącym kodzie, ale nie powiem ci: D.

Answer 3

Co powiesz na użycie czegoś takiego?

String string="yourWord"; 
String reverse = new StringBuffer(string).reverse().toString(); 

Answer 4

Oto jak można to zrobić:

StringBuilder result = new StringBuilder(); 
    StringTokenizer st = new StringTokenizer(input, " "); 
    while (st.hasMoreTokens()) { 
     StringBuilder thisToken = new StringBuilder(st.nextToken()); 
     result.append(thisToken.reverse() + " "); 
    } 
    String resultString = result.toString(); 

Answer 5

Można użyć StringUtils

return StringUtils.reverseDelimitedString(str, " "); 

Answer 6

Poniższy powinien to zrobić w czasie O (n) bez kosztownego kopiowania tablicy lub re- strukturyzacja długości tablicy znaków. Dba o wiele poprzedzających, kończących i kończących białych znaków.

public class ReverseString { 

    public static void main(String[] args) { 
     String string1 = "hello brave new world"; 
     String string2 = "hello brave new world "; 
     String string3 = " hello brave new world"; 
     String string4 = " hello brave   new world "; 

     System.out.println(reverseStringWordByWord(string1)); 
     System.out.println(reverseStringWordByWord(string2)); 
     System.out.println(reverseStringWordByWord(string3)); 
     System.out.println(reverseStringWordByWord(string4)); 
    } 

    private static String reverseStringWordByWord(String string) { 
     StringBuilder sb = new StringBuilder(); 
     int length = string.length(); 
     for(int i=0;i<length;i++) { 
      char c = string.charAt(i); 
      if(c == ' ') { 
       sb.append(c); 
      } else { 
       int j = i; 
       while(j < length && string.charAt(j) != ' ') { 
        j++; 
       } 
       sb.append(reverseString(string.substring(i, j))); 
       i = j-1; 
      } 
     } 
     return sb.toString(); 
    } 

    private static String reverseString(String string) { 
     StringBuilder sb = new StringBuilder(); 
     for(int i=string.length()-1;i>=0; i--) { 
      sb.append(string.charAt(i)); 
     } 
     return sb.toString(); 
    } 

} 

Answer 7

public String reverseStringWordByWord(String input) { 
     StringBuilder returnValue = new StringBuilder(); 
     int insertIndex = 0; 
     for(int i = 0;i < input.length();i++) { 
      if(input.charAt(i)!=' ') { 
       returnValue.insert(insertIndex, currentChar); 
      } else { 
       insertIndex = i+1; 
       returnValue.append(currentChar); 
      } 

     } 

     return returnValue.toString(); 
    } 

Answer 8

Spróbuj tego. Uwzględnia znaki interpunkcyjne i białe znaki dowolnego rodzaju.

public String reverseWordByWord(String inputStr) 
{ 
    BreakIterator wordIterator = BreakIterator.getWordInstance(); 
    wordIterator.setText(inputStr); 
    int start = wordIterator.first(); 
    StringBuilder tempBuilder; 
    StringBuilder outBuilder = new StringBuilder(); 
    for (int end = wordIterator.next(); end != BreakIterator.DONE; start = end, end = wordIterator.next()) 
    { 
     tempBuilder = new StringBuilder(inputStr.substring(start, end)); 
     outBuilder.append(tempBuilder.reverse()); 
    } 
    return outBuilder.toString(); 
} 

Answer 9

Ja sama jestem całkiem nowa w Javie, i spodziewam się, że zostałem pokonany, ale myślałem, że i tak to zrobię. Możesz rozwiązać dodatkowy problem z białymi znakami, budując ciąg znaków przy założeniu, że usuniesz niechciane dodatkowe miejsce na końcu. Jeśli wydajność jest rozważana, możesz to przemyśleć!

Edycja: Zauważ, że moje rozwiązanie (teraz) obsługuje wiodące i końcowe białe spacje.

public class StringReversal { 

public static void main(String[] args) { 
    String str = "hello brave new world"; 
    System.out.println("\"" + reverseWordByWord(str) + "\""); 
} 

public static String reverseWordByWord(String str) { 
    String reverse = ""; 
    boolean first = true; 
    for (String s : str.split(" ")) { 
     if (first) { 
      first = false; 
     } else { 
      reverse += " "; 
     } 
     StringBuilder sb = new StringBuilder(); 
     for (int i = s.length() - 1; i >= 0; --i) { 
      sb.append(s.charAt(i)); 
     } 
     reverse += sb.toString(); 
    } 
    while (reverse.length() < str.length()) { 
     reverse += " "; 
    } 
    return reverse.substring(0, reverse.length()); 
} 
} 

Answer 10

Tak, jestem przy założeniu, że uczysz/uprawiania java i że istnieje wysokie ryzyko domowej pytanie ... To znaczy, że to albo miłość albo nienawiść tę odpowiedź ...

Jeśli przyjrzeć kodu źródłowego obiektu String znajdziesz coś takiego wewnątrz:

private final char value[]; //this stores the String's characters

pierwszym krokiem jest, aby ta wartość [] z:

char[] myChars = str.toCharArray(); 

Uwaga realizacja funkcji (z openjdk-7), zwraca kopię tablicy, a nie oryginalne, ponieważ obiekty String są niezmienne.

public char[] toCharArray() { 
    char result[] = new char[count]; 
    getChars(0, count, result, 0); //Calls System.arraycopy(...) 
    return result; 
} 

Teraz, gdy mamy myChars możemy bawić się z nim i dostać się do wyniku w czasie liniowym O (n)!

public static String reverseWordByWord(String str) { 
    char[] myChars = str.toCharArray(); 
    int stringLen = myChars.length; 

    int left = 0, right = 0; 
    for(int index = 0; index < stringLen; index++) { 
     if(chars[index] == ' ') { 
      //assign right 
      reverse(chars, left, right); 
      //update left 
     } 
    } 
    //Don't forget to handle the boundary case (last word in the String)! 
} 

A oto odwrotnej funkcja:

private static void reverse(char[] chars, int left, int right) { 
    while(left < right) { 
     //Would you know how to swap 2 chars without using a "char tmp" variable? ;) 
     //Update left and right 
    } 
} 

Teraz po prostu dla zabawy warto spróbować dostać się do następnego wyjścia zamiast a może dostaniesz dokładnie to pytanie od jakiegoś ankieter że zabrakło fantazji jeden dzień:

world new brave hello

Answer 11

wziąć String i korzystając Stack metody i przy pomocy ich metod możemy przyciąć łańcuch znaków do fragmentu słów przy pomocy . Dzięki opcji Stack Natural funkcja wstaw wszystkie słowa do Satck i Usuń (pop) wszystkie słowa ze stosu. następnie wydrukuj te wszystkie.

Tutaj możemy podjąć ciąg s = "Hello Brave New World"

import java.util.*; 
public class StringReverse { 
    public static void main(String[] argv) { 
     String s = "hello brave new world";  
     Stack<String> myStack = new Stack<String>(); 
     StringTokenizer st = new StringTokenizer(s); 
     while (st.hasMoreTokens()) 
      myStack.push((String) st.nextElement());  
      // Print the stack backwards  
      System.out.print('"' + s + '"' + " backwards by word is:\n\t\"");  
     while (!myStack.empty()) {   
      System.out.print(myStack.pop());  
      System.out.print(' ');  
     }  System.out.println('"'); 
    } 
} 

Jeśli używasz żadnego pakietu z własną następnie sprawdzić Output of above program.

Answer 12

StringBuilder sb = " This is cool"; 
    sb.reverse(); //sb now contains "looc si sihT " 
    System.out.println(sb); 
    for(int i = 0; i < sb.length(); i++) 
    { 
     int index = sb.indexOf(" ", i); 
     // System.out.println(index); 
     if(index > 0) 
     { 
      sb.replace(i, index, new StringBuilder(sb.substring(i, index)).reverse().toString()); 
      i = index; 
     } 
     if(index < 0) 

     { 
      sb.replace(i, sb.length(), new StringBuilder(sb.substring(i, sb.length())).reverse().toString()); 
      break; 
     } 
    } 
    System.out.println(sb); 
    //output "cool is This " 

Answer 13

Moje podejście przy użyciu StringUtils. W teście jednostkowym.

@Test 
public void testReversesWordsAndThenAllCharacters(){ 
    String sentence = "hello brave new world"; 
    String reversedWords = StringUtils.reverseDelimited(sentence, ' '); 
    String reversedCharacters = StringUtils.reverse(reversedWords); 
    assertEquals("olleh evarb wen dlrow", reversedCharacters); 
} 

jeśli statycznych StringUtils importu, to może być wstawiane do:

reverse(reverseDelimited("hello brave new world", ' ')) 

Answer 14

nie używając funkcji split kod wyglądałby następująco:

public static void reverseSentance(String str) { 
    StringBuilder revStr = new StringBuilder(""); 
    int end = str.length(); // substring takes the end index -1 
    int counter = str.length()-1; 
    for (int i = str.length()-1; i >= 0; i--) {  
     if (str.charAt(i) == ' ' || i == 0) { 
      if (i != 0) { 
       revStr.append(str.substring(i+1, end)); 
       revStr.append(" "); 
      } 
      else { 
       revStr.append(str.substring(i,end)); 
      } 
      end = counter; 
     } 
     counter--; 
    } 
    System.out.println(revStr); 
} 

Answer 15

// Create Scanner object 
    Scanner s=new Scanner(System.in); 

    // Take no.of strings that the user wants 
    int n=s.nextInt(); 

    // Create a temp array 
    String temps[]=new String[n]; 

    // Initialize the variable before the user input is stored in it 
    String st=""; 

    // Create a words array 
    String words[]; 

    // Skip first line, if not used user input will be skipped one time 
    s.nextLine(); 

    // Read the no.of strings that user wish to.. 
    for(int k=0;k<n;k++) 
    { 

    System.out.println("String #"+(k+1)+": "); 

    // Read line 
    st=s.nextLine(); 

// Split words with a space, because words has spaces at start, end positions. 
words=st.split(" "); 

// Initialize temps[k] to avoid null 
temps[k]=""; 

// Reverse string now! 
for(int i=words.length-1;i>=0;i--) 
{ 

// Put each word in user input string from end to start with a space 
temps[k]+=words[i]+" "; 

} 
} 

    // Now print the words! 
    for(int i=0;i<n;i++) 
    { 

    // Print the reversed strings, trim them to avoid space at last, see in the reverse logic loop, space is attached at last! 
    System.out.println("String #"+(i+1)+": "+temps[i].trim()); 

    } 

Answer 16

Jeśli str = "Szybki brązowy lis przeskoczył leniwego psa!" zwróci to jak "pies! leniwy nad przeskoczył lisa brązowy szybkie" ...

private static String Reverse(String str) { 
     char charArray[] = str.toCharArray(); 
    for (int i = 0; i <str.length(); i++){ 
     if(charArray[i] == ' ') 
     return Reverse(str.substring(i + 1)) + str.substring(0, i) + " "; 
    } 

    return str + " "; 
} 

Answer 17

public class StringReversers { 

    public static void main(String[] args) { 
     String s = new String(revStr("hello brave new world")); 
     String st = new String(revWords("hello brave new world")); 
     System.out.println(s); 
     System.out.println(st); 
    } 

    public static String revStr(String s){ 
     StringBuilder sb = new StringBuilder(); 
     for (int i=s.length()-1; i>=0;i--){ 
      sb.append(s.charAt(i)); 
     } 
     return sb.toString(); 
    } 

    public static String revWords(String str) { 
     StringBuilder sb = new StringBuilder(); 
     String revd = revStr(str); 
     for (String s : revd.split(" ")){ 
      sb.append(revStr(s)); 
      sb.append(" "); 
     } 
     return sb.toString(); 
    } 

} 

Answer 18

myślę, że mój kod poniżej jest bardziej wydajny niż jakikolwiek dostępny kod tutaj:

public static void revWordsInStringCStyle(String str){ 
    char [] str_ch = str.toCharArray(); 
    System.out.println(str); 
    char temp; 
    int len = str_ch.length; 
    int left = len-1; 

    for(int right =0; right<len/2 ;right++){ 
     temp = str_ch[left]; 
     str_ch[left] = str_ch[right]; 
     str_ch[right] = temp; 
     left--; 
    } 

    for(int i =0; i < len ; i++){ 
     System.out.print(str_ch[i]); 

    } 

}

przykład: "Hello World"

staną się " dlrow olleho "

Answer 19

Jak o tym:

public class Main { 
    public static void main(String args[]){ 
     String input ="***NGuyen**Van******A*******"; 
     String temp = ""; 
     String result =""; 
     for(int i = 0 ; i < input.length() ; i++) 
     { 
      if(input.charAt(i) != '*') 
      { 
       temp = temp + input.charAt(i); 
      } 
      else 
      { 
       if(!temp.equals("")) 
        result = temp + result; 
       result = input.charAt(i) + result ; 
       temp =""; 
      } 
     } 

     System.out.println(result); 
    } 
} 
Output: *******A******Van**NGuyen*** 

Answer 20

public static void reverseByWord(String s) { 

     StringTokenizer token = new StringTokenizer(s); 

     System.out.println(token.countTokens()); 
     Stack<String> stack = new Stack<String>(); 
     while (token.hasMoreElements()) { 
      stack.push(token.nextElement().toString()); 
     } 

     while (!stack.isEmpty()) { 
      System.out.println(stack.pop()); 
     } 
    } 

Answer 21

Innym rozwiązaniem bez użycia metody podziału

public static String reverseWordsWithoutSplit(String str) { 
    StringBuffer buffer = new StringBuffer(); 
    int length = str.length(); 
    while(length >0) { 
     int wordstart = length -1; 
     while(wordstart >0 && str.charAt(wordstart) != ' '){ 
      wordstart--; 
     } 
     buffer.append(str.substring(wordstart==0?wordstart:wordstart+1, length)); 
     if(wordstart>0) 
      buffer.append(" "); 
     length = wordstart; 
    } 
    return buffer.toString(); 
} 

Answer 22

Próbowałem to zrobić bez podziału funkcji. Zamiast tego użyj podłańcucha i pętli.

static String reverseSentenceWithoutSplit(String str){ 
    StringBuilder sb = new StringBuilder(); 
    char [] charArray = str.toCharArray(); 
    int endindex = charArray.length-1; 
    // loop in reverse, char by char 
    for(int i=charArray.length-1; i>=0; i--){ 
     char c = charArray[i]; 
     if(c==' '){ 
      sb.append(str.substring(i + 1, endindex+1)); // substring- start index inclusive, end index exclusive 
      endindex=i-1;// move to first letter 
      sb.append(c); // include the space 
     } 
     if(i==0){ //grab the last word 
      sb.append(str.substring(i, endindex+1)); 
     } 
    } 
    if(sb.length()==0){ // handle case where string has no space 
     return str; 
    } 
    return sb.toString(); 
} 

wejściowy: Za tobą jest symbolem ucisku Wyjście: ucisk symbolu jest Ci Za

Wejście: ThisIsAllOneWord Output: ThisIsAllOneWord

Answer 23

Innym rozwiązaniem. To rozwiązanie jest na miejscu.

Odwróć słowa w ciągu znaków (słowa są oddzielone jedną lub więcej spacjami), spacje mogą poprzedzać słowa (s), tj. Spacja na początku zdania, koniec itd. ... Rozwiąż to miejsce.

public class ReverseWordsInString { 

public static void main(String[] args) { 
    // TODO Auto-generated method stub 

    char[] sentence = " Hi my name is person!".toCharArray(); 
    System.out.println(ReverseSentence(sentence)); 

} 
private static char[] ReverseSentence(char[] sentence) 
{ 
    //Given: "Hi my name is person!" 
    //produce: "iH ym eman si !nosrep" 
    //the obvious naive solution: utilize stringtokenize to separate each word into its own array. reverse each word and insert space between each array print 
    //better solution: drop stringtokenize and use a counter to count how many characters processed before space was hit. 
    //     once space hit, then jump back swap characters between counter-1 and start position. O(1) Space 

    if(sentence == null) return null; 
    if(sentence.length == 1) return sentence;  

    int startPosition=0; 
    int counter = 0; 
    int sentenceLength = sentence.length-1; 

    //Solution handles any amount of spaces before, between words etc...  

    while(counter <= sentenceLength) 
    { 
     if(sentence[counter] == ' ' && startPosition != -1 || sentenceLength == counter) //Have passed over a word so upon encountering a space or end of string reverse word 
     { 
      //swap from startPos to counter - 1 
      //set start position to -1 and increment counter 
      int begin = startPosition; 

      int end; 
      if(sentenceLength == counter) 
      { 
       end = counter; 
      } 
      else     
       end = counter -1; 
      char tmp; 

     //Reverse characters 
      while(end >= begin){ 

       tmp = sentence[begin]; 
       sentence[begin] = sentence[end]; 
       sentence[end] = tmp; 

       end--; begin++; 

      }    

      startPosition = -1; //flag used to indicate we have no encountered a character of a string 


     } 

     else if(sentence[counter] !=' ' && startPosition == -1) //first time you encounter a letter in a word set the start position 
     { 
      startPosition = counter; 
     } 

     counter++; 
    } 

    return sentence;   
} 

}

Answer 24

public String reverseEach(String input) 
{ 
    String[] test = input.split(" "); 
    String output=""; 
    for(String t:test) 
    { 
     String p =""; 
     for(int i=t.length()-1;i>=0;i--) 
     { 
      p=p+t.charAt(i); 
     } 
     output=output+p+" "; 
    } 
    return output; 
} 

Answer 25

/* this code uses while loop and the position of spaces come correctly which is 
    a problem if you use for loop */ 


import java.util.*; 
class StrWordRev 
{ 
public void rev(String s) 
    { 
     for(int i=s.length()-1;i>=0;i--) 
     { 
      System.out.print(s.charAt(i)); 
     } 
     System.out.print(" "); 
    } 

public void main() 
{ 
    Scanner sc=new Scanner(System.in); 
    String s,s1=""; 
    System.out.println("Enter the string : "); 
    s=sc.nextLine(); 
    int i=0; 
    while(i<s.length()) 
    { 
     s1=""; 
     while(i<s.length() && s.charAt(i)!=' ') 
     { 
      s1=s1+s.charAt(i); 
      i++; 
     } 
     rev(s1); 
     i=i+1; 
    } 
} 

Answer 26

public class WordReverse { 

static StringBuilder sb = new StringBuilder(); 

public static void main(String[] args) { 

    Scanner sc = new Scanner(System.in); 
    System.out.println("Enter the correct Sentence :"); 
    String str = sc.nextLine().replaceAll("\\s+", " ");   //remove unwanted space using regex 

    int lastIndex = 0, i = 0; 

    for (char chars : str.toCharArray()) { 
     if (chars != ' ') { 
      i++; 
     } else { 
      myReverse(str.substring(lastIndex, i).toCharArray()); 
      lastIndex = i + 1; 
      i++; 
     } 
    } 
    myReverse(str.substring(lastIndex, i).toCharArray());  //reverse the last word 

    System.out.println(sb); 
} 
public static void myReverse(char c[]) { 
    for (int i = (c.length - 1) ; i >= 0 ; i--) { 
     sb.append(c[i]); 
    } 
    sb.append(" "); 
} } 

Answer 27

Oto jeden wątek dyskusji również ten problem. Myślę, że jedna odpowiedź przy użyciu split z regex jest bardzo sprytna.

https://codereview.stackexchange.com/questions/43838/reverse-a-string-word-by-word

public String reverseWordByWord(String s) { 
    StringBuilder result = new StringBuilder(); 
    String[] words = sentence.split("\\s+");  
    for (int i = words.length - 1 ; 0 <= i; i--) { 
    result.append(words[i]).append(' '); 
    } 
    return result.toString().trim(); 
} 

Answer 28

Odpowiedź na swojej usunięciu spacji wyjścia jest proste, wystarczy

return reverse.trim(); 

String.trim() zwraca kopię napisu z początkowe i końcowe spacje pominięte (jak skopiowane z dokumentacji Javadoc).

dla ogólnego problemu, zrobiłem tę próbkę up:

String job = "This is a job interview question!"; 
StringBuilder sb = new StringBuilder(job); 
String[] words = job.split(" "); 
int i = 0; 
for (String word : words) { 
    words[i] = (new StringBuilder(word)).reverse().toString(); 
    i++; 
} 

System.out.println("job = " + job); 
System.out.print("rev = "); 
for (String word: words) { 
    sb.append(new StringBuilder(word).toString()); 
    sb.append(" "); 
} 

String rev = sb.toString().trim(); 
System.out.println(rev); 

i wyjście jest:

job = This is a job interview question! 
rev = sihT si a boj weivretni !noitseuq 

Jeśli chcesz być bardziej włącznie charakteru przestrzeni białego, np, znak tabulatora, podział wiersza, posuw formularza, a następnie zmień argument na split("\\s") jako klasę znaków regex, która reprezentuje [\ t \ r \ n \ f]. Zwróć uwagę, w jaki sposób należy wymazać znak ukośnika odwrotnego w łańcuchowej reprezentacji wyrażenia regularnego (co jest metodą dzieloną).

Answer 29

jak odwrócić wyraz w java

public class ReverseString { 

public static void main(String[] args) { 
    String reverse = ""; 
    String original = new String("hidaya"); 

     for (int i = original.length() - 1 ; i >= 0 ; i--) 
     reverse = reverse + original.charAt(i); 

     System.err.println("Orignal string is: "+original); 
     System.out.println("Reverse string is: "+reverse); 
    } 
} 

Answer 30

ten powinien pracować dla Ciebie:

import java.io.*; 

class internal1 { 
    public static void main(String s[] { 
     DataInputStream dis = new DataInputStream(System.in); 

     try { 
      String a = ""; 
      String b = ""; 
      System.out.print("Enter the string::"); 
      a = dis.readLine(); 
      System.out.print(a.length()); 
      System.out.println(" "); 
      for (int i = 0; i <= a.length() - 1; i++) { 
       if (a.charAt(i) == ' ' || a.charAt(i) == '.') { 
        for (int j = b.length() - 1; j >= 0; j--) { 
         System.out.print(b.charAt(j)); 
        } 
        b = ""; 
        System.out.print(" "); 
       } 
       b = b + a.charAt(i); 
      } 
     } 
     catch (Exception e) { 
     } 
    } 
} 

Answer 31

Oto technika kodowania przy użyciu popularnego split() funkcja, która jest dostępna we wszystkich głównych językach , Java toCharArray(), dobre do pełnej kontroli znaków w formie ciągu oraz klasy Java StringBuilder dla wydajności (dostępne również w języku C#).

myślę, że kod jest łatwiejszy do zrozumienia w porównaniu do innych opublikowanych odpowiedzi

public static String reverseWordByWord(String sentence) { 
    StringBuilder result = new StringBuilder(); 
    String[] words = sentence.split("\\s+"); // space(s) are the delimiters 

    for (String word : words) { 
     char[] charArray = word.toCharArray(); 
     int iEnd = word.length() - 1; 

     StringBuilder temp = new StringBuilder(); 
     for (int i = iEnd; i >= 0; i--) { 
      temp.append(charArray[ i]); 
     } 
     result.append(temp); 
     result.append(" ");  // separate the words 
    } 
    return result.toString().trim(); // remove the trailing spaces 
} 

przypomnieniem wymogów zamieszczonych przez autora.
Próbka wejście: "Hello World"
Wyjście: "olleh dlroW"

Answer 32

Oto rozwiązanie bez użycia funkcji ciąg jak odwrotnej, podciąg, podzielone lub tokenizera. Moje 2 centy

public String reverseWordByWord(String strToReverse) { 
    StringBuilder tempBuilder = new StringBuilder(); 
    StringBuilder reversedBuilder = new StringBuilder(); 
    char[] charArray ; 
    for (int i=0; i<=strToReverse.length()-1;i++) { 

     if (strToReverse.charAt(i) != ' ') { 
      tempBuilder.append(strToReverse.charAt(i)); // dont add if space found 
     } 

     if (strToReverse.charAt(i) == ' ' || i == strToReverse.length()-1) { 

      charArray = new String(tempBuilder).toCharArray(); // convert the temp builder to char array (for reversing) 

      for (int j=charArray.length-1; j>=0 ;j--) { 
       reversedBuilder.append(charArray[j]); 
      } 
      if (i != strToReverse.length()-1) // dont add if it is the last character 
       reversedBuilder.append(strToReverse.charAt(i)); 
      tempBuilder = new StringBuilder(); 
     } 
    } 
    System.out.println("Word by Word : "+new String(reversedBuilder)); 

    return new String(reversedBuilder); 
} 

Answer 33

import java.util.*; 
public class REVERSE 
{ 
    public static void main() 
    { 
     Scanner input = new Scanner(System.in); 
     System.out.println("Enter words: "); 
     String word = new String(input.nextLine()); 
     String reverse[] = word.split(" "); 
     String Finalword = " "; 
     for(int y = reverse.length-1;y>=0;y--){ 
      Finalword += reverse[y]+" "; 
     } 
     System.out.println(Finalword); 
    } 
} 

Answer 34

Oto najprostszy sposób, aby odwrócić ciągi słowo po słowie użyciu Arraylist i Tokenizer() Który to dobry wybór ... rzucić okiem na to:

import java.util.*; 

class ReverseWords{ 

    public static void main(String args[]){ 

    Scanner sc = new Scanner(System.in); 

    System.out.println(" Please Enter The String \n"); 
     String st=sc.nextLine(); 

    //Using ArrayList 
     ArrayList<String> List =new ArrayList<String>(); 
     StringTokenizer tokens=new StringTokenizer(st); 

     while(tokens.hasMoreTokens()){ 
      List.add(tokens.nextToken()); 
     } 
    Collections.reverse(List); 

    Iterator itr=List.iterator(); 
    while(itr.hasNext()){ 
     System.out.print(itr.next()+" "); 
    } 

    } 
}