White Space

The white space settings page lets you configure how white space characters are used to separate individual syntax elements of source files. Making good use of spacing is considered good programming style and greatly enhances developer comprehension, therefore Jalopy provides a vast amount of flexibility to control white space behavior. Because of the sheer amount of elements, you can choose between two views that group the available options in different ways to provide a somewhat greater flexibility when adjusting the more than 150 individual options.

Choose view

Lets you choose between different views in which the white space options are presented to the user. The available choices are:

Group by Java Token
The token view groups the white space options by the Java separator and operator tokens like commas, parentheses or assignments. This is the default and preferred view, because ideally it takes little more than twenty adjustments to configure behavior for all available options.
Groupy by Java Element
The element view groups the white space options logically by the different available elements like declarations, control statements or expressions. This way it is easier to adjust options for just one element as all related options are presented together.

Since 1.6

Token view

Figure 2.44. White Space Token View

Before operator

Lets you specify what operators should have a blank space printed before.

Assignment operator

Controls whether a blank space will be printed before assignment operators. The assignment operators are: = += -= *= \= %= &= |= ^= <<= >>= >>>=

Example 2.332. Assignment operator

a=(b+c)*d;
a+=12;

Example 2.333. Assignment operator with space before

a =(b+c)*d;
a +=12;

Assignment operator in annotations

Controls whether a blank space will be printed before assignment operators in annotations.

Since 1.9

Example 2.334. Assignment operator

@Name(first="Joe",last="Hacker")

Example 2.335. Assignment operator with space before

@Name(first ="Joe",last ="Hacker")

Bitwise operator

Controls whether a blank space will be printed before bitwise operators. The bitwise operators are: & | ^

Example 2.336. Bitwise operator

return(getOperatingSystem()&PLAT_UNIX)!=0;

Example 2.337. Bitwise operator with space before

return(getOperatingSystem() &PLAT_UNIX)!=0;

Logical operator

Controls whether a blank space will be printed before logical operators. The logical operators are: && ||

Example 2.338. Logical operator

if((LA(1)=='/')&&(LA(2)!='*'||(LA(2)=='*'&&LA(3)!='*'))) ...

Example 2.339. Logical operator with spaces around

if((LA(1)=='/') &&(LA(2)!='*' ||(LA(2)=='*' &&LA(3)!='*'))) ...

Math operator

Controls whether a blank space will be printed before mathematical operators. The mathematical operators are: + - / * %

Example 2.340. Mathematical operator

a=(b+c)*d;

Example 2.341. Mathematical operator with space before

a=(b +c) *d;

Relational operator

Controls whether a blank space will be printed before relational operators. The relational operators are: == != < > <= >=

Example 2.342. Relational operator

if((LA(1)=='\n'||LA(1)=='\r')) ...

Example 2.343. Relational operator with space before

if((LA(1) =='\n'||LA(1) =='\r')) ...

Shift operator

Controls whether a blank space will be printed before shift operators. The shift operators are: << >> >>>

Example 2.344. Shift operator

if(((1L<<i)&l)!=0) ...

Example 2.345. Shift operator with space before

if(((1L <<i)&l)!=0) ...

Postfix operator

Controls whether a blank space will be printed before postfix operators. The postfix operators are: ++ --

Since 1.6

Example 2.346. Postfix operator

int next = i++;

Example 2.347. Postfix operator with space before

int next = i ++;

String concat operator

Controls whether a blank space will be printed before the string concat operator.

Since 1.0.3

Example 2.348. String concat operator

a="a"+1;
b=1+"b";
c=1+2+3+"c";
d="d"+1+2+3;
e="e"+(1+2)+"e";

Example 2.349. String concat operator with space before

a="a" +1;
b=1 +"b";
c=1+2+3 +"c";
d="d" +1 +2 +3;
e="e" +(1+2) +"e";

After operator

Lets you specify what operators should have a blank space printed after.

Assignment operator

Controls whether a blank space will be printed after assignment operators. The assignment operators are: = += -= *= \= %= &= |= ^= <<= >>= >>>=

Example 2.350. Assignment operator

a=(b+c)*d;
a+=12;

Example 2.351. Assignment operator with space after

a= (b+c)*d;
a+= 12;

Assignment operator in annotations

Controls whether a blank space will be printed after assignment operators in annotations.

Since 1.9

Example 2.352. Assignment operator

@Name(first="Joe",last="Hacker")

Example 2.353. Assignment operator with space after

@Name(first= "Joe",last= "Hacker")

Bitwise operator

Controls whether a blank space will be printed after bitwise operators. The bitwise operators are: & | ^

Example 2.354. Bitwise operator

return(getOperatingSystem()&PLAT_UNIX)!=0;

Example 2.355. Bitwise operator with space after

return(getOperatingSystem()& PLAT_UNIX)!=0;

Logical operator

Controls whether a blank space will be printed after logical operators. The logical operators are: && ||

Example 2.356. Logical operator

if((LA(1)=='/')&&(LA(2)!='*'||(LA(2)=='*'&&LA(3)!='*'))) ...

Example 2.357. Logical operator with spaces around

if((LA(1)=='/')&& (LA(2)!='*'|| (LA(2)=='*'&& LA(3)!='*'))) ...

Complement operator

Controls whether a blank space will be printed after complement operators. The logical operators are: ~ !

Example 2.358. Complement operator

f(!x);

Example 2.359. Complement operator with space after

f(! x);

Mathematical operator

Controls whether a blank space will be printed after mathematical operators. The mathematical operators are: + - / * %

Example 2.360. Mathematical operator

a=(b+c)*d;

Example 2.361. Mathematical operator with space after

a=(b+ c)* d;

Relational operator

Controls whether a blank space will be printed after relational operators. The relational operators are: == != < > <= >=

Example 2.362. Relational operator

if((LA(1)=='\n'||LA(1)=='\r')) ...

Example 2.363. Relational operator with space after

if((LA(1)== '\n'||LA(1)== '\r')) ...

Shift operators

Controls whether a blank space will be printed after shift operators. The shift operators are: << >> >>>

Example 2.364. Shift operator

if(((1L<<i)&l)!=0) ...

Example 2.365. Shift operator with space after

if(((1L<< i)&l)!=0) ...

Prefix operator

Controls whether a blank space will be printed after prefix operators. The prefix operators are: ++ --

Example 2.366. Prefix operator

int previous = --i;

Example 2.367. Prefix operator with space after

int previous = -- i;

Unary operator

Controls whether a blank space will be printed after unary operators. The unary operators are: - +

Since 1.6

Example 2.368. Unary operator

int x  = 3 * -4;

Example 2.369. Unary operator with space after

int x  = 3 * - 4;

String concat operator

Controls whether a blank space will be printed after the string concat operator.

Since 1.0.3

Example 2.370. String concat operator

a="a"+1;
b=1+"b";
c=1+2+3+"c";
d="d"+1+2+3;
e="e"+(1+2)+"e";

Example 2.371. String concat operator with space after

a="a"+ 1;
b=1+ "b";
c=1+2+3+ "c";
d="d"+ 1+ 2+ 3;
e="e"+ (1+2)+ "e";

Before comma

Lets you specify what commas should have a blank space printed before.

Annotation array

Controls whether a blank space will be printed before commas of annotation arrays.

Example 2.372. Annotation array

@Target({FIELD,METHOD,CONSTRUCTOR})
public class Foo { }

Example 2.373. Annotation array with space before comma

@Target({FIELD ,METHOD ,CONSTRUCTOR})
public class Foo { }

Annotation type member argument

Controls whether a blank space will be printed before commas of annotation member arguments.

Example 2.374. Annotation

@Point(x=23,y=-3)
public class Foo { }

Example 2.375. Annotation with space before comma

@Point(x=23 ,y=-3)
public class Foo { }

Enum constant

Controls whether a blank space will be printed before commas of enum constants.

Example 2.376. Enum constants

enum Color{GREEN,BLUE}

Example 2.377. Enum constants with space before comma

enum Color{GREEN ,BLUE}

Enum constant argument

Controls whether a blank space will be printed before commas of enum constants.

Example 2.378. Enum constant arguments

enum Color{GREEN(0,255.0),BLUE(0,0,255)}

Example 2.379. Enum constant arguments with space before comma

enum Color{GREEN(0 ,255 .0),BLUE(0 ,0 ,255)}

extends/implements

Controls whether a blank space will be printed before the commas of extends and/or implements types.

Extends type

Controls whether a blank space will be printed before the commas of extends types.

Example 2.380. Extends types

interface Fooable extends Doable,Readable {}

Example 2.381. Extends types with space before comma

interface Fooable extends Doable ,Readable {}

Extends type

Controls whether a blank space will be printed before the commas of implements types.

Example 2.382. Implements types

class Foo implements I0,I1,I2 {}

Example 2.383. Implements types with space before comma

class Foo implements I0 ,I1 ,I2 {}

Multiple declarations

Controls whether a blank space will be printed before the commas of multi-field and/or multi-variable declarations.

Field

Controls whether a blank space will be printed before the commas of multi-field declarations.

Example 2.384. Multi-field declaration

class Foo {
    int a=0,b=1,c=2,d=3;
}

Example 2.385. Multi-field declaration with space before commas

class Foo {
    int a=0 ,b=1 ,c=2 ,d=3;
}

Variable

Controls whether a blank space will be printed before the commas of multi-variable declarations.

Example 2.386. Multi-variable declaration

void foo() {
    int a=0,b=1,c=2,d=3;
}

Example 2.387. Multi-variable declaration with space before commas

void foo() {
    int a=0 ,b=1 ,c=2 ,d=3;
}

Declaration parameter

Controls whether a blank space will be printed before the commas of method and/or constructor declarations parameters.

Constructor

Example 2.388. Constructor declaration

Foo(int p1,int p2,int p3) {
}

Example 2.389. Constructor declaration with space before commas

Foo(int p1 ,int p2 ,int p3) {
}

Method

Example 2.390. Method declaration

void foo(int p1,int p2,int p3) {
}

Example 2.391. Method declaration with space before commas

void foo(int p1 ,int p2 ,int p3) {
}

Throws clauses

Controls whether a blank space will be printed before the commas of throws clauses of method and/or constructor declarations.

Constructor

Controls whether a blank space will be printed before the commas of throws clauses of constructor declarations.

Example 2.392. Constructor declaration throws clause

Foo() throws IOException,FooException {
}

Example 2.393. Constructor declaration throws clause with space before commas

Foo() throws IOException ,FooException {
}

Method

Controls whether a blank space will be printed before the commas of throws clauses of method declarations.

Example 2.394. Method declaration throws clause

void foo() throws IOException,FooException {
}

Example 2.395. Method declaration throws clause with space before commas

void foo() throws IOException ,FooException {
}

Call arguments

Controls whether a blank space will be printed before the commas of call arguments.

Constructor

Controls whether a blank space will be printed before the commas of constructor call arguments.

Example 2.396. Constructor call

Foo(int p1,int p2,int p3){
    super(p1,true);
}

Example 2.397. Constructor call space before commas

Foo(int p1,int p2,int p3){
    super(p1 ,true);
}

Method

Controls whether a blank space will be printed before the commas of method call arguments.

Example 2.398. Method call

test(x,y);

Example 2.399. Method call space before commas

test(x ,y);

Creator

Controls whether a blank space will be printed before the commas of creator call arguments.

Example 2.400. Creator call

Point point=new Point(x,y);

Example 2.401. Creator call space before commas

Point point=new Point(x ,y);

Array initializer

Controls whether a blank space will be printed before the commas of array initializers.

Example 2.402. Array initializer

int[] foo=new int[]{1,2,3};

Example 2.403. Array initializer with space before commas

int[] foo=new int[]{1 ,2 ,3};

for

Controls whether a blank space will be printed before the commas of for initializer and/or incrementor parts.

Initializer

Controls whether a blank space will be printed before the commas of for initializer parts.

Example 2.404. for initializer

for(int i=0,j=array.length;i<array.length;i++) {}

Example 2.405. for initializer with space before commas

for(int i=0 ,j=array.length;i<array.length;i++) {}

Incrementor

Controls whether a blank space will be printed before the commas of for incrementor parts.

Example 2.406. for incrementor

for(int i=0,j=array.length;i<array.length;i++,j--) {}

Example 2.407. for incrementor with space before commas

for(int i=0,j=array.length;i<array.length;i++ ,j--) {}

Parameterized types

Controls whether a blank space will be printed before the commas of parameterized types.

Type parameter

Controls whether a blank space will be printed before the commas of type parameters.

Example 2.408. Type parameter

class GenericType<S,T>{}

Example 2.409. Type parameter with space before commas

class GenericType<S ,T>{}

Type argument

Controls whether a blank space will be printed before the commas of type arguments.

Example 2.410. Type argument

caller.<String,Element>foo();

Example 2.411. Type argument with space before commas

caller.<String ,Element>foo();

After comma

Lets you specify what commas should have a blank space printed after.

Annotation array

Controls whether a blank space will be printed after commas of annotation arrays.

Example 2.412. Annotation array

@Target({FIELD,METHOD,CONSTRUCTOR})
public class Foo { }

Example 2.413. Annotation array with space after comma

@Target({FIELD, METHOD, CONSTRUCTOR})
public class Foo { }

Annotation type member argument

Controls whether a blank space will be printed after commas of annotation member arguments.

Example 2.414. Annotation

@Point(x=23,y=-3)
public class Foo { }

Example 2.415. Annotation with space after comma

@Point(x=23, y=-3)
public class Foo { }

Enum constant

Controls whether a blank space will be printed after commas of enum constants.

Example 2.416. Enum constants

enum Color{GREEN,BLUE}

Example 2.417. Enum constants with space after comma

enum Color{GREEN, BLUE}

Enum constant argument

Controls whether a blank space will be printed after commas of enum constants.

Example 2.418. Enum constant arguments

enum Color{GREEN(0,255.0),BLUE(0,0,255)}

Example 2.419. Enum constant arguments with space after comma

enum Color{GREEN(0, 255, 0),BLUE(0, 0, 255)}

extends/implements

Controls whether a blank space will be printed after the commas of extends and/or implements types.

Extends type

Controls whether a blank space will be printed after the commas of extends types.

Example 2.420. Extends types

interface Fooable extends Doable,Readable {}

Example 2.421. Extends types with space after comma

interface Fooable extends Doable, Readable {}

Implements type

Controls whether a blank space will be printed after the commas of implements types.

Example 2.422. Implements types

class Foo implements I0,I1,I2 {}

Example 2.423. Implements types with space after comma

class Foo implements I0, I1, I2 {}

IMultiple declarations

Controls whether a blank space will be printed after the commas of multi-field and/or multi-variable declarations.

Field

Controls whether a blank space will be printed after the commas of multi-field declarations.

Example 2.424. Multi-field declaration

class Foo {
    int a=0,b=1,c=2,d=3;
}

Example 2.425. Multi-field declaration with space after commas

class Foo {
    int a=0, b=1, c=2, d=3;
}

Variable

Controls whether a blank space will be printed after the commas of multi-variable declarations.

Example 2.426. Multi-variable declaration

void foo() {
    int a=0,b=1,c=2,d=3;
}

Example 2.427. Multi-variable declaration with space after commas

void foo() {
    int a=0, b=1, c=2, d=3;
}

Declaration parameter

Controls whether a blank space will be printed after the commas of method and/or constructor declarations parameters.

Constructor

Controls whether a blank space will be printed after the commas of constructor declarations parameters.

Example 2.428. Constructor declaration

Foo(int p1,int p2,int p3) {
}

Example 2.429. Constructor declaration with space after commas

Foo(int p1, int p2, int p3) {
}

Method

Example 2.430. Method declaration

void foo(int p1,int p2,int p3) {
}

Example 2.431. Method declaration with space after commas

void foo(int p1, int p2, int p3) {
}

Throws clauses

Controls whether a blank space will be printed after the commas of throws clauses of method and/or constructor declarations.

Constructor

Controls whether a blank space will be printed after the commas of throws clauses of constructor declarations.

Example 2.432. Constructor declaration throws clause

Foo() throws IOException,FooException {
}

Example 2.433. Constructor declaration throws clause with space after commas

Foo() throws IOException, FooException {
}

Method

Controls whether a blank space will be printed after the commas of throws clauses of method declarations.

Example 2.434. Method declaration throws clause

void foo() throws IOException,FooException {
}

Example 2.435. Method declaration throws clause with space after commas

void foo() throws IOException, FooException {
}

Call arguments

Controls whether a blank space will be printed after the commas of call arguments.

Constructor

Controls whether a blank space will be printed after the commas of constructor call arguments.

Example 2.436. Constructor call

Foo(int p1,int p2,int p3){
    super(p1,true);
}

Example 2.437. Constructor call space after commas

Foo(int p1,int p2,int p3){
    super(p1, true);
}

Method

Controls whether a blank space will be printed after the commas of method call arguments.

Example 2.438. Method call

test(x,y);

Example 2.439. Method call space after commas

test(x, y);

Creator

Controls whether a blank space will be printed after the commas of creator call arguments.

Example 2.440. Creator call

Point point=new Point(x,y);

Example 2.441. Creator call space after commas

Point point=new Point(x, y);

Array initializer

Controls whether a blank space will be printed after the commas of array initializers.

Example 2.442. Array initializer

int[] foo=new int[]{1,2,3};

Example 2.443. Array initializer with space after commas

int[] foo=new int[]{1, 2, 3};

for

Controls whether a blank space will be printed after the commas of for initializer and/or incrementor parts.

Initializer

Controls whether a blank space will be printed after the commas of for initializer parts.

Example 2.444. for initializer

for(int i=0,j=array.length;i<array.length;i++) {}

Example 2.445. for initializer with space after commas

for(int i=0, j=array.length;i<array.length;i++) {}

Incrementor

Controls whether a blank space will be printed after the commas of for incrementor parts.

Example 2.446. for incrementor

for(int i=0,j=array.length;i<array.length;i++,j--) {}

Example 2.447. for incrementor with space after commas

for(int i=0,j=array.length;i<array.length;i++, j--) {}

Parameterized types

Controls whether a blank space will be printed after the commas of parameterized types.

Type parameter

Controls whether a blank space will be printed after the commas of type parameters.

Example 2.448. Type parameter

class GenericType<S,T>{}

Example 2.449. Type parameter with space after commas

class GenericType<S, T>{}

Type argument

Controls whether a blank space will be printed after the commas of type arguments.

Example 2.450. Type argument

caller.<String,Element>foo();

Example 2.451. Type argument with space after commas

caller.<String, Element>foo();

Before colon

Lets you specify what colons should have a blank space printed before.

assert

Controls whether colons of assert statements should have a blank space printed before.

Example 2.452. assert statement

assert condition:reportError();

Example 2.453. assert statement with space before colon

assert condition :reportError();

case

Controls whether colons of case statements should have a blank space printed before.

Example 2.454. assert statement

switch (list[i]) {
case 't':
    break;
}

Example 2.455. assert statement with space before colon

switch (list[i]) {
case 't' :
    break;
}

Conditional

Controls whether colons of the conditional operator should have a blank space printed before.

Example 2.456. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.457. Conditional operator with space before colon

String value=condition?TRUE :FALSE;

for

Controls whether colons of enhanced for statements should have a blank space printed before.

Example 2.458. Enhancement for statement

for (String s:names) { }

Example 2.459. Enhanced for statement with space before colon

for (String s :names) { }

Label

Controls whether colons of labeled statements should have a blank space printed before.

Example 2.460. Labeled statement

label: {
   ...
}

Example 2.461. Labeled statement with space before colon

label : {
    ...
}

After colon

Lets you specify what colons should have a blank space printed after.

assert

Controls whether colons of assert statements should have a blank space printed after.

Example 2.462. assert statement

assert condition:reportError();

Example 2.463. assert statement with space after colon

assert condition: reportError();

Conditional

Controls whether colons of the conditional operator should have a blank space printed after.

Example 2.464. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.465. Conditional operator with space after colon

String value=condition?TRUE: FALSE;

for

Controls whether colons of enhanced for statements should have a blank space printed after.

Example 2.466. Enhancement for statement

for (String s:names) { }

Example 2.467. Enhanced for statement with space after colon

for (String s: names) { }

Label

Controls whether colons of labeled statements should have a blank space printed after.

Example 2.468. Labeled statement

label:for(;;){
   ...
}

Example 2.469. Labeled statement with space after colon

label: for(;;){
    ...
}

Please note that this option only applies when no line break is printed after the colon.

Before semicolon

Lets you specify what semicolons should have a blank space printed before.

for

Controls whether semicolons of for statements should have a blank space printed before.

Example 2.470. for statement

for(int i=0;i<array.length;i++) {}

Example 2.471. for statement with space before semicolon

for(int i=0 ;i<array.length ;i++) {}

After semicolon

Lets you specify what semicolons should have a blank space printed after.

for

Controls whether semicolons of for statements should have a blank space printed after.

Example 2.472. for statement

for(int i=0;i<array.length;i++) {}

Example 2.473. for statement with space after semicolon

for(int i=0; i<array.length; i++) {}

Before question mark

Lets you specify what question marks should have a blank space printed before.

Conditional operator

Controls whether question marks of the conditional operator should have a blank space printed before.

Example 2.474. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.475. Conditional operator with space before question mark

String value=condition ?TRUE:FALSE;

Type parameter

Controls whether question marks of type parameters should have a blank space printed before. Please note that this option only applies if no white space after the left angle bracket is forced (See “Space after left bracket type parameter”).

Example 2.476. Type parameter

class QuestionMark<T extends Comparable< ? super Number>> {}

Example 2.477. Type parameter with space before question mark

class QuestionMark<T extends Comparable< ? super Number>> {}

Type argument

Controls whether question marks of type arguments should have a blank space printed before. Please note that this option only applies if no white space after the left angle bracket and/or commas is forced (See “Space after left bracket type argument”).

Example 2.478. Type argument

Map<X<?>,Y<? extends K,? super V>>t;

Example 2.479. Type argument with space before question mark

Map<X< ?>,Y< ? extends K, ? super V>>t;

After question mark

Lets you specify what question marks should have a blank space printed after.

Conditional operator

Controls whether question marks of the conditional operator should have a blank space printed after.

Example 2.480. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.481. Conditional operator with space after question mark

String value=condition? TRUE:FALSE;

Type parameter

Controls whether question marks of type parameters should have a blank space printed after. Please note that this option only applies if no white space before the right angle bracket is forced (See “Space before right angle bracket type parameter”).

Example 2.482. Type parameter

class X10<T extends Map.Entry<?,?>> {}

Example 2.483. Type parameter with space after question mark

class X10<T extends Map.Entry<? ,? >> {}

Type argument

Controls whether question marks of type arguments should have a blank space printed after. Please note that this option only applies if no white space before the right angle bracket and/or commas is forced (See “Space before right angle bracket type argument”).

Example 2.484. Type argument

Map<X<?>,Y>t;

Example 2.485. Type argument with space after question mark

Map<X<? >,Y>t;

Before ellipsis

Lets you specify whether a blank space should be printed before the ellipsis.

Vararg

Controls whether a blank space will be printed before the ellipsis of a variable arity parameter (varag).

Since 1.2

Example 2.486. Vararg ellipsis

public void test(String[]...args) {
}

Example 2.487. Vararg ellipsis with space before

public void test(String[] ...args) {
}

After ellipsis

Lets you specify whether a blank space should be printed after the ellipsis.

Vararg

Controls whether a blank space will be printed after the ellipsis of a variable arity parameter (varag).

Since 1.6

Example 2.488. Vararg ellipsis

public void test(String[]...args) {
}

Example 2.489. Vararg ellipsis with space after

public void test(String[]... args) {
}

Before ampersand

Lets you specify whether a blank space should be printed before the ampersand.

Type parameter

Controls whether a blank space will be printed before the ampersand of type parameters.

Since 1.6

Example 2.490. Type parameter

class Foo<S,T extends Element&List> {
}

Example 2.491. Type parameter with space before ampersand

class Foo<S,T extends Element &List> {
}

After ampersand

Lets you specify whether a blank space should be printed after the ampersand.

Type parameter

Controls whether a blank space will be printed after the ampersand of type parameters.

Since 1.6

Example 2.492. Type parameter

class Foo<S,T extends Element&List> {
}

Example 2.493. Type parameter with space after ampersand

class Foo<S,T extends Element& List> {
}

Before left parenthesis

Lets you specify what left parentheses should have a blank space printed before.

Annotation argument list

Controls whether a blank space should be printed before the left parenthesis of annotation argument lists.

Example 2.494. Annotation

@Annot(x=23,y=-3)
class Foo {
}

Example 2.495. Annotation with space before argument list

@Annot (x=23,y=-3)
class Foo {
}

Annotation type member

Controls whether a blank space should be printed before the left parenthesis annotation type members.

Example 2.496. Annotation type member

@interface MyAnnotation {
    String value();
}

Example 2.497. Annotation type member with space left paren

@interface MyAnnotation {
    String value ();
}

Enum constant argument

Controls whether a blank space should be printed before the left parenthesis of enum constant argument lists.

Example 2.498. Enum constant

enum MyEnum {
    GREEN(0,255,0)
}

Example 2.499. Enum constant with space before left parenthesis

enum MyEnum {
    GREEN (0,255,0)
}

Declaration parameter

Controls whether a blank space will be printed before the left parenthesis of method and/or constructor parameter lists.

Constructor

Control whether a blank space will be printed before the left parenthesis of constructor parameter lists.

Example 2.500. Constructor declaration

Foo(int p1,int p2,int p3) {
}

Example 2.501. Constructor declaration with space before left parenthesis

Foo (int p1,int p2,int p3) {
}

Method

Control whether a blank space will be printed before the left parenthesis of method parameter lists.

Example 2.502. Method declaration

public void foo(int p1,int p2,int p3) {
}

Example 2.503. Method declaration with space before left parenthesis

public void foo (int p1,int p2,int p3) {
}

Statement expressions

Lets you control whether a blank space will be printed before the left parenthesis of statement expressions.

if

Lets you control whether a blank space will be printed before the left parenthesis of if expressions.

Example 2.504. if statement

if(condition) {
}

Example 2.505. if statement with space before left parenthesis

if (condition) {
}

for

Lets you control whether a blank space will be printed before the left parenthesis of for expressions.

Example 2.506. for statement

for(String s : names) {
}

Example 2.507. for statement with space before left parenthesis

for (String s : names) {
}

while

Lets you control whether a blank space will be printed before the left parenthesis of while expressions.

Example 2.508. while statement

while(condition) {
}

Example 2.509. while statement with space before left parenthesis

while (condition) {
}

switch

Lets you control whether a blank space will be printed before the left parenthesis of switch expressions.

Example 2.510. switch statement

switch(c) {
}

Example 2.511. switch statement with space before left parenthesis

switch (c) {
}

throw

Lets you control whether a blank space will be printed before the left parenthesis of throw expressions.

Example 2.512. throw statement

throw(new UnsupportOperationException());

Example 2.513. throw statement with space before left parenthesis

throw (new UnsupportOperationException());

synchronized

Lets you control whether a blank space will be printed before the left parenthesis of synchronized expressions.

Example 2.514. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.515. synchronized statement with space before left parenthesis

synchronized (this) {
    performOperation();
}

catch

Lets you control whether a blank space will be printed before the left parenthesis of catch expressions.

Example 2.516. catch statement

try {
    Integer.parseInt(value);
} catch(NumberFormatException ex) {
}

Example 2.517. catch statement with space before left parenthesis

try {
    Integer.parseInt(value);
} catch (NumberFormatException ex) {
}

return

Lets you control whether a blank space will be printed before the left parenthesis of return expressions.

Example 2.518. return statement

return(200 + (a * b));

Example 2.519. return statement with space before left parenthesis

return (200 + (a * b));

Call arguments

Controls whether a blank space will be printed before the left parenthesis of call arguments.

Constructor

Controls whether a blank space will be printed before the left parenthesis of constructor call arguments.

Example 2.520. Constructor call

Foo(int p1,int p2,int p3){
    super(p1,true);
}

Example 2.521. Constructor call with space before left parenthesis

Foo(int p1,int p2,int p3){
    super (p1,true);
}

Method

Controls whether a blank space will be printed before the left parenthesis of method call arguments.

Example 2.522. Method call

test(x,y);

Example 2.523. Method call space with space before left parenthesis

test (x,y);

Creator

Controls whether a blank space will be printed before the left parenthesis of creator call arguments.

Example 2.524. Creator call

Point point=new Point(x,y);

Example 2.525. Creator call with space before left parenthesis

Point point=new Point (x,y);

After left parenthesis

Lets you specify what left parentheses should have a blank space printed after.

Annotation argument list

Controls whether a blank space should be printed after the left parenthesis of annotation argument lists.

Example 2.526. Annotation

@Annot(x=23,y=-3)
class Foo {
}

Example 2.527. Annotation with space after left parenthesis

@Annot( x=23,y=-3)
class Foo {
}

Enum constant argument

Controls whether a blank space should be printed after the left parenthesis of enum constant argument lists.

Example 2.528. Enum constant

enum MyEnum {
    GREEN(0,255,0)
}

Example 2.529. Enum constant with space after left parenthesis

enum MyEnum {
    GREEN( 0,255,0)
}

Declaration parameter

Controls whether a blank space will be printed after the left parenthesis of method and/or constructor parameter lists.

Constructor

Control whether a blank space will be printed after the left parenthesis of constructor parameter lists.

Example 2.530. Constructor declaration

Foo(int p1,int p2,int p3) {
}

Example 2.531. Constructor declaration with space after left parenthesis

Foo( int p1,int p2,int p3) {
}

Method

Control whether a blank space will be printed after the left parenthesis of method parameter lists.

Example 2.532. Method declaration

public void foo(int p1,int p2,int p3) {
}

Example 2.533. Method declaration with space after left parenthesis

public void foo( int p1,int p2,int p3) {
}

Statement expressions

Lets you control whether a blank space will be printed before the left parenthesis of statement expressions.

if

Lets you control whether a blank space will be printed after the left parenthesis of if expressions.

Example 2.534. if statement

if(condition) {
}

Example 2.535. if statement with space after left parenthesis

if( condition) {
}

for

Lets you control whether a blank space will be printed after the left parenthesis of for expressions.

Example 2.536. for statement

for(String s : names) {
}

Example 2.537. for statement with space after left parenthesis

for( String s : names) {
}

while

Lets you control whether a blank space will be printed after the left parenthesis of while expressions.

Example 2.538. while statement

while(condition) {
}

Example 2.539. while statement with space after left parenthesis

while( condition) {
}

switch

Lets you control whether a blank space will be printed after the left parenthesis of switch expressions.

Example 2.540. switch statement

switch(c) {
}

Example 2.541. switch statement with space after left parenthesis

switch( c) {
}

throw

Lets you control whether a blank space will be printed after the left parenthesis of throw expressions.

Example 2.542. throw statement

throw(new UnsupportOperationException());

Example 2.543. throw statement with space after left parenthesis

throw( new UnsupportOperationException());

synchronized

Lets you control whether a blank space will be printed after the left parenthesis of synchronized expressions.

Example 2.544. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.545. synchronized statement with space after left parenthesis

synchronized( this) {
    performOperation();
}

catch

Lets you control whether a blank space will be printed after the left parenthesis of catch expressions.

Example 2.546. catch statement

try {
    Integer.parseInt(value);
} catch(NumberFormatException ex) {
}

Example 2.547. catch statement with space after left parenthesis

try {
    Integer.parseInt(value);
} catch( NumberFormatException ex) {
}

return

Lets you control whether a blank space will be printed after the left parenthesis of return expressions.

Example 2.548. return statement

return(200 + (a * b));

Example 2.549. return statement with space after left parenthesis

return( 200 + (a * b));

Call arguments

Controls whether a blank space will be printed after the left parenthesis of call arguments.

Constructor

Controls whether a blank space will be printed after the left parenthesis of constructor call arguments.

Example 2.550. Constructor call

Foo(int p1,int p2,int p3){
    super(p1,true);
}

Example 2.551. Constructor call with space after left parenthesis

Foo(int p1,int p2,int p3){
    super( p1,true);
}

Method

Controls whether a blank space will be printed after the left parenthesis of method call arguments.

Example 2.552. Method call

test(x,y);

Example 2.553. Method call space with space after left parenthesis

test( x,y);

Creator

Controls whether a blank space will be printed after the left parenthesis of creator call arguments.

Example 2.554. Creator call

Point point=new Point(x,y);

Example 2.555. Creator call with space after left parenthesis

Point point=new Point( x,y);

Parenthesized expression

Controls whether a blank space will be printed after the left parenthesis of parenthesized expressions..

Example 2.556. Expression

int r = (a * (b + c + d) * (e + f));

Example 2.557. Expression with space after left parenthesis

int r = ( a * ( b + c + d) * ( e + f));

Type cast

Controls whether a blank space will be printed after the left parenthesis of type casts.

Example 2.558. Type cast

LineManager m = (LineManager)a.getParent();

Example 2.559. Type cast with space after left parenthesis

LineManager m = ( LineManager)a.getParent();

Before right parenthesis

Lets you specify what right parentheses should have a blank space printed before.

Annotation argument list

Controls whether a blank space should be printed before the right parenthesis of annotation argument lists.

Example 2.560. Annotation

@Annot(x=23,y=-3)
class Foo {
}

Example 2.561. Annotation with space before right parenthesis

@Annot(x=23,y=-3 )
class Foo {
}

Enum constant argument

Controls whether a blank space should be printed before the right parenthesis of enum constant argument lists.

Example 2.562. Enum constant

enum MyEnum {
    GREEN(0,255,0)
}

Example 2.563. Enum constant with space before right parenthesis

enum MyEnum {
    GREEN(0,255,0 )
}

Declaration parameter

Controls whether a blank space will be printed after the left parenthesis of method and/or constructor parameter lists.

Constructor

Control whether a blank space will be printed before the right parenthesis of constructor parameter lists.

Example 2.564. Constructor declaration

Foo(int p1,int p2,int p3) {
}

Example 2.565. Constructor declaration with space before right parenthesis

Foo(int p1,int p2,int p3 ) {
}

Method

Control whether a blank space will be printed before the right parenthesis of method parameter lists.

Example 2.566. Method declaration

public void foo(int p1,int p2,int p3) {
}

Example 2.567. Method declaration with space before right parenthesis

public void foo(int p1,int p2,int p3 ) {
}

Statement expressions

Lets you control whether a blank space will be printed before the left parenthesis of statement expressions.

if

Lets you control whether a blank space will be printed before the right parenthesis of if expressions.

Example 2.568. if statement

if(condition) {
}

Example 2.569. if statement with space before right parenthesis

if(condition ) {
}

for

Lets you control whether a blank space will be printed before the right parenthesis of for expressions.

Example 2.570. for statement

for(String s : names) {
}

Example 2.571. for statement with space before right parenthesis

for(String s : names ) {
}

while

Lets you control whether a blank space will be printed before the right parenthesis of while expressions.

Example 2.572. while statement

while(condition) {
}

Example 2.573. while statement with space before right parenthesis

while(condition ) {
}

switch

Lets you control whether a blank space will be printed before the right parenthesis of switch expressions.

Example 2.574. switch statement

switch(c) {
}

Example 2.575. switch statement with space before right parenthesis

switch(c ) {
}

throw

Lets you control whether a blank space will be printed before the right parenthesis of throw expressions.

Example 2.576. throw statement

throw(new UnsupportOperationException());

Example 2.577. throw statement with space before right parenthesis

throw(new UnsupportOperationException() );

synchronized

Lets you control whether a blank space will be printed before the right parenthesis of synchronized expressions.

Example 2.578. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.579. synchronized statement with space before right parenthesis

synchronized(this ) {
    performOperation();
}

catch

Lets you control whether a blank space will be printed before the right parenthesis of catch expressions.

Example 2.580. catch statement

try {
    Integer.parseInt(value);
} catch(NumberFormatException ex) {
}

Example 2.581. catch statement with space before right parenthesis

try {
    Integer.parseInt(value);
} catch(NumberFormatException ex ) {
}

return

Lets you control whether a blank space will be printed before the right parenthesis of return expressions.

Example 2.582. return statement

return(200 + (a * b));

Example 2.583. return statement with space before right parenthesis

return(200 + (a * b) );

Call arguments

Controls whether a blank space will be printed before the right parenthesis of call arguments.

Constructor

Controls whether a blank space will be printed before the right parenthesis of constructor call arguments.

Example 2.584. Constructor call

Foo(int p1,int p2,int p3){
    super(p1,true);
}

Example 2.585. Constructor call with space before right parenthesis

Foo(int p1,int p2,int p3){
    super(p1,true );
}

Method

Controls whether a blank space will be printed before the right parenthesis of method call arguments.

Example 2.586. Method call

test(x,y);

Example 2.587. Method call space with space before right parenthesis

test(x,y );

Creator

Controls whether a blank space will be printed before the right parenthesis of creator call arguments.

Example 2.588. Creator call

Point point=new Point(x,y);

Example 2.589. Creator call with space before right parenthesis

Point point=new Point(x,y );

Parenthesized expression

Controls whether a blank space will be printed before the right parenthesis of parenthesized expressions..

Example 2.590. Expression

int r = (a * (b + c + d) * (e + f));

Example 2.591. Expression with space before right parenthesis

int r = (a * (b + c + d ) * (e + f ) );

Type cast

Controls whether a blank space will be printed before the right parenthesis of type casts.

Example 2.592. Type cast

LineManager m = (LineManager)a.getParent();

Example 2.593. Type cast with space before right parenthesis

LineManager m = (LineManager )a.getParent();

After right parenthesis

Lets you specify what right parentheses should have a blank space printed after.

Type cast

Controls whether a blank space will be printed after the right parenthesis of type casts.

Example 2.594. Type cast

LineManager m = (LineManager)a.getParent();

Example 2.595. Type cast with space after right parenthesis

LineManager m = (LineManager) a.getParent();

Between empty parentheses

Lets you specify what empty parentheses should have a blank space printed between.

Annotation type member

Controls whether a blank space should be printed between the empty parentheses of annotation type members.

Example 2.596. Annotation type member

@interface MyAnnotation {
    String value();
}

Example 2.597. Annotation type member with space between empty parentheses

@interface MyAnnotation {
    String value( );
}

Enum constant argument

Controls whether a blank space should be printed between the empty parentheses of enum constant argument lists.

Example 2.598. Enum constant

enum MyEnum {
    GREEN()
}

Example 2.599. Enum constant with space between empty parentheses

enum MyEnum {
    GREEN( )
}

Declaration parameter

Controls whether a blank space will be printed between the empty parentheses of method and/or constructor parameter lists.

Constructor

Control whether a blank space will be printed between the empty parentheses of constructor parameter lists.

Example 2.600. Constructor declaration

Foo() {
}

Example 2.601. Constructor declaration with space between empty parentheses

Foo( ) {
}

Method

Control whether a blank space will be printed before the empty parentheses of method parameter lists.

Example 2.602. Method declaration

public void foo() {
}

Example 2.603. Method declaration with space between empty parentheses

public void foo( ) {
}

Call arguments

Controls whether a blank space will be printed between the empty parentheses of call arguments.

Constructor

Controls whether a blank space will be printed between the empty parentheses of constructor call arguments.

Example 2.604. Constructor call

Foo(int p1,int p2,int p3){
    super();
}

Example 2.605. Constructor call with space between empty parentheses

Foo(int p1,int p2,int p3){
    super( );
}

Method

Controls whether a blank space will be printed between the empty parentheses of method call arguments.

Example 2.606. Method call

test();

Example 2.607. Method call space with space between empty parenthesis

test( );

Creator

Controls whether a blank space will be printed between the empty parentheses of creator call arguments.

Example 2.608. Creator call

Point point=new Point();

Example 2.609. Creator call with space between empty parentheses

Point point=new Point( );

Other parentheses

Lets you control some general parentheses behavior.

Same direction parentheses

When enabled, no white space will be printed before or after parentheses with the same direction.

Naturally, this option is only meaningful if any of the space after left parenthesis/space before right parenthesis options have been enabled.

Since 1.0.1

Example 2.610. Parentheses with same direction

if ( ( LA( 1 ) == '/' ) && ( LA( 2 ) != '*' ) )
    ...

Example 2.611. Parentheses with same direction (compacted)

if (( LA ( 1 ) == '/' ) && ( LA( 2 ) != '*' ))
    ...

Before left brace

Controls whether a blank space should be printed before the left curly brace.

Compact declaration

Controls whether a blank space should be printed before the left curly brace of compacted declaration blocks.

Example 2.612. Compact method declaration

void foo(){int i = 1;}

Example 2.613. Compact method declaration with space before left curly brace

void foo() {int i = 1;}

Array initializer

Controls whether a blank space should be printed before the left curly brace of array initializers that fit into one line.

Example 2.614. Array initializer

String[] first=new String[]{"1", "2"};

Example 2.615. Array initializer with space before left curly brace

String[] first=new String[] {"1", "2"};

After left brace

Controls whether a blank space should be printed after left curly braces.

Annotation array

Controls whether a blank space should be printed after the left curly brace of annotation arrays.

Example 2.616. Annotation array

@Target({FIELD, METHOD, CONSTRUCTOR})
class FOO {
}

Example 2.617. Annotation array with space after left curly brace

@Target({ FIELD, METHOD, CONSTRUCTOR})
class FOO {
}

Compact declaration

Controls whether a blank space should be printed after the left curly brace of compacted declaration blocks.

Example 2.618. Compact method declaration

void foo(){int i = 1;}

Example 2.619. Compact method declaration with space after left curly brace

void foo(){ int i = 1;}

Array initializer

Controls whether a blank space should be printed after the left curly brace of array initializers.

Example 2.620. Array initializer

String[] first=new String[]{"1", "2"};

Example 2.621. Array initializer with space after left curly brace

String[] first=new String[]{ "1", "2"};

Before right brace

Controls whether a blank space should be printed after left curly braces.

Annotation array

Controls whether a blank space should be printed before the right curly brace of annotation arrays.

Example 2.622. Annotation array

@Target({FIELD, METHOD, CONSTRUCTOR})
class FOO {
}

Example 2.623. Annotation array with space before right curly brace

@Target({FIELD, METHOD, CONSTRUCTOR })
class FOO {
}

Compact declaration

Controls whether a blank space should be printed before the right curly brace of compacted declaration blocks.

Example 2.624. Compact method declaration

void foo(){int i = 1;}

Example 2.625. Compact method declaration with space before right curly brace

void foo(){int i = 1; }

Array initializer

Controls whether a blank space should be printed before the right curly brace of array initializers.

Example 2.626. Array initializer

String[] first=new String[]{"1", "2"};

Example 2.627. Array initializer with space before right curly brace

String[] first=new String[]{"1", "2" };

Between empty braces

Controls whether a blank space should be printed between empty braces.

Compact declaration

Controls whether a blank space should be printed between empty curly braces of compacted declaration blocks.

Example 2.628. Compact method declaration

void foo(){}

Example 2.629. Compact method declaration with space between empty curly braces

void foo(){ }

Array initializer

Controls whether a blank space should be printed between empty curly braces of array initializers.

Example 2.630. Array initializer

String[] first=new String[]{};

Example 2.631. Array initializer with space between empty braces

String[] first=new String[]{ };

Before left bracket

Controls whether a blank space should be printed before left brackets.

Array declaration

Controls whether a blank space should be printed before the left bracket of array declaration statements.

Example 2.632. Array declaration statement

String[] first={};

Example 2.633. Array declaration statement with space before left bracket

String [] first={};

Array creator

Controls whether a blank space should be printed before the left bracket of array creation statements.

Example 2.634. Array creator statement

String[] third=new String[3];

Example 2.635. Array creator statement with space before left bracket

String[] third=new String [3];

Array accessor

Controls whether a blank space should be printed before the left bracket of array access statements.

Example 2.636. Array accessor

value=third[3];

Example 2.637. Array accessor with space before left bracket

value=third [3];

After left bracket

Controls whether a blank space should be printed after left brackets.

Array creator

Controls whether a blank space should be printed after the left bracket of array creation statements.

Example 2.638. Array creator statement

String[] third=new String[3];

Example 2.639. Array creator statement with space after left bracket

String[] third=new String[ 3];

Array accessor

Controls whether a blank space should be printed after the left bracket of array access statements.

Example 2.640. Array accessor

value=third[3];

Example 2.641. Array accessor with space after left bracket

value=third[ 3];

Before right bracket

Controls whether a blank space should be printed before right brackets.

Array creator

Controls whether a blank space should be printed before the right bracket of array creation statements.

Example 2.642. Array creator

String[] third=new String[3];

Example 2.643. Array creator with space before right bracket

String[] third=new String[3 ];

Array accessor

Controls whether a blank space should be printed before the right bracket of array access statements.

Example 2.644. Array accessor

value=third[3];

Example 2.645. Array accessor with space before right bracket

value=third[3 ];

Between empty brackets

Controls whether a blank space should be printed between empty brackets.

Array declaration

Controls whether a blank space should be printed between empty brackets of array declaration statements.

Example 2.646. Array declaration statement

String[] first={};

Example 2.647. Array declaration statement with space between empty bracket

String[ ] first={};

Array creator

Controls whether a blank space should be printed between empty brackets of array creator statements.

Example 2.648. Array creator statement

String[] first=new String[]{};

Example 2.649. Array creator statement with space between empty bracket

String[] first=new String[ ]{};

Before left angle bracket

Controls whether a blank space should be printed before left angle brackets of parameterized types.

Type parameter

Controls whether a blank space should be printed before left angle brackets of type parameters.

Example 2.650. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.651. Type parameter with space before left angle bracket

class AngleBracket <S,T extends Element> {}

Type argument

Controls whether a blank space should be printed before left angle brackets of type arguments.

Example 2.652. Type argument

caller.<String,Element>foo();

Example 2.653. Type argument with space before left angle bracket

caller. <String,Element>foo();

After left angle bracket

Controls whether a blank space should be printed after left angle brackets of parameterized types.

Type parameter

Controls whether a blank space should be printed after left angle brackets of type parameters.

Example 2.654. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.655. Type parameter with space after left angle bracket

class AngleBracket< S,T extends Element> {}

Type argument

Controls whether a blank space should be printed after left angle brackets of type arguments.

Example 2.656. Type argument

caller.<String,Element>foo();

Example 2.657. Type argument with space after left angle bracket

caller.< String,Element>foo();

Before right angle bracket

Controls whether a blank space should be printed before right angle brackets of parameterized types.

Type parameter

Controls whether a blank space should be printed before right angle brackets of type parameters.

Example 2.658. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.659. Type parameter with space before right angle bracket

class AngleBracket<S,T extends Element > {}

Type argument

Controls whether a blank space should be printed before right angle brackets of type arguments.

Example 2.660. Type argument

caller.<String,Element>foo();

Example 2.661. Type argument with space before right angle bracket

caller.<String,Element >foo();