Note that in the situation where your array is of length 1 then you will get an "Array Index Out Of Bounds Exception".

To begin with, I didn't tell that any method must have exactly one return statement.
For maintainability reasons method has to have AS FEWER RETURN STATEMENTS as possible.

'Object.equals() method uses multiple return statements'

equals method in the Object class has only one line that checks reference equality. Basically, it is entry-level information that you should know by hard.
Most of the classes in the JDK and different frameworks override default implementations of the equals method to define equality based on an object's state.

For the purpose of explanation, I think equals probably is not the best illustration because it is short and simple.
To describe a method that has more than one exit point but still remains to be well-readable let's consider a method, which implements some intricate algorithm, and may be it's a relatively long one. And it has the following structure:
{
if (eliminate one case) throw ... // that's the early kill and that's great
if (eliminate another case) retrurn ... // and that's the early kill as well

// MAIN LOGIC

return ...
}

To conclude, in general, return statements in the middle of a method has to be avoided where it's possible.
Because it can create confusion when return inclosed by multiple loops and conditions, as well as when return statements are present in both try and catch blocks.

DISCLAIMER: I don't say no one writes like that. I say it is considered to be undesirable nowadays.

Quick digression. If you think that JDK is written by the Gods and there are no pitfalls in Java you have a lot to discover.

'how you would solve problems of that kind in general'
In terms of clean coding, it's a naive way of thinking that there's some kind of uniform recipe that can be applied anywhere.
Clean code - is a code that is EASY to read, but difficult to write.
There are tons of books on this topic and if you expect to receive an exhaustive unambiguous answer in this comment then I'll say:
Sorry silver bullets are out of stock))

If you want to see how to solve this kata in an imperative way without exiting in the middle of the loop take a look at my fork.
That's doable with a help of break statement or labels. Caution, both of them can make the code cluttered, and labels are actually discouraged to use for that reason.

By the way, your dubious attitude to streams is still unclear to me.
Streams are effective, lazily evaluated, very nice in terms of readability, and capable to solve most of the problems which traditionally were implemented using loops.
If you are striving to write clean then code functional style is more preferable over imperative. And that is the strongest suggestion in my answer.

Now you are free to ignore this information or explore it father on your own. I hardly can add anything.
Good luck.

Single exit strategy is a controversial discussed dogma. For instance the Object.equals() method uses multiple return statements. Just have a look at the source code. Perhaps you shall advise Oracle that you think they're using bad pracice and improve the Java code base with a better solution. Your approach may be good for these concrete kata, but it is indeed not a general valid way, to solve all problems of that type, as you can see.

Hence, my question was not about linking connections to anything, but wanting to know, how you would solve problems of that kind in general, if something like IntStream was not accessible. Since clairvoyance does not exist, nobody can elaborate how your solution would look like. This is just a red herring argument. I would be grateful, if you could take two minutes to show a good way that works even for cases when Streams don't work, with a single exit point. And of course, without a break in the loop, because it violates your choosen strategy.

If it was a replay to my comment can elaborate on your thought. I'm not sure that I've understood correctly what you are trying to convey.
What is the connection between import statements and best coding practices?

How would you solve it without any imports like IntStream?

Apart from the weird formatting multiple return statement is not a best practice.

the java version has been corrected.

Yes, there is something wrong with the performance of your solution. It's too slow. Your current apporoach is never going to work.

Could anyone tell me what's wrong with my solution, cause i can't find any mistake with it.

public static Object[] sortArray(Object names){
	if(names.getClass().isArray()){
		int length = Array.getLength(names);
		Object[] array = new Object[length];       
		for (int i = 0; i < length; i++) {
			array[i] = (Array.get(names, i));
		}
		if(length > 1){Arrays.sort(array);}
		return array;			
	}
	else{
		return new Object[]{names};
	}	
}