在Java中反转字符串

我将“Hello World”保存在名为

hi

的字符串变量中

我需要把它打印出来，但是颠倒了

我该怎么做？我知道Java中已经内置了某种函数来实现这一点

相关的：

您可以使用以下功能：

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

---

或者，对于JDK1.5之前的版本，使用

java.util.StringBuffer

而不是

StringBuilder

——它们具有相同的API。感谢评论员指出，如今当没有并发问题时，

StringBuilder

是首选。

看看StringBuffer下的Java 6 API

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

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

---

对于不允许

StringBuilder

或

StringBuffer

的在线判断问题，您可以使用

char[]

就地执行，如下所示：

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

---

我使用此方法将名称向后转换为小写。

下面是一个使用递归的示例：

    public String reverse(String s) {

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

        return reversedString;
    }

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

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

您也可以尝试以下方法：

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

---

反转

字符串的一种自然方法是使用
StringTokenizer
和堆栈<代码>堆栈

是一个实现易于使用的后进先出（LIFO）对象堆栈的类

String s = "Hello My name is Sufiyan";

把它朝前放在书堆里

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

---

它获取您键入的值并将其反向返回；）

公共静态字符串反转（字符串a）{
char[]rarray=a.toCharArray（）；
字符串finalvalue=“”；
for（int i=0；i

---

}

我通过以下两种方式来实现这一点：

按字符反转字符串：

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

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

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

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

按单词反转字符串：

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

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

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

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

---

这是非常简单的最小代码行

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

公共字符串反转记录（字符串s）{

String reversedWords=”“；
如果（s.length（）=0）{
如果（arr[j]=''）{
反向字+=arr[j]；
}否则{
字符串temp=“”；
而（j>=0&&arr[j]！=''）{
温度+=arr[j]；
j--；
}
j++；
温度=反向方向（温度）；
反转字+=温度；
}
j--；
}
字符串[]chk=reversedWords.split（“”）；
如果（chk==null | | chk.length==0）{
返回“”；
}
返回反向单词；
}
公共字符串反向路径（字符串s）{
char[]arr=s.toCharArray（）；
对于（int i=0，j=arr.length-1；i，这里有一个低级别的解决方案：

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

import java.util.Scanner；
公共班级1{
公共静态void main（字符串[]args）{
扫描仪输入=新扫描仪（系统输入）；
字符串inpStr=in.nextLine（）；
System.out.println（“原始字符串：+inpStr”）；
焦炭温度；
char[]arr=inpStr.toCharArray（）；
int len=arr.length；
对于（int i=0；i我尝试使用堆栈，只是为了好玩。下面是我的代码：

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

}

公共字符串反向限制（字符串s）{
堆栈=新堆栈（）；
StringBuilder sb=新的StringBuilder（）；
对于（int i=0；i
只是为了好玩。：）

时间复杂度：O（n）
空间复杂度：O（n）

公共类反向{
静态字符反转str[]；
公共静态void main（字符串[]args）{
系统输出打印LN（反转（“jatin”）；
}        
私有静态字符串反转（字符串str）{
int strlen=str.length（）；
reversedStr=新字符[strlen]；
对于（inti=0；i以上所有的解决方案都太好了，但这里我使用递归编程来生成反向字符串

这有助于寻找反向字符串的递归方法

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

}

}

由于下面没有列出反转字符串的方法（使用XOR），因此我附加此方法以反转字符串

算法基于：

1.（A XOR B）XOR B=A

2.（A XOR B）XOR A=B

代码段：

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

}

public类ReverseUsingXOR{
公共静态void main（字符串[]args）{
String str=“prateek”；
反转（str.toCharArray（））；
}   
/*例如：
*str=prateek；
*str[low]=p；
*str[high]=k；
*str[low]=p^k；
*str[high]=（p^k）^k=p；
*str[low]=（p^k）^p=k；
* 
* */
公共静态void reverseUsingXOR（char[]str）{
int低=0；
int高=str.length-1；
while（低<高）{
str[low]=（char）（str[low]^str[high]）；
str[high]=（char）（str[low]^str[high]）；
str[low]=（char）（str[low]^str[high]）；
低++；
高--；
}
//显示反向字符串
对于（int i=0；i

输出：

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

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

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

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

keetarp
正如其他人所指出的，首选的方法是使用：

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

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

但如果你想自己实现这一点，恐怕其余的回答都有缺陷

原因是
String
表示Unicode点的列表，根据可变长度编码在
char[]
数组中进行编码：

这意味着某些代码点使用数组的单个元素（一个代码单元），而其他代码点使用其中的两个，因此可能存在必须视为单个单元的字符对（连续的“高”和“低”代理）

公共静态字符串反向限制（字符串s）{
char[]chars=新字符[s.length（）]；
布尔twoCharCodepoint=false；
对于（int i=0；ipublic String reverseString(String inputString) {
    char[] inputStringArray = inputString.toCharArray();
    String reverseString = "";
    for (int i = inputStringArray.length - 1; i >= 0; i--) {
        reverseString += inputStringArray[i];
    }
    return reverseString;
}

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

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

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

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

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

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

    }

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