SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Java

Java static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your JAVA code

  • All rules 733
  • Vulnerability60
  • Bug175
  • Security Hotspot40
  • Code Smell458

  • Quick Fix 65
Filtered: 41 rules found
clumsy
    Impact
      Clean code attribute
        1. Call to Mockito method "verify", "when" or "given" should be simplified

           Code Smell
        2. Similar tests should be grouped in a single Parameterized test

           Code Smell
        3. An iteration on a Collection should be performed on the type handled by the Collection

           Code Smell
        4. "StandardCharsets" constants should be preferred

           Code Smell
        5. "Stream.collect()" calls should not be redundant

           Code Smell
        6. "Stream" call chains should be simplified when possible

           Code Smell
        7. Arrays should not be created for varargs parameters

           Code Smell
        8. Unit tests should throw exceptions

           Code Smell
        9. Jump statements should not be redundant

           Code Smell
        10. "Optional" should not be used for parameters

           Code Smell
        11. Default annotation parameter values should not be passed as arguments

           Code Smell
        12. ".isEmpty" should be used to test for the emptiness of StringBuffers/Builders

           Code Smell
        13. Arguments to "append" should not be concatenated

           Code Smell
        14. Arrays and lists should not be copied using loops

           Code Smell
        15. "catch" clauses should do more than rethrow

           Code Smell
        16. Synchronizing on a "Lock" object should be avoided

           Code Smell
        17. Classes with only "static" methods should not be instantiated

           Code Smell
        18. Redundant modifiers should not be used

           Code Smell
        19. The diamond operator ("<>") should be used

           Code Smell
        20. Switches should be used for sequences of simple "String" tests

           Code Smell
        21. Do not perform unnecessary mathematical operations

           Code Smell
        22. Unnecessary boxing and unboxing should be avoided

           Bug
        23. Catches should be combined

           Code Smell
        24. Methods of "Random" that return floating point values should not be used in random integer generation

           Code Smell
        25. String operations with predictable outcomes should be avoided

           Bug
        26. Classes should not be empty

           Code Smell
        27. Extensions and implementations should not be redundant

           Code Smell
        28. Redundant casts should not be used

           Code Smell
        29. "toString()" should never be called on a String object

           Code Smell
        30. Local variables should not be declared and then immediately returned or thrown

           Code Smell
        31. A "while" loop should be used instead of a "for" loop

           Code Smell
        32. Exception types should not be tested using "instanceof" in catch blocks

           Code Smell
        33. Overriding methods should do more than simply call the same method in the super class

           Code Smell
        34. Primitive wrappers should not be instantiated only for "toString" or "compareTo" calls

           Code Smell
        35. Case insensitive string comparisons should be made without intermediate upper or lower casing

           Code Smell
        36. "Collection.isEmpty()" should be used to test for emptiness

           Code Smell
        37. "String.valueOf()" should not be appended to a "String"

           Code Smell
        38. Exceptions in "throws" clauses should not be superfluous

           Code Smell
        39. Return of boolean expressions should not be wrapped into an "if-then-else" statement

           Code Smell
        40. Boolean literals should not be redundant

           Code Smell
        41. Mergeable "if" statements should be combined

           Code Smell

        ".isEmpty" should be used to test for the emptiness of StringBuffers/Builders

        intentionality - efficient
        maintainability
        Code Smell
        Quick FixIDE quick fixes available with SonarQube for IDE
        • performance
        • clumsy

        Why is this an issue?

        It is inefficient to build a String from a StringBuilder or StringBuffer just to check if it’s empty. Instead, directly use the .isEmpty method.

        Noncompliant code example

        StringBuilder sb = new StringBuilder();
        // ...
        if ("".equals(sb.toString()) { // Noncompliant
          // ...
        }
        if (sb.toString().isEmpty()) { // Noncompliant
          // ...
        }
        

        Compliant solution

        StringBuilder sb = new StringBuilder();
        // ...
        if (sb.isEmpty()) {
          // ...
        }
        if (sb.isEmpty()) {
          // ...
        }
        

        Benchmarks

        Method stringBuilderSize Runtime Average time Error margin

        isEmpty

        10

        Temurin 21

        6.57 ns/op

        ±0.38 ns/op

        isEmpty

        100

        Temurin 21

        6.68 ns/op

        ±0.10 ns/op

        isEmpty

        1000

        Temurin 21

        6.80 ns/op

        ±0.12 ns/op

        length

        10

        Temurin 21

        6.83 ns/op

        ±0.12 ns/op

        length

        100

        Temurin 21

        6.66 ns/op

        ±0.11 ns/op

        length

        1000

        Temurin 21

        6.67 ns/op

        ±0.07 ns/op

        toStringEquals

        10

        Temurin 21

        13.92 ns/op

        ±0.18 ns/op

        toStringEquals

        100

        Temurin 21

        59.09 ns/op

        ±0.53 ns/op

        toStringEquals

        1000

        Temurin 21

        465.79 ns/op

        ±5.86 ns/op

        toStringIsEmpty

        10

        Temurin 21

        13.83 ns/op

        ±0.23 ns/op

        toStringIsEmpty

        100

        Temurin 21

        60.06 ns/op

        ±3.42 ns/op

        toStringIsEmpty

        1000

        Temurin 21

        484.58 ns/op

        ±4.24 ns/op

        Benchmarking code

        The results were generated by running the following snippet with JMH.

        @Param({"10", "100", "1000"})
        int stringBuilderSize;
        
        
        private StringBuilder sb;
        
        @Setup(Level.Iteration)
        public void setup() {
          sb = new StringBuilder();
          IntStream.range(0, stringBuilderSize).forEach(i -> sb.append("word"));
        }
        
        @Benchmark
        public StringBuilder toStringEquals() {
          if ("".equals((sb.toString()))) {
            return sb;
          }
          return new StringBuilder();
        }
        
        @Benchmark
        public StringBuilder toStringIsEmpty() {
          if (sb.toString().isEmpty()) {
            return sb;
          }
          return new StringBuilder();
        }
        
        @Benchmark
        public StringBuilder length() {
          if (sb.length() == 0) {
            return sb;
          }
          return new StringBuilder();
        }
        
        @Benchmark
        public StringBuilder isEmpty() {
          if (sb.isEmpty()) {
            return sb;
          }
          return new StringBuilder();
        }
        
          Available In:
        • SonarQube IdeCatch issues on the fly,
          in your IDE
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories
        • SonarQube ServerAnalyze code in your
          on-premise CI

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use