What do you mean for "without reverse function or loops". First of all in java are called methods, not functions, and second in some way you need to iterate the strings. This code just does the job with a recursive method. Call it from your constructor and you’re done. There aren't any already built-in java methods to do what you want.

public class HelloWorld{


public String recursiveReverse(String[] words,StringBuilder b,int length){
     if (length < 0) 
        return b.toString();
     else{
        b.append(words[length] + " ");
        length--;
        return recursiveReverse(words,b,length);
     }
            
}

public String reverse (String input){
   String[] words = input.split(" ");
   StringBuilder reverse = new StringBuilder();
   return recursiveReverse(words,reverse,words.length-1);
}

     public static void main(String []args){
        HelloWorld a = new HelloWorld();
        System.out.println(a.reverse("hello this is a test reverse this string"));
     }
}

Output:

string this reverse test a is this hello

Well, it depends on what they actually mean with "predefined method". Strings are immutable and you can't get the contents of a string in a way that makes it reversible unless you use at least length and charAt or toCharArray. Excluding solutions using Reflection or Unsafe, that would be possible but not sensible.

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!

The last index in an array is not array.length but array.length - 1. Arrays are indexed on a zero-base, the first index is 0.

An array with two elements for example has indices [0] and [1], not [2].

You access, in the first iteration, stringChars[index2] and index2 = length where length = myString.length(). Thus the IndexOutOfBoundException. Carefully read through your code and analyze which indices you need. Create a small example, use some small print statements to debug your code and see which indices you are actually using.

---

Here is an example for a more compact reverse algorithm:

char[] input = ...

// Iterate in place, from both sides at one time
int fromFront = 0;
int fromEnd = input.length - 1;

while (fromFront < fromEnd) {
    // Swap elements
    char temp = input[fromEnd];
    input[fromEnd] = input[fromFront];
    input[fromFront] = temp;

    fromFront++;
    fromEnd--;
}

The algorithm swaps the element from the first position with the element from the last position in place. Then it moves one forward swapping the second element with the second to last and so on. It stops once both indices meet each other (if length is odd) or if the first index gets greater then the other (if length is even).

A more easy version, however without in-place, is to create a new array:

char[] input = ...
char[] reversedInput = new char[input.length];

// Reversely iterate through source
int forwardIndex = 0;
for (int i = input.length - 1; i > 0; i--) {
    reversedInput[forwardIndex] = input[i];
    forwardIndex++;
}

Try walking through it on paper. Here's an algorithm to follow: Reverse: input is "str". If str is blank, return blank. separate str into the first character, car, and the remaining characters, cdr. Invoke this algorithm with an input of cdr, label result "reversedCdr". Return reversedCdr + car. If you do this by hand, you'll see what's happening. Make sure to carefully track the stack. Here's an example. Reverse(str is "nab") str isn't blank, keep going car is "n", cdr is "ab". Call reverse(str is "ab") str isn't blank, keep going car is "a", cdr is "b" Call reverse(str is "a") str isn't blank, keep going car is "b", cdr is "" Call reverse(str is "") str is blank, return blank. Return "" + "b", "b" Return "b" + "a", "ba" Return "ba" + "n", "ban"