反转Java中的字符串

467

我"Hello World"保存在一个名为的String变量中hi。

我需要打印，但是要反转。

我怎样才能做到这一点？我知道Java中已经内置了某种功能。

相关：用Java反转“ Hello World”字符串的每个单词

java  string 
— 罗恩
source
7
@JRL应该确实是String ih =“ dlroW olleH”; System.out.println（ih）;
— 马修·法威尔
4
我希望我可以撤回我的近距离表决（作为重复）。我重新阅读了另一个问题，并意识到它与此根本不同。但是，这个问题在整个站点上仍然重复很多次。可能应该只是找到一个不同的问题来标记这是一个骗子。
— 罗布·赫鲁斯卡
您可以使用StringBuilder类的reverse（）函数，toCharArray（）方法，交换字符等等。请参阅此资源以获取更多示例，flowerbrackets.com / 2
— Shiva
StringBuilder.reverse（）是更具可读性和优雅的解决方案。
— lokesh
— dasunse

Answers:

980

您可以使用此：

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

或者，对于JDK 1.5之前的版本，请使用java.util.StringBuffer代替StringBuilder-它们具有相同的API。感谢评论员指出，StringBuilder在当今没有并发问题的情况下，这是首选。

— 丹尼尔·布罗克曼
source
13
“感谢评论员指出，现在首选StringBuilder”？有一个明确的声明，如果需要考虑线程安全性，可以使用StringBuffer。否则，可以使用StringBuilder。StringBuilder不能替代StringBuffer。
— ha9u63ar 2015年
15
@ ha9u63ar对于这种使用本地一次性StringBuilder并发的方案，不必担心（我认为这就是他的意思）。
— xehpuk
2
以下是了解两者之间确切区别的链接：javatpoint.com/… 简而言之：StringBuilder 比StringBuffer 效率更高。这不是线程安全的，即多个线程可以同时调用StringBuilder的方法。
— Vishnu Narang
只要合并字符，此操作就不适用于BMP以外的Unicode字符。
— 瑙
2
@Daniel Brockman，谢谢您的简洁回答。OP在这里说，我将“ Hello World”保存在一个名为hi的String变量中。那意味着String hi = "Hello World";。所以我觉得在你的答案应该不被周围的任何双引号hi。我的意思是应该这样new StringBuilder(hi).reverse().toString()
— 阿布·纳菲·伊卜纳·扎希德（Abu Nafee Ibna Zahid）女士
109

对于不允许或的在线法官问题，您可以使用以下方法就地解决：StringBuilderStringBufferchar[]

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);
}
— 萨米·埃尔塔莫（Sami Eltamawy）
source
虽然只是一个笔记。对于占用两个字节的“字符”，这将严重失败。
— 米纳斯吉米娜
实际上，它通常对于占用2个字节的大多数字符都可以正常工作。它真正失败的原因是占用2 x 16位代码单元（在UTF-16中）的Unicode代码点。
— 斯蒂芬·C
这是一个很好的解决方案，但是如果我们以最小的复杂度在字符串中包含10k个字符，我们也可以这样做。
— Jatinder Kumar
62 
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

— 凯文·鲍索克斯（Kevin Bowersox）
source
4
好的解决方案（1+）。一种增强功能-StringBuilder（自java5起）将比StringBuffer快。问候。
— 米哈尔Šrajer
31
这在一般情况下不起作用，因为它没有考虑到Unicode中的某些“字符”由代理对（即两个Java字符）表示，并且此解决方案导致该对的顺序错误。根据JavaDoc，StringBuilder的反向方法应该可以：docs.oracle.com/javase/7/docs/api/java/lang/…–
— Ian Fairman
59 
String string="whatever";
String reverse = new StringBuffer(string).reverse().toString();
System.out.println(reverse);
— 陆迁格里戈尔
source
7
它的复杂性是什么？O（N）或更大？N等于字符串的长度。
— Mukit09
O（n），因为它必须至少迭代一次字符串的字符。
— PlsWork '17
26

我通过以下两种方式来做到这一点：

按字符反向字符串：

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

用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);
}
— 维卡斯迪普·辛格（Vikasdeep Singh）
source
19

看看StringBuffer下的Java 6 API

String s = "sample";
String result = new StringBuffer(s).reverse().toString();
— 安德鲁·布里格斯
source
这比StringBuilder好吗？
— CamHart '17
@CamHart不，它慢一些，但可能只有一点点。
— jcsahnwaldt说GoFundMonica
1
一个几乎有1亿个方法调用的基准测试表明StringBuffer和StringBuilder之间存在显着差异：stackoverflow.com/questions/355089/…但是，在这种情况下，只有两个调用（reverse()和toString()），因此差异可能不会是可测量的。
— jcsahnwaldt说GoFundMonica
17

这是使用递归的示例：

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);
}
— C0D3LIC1OU5
source
2
已经有了更好的答案，尤其是@DanielBrockman的答案。如果标准库中已经存在一种算法，则无需手工设计并重新发明轮子。
— Willi Mentzel 2014年
14
“更好的答案”的概念是主观的。这可能正是某人正在寻找的东西。
— C0D3LIC1OU5 2014年
2
OP已经声明“ Java中已经内置了某种可以执行此功能的功能”，因此他的目标是确切地知道这是哪个“功能”。仅仅发布与实际问题无关的答案是无稽之谈。如果有人要求自定义实现，则您的答案是合理的，在这种情况下则不合理。
— Willi Mentzel 2014年
下注。大多数其他解决方案都是O（n），并且可以处理几乎任何长度的字符串，这个解决方案是O（n ^ 2），对于长度超过5000个字符的字符串，它往往会因StackOverflowError崩溃（在JDK 8 VM上，默认配置） 。
— jcsahnwaldt说GoFundMonica
1.其他解决方案不使用递归，并且可以很好地处理长字符串。为什么要对这样的任务使用递归而不是迭代？这没有道理。（除非您来自功能编程的背景，否则当您以命令式/ OO语言编写代码时，通常会导致问题。）2.字符串串联（无辜的小“ +”）是O（n）。您必须是Java新手，否则您会知道的。
— jcsahnwaldt说GoFundMonica
12

这是一个底层解决方案：

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));
    }
}
— 阿图尔·格里吉奥（Artur Grigio）
source
12

我尝试使用Stack只是为了好玩。这是我的代码：

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

}
— 恩里科·朱林（Enrico Giurin）
source
11

由于未列出以下方法（使用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]);
        }
    }

}

输出：

基塔普

— 普拉泰克·乔希（Prateek Joshi）
source
8

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

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

但是，如果您想自己实现这一点，恐怕其余的回答都存在缺陷。

原因是String表示一个Unicode点列表，char[]根据可变长度编码将其编码为数组：UTF-16。

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

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"));
}
— 爱德华
source
很好的解决，只有一部分缺少的是现在:-D处理相结合变音符号
— 勒内·
6

最少的行代码非常简单

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));
            }
    }
}
— 内伦德拉
source
我现在要写这个。。发现你已经写了！
— 詹西
4

这对我有用

public static void main(String[] args) {

    String text = "abcdefghijklmnopqrstuvwxyz";

    for (int i = (text.length() - 1); i >= 0; i--) {
        System.out.print(text.charAt(i));
    }
}
— 黑暗精神
source
4

1.使用字符数组：

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：

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

要么

return new StringBuilder(inputString).reverse().toString();
— 阿维吉特·卡玛卡（Avijit Karmakar）
source
3 
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);

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

— 暴风鹰
source
2 
    public String reverse(String s) {

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

        return reversedString;
    }
— 唐·沙巴齐（Dom Shahbazi）
source
同样，代理对将通过这种方式损坏。
— HyperNeutrino
@JamesSmith能否请您对此进行扩展？
— Dom Shahbazi 2015年
1
一些unicode字符由两个字符组成。如果将这两个开关切换，则字符串已损坏。另外，一个经常被忽略的错误是正则表达式。
— HyperNeutrino，2015年
2

反转a的一种自然方法String是使用a StringTokenizer和堆栈。Stack是一个实现易于使用的后进先出（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());
}

向后打印堆栈

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

System.out.println('"');
— 苏菲扬·戈里（Sufiyan Ghori）
source
2

以上所有解决方案都很好，但是在这里我使用递归编程制作反向字符串。

这对于谁正在寻找执行反向字符串的递归方式很有帮助。 

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

}

}
— Dhiral Pandya
source
2

程序：

我们可以使用split（）分割字符串，然后使用反向循环并添加字符。

程式码片段：

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
— 皮疹
source
1

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

}
— rvd
source
1

您也可以尝试以下操作：

public class StringReverse {
    public static void main(String[] args) {
        String str = "Dogs hates cats";
        StringBuffer sb = new StringBuffer(str);
        System.out.println(sb.reverse());
    }
}
— 阿努拉格·戈尔
source
1
有很多方法可以反向转换字符串。这是使用java的stringbuffer类的一种方法。公认的答案是使用diff类进行反向转换，这在旧版本的JDK中不可用。
— Anurag Goel 2014年
1 
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){
  }
— 迪帕克·辛格
source
1

递归：

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

纯娱乐..：）

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

将i从0遍历到len / 2，然后 

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

时间复杂度：O（n）

空间复杂度：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);
    }

}
— 贾廷·戈亚尔
source
1 
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;
}
— 穆罕默德·阿沙里布（Muhammad Aasharib Nawshad）
source
1 
    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(); 

    }
— Mutlu
source
这只是一个字符串地输出char。而且它不能在程序中的任何地方使用。最好创建一个String变量，将“ char”一一插入到字符串中，然后返回该字符串。
— Zombie Chibi XD
1 
    //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.
— 阿比
source
@Dharman感谢您的回复。添加了说明和更多解决方案。
— 阿比（Abhi）
0 
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);

}

}
— 库玛拉韦尔J
source
0 
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);        
    }
}

如果要使用简单的for循环！

— 阿佩特雷·伊努特（Apetrei Ionut）
source
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.