递归:

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

你可以用这个:

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

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

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

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

}

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

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

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

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