StringBuilder reverse does not produce a new StringBuilder instance. It causes the underlying characters of the current StringBuilder to be reversed. So,

Use with AIString a = s.reverse().toString(); 
String b = s.toString();

The second s.toString() is operating on the reversed StringBuilder.

you have to do

Use with AIString original = s.toString(); 
String reversed = s.reverse().toString();
return original.equals(reversed);

You said "efficient'. This is "concise". Code that consumes fewer lines isn't always better at performance. To know how "efficient" that method is in Java, we'd have to look at the source for the API implementation. The ways I can think of to efficiently reverse a string are these, not all of them are possible in C#: Allocate a new array the same size as the source and copy items into it. (O(N) CPU, O(N) memory). Allocate a temporary character and perform multiple swaps. (O(N) CPU, O(1) memory, not possible in C# because a string is immutable, any attempt to do this requires an additional O(N) allocation.) Recursion. (O(N) CPU, stack-based O(N) memory which is generally seen as cheaper than allocation. High risk of stack overflow as string sizes increase.) In C#, you could write an IEnumerator that iterates in reverse (and I'm pretty sure LINQ's Reverse() does this). That's not quite as efficient as recursion. It has to allocate a char or string for each iteration, and if your goal is an output array you still need an O(N) destination array. Basically in C# managed code there are no in-place string operations without copying to an intermediate char[] or StringBuffer and allocating a new final string. Womp womp. If someone can prove me wrong I will be ecstatic. But my understanding of the new superfluous low-level memory enhancements is they don't give us mutable strings, but instead good ways to reuse one buffer with reference semantics for many repeated string manipulations or read-only access.

The previous solution given will work! I'm going to suggest some modifications. Here's the original:public static String reverse(String str) { String reversed = ""; for (int i = str.length() - 1; i >= 0; i--) { reversed += str.substring(i, i + 1); } return reversed;}That call to str.substring(i, i + 1) is essentially a way of picking out a single character at index i, but there's actually a built in String method for that: charAt. And I think things read a bit more easily using it. Using it is also a bit semantically clearer in my opinion (others can disagree!):public static String reverse(String str) { String reversed = ""; for (int i = str.length() - 1; i >= 0; i--) { reversed += str.charAt(i); } return reversed;}It's generally better to use a StringBuilder, though, since that keeps us from generating a lot of Strings along the way (what if our input String was a very long String)?public static String reverse(String str) { StringBuilder reversed = new StringBuilder(); for (int i = 0; i < str.length(); ++i) { reversed.insert(0, str.charAt(i)); } return reversed.toString();}Note that here, I actually iterated forward through the String and prepended (using insert), but you could iterate backwards and use the append method, too. But the main point is that using a StringBuilder keeps us from having to generate new Strings for each character in the input.I hope that helps!