Questions? Don’t hesitate to ask. We love to help!

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: = += -= *= \= %= &= |= ^= <<= >>= >>>=

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

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

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

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

Bitwise operator

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

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

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

Logical operator

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

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

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: + - / * %

a=(b+c)*d;

a=(b +c) *d;

Relational operator

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

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

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

Shift operator

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

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

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

int next = i++;

int next = i ++;

String concat operator

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

Since 1.0.3

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

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

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: = += -= *= \= %= &= |= ^= <<= >>= >>>=

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

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

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

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

Bitwise operator

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

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

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

Logical operator

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

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

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: ~ !

f(!x);

f(! x);

Mathematical operator

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

a=(b+c)*d;

a=(b+ c)* d;

Relational operator

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

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

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

Shift operators

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

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

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

Prefix operator

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

int previous = --i;

int previous = -- i;

Unary operator

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

Since 1.6

int x  = 3 * -4;

int x  = 3 * - 4;

String concat operator

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

Since 1.0.3

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

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

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.

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

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

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

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

Enum constant

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

enum Color{GREEN,BLUE}

enum Color{GREEN ,BLUE}

Enum constant argument

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

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

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.

interface Fooable extends Doable,Readable {}

interface Fooable extends Doable ,Readable {}

Extends type

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

class Foo implements I0,I1,I2 {}

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.

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

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.

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

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

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

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

Method

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

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.

Foo() throws IOException,FooException {
}

Foo() throws IOException ,FooException {
}

Method

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

void foo() throws IOException,FooException {
}

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.

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

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.

test(x,y);

test(x ,y);

Creator

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

Point point=new Point(x,y);

Point point=new Point(x ,y);

Array initializer

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

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

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.

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

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.

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

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.

class GenericType<S,T>{}

class GenericType<S ,T>{}

Type argument

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

caller.<String,Element>foo();

caller.<String ,Element>foo();

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.

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

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

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

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

Enum constant

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

enum Color{GREEN,BLUE}

enum Color{GREEN, BLUE}

Enum constant argument

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

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

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.

interface Fooable extends Doable,Readable {}

interface Fooable extends Doable, Readable {}

Implements type

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

class Foo implements I0,I1,I2 {}

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.

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

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.

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

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.

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

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

Method

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

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.

Foo() throws IOException,FooException {
}

Foo() throws IOException, FooException {
}

Method

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

void foo() throws IOException,FooException {
}

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.

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

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.

test(x,y);

test(x, y);

Creator

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

Point point=new Point(x,y);

Point point=new Point(x, y);

Array initializer

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

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

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.

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

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.

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

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.

class GenericType<S,T>{}

class GenericType<S, T>{}

Type argument

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

caller.<String,Element>foo();

caller.<String, Element>foo();

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.

assert condition:reportError();

assert condition :reportError();

case

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

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

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

Conditional

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

String value=condition?TRUE:FALSE;

String value=condition?TRUE :FALSE;

for

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

for (String s:names) { }

for (String s :names) { }

Label

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

label: {
   ...
}

label : {
    ...
}

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.

assert condition:reportError();

assert condition: reportError();

Conditional

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

String value=condition?TRUE:FALSE;

String value=condition?TRUE: FALSE;

for

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

for (String s:names) { }

for (String s: names) { }

Label

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

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

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

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

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.

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

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

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.

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

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

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.

String value=condition?TRUE:FALSE;

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”).

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

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”).

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

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

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.

String value=condition?TRUE:FALSE;

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”).

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

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”).

Map<X<?>,Y>t;

Map<X<? >,Y>t;

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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

@interface MyAnnotation {
    String value();
}

@interface MyAnnotation {
    String value ();
}

Enum constant argument

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

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

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.

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

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

Method

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

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

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.

if(condition) {
}

if (condition) {
}

for

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

for(String s : names) {
}

for (String s : names) {
}

while

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

while(condition) {
}

while (condition) {
}

switch

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

switch(c) {
}

switch (c) {
}

throw

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

throw(new UnsupportOperationException());

throw (new UnsupportOperationException());

synchronized

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

synchronized(this) {
    performOperation();
}

synchronized (this) {
    performOperation();
}

catch

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

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

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.

return(200 + (a * b));

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.

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

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.

test(x,y);

test (x,y);

Creator

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

Point point=new Point(x,y);

Point point=new Point (x,y);

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.

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

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

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

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.

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

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

Method

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

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

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.

if(condition) {
}

if( condition) {
}

for

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

for(String s : names) {
}

for( String s : names) {
}

while

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

while(condition) {
}

while( condition) {
}

switch

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

switch(c) {
}

switch( c) {
}

throw

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

throw(new UnsupportOperationException());

throw( new UnsupportOperationException());

synchronized

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

synchronized(this) {
    performOperation();
}

synchronized( this) {
    performOperation();
}

catch

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

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

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.

return(200 + (a * b));

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.

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

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.

test(x,y);

test( x,y);

Creator

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

Point point=new Point(x,y);

Point point=new Point( x,y);

Parenthesized expression

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

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

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.

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

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

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.

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

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

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

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.

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

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

Method

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

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

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.

if(condition) {
}

if(condition ) {
}

for

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

for(String s : names) {
}

for(String s : names ) {
}

while

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

while(condition) {
}

while(condition ) {
}

switch

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

switch(c) {
}

switch(c ) {
}

throw

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

throw(new UnsupportOperationException());

throw(new UnsupportOperationException() );

synchronized

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

synchronized(this) {
    performOperation();
}

synchronized(this ) {
    performOperation();
}

catch

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

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

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.

return(200 + (a * b));

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.

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

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.

test(x,y);

test(x,y );

Creator

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

Point point=new Point(x,y);

Point point=new Point(x,y );

Parenthesized expression

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

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

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.

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

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

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.

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

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

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.

@interface MyAnnotation {
    String value();
}

@interface MyAnnotation {
    String value( );
}

Enum constant argument

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

enum MyEnum {
    GREEN()
}

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.

Foo() {
}

Foo( ) {
}

Method

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

public void foo() {
}

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.

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

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.

test();

test( );

Creator

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

Point point=new Point();

Point point=new Point( );

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

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

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

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.

void foo(){int i = 1;}

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.

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

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

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.

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

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

void foo(){int i = 1;}

void foo(){ int i = 1;}

Array initializer

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

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

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

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.

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

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

void foo(){int i = 1;}

void foo(){int i = 1; }

Array initializer

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

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

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

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.

void foo(){}

void foo(){ }

Array initializer

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

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

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

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.

String[] first={};

String [] first={};

Array creator

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

String[] third=new String[3];

String[] third=new String [3];

Array accessor

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

value=third[3];

value=third [3];

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.

String[] third=new String[3];

String[] third=new String[ 3];

Array accessor

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

value=third[3];

value=third[ 3];

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.

String[] third=new String[3];

String[] third=new String[3 ];

Array accessor

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

value=third[3];

value=third[3 ];

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.

String[] first={};

String[ ] first={};

Array creator

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

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

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

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.

class AngleBracket<S,T extends Element> {}

class AngleBracket <S,T extends Element> {}

Type argument

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

caller.<String,Element>foo();

caller. <String,Element>foo();

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.

class AngleBracket<S,T extends Element> {}

class AngleBracket< S,T extends Element> {}

Type argument

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

caller.<String,Element>foo();

caller.< String,Element>foo();

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.

class AngleBracket<S,T extends Element> {}

class AngleBracket<S,T extends Element > {}

Type argument

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

caller.<String,Element>foo();

caller.<String,Element >foo();

Lets you configure the white space behavior for declarations.

Lets you configure the white space behavior for control statements.

Lets you configure the white space behavior for expressions.

Lets you control the white space behavior for arrays.

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