[Skip to content]
TRIEMAX Software
You are here: Home > Products > Jalopy >

### 2.6.2. White Space

The white space settings page lets you control the white space handling for the individual elements of a Java source file.

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:

- Token view

  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 only little more than twenty clicks to adjust behavior for all available options.

- Element view

  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.6.2.1. Token view

Figure 2.34. White Space Token View

##### 2.6.2.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.98. Assignment operator

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

Example 2.99. Assignment operator with space before

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

###### Bitwise operator

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

Example 2.100. Bitwise operator

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

Example 2.101. 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.102. Logical operator

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

Example 2.103. 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.104. Mathematical operator

    a=(b+c)*d;

Example 2.105. 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.106. Relational operator

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

Example 2.107. 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.108. Shift operator

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

Example 2.109. 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.110. Postfix operator

    int next = i++;

Example 2.111. 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.112. 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.113. 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.6.2.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.114. Assignment operator

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

Example 2.115. Assignment operator with space after

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

###### Bitwise operator

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

Example 2.116. Bitwise operator

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

Example 2.117. 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.118. Logical operator

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

Example 2.119. 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.120. Complement operator

    f(!x);

Example 2.121. 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.122. Mathematical operator

    a=(b+c)*d;

Example 2.123. 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.124. Relational operator

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

Example 2.125. 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.126. Shift operator

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

Example 2.127. 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.128. Prefix operator

    int previous = --i;

Example 2.129. 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.130. Unary operator

    int x  = 3 * -4;

Example 2.131. 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.132. 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.133. 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.6.2.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.134. Annotation array

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

Example 2.135. 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.136. Annotation

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

Example 2.137. 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.138. Enum constants

    enum Color{GREEN,BLUE}

Example 2.139. 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.140. Enum constant arguments

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

Example 2.141. 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.142. Extends types

    interface Fooable extends Doable,Readable {}

Example 2.143. 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.144. Implements types

    class Foo implements I0,I1,I2 {}

Example 2.145. 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.146. Multi-field declaration

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

Example 2.147. 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.148. Multi-variable declaration

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

Example 2.149. Multi-variable declaration with space before commas

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

###### Declaration parameters

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

###### Constructor

Example 2.150. Constructor declaration

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

Example 2.151. Constructor declaration with space before commas

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

###### Method

Example 2.152. Method declaration

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

Example 2.153. 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.154. Constructor declaration throws clause

    Foo() throws IOException,FooException {
    }

Example 2.155. 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.156. Method declaration throws clause

    void foo() throws IOException,FooException {
    }

Example 2.157. 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.158. Constructor call

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

Example 2.159. 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.160. Method call

    test(x,y);

Example 2.161. 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.162. Creator call

    Point point=new Point(x,y);

Example 2.163. 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.164. Array initializer

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

Example 2.165. 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.166. for initializer

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

Example 2.167. 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.168. for incrementor

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

Example 2.169. 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.170. Type parameter

    class GenericType<S,T>{}

Example 2.171. 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.172. Type argument

    caller.<String,Element>foo();

Example 2.173. Type argument with space before commas

    caller.<String ,Element>foo();

##### 2.6.2.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.174. Annotation array

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

Example 2.175. 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.176. Annotation

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

Example 2.177. 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.178. Enum constants

    enum Color{GREEN,BLUE}

Example 2.179. 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.180. Enum constant arguments

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

Example 2.181. 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.182. Extends types

    interface Fooable extends Doable,Readable {}

Example 2.183. 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.184. Implements types

    class Foo implements I0,I1,I2 {}

Example 2.185. 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.186. Multi-field declaration

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

Example 2.187. 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.188. Multi-variable declaration

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

Example 2.189. Multi-variable declaration with space after commas

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

###### Declaration parameters

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.190. Constructor declaration

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

Example 2.191. Constructor declaration with space after commas

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

###### Method

Example 2.192. Method declaration

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

Example 2.193. 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.194. Constructor declaration throws clause

    Foo() throws IOException,FooException {
    }

Example 2.195. 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.196. Method declaration throws clause

    void foo() throws IOException,FooException {
    }

Example 2.197. 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.198. Constructor call

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

Example 2.199. 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.200. Method call

    test(x,y);

Example 2.201. 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.202. Creator call

    Point point=new Point(x,y);

Example 2.203. 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.204. Array initializer

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

Example 2.205. 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.206. for initializer

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

Example 2.207. 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.208. for incrementor

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

Example 2.209. 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.210. Type parameter

    class GenericType<S,T>{}

Example 2.211. 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.212. Type argument

    caller.<String,Element>foo();

Example 2.213. Type argument with space after commas

    caller.<String, Element>foo();

##### 2.6.2.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.214. assert statement

    assert condition:reportError();

Example 2.215. 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.216. assert statement

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

Example 2.217. 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.218. Conditional operator

    String value=condition?TRUE:FALSE;

Example 2.219. 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.220. Enhancement for statement

    for (String s:names) { }

Example 2.221. 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.222. Labeled statement

    label: {
       ...
    }

Example 2.223. Labeled statement with space before colon

    label : {
        ...
    }

##### 2.6.2.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.224. assert statement

    assert condition:reportError();

Example 2.225. 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.226. Conditional operator

    String value=condition?TRUE:FALSE;

Example 2.227. 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.228. Enhancement for statement

    for (String s:names) { }

Example 2.229. 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.230. Labeled statement

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

Example 2.231. 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.6.2.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.232. for statement

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

Example 2.233. for statement with space before semicolon

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

##### 2.6.2.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.234. for statement

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

Example 2.235. for statement with space after semicolon

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

##### 2.6.2.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.236. Conditional operator

    String value=condition?TRUE:FALSE;

Example 2.237. 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.238. Type parameter

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

Example 2.239. 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.240. Type argument

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

Example 2.241. Type argument with space before question mark

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

##### 2.6.2.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.242. Conditional operator

    String value=condition?TRUE:FALSE;

Example 2.243. 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.244. Type parameter

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

Example 2.245. 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.246. Type argument

    Map<X<?>,Y>t;

Example 2.247. Type argument with space after question mark

    Map<X<? >,Y>t;

##### 2.6.2.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.248. Vararg ellipsis

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

Example 2.249. Vararg ellipsis with space before

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

##### 2.6.2.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.250. Vararg ellipsis

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

Example 2.251. Vararg ellipsis with space after

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

##### 2.6.2.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.252. Type parameter

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

Example 2.253. Type parameter with space before ampersand

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

##### 2.6.2.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.254. Type parameter

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

Example 2.255. Type parameter with space after ampersand

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

##### 2.6.2.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.256. Annotation

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

Example 2.257. 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.258. Annotation type member

    @interface MyAnnotation {
        String value();
    }

Example 2.259. 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.260. Enum constant

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

Example 2.261. Enum constant with space before left parenthesis

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

###### Declaration parameters

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.262. Constructor declaration

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

Example 2.263. 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.264. Method declaration

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

Example 2.265. 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.266. if statement

    if(condition) {
    }

Example 2.267. 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.268. for statement

    for(String s : names) {
    }

Example 2.269. 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.270. while statement

    while(condition) {
    }

Example 2.271. 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.272. switch statement

    switch(c) {
    }

Example 2.273. 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.274. throw statement

    throw(new UnsupportOperationException());

Example 2.275. 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.276. synchronized statement

    synchronized(this) {
        performOperation();
    }

Example 2.277. 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.278. catch statement

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

Example 2.279. 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.280. return statement

    return(200 + (a * b));

Example 2.281. 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.282. Constructor call

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

Example 2.283. 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.284. Method call

    test(x,y);

Example 2.285. 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.286. Creator call

    Point point=new Point(x,y);

Example 2.287. Creator call with space before left parenthesis

    Point point=new Point (x,y);

##### 2.6.2.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.288. Annotation

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

Example 2.289. 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.290. Enum constant

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

Example 2.291. Enum constant with space after left parenthesis

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

###### Declaration parameters

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.292. Constructor declaration

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

Example 2.293. 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.294. Method declaration

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

Example 2.295. 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.296. if statement

    if(condition) {
    }

Example 2.297. 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.298. for statement

    for(String s : names) {
    }

Example 2.299. 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.300. while statement

    while(condition) {
    }

Example 2.301. 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.302. switch statement

    switch(c) {
    }

Example 2.303. 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.304. throw statement

    throw(new UnsupportOperationException());

Example 2.305. 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.306. synchronized statement

    synchronized(this) {
        performOperation();
    }

Example 2.307. 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.308. catch statement

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

Example 2.309. 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.310. return statement

    return(200 + (a * b));

Example 2.311. 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.312. Constructor call

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

Example 2.313. 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.314. Method call

    test(x,y);

Example 2.315. 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.316. Creator call

    Point point=new Point(x,y);

Example 2.317. 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.318. Expression

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

Example 2.319. 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.320. Type cast

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

Example 2.321. Type cast with space after left parenthesis

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

##### 2.6.2.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.322. Annotation

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

Example 2.323. 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.324. Enum constant

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

Example 2.325. Enum constant with space before right parenthesis

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

###### Declaration parameters

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.326. Constructor declaration

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

Example 2.327. 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.328. Method declaration

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

Example 2.329. 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.330. if statement

    if(condition) {
    }

Example 2.331. 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.332. for statement

    for(String s : names) {
    }

Example 2.333. 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.334. while statement

    while(condition) {
    }

Example 2.335. 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.336. switch statement

    switch(c) {
    }

Example 2.337. 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.338. throw statement

    throw(new UnsupportOperationException());

Example 2.339. 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.340. synchronized statement

    synchronized(this) {
        performOperation();
    }

Example 2.341. 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.342. catch statement

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

Example 2.343. 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.344. return statement

    return(200 + (a * b));

Example 2.345. 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.346. Constructor call

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

Example 2.347. 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.348. Method call

    test(x,y);

Example 2.349. 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.350. Creator call

    Point point=new Point(x,y);

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

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

Example 2.353. 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.354. Type cast

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

Example 2.355. Type cast with space before right parenthesis

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

##### 2.6.2.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.356. Type cast

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

Example 2.357. Type cast with space after right parenthesis

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

##### 2.6.2.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.358. Annotation type member

    @interface MyAnnotation {
        String value();
    }

Example 2.359. 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.360. Enum constant

    enum MyEnum {
        GREEN()
    }

Example 2.361. Enum constant with space between empty parentheses

    enum MyEnum {
        GREEN( )
    }

###### Declaration parameters

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.362. Constructor declaration

    Foo() {
    }

Example 2.363. 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.364. Method declaration

    public void foo() {
    }

Example 2.365. 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.366. Constructor call

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

Example 2.367. 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.368. Method call

    test();

Example 2.369. 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.370. Creator call

    Point point=new Point();

Example 2.371. Creator call with space between empty parentheses

    Point point=new Point( );

##### 2.6.2.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.372. Parentheses with same direction

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

Example 2.373. Parentheses with same direction (compacted)

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

##### 2.6.2.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.374. Compact method declaration

    void foo(){int i = 1;}

Example 2.375. 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.376. Array initializer

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

Example 2.377. Array initializer with space before left curly brace

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

##### 2.6.2.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.378. Annotation array

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

Example 2.379. 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.380. Compact method declaration

    void foo(){int i = 1;}

Example 2.381. 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.382. Array initializer

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

Example 2.383. Array initializer with space after left curly brace

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

##### 2.6.2.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.384. Annotation array

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

Example 2.385. 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.386. Compact method declaration

    void foo(){int i = 1;}

Example 2.387. 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.388. Array initializer

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

Example 2.389. Array initializer with space before right curly brace

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

##### 2.6.2.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.390. Compact method declaration

    void foo(){}

Example 2.391. 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.392. Array initializer

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

Example 2.393. Array initializer with space between empty braces

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

##### 2.6.2.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.394. Array declaration statement

    String[] first={};

Example 2.395. 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.396. Array creator statement

    String[] third=new String[3];

Example 2.397. 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.398. Array accessor

    value=third[3];

Example 2.399. Array accessor with space before left bracket

    value=third [3];

##### 2.6.2.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.400. Array creator statement

    String[] third=new String[3];

Example 2.401. 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.402. Array accessor

    value=third[3];

Example 2.403. Array accessor with space after left bracket

    value=third[ 3];

##### 2.6.2.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.404. Array creator

    String[] third=new String[3];

Example 2.405. 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.406. Array accessor

    value=third[3];

Example 2.407. Array accessor with space before right bracket

    value=third[3 ];

##### 2.6.2.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.408. Array declaration statement

    String[] first={};

Example 2.409. 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.410. Array creator statement

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

Example 2.411. Array creator statement with space between empty bracket

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

##### 2.6.2.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.412. Type parameter

    class AngleBracket<S,T extends Element> {}

Example 2.413. 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.414. Type argument

    caller.<String,Element>foo();

Example 2.415. Type argument with space before left angle bracket

    caller. <String,Element>foo();

##### 2.6.2.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.416. Type parameter

    class AngleBracket<S,T extends Element> {}

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

    caller.<String,Element>foo();

Example 2.419. Type argument with space after left angle bracket

    caller.< String,Element>foo();

##### 2.6.2.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.420. Type parameter

    class AngleBracket<S,T extends Element> {}

Example 2.421. 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.422. Type argument

    caller.<String,Element>foo();

Example 2.423. Type argument with space before right angle bracket

    caller.<String,Element >foo();

#### 2.6.2.2. Element view

Figure 2.35. White Space Element View

##### 2.6.2.2.1. Declarations

Lets you configure the white space behavior for declarations.

###### 2.6.2.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.6.2.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.6.2.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 "Space after comma 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 "Space after comma 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.6.2.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 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.6.2.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 "Space before comma multi-field".

After comma in multi-field

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

###### 2.6.2.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 "Space before left parenthesis constructor declaration".

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 "Space after comma constructor declaration parameter".

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.6.2.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 "Space before ellipsis vargs".

After ellipsis in parameter list

Please refer to the explanation for "Space after ellipsis varargs".

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.6.2.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.6.2.2.1.9. Labels

Before colon

Please refer to the explanation for "Space before label colon".

After colon

Please refer to the explanation for "Space after label colon".

##### 2.6.2.2.2. Control Statements

Lets you configure the white space behavior for control statements.

###### 2.6.2.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 "Space after left parenthesis if".

Before right parenthesis of expression list

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

###### 2.6.2.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.6.2.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.6.2.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 "Space before left parenthesis 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.6.2.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.6.2.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 "Space before left parenthesis catch".

After left parenthesis of expression list

Please refer to the explanation for "Space after left parenthesis catch".

Before right parenthesis of expression list

Please refer to the explanation for "Space before right parenthesis catch".

###### 2.6.2.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.6.2.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.6.2.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 "Space before right parenthesis return".

##### 2.6.2.2.3. Expressions

Lets you configure the white space behavior for expressions.

###### 2.6.2.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.6.2.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 "Space before right parenthesis creator call".

Between empty parentheses of argument list

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

###### 2.6.2.2.3.3. Method call

1. Before left parenthesis of argument list

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

2. After left parenthesis of argument list

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

3. Before comma in argument list

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

4. After comma in argument list

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

5. Before right parenthesis of argument list

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

6. Between empty parentheses of argument list

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

###### 2.6.2.2.3.4. Operators

1. Before assignment operator

   Please refer to the explanation for "Space before assignment operator".

2. After assignment operator

   Please refer to the explanation for "Space after assignment operator".

3. Before bitwise operator

   Please refer to the explanation for "Space before bitwise operator".

4. After bitwise operator

   Please refer to the explanation for "Space after bitwise operator".

5. Before logical operator

   Please refer to the explanation for "Space before logical operator".

6. After logical operator

   Please refer to the explanation for "Space after logical operator".

7. Before mathematical operator

   Please refer to the explanation for "Space before mathematical operator".

8. After mathematical operator

   Please refer to the explanation for "Space after mathematical operator".

9. Before string concat operator

   Please refer to the explanation for "Space before concat operator".

10. After string concat operator

    Please refer to the explanation for "Space after concat operator".

11. Before relational operator

    Please refer to the explanation for "Space before relational operator".

12. After relational operator

    Please refer to the explanation for "Space after relational operator".

13. Before shift operator

    Please refer to the explanation for "Space before shift operator".

14. After shift operator

    Please refer to the explanation for "Space after shift operator".

15. Before conditional question operator

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

16. After conditional question operator

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

17. Before conditional colon operator

    Please refer to the explanation for "Space before conditional operator colon".

18. After conditional colon operator

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

###### 2.6.2.2.3.5. Parenthesized expression

Lets you control the white space behavior for parenthesized expressions.

1. After left parenthesis

   Please refer to the explanation for "Space after left parenthesis expression".

2. Before right parenthesis

   Please refer to the explanation for "Space before right parenthesis expression".

###### 2.6.2.2.3.6. Type cast

Lets you control the white space behavior for type casts.

1. After left parenthesis

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

2. Before right parenthesis

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

3. After right parenthesis

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

##### 2.6.2.2.4. Arrays

Lets you control the white space behavior for arrays.

###### 2.6.2.2.4.1. Declaration

Lets you control the white space behavior for array declarations.

1. Before left bracket

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

2. Between empty brackets

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

###### 2.6.2.2.4.2. Allocation

Lets you control the white space behavior for array allocations.

1. Before left bracket

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

2. After left bracket

   Please refer to the explanation for "Space after left bracket array creator".

3. Before right bracket

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

4. Between empty brackets

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

###### 2.6.2.2.4.3. Initializer

Lets you control the white space behavior for array initializers.

1. Before left brace

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

2. After left brace

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

3. Before comma

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

4. After comma

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

5. Before right brace

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

6. Between empty braces

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

###### 2.6.2.2.4.4. Accessor

Lets you control the white space behavior for array accesssors.

1. Before left bracket

   Please refer to the explanation for "Space before left bracket array accessor".

2. After left bracket

   Please refer to the explanation for "Space after left bracket array accessor".

3. Before right bracket

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

##### 2.6.2.2.5. Parameterized types

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

###### 2.6.2.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.6.2.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".