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

String a = s.reverse().toString(); 
String b = s.toString();

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

you have to do

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

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!

I think you are on the right lines, just a few things I'd change: Firstly we have the ability to specify the length of the StringBuilder because we know it is going to be the same length as the String we are reversing.

It is not necessary to loop through the entire array, just half the array will suffice performing operations which are essentially just switching the characters. So the right-most character is now the left-most character, this saves a little computation.

public static void main(String[] args) throws IOException {
    String str = "Reverse me";
    StringBuilder printStr = new StringBuilder();
    printStr.setLength(str.length());

    for(int i =0; i<str.length()/2;i++){
        char left = str.charAt(i);
        final int fromRight = str.length() - i - 1;
        printStr.insert(i, str.charAt(fromRight));
        printStr.insert(fromRight, left);
    }
}

Here is a visual representation of how to character switching essentially works: More information can be found here

Your first problem might be that straight uses index j, while the rest of the code uses index i.

Here is your code as an MCVE (Minimal, Complete, and Verifiable example):

StringBuilder stringBuilder = new StringBuilder("tor");
String straight = stringBuilder.toString();
String reverse = stringBuilder.reverse().toString();
System.out.println("stringBuilders[i].reverse().toString() = " +  stringBuilder.reverse().toString() +
                   " reverse = " + reverse +
                   "    straight = " + straight +
                   " rev == str? " + reverse.equals(straight));

Output is:

stringBuilders[i].reverse().toString() = tor reverse = rot    straight = tor rev == str? false

That is not the output you showed.

Anyway, your main problem is that reverse():

Causes this character sequence to be replaced by the reverse of the sequence.

So, your first call to reverse() makes the stringBuilder have the value rot, which is also the value assigned to the reverse variable.

Your second call to reverse() in the print statement reverse it back to the value tor, which is then the value printed.