[Skip to content]

2.8.9. 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

2.8.9.1. Token view

Figure 2.44. White Space Token View

White Space Token View

2.8.9.1.1. 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.342. Assignment operator

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

Example 2.343. 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.344. Assignment operator

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

Example 2.345. 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.346. Bitwise operator

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

Example 2.347. 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.348. Logical operator

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

Example 2.349. 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.350. Mathematical operator

a=(b+c)*d;

Example 2.351. 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.352. Relational operator

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

Example 2.353. 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.354. Shift operator

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

Example 2.355. 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.356. Postfix operator

int next = i++;

Example 2.357. 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.358. 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.359. 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";

2.8.9.1.2. 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.360. Assignment operator

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

Example 2.361. 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.362. Assignment operator

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

Example 2.363. 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.364. Bitwise operator

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

Example 2.365. 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.366. Logical operator

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

Example 2.367. 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.368. Complement operator

f(!x);

Example 2.369. 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.370. Mathematical operator

a=(b+c)*d;

Example 2.371. 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.372. Relational operator

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

Example 2.373. 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.374. Shift operator

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

Example 2.375. 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.376. Prefix operator

int previous = --i;

Example 2.377. 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.378. Unary operator

int x  = 3 * -4;

Example 2.379. 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.380. 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.381. 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";

2.8.9.1.3. 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.382. Annotation array

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

Example 2.383. 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.384. Annotation

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

Example 2.385. 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.386. Enum constants

enum Color{GREEN,BLUE}

Example 2.387. 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.388. Enum constant arguments

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

Example 2.389. 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.390. Extends types

interface Fooable extends Doable,Readable {}

Example 2.391. 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.392. Implements types

class Foo implements I0,I1,I2 {}

Example 2.393. 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.394. Multi-field declaration

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

Example 2.395. 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.396. Multi-variable declaration

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

Example 2.397. 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.398. Constructor declaration

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

Example 2.399. Constructor declaration with space before commas

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

Method

Example 2.400. Method declaration

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

Example 2.401. 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.402. Constructor declaration throws clause

Foo() throws IOException,FooException {
}

Example 2.403. 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.404. Method declaration throws clause

void foo() throws IOException,FooException {
}

Example 2.405. 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.406. Constructor call

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

Example 2.407. 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.408. Method call

test(x,y);

Example 2.409. 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.410. Creator call

Point point=new Point(x,y);

Example 2.411. 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.412. Array initializer

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

Example 2.413. 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.414. for initializer

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

Example 2.415. 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.416. for incrementor

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

Example 2.417. 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.418. Type parameter

class GenericType<S,T>{}

Example 2.419. 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.420. Type argument

caller.<String,Element>foo();

Example 2.421. Type argument with space before commas

caller.<String ,Element>foo();

2.8.9.1.4. 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.422. Annotation array

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

Example 2.423. 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.424. Annotation

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

Example 2.425. 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.426. Enum constants

enum Color{GREEN,BLUE}

Example 2.427. 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.428. Enum constant arguments

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

Example 2.429. 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.430. Extends types

interface Fooable extends Doable,Readable {}

Example 2.431. 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.432. Implements types

class Foo implements I0,I1,I2 {}

Example 2.433. 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.434. Multi-field declaration

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

Example 2.435. 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.436. Multi-variable declaration

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

Example 2.437. 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.438. Constructor declaration

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

Example 2.439. Constructor declaration with space after commas

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

Method

Example 2.440. Method declaration

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

Example 2.441. 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.442. Constructor declaration throws clause

Foo() throws IOException,FooException {
}

Example 2.443. 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.444. Method declaration throws clause

void foo() throws IOException,FooException {
}

Example 2.445. 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.446. Constructor call

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

Example 2.447. 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.448. Method call

test(x,y);

Example 2.449. 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.450. Creator call

Point point=new Point(x,y);

Example 2.451. 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.452. Array initializer

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

Example 2.453. 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.454. for initializer

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

Example 2.455. 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.456. for incrementor

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

Example 2.457. 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.458. Type parameter

class GenericType<S,T>{}

Example 2.459. 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.460. Type argument

caller.<String,Element>foo();

Example 2.461. Type argument with space after commas

caller.<String, Element>foo();

2.8.9.1.5. 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.462. assert statement

assert condition:reportError();

Example 2.463. 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.464. assert statement

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

Example 2.465. 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.466. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.467. 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.468. Enhancement for statement

for (String s:names) { }

Example 2.469. 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.470. Labeled statement

label: {
   ...
}

Example 2.471. Labeled statement with space before colon

label : {
    ...
}

2.8.9.1.6. 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.472. assert statement

assert condition:reportError();

Example 2.473. 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.474. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.475. 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.476. Enhancement for statement

for (String s:names) { }

Example 2.477. 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.478. Labeled statement

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

Example 2.479. Labeled statement with space after colon

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

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

2.8.9.1.7. 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.480. for statement

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

Example 2.481. for statement with space before semicolon

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

2.8.9.1.8. 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.482. for statement

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

Example 2.483. for statement with space after semicolon

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

2.8.9.1.9. 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.484. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.485. 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.486. Type parameter

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

Example 2.487. 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.488. Type argument

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

Example 2.489. Type argument with space before question mark

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

2.8.9.1.10. 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.490. Conditional operator

String value=condition?TRUE:FALSE;

Example 2.491. 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.492. Type parameter

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

Example 2.493. 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.494. Type argument

Map<X<?>,Y>t;

Example 2.495. Type argument with space after question mark

Map<X<? >,Y>t;

2.8.9.1.11. 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.496. Vararg ellipsis

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

Example 2.497. Vararg ellipsis with space before

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

2.8.9.1.12. 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.498. Vararg ellipsis

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

Example 2.499. Vararg ellipsis with space after

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

2.8.9.1.13. 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.500. Type parameter

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

Example 2.501. Type parameter with space before ampersand

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

2.8.9.1.14. 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.502. Type parameter

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

Example 2.503. Type parameter with space after ampersand

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

2.8.9.1.15. 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.504. Annotation

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

Example 2.505. 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.506. Annotation type member

@interface MyAnnotation {
    String value();
}

Example 2.507. 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.508. Enum constant

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

Example 2.509. 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.510. Constructor declaration

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

Example 2.511. 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.512. Method declaration

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

Example 2.513. 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.514. if statement

if(condition) {
}

Example 2.515. 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.516. for statement

for(String s : names) {
}

Example 2.517. 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.518. while statement

while(condition) {
}

Example 2.519. 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.520. switch statement

switch(c) {
}

Example 2.521. 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.522. throw statement

throw(new UnsupportOperationException());

Example 2.523. 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.524. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.525. 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.526. catch statement

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

Example 2.527. 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.528. return statement

return(200 + (a * b));

Example 2.529. 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.530. Constructor call

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

Example 2.531. 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.532. Method call

test(x,y);

Example 2.533. 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.534. Creator call

Point point=new Point(x,y);

Example 2.535. Creator call with space before left parenthesis

Point point=new Point (x,y);

2.8.9.1.16. 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.536. Annotation

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

Example 2.537. 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.538. Enum constant

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

Example 2.539. 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.540. Constructor declaration

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

Example 2.541. 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.542. Method declaration

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

Example 2.543. 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.544. if statement

if(condition) {
}

Example 2.545. 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.546. for statement

for(String s : names) {
}

Example 2.547. 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.548. while statement

while(condition) {
}

Example 2.549. 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.550. switch statement

switch(c) {
}

Example 2.551. 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.552. throw statement

throw(new UnsupportOperationException());

Example 2.553. 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.554. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.555. 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.556. catch statement

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

Example 2.557. 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.558. return statement

return(200 + (a * b));

Example 2.559. 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.560. Constructor call

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

Example 2.561. 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.562. Method call

test(x,y);

Example 2.563. 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.564. Creator call

Point point=new Point(x,y);

Example 2.565. 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.566. Expression

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

Example 2.567. 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.568. Type cast

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

Example 2.569. Type cast with space after left parenthesis

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

2.8.9.1.17. 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.570. Annotation

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

Example 2.571. 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.572. Enum constant

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

Example 2.573. 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.574. Constructor declaration

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

Example 2.575. 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.576. Method declaration

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

Example 2.577. 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.578. if statement

if(condition) {
}

Example 2.579. 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.580. for statement

for(String s : names) {
}

Example 2.581. 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.582. while statement

while(condition) {
}

Example 2.583. 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.584. switch statement

switch(c) {
}

Example 2.585. 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.586. throw statement

throw(new UnsupportOperationException());

Example 2.587. 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.588. synchronized statement

synchronized(this) {
    performOperation();
}

Example 2.589. 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.590. catch statement

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

Example 2.591. 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.592. return statement

return(200 + (a * b));

Example 2.593. 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.594. Constructor call

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

Example 2.595. 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.596. Method call

test(x,y);

Example 2.597. 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.598. Creator call

Point point=new Point(x,y);

Example 2.599. 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.600. Expression

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

Example 2.601. 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.602. Type cast

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

Example 2.603. Type cast with space before right parenthesis

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

2.8.9.1.18. 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.604. Type cast

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

Example 2.605. Type cast with space after right parenthesis

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

2.8.9.1.19. 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.606. Annotation type member

@interface MyAnnotation {
    String value();
}

Example 2.607. 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.608. Enum constant

enum MyEnum {
    GREEN()
}

Example 2.609. 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.610. Constructor declaration

Foo() {
}

Example 2.611. 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.612. Method declaration

public void foo() {
}

Example 2.613. 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.614. Constructor call

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

Example 2.615. 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.616. Method call

test();

Example 2.617. 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.618. Creator call

Point point=new Point();

Example 2.619. Creator call with space between empty parentheses

Point point=new Point( );

2.8.9.1.20. 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.620. Parentheses with same direction

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

Example 2.621. Parentheses with same direction (compacted)

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

2.8.9.1.21. 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.622. Compact method declaration

void foo(){int i = 1;}

Example 2.623. 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.624. Array initializer

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

Example 2.625. Array initializer with space before left curly brace

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

2.8.9.1.22. 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.626. Annotation array

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

Example 2.627. 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.628. Compact method declaration

void foo(){int i = 1;}

Example 2.629. 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.630. Array initializer

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

Example 2.631. Array initializer with space after left curly brace

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

2.8.9.1.23. 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.632. Annotation array

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

Example 2.633. 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.634. Compact method declaration

void foo(){int i = 1;}

Example 2.635. 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.636. Array initializer

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

Example 2.637. Array initializer with space before right curly brace

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

2.8.9.1.24. 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.638. Compact method declaration

void foo(){}

Example 2.639. 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.640. Array initializer

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

Example 2.641. Array initializer with space between empty braces

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

2.8.9.1.25. 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.642. Array declaration statement

String[] first={};

Example 2.643. 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.644. Array creator statement

String[] third=new String[3];

Example 2.645. 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.646. Array accessor

value=third[3];

Example 2.647. Array accessor with space before left bracket

value=third [3];

2.8.9.1.26. 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.648. Array creator statement

String[] third=new String[3];

Example 2.649. 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.650. Array accessor

value=third[3];

Example 2.651. Array accessor with space after left bracket

value=third[ 3];

2.8.9.1.27. 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.652. Array creator

String[] third=new String[3];

Example 2.653. 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.654. Array accessor

value=third[3];

Example 2.655. Array accessor with space before right bracket

value=third[3 ];

2.8.9.1.28. 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.656. Array declaration statement

String[] first={};

Example 2.657. 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.658. Array creator statement

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

Example 2.659. Array creator statement with space between empty bracket

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

2.8.9.1.29. 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.660. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.661. 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.662. Type argument

caller.<String,Element>foo();


Example 2.663. Type argument with space before left angle bracket

caller. <String,Element>foo();


2.8.9.1.30. 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.664. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.665. 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.666. Type argument

caller.<String,Element>foo();


Example 2.667. Type argument with space after left angle bracket

caller.< String,Element>foo();


2.8.9.1.31. 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.668. Type parameter

class AngleBracket<S,T extends Element> {}

Example 2.669. 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.670. Type argument

caller.<String,Element>foo();


Example 2.671. Type argument with space before right angle bracket

caller.<String,Element >foo();


2.8.9.2. Element view

Figure 2.45. White Space Element View

White Space Element View

2.8.9.2.1. Declarations

Lets you configure the white space behavior for declarations.

2.8.9.2.1.1. Classes

Lets you configure the white space behavior for class declarations.

Before comma in implements clause

Please refer to the explanation for “Space before comma implements type”.

After comma in implements clause

Please refer to the explanation for “Space after comma implements type”.

2.8.9.2.1.2. Interfaces

Lets you configure the white space behavior for interface declarations.

Before comma in extends clause

Please refer to the explanation for “Space before comma extends type”.

After comma in extends clause

Please refer to the explanation for “Space after comma extends type”.

2.8.9.2.1.3. Enums

Lets you configure the white space behavior for enum declarations.

Before comma between constants

Please refer to the explanation for “Space before comma enum constant”.

After comma between constants

Please refer to the explanation for Section 2.8.9.1.4, “Enum constant”.

Before left parenthesis in constant argument list

Please refer to the explanation for “Space before left parenthesis enum constant argument”.

After left parenthesis in constant argument list

Please refer to the explanation for “Space after left parenthesis enum constant argument”.

Before comma in constant argument list

Please refer to the explanation for “Space before comma enum constant argument”.

After comma in constant argument list

Please refer to the explanation for Section 2.8.9.1.4, “Enum constant argument”.

Before right parenthesis in constant argument list

Please refer to the explanation for “Space before right parenthesis enum constant argument”.

Between empty parentheses in constant argument list

Please refer to the explanation for “Space between empty parentheses enum constant argument”.

2.8.9.2.1.4. Annotations

Lets you configure the white space behavior for annotation type declarations.

Before left parenthesis of type members

Please refer to the explanation for “Space before left parenthesis annotation type member”.

Between empty parentheses of type members

Please refer to the explanation for “Space between empty parentheses annotation type member”.

Before left parenthesis of member list

Please refer to the explanation for “Space before left parenthesis annotation argument list”.

After left parenthesis of member list

Please refer to the explanation for “Space after left parenthesis annotation argument list”.

Before assignment operator

Please refer to the explanation for “Space before assignment operator in annotations”.

After assignment operator

Please refer to the explanation for “Space after assignment operator in annotations”.

Before comma in member list

Please refer to the explanation for “Space before comma annotation type member argument”.

After comma in member list

Please refer to the explanation for “Space after comma annotation type member argument”.

Before right parenthesis of member list

Please refer to the explanation for “Space before right parenthesis annotation argument list”.

After left curly brace of annotation array

Please refer to the explanation for “Space after left curly brace annnotation array”.

Before comma in annotation array

Please refer to the explanation for “Space before comma annotation array”.

After comma in annotation array

Please refer to the explanation for “Space after comma annotation array”.

Before right curly brace of annotation array

Please refer to the explanation for “Space before right curly brace annotation array”.

2.8.9.2.1.5. Fields

Lets you configure the white space behavior for field declarations.

Before comma in multi-field

Please refer to the explanation for Section 2.8.9.1.3, “Field”.

After comma in multi-field

Please refer to the explanation for Space after comma multi-field.

2.8.9.2.1.6. Constructors

Lets you configure the white space behavior for constructor declarations.

Before left parenthesis of parameter list

Please refer to the explanation for Section 2.8.9.1.15, “Constructor”.

After left parenthesis of parameter list

Please refer to the explanation for “Space after left parenthesis constructor declaration”.

Before comma in parameter list

Please refer to the explanation for “Space before comma constructor declaration parameter”.

After comma in parameter list

Please refer to the explanation for Section 2.8.9.1.4, “Constructor”.

Before right parenthesis of parameter list

Please refer to the explanation for “Space before right parenthesis constructor declaration parameter”.

Between empty parentheses of parameter list

Please refer to the explanation for “Space between empty parentheses constructor declaration”.

Before comma in throws clause

Please refer to the explanation for “Space before comma constructor throws type”.

After comma in throws clause

Please refer to the explanation for “Space after comma constructor declaration throws type”.

2.8.9.2.1.7. Methods

Lets you configure the white space behavior for method declarations.

Before left parenthesis of parameter list

Please refer to the explanation for “Space before left parenthesis method declaration”.

After left parenthesis of parameter list

Please refer to the explanation for “Space after left parenthesis method declaration”.

Before comma in parameter list

Please refer to the explanation for “Space before comma method declaration parameter”.

After comma in parameter list

Please refer to the explanation for “Space after comma method declaration parameter”.

Before ellipsis in parameter list

Please refer to the explanation for Section 2.8.9.1.11, “Vararg”.

After ellipsis in parameter list

Please refer to the explanation for Section 2.8.9.1.12, “Vararg”.

Before right parenthesis of parameter list

Please refer to the explanation for “Space before right parenthesis method declaration parameter”.

Between empty parentheses of parameter list

Please refer to the explanation for “Space between empty parentheses enum constant argument”.

Before comma in throws clause

Please refer to the explanation for “Space before comma method throws type”.

After comma in throws clause

Please refer to the explanation for “Space after comma method declaration throws type”.

2.8.9.2.1.8. Local variables

Lets you configure the white space behavior for local variable declarations.

Before comma in multi-variable

Please refer to the explanation for Space before comma multi-var.

After comma in multi-variable

Please refer to the explanation for Space after comma multi-variable.

2.8.9.2.1.9. Labels
Before colon

Please refer to the explanation for Section 2.8.9.1.5, “Label”.

After colon

Please refer to the explanation for “Space after label colon”.

2.8.9.2.2. Control Statements

Lets you configure the white space behavior for control statements.

2.8.9.2.2.1. if

Lets you configure the white space behavior for if statements.

Before left parenthesis of expression list

Please refer to the explanation for “Space before left parenthesis if”.

After left parenthesis of expression list

Please refer to the explanation for Section 2.8.9.1.16, “if”.

Before right parenthesis of expression list

Please refer to the explanation for “Space before right parenthesis if”.

2.8.9.2.2.2. for

Lets you configure the white space behavior for for statements.

Before left parenthesis of expression list

Please refer to the explanation for “Space before left parenthesis for”.

After left parenthesis of expression list.

Please refer to the explanation for “Space after left parenthesis for”.

Before comma in initialization

Please refer to the explanation for “Space before comma for initializer”.

After comma in initialization

Please refer to the explanation for “Space after comma for initializer”.

Before comma in increment

Please refer to the explanation for “Space before comma for incrementor”.

After comma in increment

Please refer to the explanation for “Space after comma for incrementor”.

Before semicolon

Please refer to the explanation for “Space before semi colon for”.

After semicolon

Please refer to the explanation for “Space after semi colon for”.

Before colon

Please refer to the explanation for “Space before enhanced for colon”.

After colon

Please refer to the explanation for “Space after enhanced for colon”.

Before right parenthesis of expression list

Please refer to the explanation for “Space before right parenthesis for”.

2.8.9.2.2.3. while/do-while

Lets you configure the white space behavior for while and do/while statements.

Before left parenthesis of expression list

Please refer to the explanation for “Space before left parenthesis while”.

After left parenthesis of expression list

Please refer to the explanation for “Space after left parenthesis while”.

Before right parenthesis of expression list

Please refer to the explanation for “Space before right parenthesis while”.

2.8.9.2.2.4. switch

Lets you configure the white space behavior for switch statements.

Before left parenthesis of expression list

Please refer to the explanation for Section 2.8.9.1.15, “switch”.

After left parenthesis of expression list

Please refer to the explanation for “Space after left parenthesis switch”.

Before right parenthesis of expression list

Please refer to the explanation for “Space before right parenthesis switch”.

Before colon

Please refer to the explanation for “Space before case colon”.

2.8.9.2.2.5. synchronized

Lets you configure the white space behavior for synchronized statements.

Before left parenthesis of expression list

Please refer to the explanation for “Space before left parenthesis synchronized”.

After left parenthesis of expression list

Please refer to the explanation for “Space after left parenthesis synchronized”.

Before right parenthesis of expression list

Please refer to the explanation for “Space before right parenthesis synchronized”.

2.8.9.2.2.6. catch

Lets you configure the white space behavior for catch statements.

Before left parenthesis of expression list

Please refer to the explanation for Section 2.8.9.1.15, “catch”.

After left parenthesis of expression list

Please refer to the explanation for Section 2.8.9.1.16, “catch”.

Before right parenthesis of expression list

Please refer to the explanation for Section 2.8.9.1.17, “catch”.

2.8.9.2.2.7. assert

Lets you configure the white space behavior for assert statements.

Before colon

Please refer to the explanation for “Space before assertion colon”.

After colon

Please refer to the explanation for “Space after assertion colon”.

2.8.9.2.2.8. throw

Lets you configure the white space behavior for throw statements.

Before left parenthesis of expression

Please refer to the explanation for “Space before left parenthesis throw”.

After left parenthesis of expression

Please refer to the explanation for “Space after left parenthesis throw”.

Before right parenthesis of expression

Please refer to the explanation for “Space before right parenthesis throw”.

2.8.9.2.2.9. return

Lets you configure the white space behavior for return statements.

Before left parenthesis of expression

Please refer to the explanation for “Space before left parenthesis return”.

After left parenthesis of expression

Please refer to the explanation for “Space after left parenthesis return”.

Before right parenthesis of expression

Please refer to the explanation for Section 2.8.9.1.17, “return”.

2.8.9.2.3. Expressions

Lets you configure the white space behavior for expressions.

2.8.9.2.3.1. Constructor call

Lets you configure the white space behavior for constructor calls.

Before left parenthesis of argument list

Please refer to the explanation for “Space before left parenthesis constructor call”.

After left parenthesis of argument list

Please refer to the explanation for “Space after left parenthesis constructor call”.

Before comma in argument list

Please refer to the explanation for “Space before comma constructor call argument”.

After comma in argument list

Please refer to the explanation for “Space after comma constructor call argument”.

Before right parenthesis of argument list

Please refer to the explanation for “Space before right parenthesis constructor call”.

Between empty parentheses of argument list

Please refer to the explanation for “Space between empty parentheses constructor call”.

2.8.9.2.3.2. Creator call
Before left parenthesis of argument list

Please refer to the explanation for “Space before left parenthesis creator call”.

After left parenthesis of argument list

Please refer to the explanation for “Space after left parenthesis creator call”.

Before comma in argument list

Please refer to the explanation for “Space before comma creator call argument”.

After comma in argument list

Please refer to the explanation for “Space after comma creator call argument”.

Before right parenthesis of argument list

Please refer to the explanation for Section 2.8.9.1.17, “Creator”.

Between empty parentheses of argument list

Please refer to the explanation for “Space between empty parentheses creator call”.

2.8.9.2.3.3. Method call
Before left parenthesis of argument list

Please refer to the explanation for “Space before left parenthesis method call”.

After left parenthesis of argument list

Please refer to the explanation for “Space after left parenthesis method call”.

Before comma in argument list

Please refer to the explanation for “Space before comma method call argument”.

After comma in argument list

Please refer to the explanation for “Space after comma method call argument”.

Before right parenthesis of argument list

Please refer to the explanation for “Space before right parenthesis method call”.

Between empty parentheses of argument list

Please refer to the explanation for “Space between empty parentheses method call”.

2.8.9.2.3.4. Operators
Before assignment operator

Please refer to the explanation for “Space before assignment operator”.

After assignment operator

Please refer to the explanation for Section 2.8.9.1.2, “Assignment operator”.

Before assignment operator in annotations

Please refer to the explanation for “Space before assignment operator in annotations”.

After assignment operator in annotations

Please refer to the explanation for “Space after assignment operator in annotations”.

Before bitwise operator

Please refer to the explanation for “Space before bitwise operator”.

After bitwise operator

Please refer to the explanation for “Space after bitwise operator”.

Before logical operator

Please refer to the explanation for “Space before logical operator”.

After logical operator

Please refer to the explanation for “Space after logical operator”.

Before mathematical operator

Please refer to the explanation for “Space before mathematical operator”.

After mathematical operator

Please refer to the explanation for “Space after mathematical operator”.

Before string concat operator

Please refer to the explanation for “Space before concat operator”.

After string concat operator

Please refer to the explanation for “Space after concat operator”.

Before relational operator

Please refer to the explanation for Section 2.8.9.1.1, “Relational operator”.

After relational operator

Please refer to the explanation for “Space after relational operator”.

Before shift operator

Please refer to the explanation for “Space before shift operator”.

After shift operator

Please refer to the explanation for “Space after shift operator”.

Before conditional question operator

Please refer to the explanation for “Space before question mark conditional operator”.

After conditional question operator

Please refer to the explanation for “Space after question mark conditional operator”.

Before conditional colon operator

Please refer to the explanation for Section 2.8.9.1.5, “Conditional”.

After conditional colon operator

Please refer to the explanation for “Space after conditional operator colon”.

2.8.9.2.3.5. Parenthesized expression

Lets you control the white space behavior for parenthesized expressions.

After left parenthesis

Please refer to the explanation for Section 2.8.9.1.16, “Parenthesized expression”.

Before right parenthesis

Please refer to the explanation for Section 2.8.9.1.17, “Parenthesized expression”.

2.8.9.2.3.6. Type cast

Lets you control the white space behavior for type casts.

After left parenthesis

Please refer to the explanation for “Space after left parenthesis type cast”.

Before right parenthesis

Please refer to the explanation for “Space before right parenthesis type cast”.

After right parenthesis

Please refer to the explanation for “Space after right parenthesis type cast”.

2.8.9.2.4. Arrays

Lets you control the white space behavior for arrays.

2.8.9.2.4.1. Declaration

Lets you control the white space behavior for array declarations.

Before left bracket

Please refer to the explanation for “Space before left bracket array declaration”.

Between empty brackets

Please refer to the explanation for “Space between empty brackets array declaration”.

2.8.9.2.4.2. Allocation

Lets you control the white space behavior for array allocations.

Before left bracket

Please refer to the explanation for “Space before left bracket creator”.

After left bracket

Please refer to the explanation for Section 2.8.9.1.26, “Array creator”.

Before right bracket

Please refer to the explanation for “Space before right bracket array creator”.

Between empty brackets

Please refer to the explanation for “Space between empty brackets array creator”.

2.8.9.2.4.3. Initializer

Lets you control the white space behavior for array initializers.

Before left brace

Please refer to the explanation for “Space before left curly brace array initializer”.

After left brace

Please refer to the explanation for “Space after left curly brace array initializer”.

Before comma

Please refer to the explanation for “Space before comma array initializer”.

After comma

Please refer to the explanation for “Space after comma array initializer”.

Before right brace

Please refer to the explanation for “Space before right curly brace array initializer”.

Between empty braces

Please refer to the explanation for “Space between empty curly braces array initializer”.

2.8.9.2.4.4. Accessor

Lets you control the white space behavior for array accesssors.

Before left bracket

Please refer to the explanation for Section 2.8.9.1.25, “Array accessor”.

After left bracket

Please refer to the explanation for Section 2.8.9.1.26, “Array accessor”.

Before right bracket

Please refer to the explanation for “Space before right bracket array accessor”.

2.8.9.2.5. Parameterized types

Lets you control the white space behavior for parameterized (generic) types.

2.8.9.2.5.1. Type parameter

Lets you configure the white space behavior for type parameters.

Before left angle bracket

Please refer to the explanation for “Space before left angle bracket type parameter”.

After left angle bracket

Please refer to the explanation for “Space after left bracket type parameter”.

Before comma in brackets

Please refer to the explanation for “Space before comma type parameter”.

After comma in brackets

Please refer to the explanation for “Space after comma type parameter”.

Before ampersand in brackets

Please refer to the explanation for “Space before ampersand type parameter”.

After ampersand in brackets

Please refer to the explanation for “Space after ampersand type parameter”.

Before question mark in brackets

Please refer to the explanation for “Space before question mark type parameter”.

After question mark in brackets

Please refer to the explanation for “Space after question mark type parameter”.

Before right angle bracket

Please refer to the explanation for “Space before right angle bracket type parameter”.

2.8.9.2.5.2. Type argument

Lets you configure the white space behavior for type arguments.

Before left angle bracket

Please refer to the explanation for “Space before left angle bracket type argument”.

After left angle bracket

Please refer to the explanation for “Space before left angle bracket type argument”.

Before comma in brackets

Please refer to the explanation for “Space before comma type argument”.

After comma in brackets

Please refer to the explanation for “Space after comma type argument”.

Before question mark in brackets

Please refer to the explanation for “Space before question mark type argument”.

After question mark in brackets

Please refer to the explanation for “Space after question mark type argument”.

Before right angle bracket

Please refer to the explanation for “Space before right angle bracket type argument”.