Java Refactoring for Eclipse IDE

Java Refactorings Available

See the table below to browse all the available refactorings. Note that all jSparrow rules have a Minimum Java Version, which means that a rule with (for example) a Minimum Java version of 1.1 can be used on Java version 1.1 and all Java versions after 1.1.

jSparrow in-depth

Technical FAQs

• What is a jSparrow Rule?

  A jSparrow rule is a definition of many small composed refactoring steps performed by jSparrow. One rule by itself can only change a very specific area within your code.

  E.g., the ‘Use Functional Interface’ rule transforms anonymous classes to lambda expressions when possible.
  
  The more rules you apply to your project, the more significant the changes to your code will be.

  Free Trial

  All jSparrow rules are described and illustrated with code examples in the jSparrow documentation space.

• What is the jSparrow Eclipse Plugin?

  The jSparrow Eclipse Plugin (JEP) is the integration of jSparrow in the Eclipse IDE. JEP has a rich user interface and allows customers to have full control over the refactorings they perform on the source base. JEP is available in Eclipse Marketplace and is compatible with all the latest Eclipse versions starting from Eclipse Photon.

  • Can I create my own rule?

    jSparrow focuses on providing ready-to-use well-tested refactoring rules. We are open to recommendations. If any customer request is considered a fine addition to our existing rule-set it will be prioritized on our roadmap.

• What is jSparrow Maven Plugin?

  The jSparrow Maven Plugin (JMP) is a continuous integration tool to apply automatic refactorings. JMP provides a standalone version of jSparrow which contains nearly the same functionalities as the jSparrow Eclipse Plugin but works without an UI. The necessary configurations can be provided through yml files.

  • Can I include jSparrow in a Jenkins build?

    Yes, you can include the jSparrow Maven Plugin in a Jenkins build process. The configuration is highly customizable and depends very much on your environment. For more information, see Integrating jSparrow Maven Plugin in Jenkins.

• What is jSparrow GitHub Cloud App?

  The jSparrow GitHub Cloud App (MVP) Creates a pull request to GitHub which invokes jSparrow – Rest POST call which sends url to git and which changeset to check. jSparrow then fetches code from GitHub using the JGit library and GitHub App authentication. Then jSparrow makes changes to the code which gets pushed back to GitHub using the JGit library.

• Why should I refactor java sources?

  The new Java 6-month release cadence has shown to be successful at least regarding the introduction of new modern language features to the Java language. For example, Java Records, Pattern Matching for Instanceof, Text Blocks, and Switch Expressions are now formalized as standard features. Many more new APIs and internal JDK improvements are released and will continue to be released with each semiannual JDK update.

  By upgrading to the latest JDK, one may immediately get a more efficient, more secure, and lighter JVM. Additionally, this opens the possibility to employ the new language features into the existing source base. For example, by using automated refactoring tools, a fair amount of old language constructs like Anonymous Classes, Switch statements, Try-Catch statements, etc, can be replaced with more up-to-date alternatives like Lambda Expressions, Switch Expressions, Try-With-Resources, etc. On the other hand, by delaying the upgrade, users would deprive themselves of the important improvements on the late JDK versions. Thus, accumulating more technical debt.

  • Does refactoring improve my code’s performance?

    A refactored code is simpler, and it does increase system responsiveness. Users can operate faster and have reduced waiting times and error messages. Another benefit is also reduced power consumption. Many case studies repeatedly prove that refactoring leads to improved performance for systems, with all the added benefits such as higher work efficiency, saved resources, and optimized budgets and costs. Particularly in Java, some new language constructs are more efficient than their outdated alternatives.

  • When should refactoring be done in agile?

    Nowadays, agile software development is prevalent and dominant, and agile teams are extending their code from one release to another. However, without continuous refactoring, such a process is hard to maintain: it becomes more and more challenging to operate on a code that otherwise could become intensely cluttered, hard to read, and unorganized. It also creates unhealthy, unstructured dependencies from packages and classes, overly significant dependencies on specific classes, and bad allocations of class responsibilities. And these are just some of the most common hundreds of issues that arise from unclear and disorganized code.

    The extreme programming (XP) practices, which are part of the Agile frameworks used by IT companies, also exclusively include the following list of steps, which also involve refactoring:

    • Code Unit test first
    • Pair program
    • Setup a dedicated integration computer (build machine)
    • Run acceptance tests
    • Refactoring
  • What is a code refactoring example?

    With Java’s evolution and the new features introduced, coding standards have changed. Lambdas and streams were game-changers in Java 8. Later on, Java 9 brought significant features which not only helped developers to modularize the code but also improved the performance of the JVM and added more modern language flavors to Java. Let’s take an example from a real world project and see how we can transform it into today’s Java:

    Code example from real world project The purpose of this code is to generate a list of String values from a given input and concatenate them into one single value. A while loop is used to iterate through all elements of the generated list and append them into a StringBuilder. In the end, the StringBuilder is converted into a single String value and returned.

    StringBuilder sb = new StringBuilder();List< String> list = generateList(input);int i = 0; while (i< list.size()) {String t = list.get(i);sb.append(t); i++; } return sb.toString();

    Transform the while loop into an enhanced for-loop The first improvement we can do to this code, is to eliminate some boilerplate code by transforming the while loop into an enhanced for loop (introduced since Java 5). Internally, the javac compiler converts the enhanced for-loop into a while loop with an iterator. The performance of this code is not going to be affected by this transformation.

    StringBuilder sb = new StringBuilder();List<String> list = generateList(input);for(String t : list) {sb.append(t); } return sb.toString();

    Transform the enhanced for-loop into a stream We can continue further and simplify the code by converting the enhanced for-loop into a stream. Arguably, the cost of creating the stream will pay off when working with large collections.

    StringBuilder sb = new StringBuilder();List<String> list = generateList(input);list.forEach(t -> sb.append(t));return sb.toString();

    Use method references The lambda expression in the forEach can be further simplified into a method reference.

    StringBuilder sb = new StringBuilder();List<String> list = generateList(input);list.forEach(sb::append); return sb.toString();

    Using String Joiner The code above is still using a StringBuilder for the sole purpose of concatenating the values of a list. Since the concatenation of the values does not contain any complex logic, we can simplify the code further by using a StringJoiner:

    List<String> list = generateList(input);return String.join("", list); See Another Example (YT Video)
  • How can I install jSparrow on Eclipse IDE?

    Please go to jSparrow documentation space to see a detailed step-by-step description.

• What is automatic code refactoring?

  Automatic code refactoring is to increase code quality automatically rather than manually. Automatic refactoring usually happens in the IDE environment or in the dev-ops tool chain where a developer can highlight a code. It can also be taken further by replacing old language constructs with new up-to-date alternatives, resolving security issues, eliminating duplicates, eliminating usages of deprecated code, migrating the versions of third-party libraries, changing the name of methods, renaming argument variables, or reducing the number of arguments.

  jSparrow is the only tool capable of automatically refactoring your code.

  Pricing
  • What is continuous refactoring?

    Also known as Merciless refactoring or the Boy scout rule: a refactoring that is ceaseless and integrated into the work of a developer’s team. The boy scout rule states that you have to leave the playground cleaner than you’ve found it.

    In continuous refactoring, you include refactoring as part of your daily tasks, and you keep the balance between it and adding new features. This requires good team communication, good organization, and very often a ‘collective code’, where everybody can improve the work of somebody else. Many teams are worried about that approach because it also includes the risk of failing. It does, however, have the opportunity for continuous improvement, which could return huge benefits, such as high quality and low costs.

  • What is the definition of refactoring?

    Refactoring is a process of restructuring and reordering an existing source code, without affecting its external forms of action and behavior. It usually does so by transforming functions and rethinking algorithms. In simpler terms, refactoring is changing software internally (code) without affecting the software externally (software UI, UX, etc.)