CODEWITHSUNDEEP
javaarrayssyntaxdeclaration
Peter Lawrey
Peter Lawrey

Reputation: 533590

Strange array return type

Has any one seen the array [] placed after the method signature like this?

public static String mySplit(String s)[] {
    return s.split(",");
}

public static void main(String... args) {
    String[] words = mySplit("a,b,c,d,e");
    System.out.println(Arrays.toString(words));
}

prints

[a, b, c, d, e]

In the past, odd notations have been for "C" compatibility, but I wouldn't imagine someone writing this in C either.

Does anyone know why this is even allowed?

I am using Java 7 update 10, in case it matters.

This does the same thing in Java 6. http://ideone.com/91rZV1

BTW this doesn't compile, nor would I expect it to

public static <T> List mySplit(String s)<T> {
    return Collections.emptyList();
}

Upvotes: 73

Views: 2332

Answers (6)

Matt Fenwick
Matt Fenwick

Reputation: 49095

Good question; when I implemented a Java parser I remember getting really confused by the JLS grammar at this point.

To expand on John's answer, here's what's going on:

  • this is called "mixed notation" in the spec
  • the grammar breaks type declarations into two pieces, each of which may have 0 or more []s

There are (at least) 5 places where this matters:

  • method type signatures
  • local variable declarations
  • field declarations
  • formal parameters
  • for-loops

Here's an excerpt from the grammar, focusing on method declarations:

MethodOrFieldDecl:
    Type Identifier MethodOrFieldRest

MethodOrFieldRest:  
    FieldDeclaratorsRest ;
    MethodDeclaratorRest

MethodDeclaratorRest:
    FormalParameters {[]} [throws QualifiedIdentifierList] (Block | ;)

Type:
    BasicType {[]}
    ReferenceType  {[]}

(Warning: it's difficult to read the grammar because the square and curly brackets are sometimes literals and sometimes metacharacters.)

This shows that [] can appear both under the Type rule, and as part of the MethodDeclaratorRest rule. It is optional in both places.

Upvotes: 4

Ahmed Kato
Ahmed Kato

Reputation: 1707

Yes, this is allowed,

same reason that:

String[] myArray;

is equivalent to

String myArray[];

Upvotes: 1

MrSmith42
MrSmith42

Reputation: 10151

It's like

  String[] a;

is the same as 

  String a[];

Same works for the syntax of method return types

  public static String mySplit(String s)[] {

is the same as 

  public static String[] mySplit(String s) {

But I think I never saw the version you mentioned in productive code yet.

Upvotes: 20

Reinstate Monica -- notmaynard
Reinstate Monica -- notmaynard

Reputation: 5490

I believe it's just telling Java that the return type is an array of Strings, the same as declaring

static String[] mySplit(String s) {...

Similar to declaring variables:

String myStringArray[];

is equivalent to

String[] myStringArray;

Upvotes: 4

Peter Elliott
Peter Elliott

Reputation: 3322

I think its the same reason that the following variable declarations are both equivalent

String[] array
String array[]

this is a thing C developers do, so it was included to help them.

Upvotes: 6

Jon Skeet
Jon Skeet

Reputation: 1501163

Does anyone know why this is even allowed?

In this case it's for backward compatibility with Java itself. From the JLS section 8.4:

For compatibility with older versions of the Java SE platform, the declaration of a method that returns an array is allowed to place (some or all of) the empty bracket pairs that form the declaration of the array type after the formal parameter list. This is supported by the following obsolescent production, but should not be used in new code.

And yes, you should indeed regard it as an abomination which has no good purpose other than to shock other developers. Actually, you might be able to use it to win some money at parties by betting that it would compile, against folks who've never seen it...

Here's the kind of method which right-minded coders would expect to be invalid:

public String[] mwahahaha(String[] evil[])[] {
    return evil;
}

Upvotes: 90

Related Questions