Invertir cadena palabra por palabra en Java

Tengo el siguiente código para invertir una cadena palabra por palabra, tengo una pregunta, ¿podría alguien primero indicar cómo mejorar el código? y segundo, ¿cómo puedo eliminar el espacio con el que termino al comienzo de la nueva cadena?

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 = 0; j--){ reverse += temp.charAt(j); if((j == 0) && (i != strLeng)) reverse += " "; } temp = ""; } } return reverse; } 

la frase en este momento se convierte en:

olleh evarb wen dlrow

observe el espacio al comienzo de la nueva cadena.

Al no usar la función dividida, el código se vería así:

 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); } 

Si str = “¡El rápido zorro marrón saltó sobre el perro perezoso!” lo devolverá como “perro! perezoso el más saltó el zorro marrón rápido El” …

  private static String Reverse(String str) { char charArray[] = str.toCharArray(); for (int i = 0; i  

He aquí cómo puedes hacerlo:

  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(); 

Mi enfoque usando StringUtils. En una prueba unitaria.

 @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); } 

Si está importando StringUtils estáticamente, esto podría estar inline a:

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

Lo primero que haría es separar el código invirtiendo las palabras del código de forma invirtiendo cada palabra individualmente. Este lazo interno:

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

Sería una llamada de función / método.

Además, para hacer que su código sea más eficaz, en lugar de concatenar cadenas con el operador + , usaría una clase de buffer de cadena. Tales como StringBuffer o StringBuilder .

Antes que nada, debes desacoplarlo en tres funciones. La primera división de la secuencia grande en una lista de cadenas usando el espacio como delimitador, la segunda inversión de una cadena sin espacios y las últimas cadenas concatenadas.

Cuando lo haga, será más fácil ubicar el motivo por el que aparece el espacio. Ya puedes ver eso en el código actual, pero no voy a decirte: D.

¿Qué hay de usar algo como esto?

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

Podría usar StringUtils

 return StringUtils.reverseDelimitedString(str, " "); 

Prueba esto. Tiene en cuenta los signos de puntuación y los espacios en blanco de cualquier tipo.

 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(); } 
 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(); } } 
 public static void reverseByWord(String s) { StringTokenizer token = new StringTokenizer(s); System.out.println(token.countTokens()); Stack stack = new Stack(); while (token.hasMoreElements()) { stack.push(token.nextElement().toString()); } while (!stack.isEmpty()) { System.out.println(stack.pop()); } } 

Otra solución sin usar el método de división

  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(); } 

Otra solución. Esta solución está en su lugar.

Invertir palabras en una cadena (las palabras están separadas por uno o más espacios), los espacios pueden preceder a la (s) palabra (s), es decir, el espacio al comienzo de la oración, el final, etc. Resuélvelo en el lugar.

 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; } 

}

Aquí hay un tema que también trata este problema. Creo que una respuesta usando split con regex es muy inteligente.

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(); } 

La respuesta a su eliminación del carácter de espacio inicial es fácil, solo

 return reverse.trim(); 

String.trim() devuelve una copia de la cadena, con el espacio en blanco String.trim() y final omitido (como se copió de la documentación de Javadoc).

Para su problema general, hice esta muestra:

 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); 

y el resultado es:

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

Si desea ser más inclusivo de cualquier carácter de espacio en blanco, por ejemplo, carácter de tabulación, salto de línea, avance de formulario, entonces cambie el argumento de split() para split("\\s") ya que \s es la clase de caracteres regex [\ t \ r \ n \ f]. Observe cómo debe escapar el carácter de barra diagonal inversa en su representación de cadena Java de una expresión regular (que es lo que espera el método de división).

cómo revertir la palabra en 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); } } 

Aquí hay una técnica de encoding que usa la popular función split (), que está disponible en todos los idiomas principales, Java toCharArray (), buena para el control total de caracteres en forma de cadena, y la clase Java StringBuilder para el rendimiento (disponible en C # también).

Creo que el código es más fácil de entender que las otras respuestas publicadas

 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 } 

Recordatorio de los requisitos publicados por el autor.
Ejemplo de entrada : “Hola mundo”
Salida : “olleH dlroW”

 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(); } 

Soy bastante nuevo en Java, y espero haber sido derrotado, pero pensé que podría intentarlo de todos modos. Podría resolver el problema del espacio en blanco adicional construyendo la cadena con la suposición de que eliminará el espacio adicional no deseado al final. Si el rendimiento es una consideración, entonces es posible que desee replantearse esto.

Editar: Tenga en cuenta que mi solución (ahora) maneja los espacios en blanco iniciales y finales.

 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()); } } 

Entonces, supongo que estás aprendiendo / practicando java y que existe un alto riesgo de que surja la tarea … Esto significa que amarás u odiarás esta respuesta …

Si echas un vistazo al código fuente del objeto String, encontrarás algo como esto en el interior:

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

El primer paso es obtener ese valor [] con:

 char[] myChars = str.toCharArray(); 

Observe la implementación de la función (desde openjdk-7 ), devuelve una copia de la matriz y no la original porque los objetos String son inmutables.

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

¡Ahora que tenemos myChars podemos jugar con eso y obtener el resultado en tiempo lineal 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)! } 

Y aquí está la función inversa :

 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 } } 

Ahora, solo por diversión, quizás quieras intentar obtener la siguiente salida y tal vez obtendrás la pregunta exacta de algún entrevistador que se quedó sin fantasía algún día:

world new brave hello

Lo siguiente debería hacerlo en O (n) sin ninguna costosa copia de matriz o reestructuración de la longitud del conjunto de caracteres. Se ocupa de múltiples espacios en blanco precedentes, intermedios y finales.

 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=0; i--) { sb.append(string.charAt(i)); } return sb.toString(); } } 

Tome una Cadena y use los métodos de Stack con el Objeto StringTokenizer y con sus métodos podemos cortar la Cadena en la pieza de Palabras usando delimeter . Mediante la función Stack Natural, inserte (push) todas las palabras en el Satck y quite (pop) todas las palabras de Stack. luego imprima todos esos.

Aquí podemos tomar la cadena s = “hola valiente nuevo mundo”

 import java.util.*; public class StringReverse { public static void main(String[] argv) { String s = "hello brave new world"; Stack myStack = new Stack(); 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('"'); } } 

Si está usando cualquier paquete con el suyo, entonces verifique el progtwig de Salida del progtwig anterior .

  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 " 
  // 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=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 

Creo que mi código a continuación es más eficiente que cualquier código disponible aquí:

 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 

}

Ejemplo: "hola mundo"

se convertirá en: "dlrow olleho"

Qué tal esto :

  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*** 

Intenté prescindir de la función de división. En cambio, usa subcadena y para bucle.

 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(); } 

Entrada: Detrás de ti hay un símbolo de opresión Salida: opresión del símbolo a ¿Estás detrás?

Entrada: ThisIsAllOneWord Output: ThisIsAllOneWord

 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; } 
 /* 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 

Esto debería funcionar para usted:

 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) { } } }