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

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中的每个方法都是同步的，因此它是线程安全的。

看一下StringBuffer下的Java 6 API

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

    public String reverse(String s) {

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

        return reversedString;
    }

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

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

OR

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

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

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

}