小开

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

小开

最佳答案

你可以用这个:

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

StringBuilder是在Java 5中添加的。对于Java 5之前的版本，可以使用StringBuffer类-它具有相同的API。

小开

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

小开

看一下StringBuffer下的Java 6 API

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

小开

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

小开

对于不允许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);
}

小开

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

我使用这种方法将名称反向转换为小写。

小开

    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 class StringReverse {
public static void main(String[] args) {
String str = "Dogs hates cats";
StringBuffer sb = new StringBuffer(str);
System.out.println(sb.reverse());
}
}

小开

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循环!

小开

反转String的一种自然方法是使用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('"');

小开

它会得到你输入的值，并反向返回;)

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;

｝

小开

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

反向字符串字符:

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

小开

public class Test {


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

小开

字符串(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);


}

小开

下面是一个低级的解决方案:

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

小开

我尝试了，只是为了好玩，通过使用一个堆栈。下面是我的代码:

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


}

小开

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

小开

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

这对于寻找递归方法做反向字符串的人是有帮助的。

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


}

输出:

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点的列表，根据变长编码:utf - 16编码在char[]数组中。

这意味着一些代码点使用数组的单个元素(一个代码单元)，但其他代码点使用其中的两个，因此可能会有一对字符必须被视为单个单元(连续的“高”和“低”代理)。

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

小开

这招对我很管用

public static void main(String[] args) {


String text = "abcdefghijklmnopqrstuvwxyz";


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

小开

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

小开

过程:

我们可以使用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

小开

递归:

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

小开

反转字符串有很多种方法。

1. 将字符串转换为字节:getBytes()方法用于将输入字符串转换为字节[]。

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

# EYZ0 # EYZ1

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.使用ArrayList对象:使用toCharArray()内置方法将输入字符串转换为字符数组。然后，将数组的字符添加到ArrayList对象中。Java还为Collections类内置了reverse()方法。由于Collections类reverse()方法接受一个列表对象，为了反转列表，我们将传递LinkedList对象，这是一种字符列表类型。

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

小开

字符序列(或)字符串^{字符串的家族}:

String testString = "Yashwanth@777"; // ~1 1⁄4→D800₁₆«2²⁰

使用# EYZ0

首先使用方法CharSequence.chars()将String转换为流，然后使用方法IntStream.range生成连续的数字流。然后我们将这个stream序列映射到String中。

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

使用传统的for循环

如果您想反转字符串，那么我们需要遵循以下步骤。

将字符串转换为字符数组。
以倒序遍历数组，将每个字符附加到临时字符串变量，直到最后一个字符。

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

简单的方法使用反向方法提供的StringBuffer或StringBuilder类

StringBuilder和StringBuffer是可变的字符序列。这意味着可以改变这些对象的值。

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具有与StringBuilder相同的方法，但是StringBuffer中的每个方法都是同步的，因此它是线程安全的。

小开

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

小开

java中的简单For循环

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

小开

使用`charAt()`方法

    String name = "gaurav";
String reversedString = "";
    

for(int i = name.length()-1; i>=0; i--){
reversedString = reversedString + name.charAt(i);
}
System.out.println(reversedString);

使用`toCharArray()`方法

String name = "gaurav";
char [] stringCharArray = name.toCharArray();
String reversedString = "";
    

for(int i = stringCharArray.length-1; i>=0; i--) {
reversedString = reversedString + stringCharArray[i];
}
System.out.println(reversedString);

使用Stringbuilder的`reverse()`方法

    String name = "gaurav";
    

String reversedString = new StringBuilder(name).reverse().toString();
    

System.out.println(reversedString);

检查# EYZ0

小开

简而言之，Java并没有提供一个通用的解决方案来反转字符串，因为“代理对”。问题，你必须考虑到这一点。

如果要求保证它适用于所有Unicode和所有语言(包括Welsh:)，那么您必须自己编写。只需将字符串作为代码点进行就地数组交换:

public static String reverse(String str)
{
// You get what you ask for ;)
if (str == null) return null;


// str.length() is equal to the number of unicode code points in a string
if (str.isEmpty() || str.length() == 1) return str;


final int[] codePoints = str.codePoints().toArray();
final int len = codePoints.length;


// swap in place
for(int i = 0; i < codePoints.length/2; i++)
{
int tmp = codePoints[i];
codePoints[i] = codePoints[len-i-1];
codePoints[len-i-1] = tmp;
}


return new String(codePoints,0,len);
}

如果你通过使用String.getBytes()来做到这一点，那么所有的字节都将被反转，这将反转所有的UTF-8编码，并且任何使用不是int码位的字符的尝试都将失败。代码点(BMP之外的代码点)。

作为一般的解决方案，这是相当有效的，但它非常简单，并保证对任何字符串都有效，这可能是你想要的“一般解决方案”。

唯一的问题是，如果你从UTF8/16编码文件中读取字符串，你可能在开始时有一个BOM，但这超出了问题的范围。

蓝

小开

使用apache.commons.lang3

StringUtils.reverse(hi)

小开

        String str = "Hello World";


char[] strCharArr = str.toCharArray();


for(int i = 0, k= strCharArr.length-1;i != k; i++, k--) {
char temp = strCharArr[i];
strCharArr[i] = strCharArr[k];
strCharArr[k] = temp;
}


System.out.println(String.valueOf(strCharArr));

反转Java中的字符串

过程:

代码片段:

使用charAt()方法

使用toCharArray()方法

使用Stringbuilder的reverse()方法

使用`charAt()`方法

使用`toCharArray()`方法

使用Stringbuilder的`reverse()`方法