reves - Invertir una cadena en Java

reversa de una cadena java

Question

Tengo "Hello World" guardado en una variable de cadena llamada hi .

Necesito imprimirlo, pero revertido.

¿Cómo puedo hacer esto? Entiendo que hay algún tipo de función ya incorporada en Java que hace eso.

Relacionado: Invierta cada palabra individual de la cadena "Hello World" con Java

Answer 1

Todo el mundo propone una manera de revertir la cadena aquí. Si usted, el lector de la respuesta, está interesado, mi manera de usar /u202E unicode está aquí.

public static String reverse(String s) {
        return "/u202E" + s;
}

Answer 2

Procedimiento:

Podemos usar split () para dividir la cadena. Luego use el ciclo inverso y añada los caracteres.

Fragmento de código:

class test
{
  public static void main(String args[]) 
  {
      String str = "world";
      String[] split= str.split("");

      String revers = "";
      for (int i = split.length-1; i>=0; i--)
      {
        revers += split[i];
      }
      System.out.printf("%s", revers);
   }  
}

 //output : dlrow

Answer 3

Aquí hay un ejemplo usando recursión:

public void reverseString() {
    String alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String reverseAlphabet = reverse(alphabet, alphabet.length()-1);
}

String reverse(String stringToReverse, int index){
    if(index == 0){
        return stringToReverse.charAt(0) + "";
    }

    char letter = stringToReverse.charAt(index);
    return letter + reverse(stringToReverse, index-1);
}

Answer 4

Aquí hay una solución de bajo nivel:

import java.util.Scanner;

public class class1 {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        String inpStr = in.nextLine();
        System.out.println("Original String :" + inpStr);
        char temp;
        char[] arr = inpStr.toCharArray();
        int len = arr.length;
        for(int i=0; i<(inpStr.length())/2; i++,len--){
            temp = arr[i];
            arr[i] = arr[len-1];
            arr[len-1] = temp;
        }

        System.out.println("Reverse String :" + String.valueOf(arr));
    }
}

Answer 5

Como otros han señalado, la forma preferida es usar:

new StringBuilder(hi).reverse().toString()

pero si desea implementar esto por su cuenta, me temo que el resto de respuestas tienen fallas.

La razón es que String representa una lista de puntos Unicode , codificados en una matriz char[] acuerdo con la codificación de longitud variable: UTF-16 .

Esto significa que algunos puntos de código usan un solo elemento de la matriz (una unidad de código) pero otros usan dos de ellos, por lo que puede haber pares de caracteres que deben tratarse como una sola unidad (sustitutos consecutivos "alto" y "bajo")

public static String reverseString(String s) {
    char[] chars = new char[s.length()];
    boolean twoCharCodepoint = false;
    for (int i = 0; i < s.length(); i++) {
        chars[s.length() - 1 - i] = s.charAt(i);
        if (twoCharCodepoint) {
            swap(chars, s.length() - 1 - i, s.length() - i);
        }
        twoCharCodepoint = !Character.isBmpCodePoint(s.codePointAt(i));
    }
    return new String(chars);
}

private static void swap(char[] array, int i, int j) {
    char temp = array[i];
    array[i] = array[j];
    array[j] = temp;
}

public static void main(String[] args) throws Exception {
    FileOutputStream fos = new FileOutputStream("C:/temp/reverse-string.txt");
    StringBuilder sb = new StringBuilder("Linear B Syllable B008 A: ");
    sb.appendCodePoint(65536); //http://unicode-table.com/es/#10000
    sb.append(".");
    fos.write(sb.toString().getBytes("UTF-16"));
    fos.write("/n".getBytes("UTF-16"));
    fos.write(reverseString(sb.toString()).getBytes("UTF-16"));
}

Answer 6

Dado que el método a continuación (usar XOR ) para revertir una cadena no está en la lista, adjunto este método para revertir una cadena.

El algoritmo se basa en:

1. (A XOR B) XOR B = A

2. (A XOR B) XOR A = B

Fragmento de código:

public class ReverseUsingXOR {
    public static void main(String[] args) {
        String str = "prateek";
        reverseUsingXOR(str.toCharArray());
    }   

    /*Example:
     * str= prateek;
     * str[low]=p;
     * str[high]=k;
     * str[low]=p^k;
     * str[high]=(p^k)^k =p;
     * str[low]=(p^k)^p=k;
     * 
     * */
    public static void reverseUsingXOR(char[] str) {
        int low = 0;
        int high = str.length - 1;

        while (low < high) {
            str[low] = (char) (str[low] ^ str[high]);
            str[high] = (char) (str[low] ^ str[high]);   
            str[low] = (char) (str[low] ^ str[high]);
            low++;
            high--;
        }

        //display reversed string
        for (int i = 0; i < str.length; i++) {
            System.out.print(str[i]);
        }
    }

}

Salida:

Keetarp

Answer 7

Eche un vistazo a la API de Java 6 en StringBuffer

String s = "sample";
String result = new StringBuffer(s).reverse().toString();

Answer 8

Es muy sencillo en código de líneas mínimo.

public class ReverseString {
    public static void main(String[] args) {
        String s1 = "neelendra";
        for(int i=s1.length()-1;i>=0;i--)
            {
                System.out.print(s1.charAt(i));
            }
    }
}

Answer 9

Esto hizo el truco para mí

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

    for (int i = (text.length() - 1); i >= 0; i--) {
        System.out.print(text.charAt(i));
    }
}

Answer 10

Estoy haciendo esto usando las siguientes dos maneras:

Cadena inversa por personajes:

public static void main(String[] args) {
    // Using traditional approach
    String result="";
    for(int i=string.length()-1; i>=0; i--) {
        result = result + string.charAt(i);
    }
    System.out.println(result);

    // Using StringBuffer class
    StringBuffer buffer = new StringBuffer(string);
    System.out.println(buffer.reverse());    
}

Cadena inversa por palabras:

public static void reverseStringByWords(String string) {
    StringBuilder stringBuilder = new StringBuilder();
    String[] words = string.split(" ");

    for (int j = words.length-1; j >= 0; j--) {
        stringBuilder.append(words[j]).append('' '');
    }
    System.out.println("Reverse words: " + stringBuilder);
}

Answer 11

La solución anterior es demasiado buena, pero aquí estoy haciendo una cadena inversa usando programación recursiva.

Esto es útil para quien busca una forma recursiva de hacer una cadena inversa.

public class ReversString {

public static void main(String args[]) {
    char s[] = "Dhiral Pandya".toCharArray();
    String r = new String(reverse(0, s));
    System.out.println(r);
}

public static char[] reverse(int i, char source[]) {

    if (source.length / 2 == i) {
        return source;
    }

    char t = source[i];
    source[i] = source[source.length - 1 - i];
    source[source.length - 1 - i] = t;

    i++;
    return reverse(i, source);

}

}

Answer 12

Lo intenté, solo por diversión, usando una pila. Aquí mi código:

public String reverseString(String s) {
    Stack<Character> stack = new Stack<Character>();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < s.length(); i++) {
        stack.push(s.charAt(i));
    }
    while (!stack.empty()) {
        sb.append(stack.pop());
    }
    return sb.toString();

}

Answer 13

Obtiene el valor que escribió y lo devuelve invertido;)

public static  String reverse (String a){
    char[] rarray = a.toCharArray();
    String finalvalue = "";
    for (int i = 0; i < rarray.length; i++)
    {
        finalvalue += rarray[rarray.length - 1 - i];
    }   
return finalvalue;

}

Answer 14

Para los problemas de jueces en línea que no permiten StringBuilder o StringBuffer , puede hacerlo usando char[] siguiente manera:

public static String reverse(String input){
    char[] in = input.toCharArray();
    int begin=0;
    int end=in.length-1;
    char temp;
    while(end>begin){
        temp = in[begin];
        in[begin]=in[end];
        in[end] = temp;
        end--;
        begin++;
    }
    return new String(in);
}

Answer 15

Puedes usar esto:

new StringBuilder("hi").reverse().toString()

O, para versiones anteriores a JDK 1.5, use java.util.StringBuffer lugar de StringBuilder - tienen la misma API. Gracias a los comentaristas por señalar que StringBuilder es el preferido hoy en día.

Answer 16

Solo por diversión..:)

Algorithm (str,len)
char reversedStr[] =new reversedStr[len]

Recorrer i de 0 a len / 2 y luego

reversedStr[i]=str[len-1-i]  
reversedStr[len-1=i]=str[i]
return reversedStr;

Complejidad del tiempo: O (n)

Complejidad del espacio: O (n)

public class Reverse {
    static char reversedStr[];

    public static void main(String[] args) {
        System.out.println(reversestr("jatin"));
    }


    private static String reversestr(String str) {
        int strlen = str.length();
        reversedStr = new char[strlen];

        for (int i = 0; i <= strlen / 2; i++) {
            reversedStr[i] = str.charAt(strlen - 1 - i);
            reversedStr[strlen - 1 - i] = str.charAt(i);

        }
        return new String(reversedStr);
    }

}

Answer 17

También puedes probar esto:

public class StringReverse {
    public static void main(String[] args) {
        String str = "Dogs hates cats";
        StringBuffer sb = new StringBuffer(str);
        System.out.println(sb.reverse());
    }
}

Answer 18

Una forma natural de revertir una String es usar un StringTokenizer y una pila. Stack es una clase que implementa una pila de objetos fácil de usar de último en entrar, primero en salir (LIFO).

String s = "Hello My name is Sufiyan";

Ponlo en la pila al frente.

Stack<String> myStack = new Stack<>();
StringTokenizer st = new StringTokenizer(s);
while (st.hasMoreTokens()) {
     myStack.push(st.nextToken());
}

Imprime la pila al revés

System.out.print(''"'' + s + ''"'' + " backwards by word is:/n/t/"");
while (!myStack.empty()) {
  System.out.print(myStack.pop());
  System.out.print('' '');
}

System.out.println(''"'');

Answer 19

cadena pública reversewords (cadena s) {

    String reversedWords = "";

    if(s.length()<=0) {
        return reversedWords;
    }else if(s.length() == 1){
        if(s == " "){
            return "";
        }
        return s;
    }

    char arr[] = s.toCharArray();
    int j = arr.length-1;
    while(j >= 0 ){
        if( arr[j] == '' ''){
            reversedWords+=arr[j];
        }else{
            String temp="";
            while(j>=0 && arr[j] != '' ''){
                temp+=arr[j];
                j--;
            }
            j++;
            temp = reverseWord(temp);
            reversedWords+=temp;
        }
        j--;

    }

    String[] chk = reversedWords.split(" ");

    if(chk == null || chk.length == 0){
        return "";
    }

    return reversedWords;



}

public String reverseWord(String s){

    char[] arr = s.toCharArray();

    for(int i=0,j=arr.length-1;i<=j;i++,j--){
        char tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }
    return String.valueOf(arr);

}

Answer 20

1. Usando Character Array:

public String reverseString(String inputString) {
    char[] inputStringArray = inputString.toCharArray();
    String reverseString = "";
    for (int i = inputStringArray.length - 1; i >= 0; i--) {
        reverseString += inputStringArray[i];
    }
    return reverseString;
}

2. Utilizando StringBuilder:

public String reverseString(String inputString) {
    StringBuilder stringBuilder = new StringBuilder(inputString);
    stringBuilder = stringBuilder.reverse();
    return stringBuilder.toString();
}

O

return new StringBuilder(inputString).reverse().toString();

Answer 21

    public String reverse(String s) {

        String reversedString = "";
        for(int i=s.length(); i>0; i--) {
            reversedString += s.charAt(i-1);
        }   

        return reversedString;
    }

Answer 22

String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);

Answer 23

StringBuilder s = new StringBuilder("racecar");
    for (int i = 0, j = s.length() - 1; i < (s.length()/2); i++, j--) {
        char temp = s.charAt(i);
        s.setCharAt(i, s.charAt(j));
        s.setCharAt(j, temp);
    }

    System.out.println(s.toString());

Answer 24

System.out.print("Please enter your name: ");
String name = keyboard.nextLine();

String reverse = new StringBuffer(name).reverse().toString();
String rev = reverse.toLowerCase();
System.out.println(rev);

Utilicé este método para convertir los nombres al revés y en minúsculas.

Answer 25

import java.util.Scanner;

public class Test {

    public static void main(String[] args){
        Scanner input = new Scanner (System.in);
        String word = input.next();
        String reverse = "";
        for(int i=word.length()-1; i>=0; i--)
            reverse += word.charAt(i);
        System.out.println(reverse);        
    }
}

Si quieres usar un simple for loop!

Answer 26

import java.util.Scanner;
public class StringReverseExample
{
    public static void main(String[] args)
    {
        String str,rev;
        Scanner in = new Scanner(System.in);
        System.out.print("Enter the string : ");
        str = in.nextLine();
        rev = new StringBuffer(str).reverse().toString();
        System.out.println("/nString before reverse:"+str);
        System.out.println("String after reverse:"+rev);
    }
}
/* Output : 
Enter the string : satyam

String before reverse:satyam
String after reverse:maytas */

Answer 27

package logicprogram;
import java.io.*;

public class Strinrevers {
public static void main(String args[])throws IOException
{
    BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    System.out.println("enter data");
    String data=br.readLine();
    System.out.println(data);
    String str="";
    char cha[]=data.toCharArray();

    int l=data.length();
    int k=l-1;
    System.out.println(l);


    for(int i=0;k>=i;k--)
    {

        str+=cha[k];


    }
    //String text=String.valueOf(ch);
    System.out.println(str);

}

}

Answer 28

public class Test {

public static void main(String args[]) {
   StringBuffer buffer = new StringBuffer("Game Plan");
   buffer.reverse();
   System.out.println(buffer);
 }  
}

Answer 29

public static String reverseIt(String source) {
    int i, len = source.length();
    StringBuilder dest = new StringBuilder(len);

    for (i = (len - 1); i >= 0; i--){
        dest.append(source.charAt(i));
    }

    return dest.toString();
}

http://www.java2s.com/Code/Java/Language-Basics/ReverseStringTest.htm

Answer 30

public void reverString(){
System.out.println("Enter value");
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 try{

  String str=br.readLine();
  char[] charArray=str.toCharArray();
  for(int i=charArray.length-1; i>=0; i--){
   System.out.println(charArray[i]);
  }
  }
   catch(IOException ex){
  }