Duplicates Finder (Java)

Build runner

Select Duplicates Finder (Java) from the drop-down list. This runner is used for gathering IntelliJ IDEA duplicates results.

Run before build

In the appropriate fields, enter the Ant scripts and targets (optional) that you want to run prior to starting the build.

Test sources

If this option is checked, the test sources will be included in the duplicates analysis.

tip

Tests contain the test data which can be duplicated. Thus, it does not make much sense to verify tests for duplicates. We recommend you not to select this option to avoid too long builds creation.

Detalization level

Use these options to define which elements of the source code should be distinguished when searching for repetitive code fragments. Code fragments can be considered duplicated, if they are structurally similar, but contain different variables, fields, methods, types or literals. Refer to the samples below:

Distinguish Variables

If this option is checked, the similar contents with different variable names will be recognized as different. If this option is not checked, such contents will be recognized as duplicated:

public static void main(String[] args) {
            int i = 0;
            int j = 0;
            if (i == j) {
                System.out.println("sum of " + i + " and " + j + " = " + i + j);
            }

            long k = 0;
            long n = 0;
            if (k == n) {
                System.out.println("sum of " + k + " and " + n + " = " + k + n);
            }
    }

Distinguish Fields

If this option is checked, the similar contents with different field names will be recognized as different. If this option is not checked, such contents will be recognized as duplicated:

myTable.addSelectionListener(new SelectionListener() {
            public void widgetDefaultSelected(SelectionEvent e) {
            }
            /*.....**/

        });

myTree.addSelectionListener(new SelectionListener() {
            public void widgetDefaultSelected(SelectionEvent e) {
            }
           /*.....**/

        });

Distinguish Methods

If this option is checked, the methods of similar structure will be recognized as different. If this option is not checked, such methods will be recognized as duplicated. In this case, they can be extracted and reused. Initial version:

public void buildCanceled(Build build, SessionData data) {
        /*  ... **/
        for (IListener listener : getListeners()) {
            listener.buildCanceled(build, data);
        }
    }

    public void buildFinished(Build build, SessionData data) {
         /*  ... **/
        for (IListener listener : getListeners()) {
            listener.buildFinished(build, data);
        }
    }

After duplicates analysis without distinguishing methods, the duplicated fragments can be extracted:

public void buildCanceled(final Build build, final SessionData data) {
    enumerateListeners(new Processor() {
      public void process(final IListener listener) {
        listener.buildCanceled(build, data);
      }
    });
  }

  public void buildFinished(final Build build, final SessionData data) {
    enumerateListeners(new Processor() {
      public void process(final IListener listener) {
        listener.buildFinished(build, data);
      }
    });
  }

  private void enumerateListeners(Processor processor) {/*  ... **/

  for (IListener listener : getListeners()) {
      processor.process(listener);
    }
  }

  private interface Processor {
    void process(IListener listener);
  }

Distinguish Types

If this option is checked, the similar code fragments with different type names will be recognized as different. If this option is not checked, such code fragments will be recognized as duplicates.

new MyIDE().updateStatus()

new TheirIDE().updateStatus()

Distinguish Literals

If this option is checked, similar line of code with different litarels will be considered different If this option is not checked, such lines will be recognized as duplicates.

myWatchedLabel.setToolTipText("Not Logged In"); myWatchedLabel.setToolTipText("Logging In...");

Ignore Duplicates with Complexity Simpler Than

Complexity of the source code is defined by the amount of statements, expressions, declarations and method calls. Complexity of each of them is defined by its cost. Summarized costs of all these elements of the source code fragment yields the total complexity. Use this field to specify the lowest level of complexity of the source code to be taken into consideration when detecting duplicates. For meaningful results start with value 10.

Ignore Duplicate Subexpressions with Complexity Simpler Than

Use this field to specify the lowest level of complexity of subexpressions to be taken into consideration when detecting duplicates.

Check if Subexpression Can be Extracted

If this option is checked, the duplicated subexpressions can be extracted.