Een tekenreeks in Java omkeren

Ik heb "Hello World"bewaard in een String-variabele met de naam hi.

Ik moet het afdrukken, maar omgekeerd.

Hoe kan ik dit doen? Ik begrijp dat er al een soort functie in Java is ingebouwd die dat doet.

Gerelateerd: Keer elk afzonderlijk woord van de Hello World -tekenreeks om met Java

Antwoord 1, autoriteit 100%

U kunt dit gebruiken:

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

Of gebruik voor eerdere versies dan JDK 1.5 java.util.StringBufferin plaats van StringBuilder– ze hebben dezelfde API. Bedankt commentatoren om erop te wijzen dat StringBuildertegenwoordig de voorkeur heeft als er geen zorgen over gelijktijdigheid zijn.

Antwoord 2, autoriteit 11%

Voor Online Judges-problemenwaarbij StringBuilderof StringBufferniet is toegestaan, kunt u dit ter plaatsedoen met char[]als volgt:

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

Antwoord 3, autoriteit 6%

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

Antwoord 4, autoriteit 6%

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

Antwoord 5, autoriteit 3%

Ik doe dit op de volgende twee manieren:

Omgekeerde tekenreeks door KARAKTERS:

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

Steekreeks om met WORDS:

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

Antwoord 6, autoriteit 2%

Bekijk de Java 6 API onder StringBuffer

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

Antwoord 7, autoriteit 2%

Hier is een voorbeeld waarin recursie wordt gebruikt:

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

Antwoord 8

Hier is een oplossing op laag niveau:

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

Antwoord 9

Ik heb het voor de lol geprobeerd door een stapel te gebruiken. Hier mijn code:

public String reverseString(String s) {
    Stack<Character> stack = new Stack<>();
    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();
}

Antwoord 10

Aangezien de onderstaande methode (met behulp van XOR) om een string om te kerenniet wordt vermeld, voeg ik deze methode toe om een ​​string om te keren.

Het Algoritmeis gebaseerd op:

1.(A XOR B) XOR B = A

2.(A XOR B) XOR A = B

Codefragment:

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

Uitvoer:

keetarp

Antwoord 11

Zoals anderen al hebben opgemerkt, is de beste manier om het volgende te gebruiken:

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

Maar als u dit zelf wilt implementeren, ben ik bang dat de rest van de reacties gebreken vertoont.

De reden is dat Stringeen lijst met Unicode-punten vertegenwoordigt, gecodeerd in een char[]-array volgens de codering met variabele lengte : UTF-16.

Dit betekent dat sommige codepunten een enkel element van de array gebruiken (één code-eenheid), maar andere gebruiken er twee, dus er kunnen paren tekens zijn die als een enkele eenheid moeten worden behandeld (opeenvolgend “hoog” en “laag ” surrogaten).

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

Antwoord 12

Het is heel eenvoudig in minimale code van regels

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

Antwoord 13

Dit deed de truc voor mij

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

Antwoord 14

1. Tekenreeks gebruiken:

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. StringBuilder gebruiken:

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

OF

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

Antwoord 15

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

Ik heb deze methode gebruikt om namen achterstevoren en in kleine letters om te zetten.

Antwoord 16

Een natuurlijke manier om een ​​Stringom te keren is door een StringTokenizeren een stapel te gebruiken. Stackis een klasse die een gebruiksvriendelijke last-in, first-out (LIFO)-stapel objecten implementeert.

String s = "Hello My name is Sufiyan";

Leg het naar voren in de stapel

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

Druk de stapel achterstevoren af

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

Antwoord 17

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

Antwoord 18

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

Antwoord 19

Alle bovenstaande oplossingen zijn te goed, maar hier maak ik een omgekeerde string met recursieve programmering.

Dit is handig voor wie op zoek is naar een recursieve manier om reverse strings uit te voeren.

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

Antwoord 20

Je kunt ook dit proberen:

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

Antwoord 21

Procedure:

We kunnen split() gebruiken om de tekenreeks te splitsen. Gebruik vervolgens de omgekeerde lus en voeg de tekens toe.

Codefragment:

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

Antwoord 22

Het krijgt de waarde die je hebt getypt en retourneert het omgekeerd 😉

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;

}

Antwoord 23

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

Antwoord 24

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

Antwoord 25

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

Antwoord 26

recursie:

public String stringReverse(String string) {
    if (string == null || string.length() == 0) {
        return string;
    }
    return stringReverse(string.substring(1)) + string.charAt(0);
 }

Antwoord 27

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

Antwoord 28

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

Antwoord 29

   //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.

Antwoord 30

Voor de lol..:)

Algorithm (str,len):
  char reversedStr[] =new reversedStr[len]
  Traverse i from 0 to len/2 and then
    reversedStr[i]=str[len-1-i]  
    reversedStr[len-1=i]=str[i]
  return reversedStr;

Tijdcomplexiteit:O(n)
Ruimtecomplexiteit :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);
    }
}