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

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

2.将字符串转换为字符数组:用户输入需要反转的字符串。(个人建议)

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

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

反转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('"');

看一下StringBuffer下的Java 6 API

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

字符串家族的字符序列(或)

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

使用Java 8流API

首先使用CharSequence.chars()方法将String转换为流，然后使用IntStream方法。范围来生成连续的数字流。然后我们将这个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 String reverse(String s) {

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

        return reversedString;
    }