web-dev-qa-db-de.com

Einen String in Java umkehren

Ich habe "Hello World" in einer String-Variablen namens hi gespeichert.

Ich muss es ausdrucken, aber umgekehrt.

Wie kann ich das machen? Ich verstehe, dass in Java bereits eine Art Funktion eingebaut ist, die das macht.

Verwandte: Kehre jedes einzelne Wort der Zeichenfolge "Hello World" mit Java um

javastring
425
Ron

Sie können dies verwenden:

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

Oder verwenden Sie für Versionen vor JDK 1.5 Java.util.StringBuffer anstelle von StringBuilder - sie haben dieselbe API. Vielen Dank an die Kommentatoren, die darauf hingewiesen haben, dass StringBuilder heutzutage bevorzugt wird, wenn keine Bedenken hinsichtlich der Parallelität bestehen.

915
Daniel Brockman

Bei Online Judges-Problemen, die StringBuilder oder StringBuffer nicht zulassen, können Sie an Ort und Stelle mit char[] wie folgt vorgehen:

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);
}
104
Sami Eltamawy
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

61
Kevin Bowersox
String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);
58
Luchian Grigore

Ich verwende dazu die folgenden zwei Möglichkeiten:

mgekehrte Zeichenfolge von CHARACTERS:

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

String mit WORDS umkehren:

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

Schauen Sie sich die Java 6-API unter StringBuffer an

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

Hier ist ein Beispiel mit Rekursion:

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

Hier ist eine einfache Lösung:

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));
    }
}
12
Artur Grigio

Da die folgende Methode (mit X ODER) zum Umkehren einer Zeichenfolge nicht aufgeführt ist, füge ich diese Methode zum Umkehren hinzu ein Faden.

Der Algorithmus basiert auf:

1. (A XOR B) XOR B = A

2. (A XOR B) XOR A = B

Code-Auszug:

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

}

Ausgabe:

keetarp

11
Prateek Joshi

Ich habe es aus Spaß mit einem Stack versucht. Hier mein Code:

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

}
10
Enrico Giurin

Wie andere betont haben, ist der bevorzugte Weg zu verwenden:

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

aber wenn Sie dies selbst umsetzen möchten, fürchte ich, dass die restlichen Antworten Fehler aufweisen.

Der Grund dafür ist, dass String eine Liste von Unicode-Punkten darstellt, die in einem char[] -Array gemäß der Codierung variabler Länge codiert sind: TF-16 .

Dies bedeutet, dass einige Codepunkte ein einzelnes Element des Arrays verwenden (eine Codeeinheit), andere jedoch zwei, sodass möglicherweise Zeichenpaare als einzelne Einheit behandelt werden müssen (aufeinanderfolgende "hohe" und "niedrige" Ersatzzeichen).

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

Es ist sehr einfach in minimalen Zeilencodes

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

Das hat den Trick für mich getan

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

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

1. Using 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. Verwenden von StringBuilder:

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

OR

return new StringBuilder(inputString).reverse().toString();
3
Avijit Karmakar
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);

Ich habe diese Methode verwendet, um Namen rückwärts und in Kleinbuchstaben umzuwandeln.

3
Stormhawks

Vorgehensweise:

Wir können split () verwenden, um die Zeichenfolge zu teilen. Verwenden Sie dann die umgekehrte Schleife und fügen Sie die Zeichen hinzu.

Code-Auszug:

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
2
rashedcs

Die obige Lösung ist zu gut, aber hier mache ich eine umgekehrte Zeichenfolge mit rekursiver Programmierung.

Dies ist hilfreich für Benutzer, die nach rekursiven Methoden suchen, um umgekehrte Zeichenfolgen zu erstellen.

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

}

}
2
Dhiral Pandya
public class Test {

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

Eine natürliche Möglichkeit, ein String umzukehren, besteht darin, ein StringTokenizer und einen Stapel zu verwenden. Stack ist eine Klasse, die einen benutzerfreundlichen LIFO-Stapel (Last-In, First-Out) von Objekten implementiert.

String s = "Hello My name is Sufiyan";

Legen Sie es mit der Vorderseite nach vorne in den Stapel

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

Drucken Sie den Stapel rückwärts

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

System.out.println('"');
2
Sufiyan Ghori
    public String reverse(String s) {

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

        return reversedString;
    }
2
Dom Shahbazi

Nur zum Spaß..:)

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

Überquere i von 0 nach len/2 und dann

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

Zeitkomplexität: O (n)

Raumkomplexität: 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);
    }

}
2
jatin Goyal
public static String revString(String str){
    char[] revCharArr = str.toCharArray();
    for (int i=0; i< str.length()/2; i++){
        char f = revCharArr[i];
        char l = revCharArr[str.length()-i-1];
        revCharArr[i] = l;
        revCharArr[str.length()-i-1] = f;
    }
    String revStr = new String(revCharArr);
    return revStr;
}
1
Muhammad Aasharib Nawshad
    public static void reverseString(String s){
        System.out.println("---------");
        for(int i=s.length()-1; i>=0;i--){
            System.out.print(s.charAt(i));    
        }
        System.out.println(); 

    }
1
Mutlu
public static void main(String[] args) {
    String str = "Prashant";
    int len = str.length();
    char[] c = new char[len];
    for (int j = len - 1, i = 0; j >= 0; j--, i++) {
        c[i] = str.charAt(j);
    }
    str = String.copyValueOf(c);
    System.out.println(str);
}
1
Prashant Kumar

rekursion:

 public String stringReverse(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }
    return stringReverse(string.substring(1)) + string.charAt(0);
 }
1
connect2krish
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){
  }
1
Deepak Singh

Sie können dies auch versuchen:

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

public String reverseWords (String 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);

}
1
rvd

Jeder schlägt hier einen Weg vor, die Saite umzukehren. Wenn Sie, der Leser der Antwort, interessiert sind, ist mein Weg mit \u202E Unicode hier.

_public static String reverse(String s) {
        return "\u202E" + s;
}
_

Es kann ab hier getestet werden.

1
snr
    //Solution #1 -- Using array and charAt()
    String name = "reverse"; //String to reverse
    Character[] nameChar =  new Character[name.length()]; // Declaring a character array with length as length of the String which you want to reverse.
    for(int i=0;i<name.length();i++)// this will loop you through the String
    nameChar[i]=name.charAt(name.length()-1-i);// Using built in charAt() we can fetch the character at a given index. 
    for(char nam:nameChar)// Just to print the above nameChar character Array using an enhanced for loop
    System.out.print(nam);


    //Solution #2 - Using StringBuffer and reverse ().
    StringBuffer reverseString = new StringBuffer("reverse");
    System.out.println(reverseString.reverse()); //reverse () Causes the character sequence to be replaced by the reverse of the sequence.
1
abhi

Es erhält den von Ihnen eingegebenen Wert und kehrt ihn um;)

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;

}

0
Kelk

Einfache For-Schleife in Java

 public void reverseString(char[] s) {
    int length = s.length;
    for (int i = 0; i < s.length / 2; i++) {
        // swaping character
        char temp = s[length - i - 1];
        s[length - i - 1] = s[i];
        s[i] = temp;
    }
}
0
Sameer Shrestha
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);        
    }
}

Wenn Sie eine einfache for-Schleife verwenden möchten!

0
Apetrei Ionut
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);

}

}
0
kumaravel j
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());
0
camel-man

Zeichenfolge (oder) ZeichenfolgeFamilie der Zeichenfolge:

String testString = "[email protected]"; // ~1 1⁄4→D800₁₆«2²⁰

Java 8 Stream API verwenden

Zuerst konvertieren wir String mit der Methode CharSequence.chars() in Stream, dann generieren wir mit der Methode IntStream.range einen sequentiellen Stream von Zahlen. Dann ordnen wir diese Sequenz des Streams String zu.

public static String reverseString_Stream(String str) {
    IntStream cahrStream = str.chars();
    final int[] array = cahrStream.map( x -> x ).toArray();

    int from = 0, upTo = array.length;
    IntFunction<String> reverseMapper = (i) -> ( Character.toString((char) array[ (upTo - i) + (from - 1) ]) );

    String reverseString = IntStream.range(from, upTo) // for (int i = from; i < upTo ; i++) { ... }
            .mapToObj( reverseMapper )                 // array[ lastElement ]
            .collect(Collectors.joining())             // Joining stream of elements together into a String.
            .toString();                               // This object (which is already a string!) is itself returned.

    System.out.println("Reverse Stream as String : "+ reverseString);
    return reverseString;
}

Verwenden einer traditionellen for-Schleife

Wenn Sie die Zeichenfolge umkehren möchten, müssen Sie die folgenden Schritte ausführen.

  • Konvertieren Sie String in ein Array von Zeichen.
  • Durchlaufen Sie ein Array in umgekehrter Reihenfolge, und hängen Sie jedes Zeichen bis zum letzten Zeichen an die temporäre Zeichenfolgenvariable an.
public static String reverseString( String reverse ) {
    if( reverse != null && reverse != "" && reverse.length() > 0 ) {

        char[] arr = reverse.toCharArray();
        String temp = "";
        for( int i = arr.length-1; i >= 0; i-- ) {
            temp += arr[i];
        }
        System.out.println("Reverse String : "+ temp);
    }
    return null;
}

Einfache Verwendung der von StringBuffer- oder StringBuilder-Klassen bereitgestellten umgekehrten Methode

StringBuilder und StringBuffer sind veränderbare Zeichenfolgen. Das heißt, man kann den Wert dieser Objekte ändern.

StringBuffer buffer = new StringBuffer(str);
System.out.println("StringBuffer - reverse : "+ buffer.reverse() );

String builderString = (new StringBuilder(str)).reverse().toString;
System.out.println("StringBuilder generated reverse String : "+ builderString  );

StringBuffer hat die gleichen Methoden wie der StringBuilder, aber jede Methode in StringBuffer ist synchronisiert, damit es threadsicher ist.

0
Yash

Es gibt viele Möglichkeiten, eine Zeichenfolge umzukehren.

1. Konvertieren eines Strings in Bytes: Die getBytes () -Methode wird verwendet, um den Eingabe-String in Bytes [] zu konvertieren. 

import Java.lang.*;
import Java.io.*;
import Java.util.*;
class ReverseString{
public static void main(String[] args)
{
    String input = "GeeksforGeeks";
    byte [] strAsByteArray = input.getBytes();
    byte [] result =  new byte [strAsByteArray.length];

    for (int i = 0; i<strAsByteArray.length; i++)
        result[i] = 
         strAsByteArray[strAsByteArray.length-i-1];

    System.out.println(new String(result));
}
}

2. Konvertieren des Strings in ein Zeichenarray: Der Benutzer gibt den zu invertierenden String ein. (persönlich vorgeschlagen)

import Java.lang.*;
import Java.io.*;
import Java.util.*;


class ReverseString{
public static void main(String[] args)
{
    String input = "GeeksForGeeks";

    // convert String to character array
    // by using toCharArray
    char[] try1 = input.toCharArray();

    for (int i = try1.length-1; i>=0; i--)
        System.out.print(try1[i]);
}
}

3. Verwenden des ArrayList-Objekts: Konvertieren Sie die Eingabezeichenfolge mit der integrierten Methode toCharArray () in das Zeichenarray. Fügen Sie dann die Zeichen des Arrays in das ArrayList-Objekt ein. Java hat auch die reverse () -Methode für die Collections-Klasse eingebaut. Da die reverse () -Methode der Collections-Klasse ein Listenobjekt benötigt, übergeben wir das LinkedList-Objekt, bei dem es sich um eine Art Liste von Zeichen handelt. 

import Java.lang.*;
import Java.io.*;
import Java.util.*;

 class ReverseString{

public static void main(String[] args)
{
    String input = "Geeks For Geeks";
    char[] hello = input.toCharArray();
    List<Character> trial1 = new ArrayList<>();

    for (char c: hello)
        trial1.add(c);

    Collections.reverse(trial1);
    ListIterator li = trial1.listIterator();
    while (li.hasNext())
        System.out.print(li.next());
}
}
0
Sahil Nagpal