Java Refactor

Suggests and applies version-gated Java refactorings. Use when user asks to "refactor this", "clean up this code", "modernize this Java", "simplify this", "extract method", "improve this class", or "make this more idiomatic".

Refactor the Java code I've selected or provided. Follow these steps:

Step 1 — Detect Java version

Check pom.xml (<java.version> or <maven.compiler.source>) or build.gradle (sourceCompatibility). If not found, ask: "What Java version are you targeting? (8, 11, 17, 21, or other)"

Step 2 — Apply safe refactorings (all Java versions)

These refactorings are safe regardless of Java version:

  • Extract method: if a method is longer than 20 lines or has a distinct sub-step, extract it with a descriptive name
  • Rename for clarity: rename variables, methods, or classes with unclear names
  • Remove duplication: identify repeated logic blocks and extract to a shared method
  • Replace magic literals: replace inline numbers/strings with named static final constants
  • Simplify conditionals: replace nested if/else chains with early returns or ternary where clearer
  • Remove dead code: delete unreachable branches, unused variables, unused imports

Step 3 — Apply version-gated refactorings (only if target version supports it)

State the minimum Java version required for each suggestion:

  • Java 8+ — Replace anonymous classes with lambdas: e.g., new Comparator<String>() { ... } → (a, b) -> a.compareTo(b)
  • Java 8+ — Replace imperative loops with streams: e.g., for-each + list.add → list.stream().filter(...).collect(Collectors.toList())
  • Java 8+ — Use Optional instead of null returns: e.g., return null → return Optional.empty()
  • Java 9+ — Use List.of / Map.of: e.g., new ArrayList<>(Arrays.asList(...)) → List.of(...)
  • Java 10+ — Use var for local variables: where the type is obvious from the right-hand side
  • Java 16+ — Replace data classes with records: e.g., a class with only final fields, a constructor, and getters → record
  • Java 17+ — Replace instanceof + cast chains with pattern matching: e.g., if (obj instanceof String) { String s = (String) obj; } → if (obj instanceof String s)

Output format

For each refactoring:

  1. What: one sentence describing the change
  2. Why: one sentence explaining the benefit
  3. Before: the original code snippet
  4. After: the refactored code snippet
  5. Java version required: (e.g., "Java 8+" or "All versions")

Then offer: "Want me to apply these changes to the file?"

Next Steps

After completing refactoring:

  • If tests don't exist for the refactored code → suggest running /java-test to generate tests
  • If the refactoring changed public API signatures → suggest running /java-docs to update Javadoc
  • Remind the user to run their build: mvn compile -q or ./gradlew build -q