Overview

Checkstyle is configured using properties, which are string representations. This document describes how these string representations are mapped to typed properties.

integer

This property represents an integer. The string representation is parsed using the java.lang.Integer class.

string

This property represents a string. The literal string representation is used.

boolean

This property represents a boolean. The default value is false. The following string representations will map to true:

  • yes
  • true
  • on

Anything else will map to false.

stringSet

This property represents a set of strings. The string representation is parsed as a set of comma (',') separated strings.

Alternatively, this property can be supplied multiple times which is equivalent to a set of comma separated strings. For example, the following:

<property name="tokens" value="DIV_ASSIGN,PLUS_ASSIGN"/>
      

can instead be expressed as:

<property name="tokens" value="DIV_ASSIGN"/>
<property name="tokens" value="PLUS_ASSIGN"/>
      

intSet

This property represents a set of integers. The string representation is parsed as a set of comma (',') separated integers that are parsed using the java.lang.Integer class.

Alternatively, this property can be supplied multiple times which is equivalent to a set of comma separated integers. For example, the following:

<property name="tokens" value="42,666"/>
      

can instead be expressed as:

<property name="tokens" value="42"/>
<property name="tokens" value="666"/>
      

regexp

This property represents a regular expression. The string representation is parsed using java.util.regex package.

uri

This property represents a URI. The string representation is parsed using a custom routine to analyze what type of URI the string is. It can be a URL, regular file, or a resource path. It will try loading the path as a URL first, then as a file that must exist, and then finally as a resource on the classpath.

parenPad

This property represents the policy for padding with white space. The following table describes the valid options:

Option Definition
nospace Do not pad. For example, method(a, b);
space Ensure padding. For example, method( a, b );

wrapOp

This property represents the policy for wrapping lines. The following table describes the valid options:

Option Definition
nl The token must be on a new line. For example:
    someVariable = aBigVariableNameToMakeThings + "this may work"
                   + lookVeryInteresting;
            
eol The token must be at the end of the line. For example:
    someVariable = aBigVariableNameToMakeThings + "this may work" +
                   lookVeryInteresting;
            

block

This property represents the policy for checking block statements. The following table describes the valid options:

Option Definition
text Require that there is some text in the block. For example:
    catch (Exception ex) {
        // This is a bad coding practice
    }
            
statement Require that there is a statement in the block. For example:
    finally {
        lock.release();
    }
            

lcurly

This property represents the policy for checking the placement of a left curly brace ('{'). The following table describes the valid options:

Option Definition
eol The brace must always be on the end of the line. For example:
    if (condition) {
        ...
            
nl The brace must always be on a new line. For example:
    if (condition)
    {
        ...
            
nlow If the statement/expression/declaration connected to the brace spans multiple lines, than apply eol rule. Otherwise apply the nl rule. nlow is a mnemonic for "new line on wrap". For the example above Checkstyle will enforce:
    if (condition) {
        ...
            
But for a statement spanning multiple lines, Checkstyle will enforce:
    if (condition1 && condition2 &&
        condition3 && condition4)
    {
        ...
            

rcurly

This property represents the policy for checking the placement of a right curly brace ('}'). The following table describes the valid options:

Option Definition
same The brace should be on the same line as the next part of a multi-block statement (one that directly contains multiple blocks: if/else-if/else or try/catch/finally). It also allows single-line format of multi-block statements.

Examples:

    // try-catch-finally blocks
    try {
        ...
    } catch (Exception ex) { // this is OK
        ...
    } finally { // this is OK
        ...
    }

    try {
        ...
    } // this is NOT OK, not on the same line as the next part of a multi-block statement
    catch (Exception ex) {
          ...
    } // this is NOT OK, not on the same line as the next part of a multi-block statement
    finally {
          ...
    }

    // if-else blocks
    if (a > 0) {
       ...
    } else { // this is OK
       ...
    }

    if (a > 0) {
       ...
    } // this is NOT OK, not on the same line as the next part of a multi-block statement
    else {
       ...
    }

    if (a > 0) {
       ...
    } int i = 5; // this is NOT OK, next part of a multi-block statement is absent

    // Single line blocks will rise violations, because right curly
    // brace is not on the same line as the next part of a multi-block
    // statement, it just ends the line.
    public long getId() {return id;} // this is NOT OK

    Thread t = new Thread(new Runnable() {
       @Override
       public void run() {
                  ...
       } // this is NOT OK, brace is not on the same line as the next part of a multi-block statement
    }); // this is OK, allowed for better code readability

    if (a > 0) { ... } // OK, single-line multi-block statement
    if (a > 0) { ... } else { ... } // OK, single-line multi-block statement
    if (a > 0) {
        ...
    } else { ... } // OK, single-line multi-block statement
              
alone The brace must be alone on the line. For example:
    try {
        ...
    }
    finally {
        ...
    }
            
alone_or_singleline The brace must be alone on the line, yet single-line format of block is allowed. For example:
    // Brace is alone on the line
    try {
        ...
    }
    finally {
        ...
    }

    // Single-line format of block
    public long getId() { return id; }
                  

scope

This property represents a Java scope. The scope is treated inclusively (as javadoc does): 'package' means all 'package', 'protected' and 'public' methods/fields/classes. The valid options are:

  • nothing
  • public
  • protected
  • package
  • private
  • anoninner

access_modifiers

This property represents Java access modifiers.

  • public
  • protected
  • package
  • private

severity

This property represents the severity level of a check violation. The valid options are:

  • ignore
  • info
  • warning
  • error

importOrder

This property represents the policy for checking imports order. The following table describes the valid options:

Option Definition
top All static imports are at the top. For example:
    import static a.b.C.*;
    import static x.y.Z.*;

    import a.b.D;
    import x.y.Z;
above All static imports are above the local group. For example:
    import static a.b.C.*;
    import a.b.D;

    import static x.y.Z.*;
    import x.y.Z;
inflow All static imports are processed like non static imports. For example:
    import static a.b.C.*;
    import a.b.D;

    import x.y.Z;
    import static x.y.Z.*;
under All static imports are under the local group. For example:
    import a.b.D;
    import static a.b.C.*;

    import x.y.Z;
    import static x.y.Z.*;
bottom All static imports are at the bottom. For example:
    import a.b.D;
    import x.y.Z;

    import static a.b.C.*;
    import static x.y.Z.*;

elementStyle

This property represents the policy for the styles for defining elements in an annotation. The following table describes the valid options:

Option Definition
expanded The expanded version is sometimes referred to as "named parameters" in other languages. Example:
@SuppressWarnings(value={"unchecked","unused",})
compact This style can only be used when there is an element called 'value' which is either the sole element or all other elements have default values. Examples:
@SuppressWarnings({"unchecked","unused",})
and:
@SuppressWarnings("unchecked")
compact_no_array It is similar to the compact style but single value arrays are flagged. With annotations a single value array does not need to be placed in an array initializer. This style can only be used when there is an element called 'value' which is either the sole element or all other elements have default values. Example:
@SuppressWarnings("unchecked")
ignore Anything goes.

closingParens

This property represents the policy for the styles for the ending parenthesis. The following table describes the valid options:

Option Definition
always Example:
@Deprecated()
never Example:
@Deprecated
ignore Anything goes.

trailingArrayComma

This property represents the policy for the styles for the trailing array comma. The following table describes the valid options:

Option Definition
always Example:
@SuppressWarnings(value={"unchecked","unused",})
never Example:
@SuppressWarnings(value={"unchecked","unused"})
ignore Anything goes.