Optimize get_java_runtime_setup_steps

This optimization achieves a **20% runtime improvement** (531μs → 441μs) by replacing conditional string concatenation with a precomputed dictionary lookup.

**What changed:**
- The original code builds strings dynamically on every function call, performing string concatenation operations based on conditional checks
- The optimized version precomputes all possible string outputs once at module load time and stores them in a dictionary (`_JAVA_SETUP_MAP`)
- The function now performs a simple O(1) dictionary lookup instead of executing string operations

**Why it's faster:**
1. **Eliminates repeated string operations**: String concatenation in Python creates new string objects. The original code performs this work on every call, while the optimized version does it once at module initialization
2. **Reduces conditional branching**: The original code evaluates two conditional branches per call. The optimized version performs a single dictionary lookup, which is highly optimized in Python's C implementation
3. **Better CPU cache utilization**: Precomputed strings stored in memory are more likely to remain in CPU cache across multiple function calls

**Performance characteristics by test case:**
- **Single calls**: Show mixed results (some 3-15% slower per individual call) due to dictionary lookup overhead, but the overall benchmark shows 20% improvement
- **Repeated calls (500 iterations)**: Show strong gains of 17-27% faster, where the optimization truly shines. This is where the elimination of repeated string operations matters most
- **Subsequent calls**: Tests with multiple consecutive calls (result1, result2, result3) show increasing speedup on later calls (up to 25% faster), indicating better memory access patterns

**Impact on workloads:**
This function generates GitHub Actions workflow configuration. The optimization is most beneficial when:
- The function is called multiple times during workflow generation (common in CI/CD setup scenarios)
- Build configurations are generated in batch operations
- The same build tool type is queried repeatedly

The trade-off of slightly slower individual first-time calls is more than compensated by the significant gains in repeated execution scenarios, making this a net-positive optimization for typical usage patterns where configuration generation happens in batches or loops.

Author: codeflash-ai[bot]

codeflash/cli_cmds/init_java.py

@@ -26,6 +26,12 @@
 from codeflash.code_utils.shell_utils import get_shell_rc_path, is_powershell
 from codeflash.telemetry.posthog_cf import ph
 
+_JAVA_SETUP_BASE = """- name: Set up JDK 17
+        uses: actions/setup-java@v4
+        with:
+          java-version: '17'
+          distribution: 'temurin'"""
+
 
 class JavaBuildTool(Enum):
     """Java build tools."""
@@ -519,20 +525,7 @@ def configure_java_project(setup_info: JavaSetupInfo) -> bool:
 
 def get_java_runtime_setup_steps(build_tool: JavaBuildTool) -> str:
     """Generate the appropriate Java setup steps for GitHub Actions."""
-    java_setup = """- name: Set up JDK 17
-        uses: actions/setup-java@v4
-        with:
-          java-version: '17'
-          distribution: 'temurin'"""
-
-    if build_tool == JavaBuildTool.MAVEN:
-        java_setup += """
-          cache: 'maven'"""
-    elif build_tool == JavaBuildTool.GRADLE:
-        java_setup += """
-          cache: 'gradle'"""
-
-    return java_setup
+    return _JAVA_SETUP_MAP.get(build_tool, _JAVA_SETUP_BASE)
 
 
 def get_java_dependency_installation_commands(build_tool: JavaBuildTool) -> str:
@@ -551,3 +544,10 @@ def get_java_test_command(build_tool: JavaBuildTool) -> str:
     if build_tool == JavaBuildTool.GRADLE:
         return "./gradlew test"
     return "mvn test"
+
+_JAVA_SETUP_MAP = {
+    JavaBuildTool.MAVEN: _JAVA_SETUP_BASE + """
+          cache: 'maven'""",
+    JavaBuildTool.GRADLE: _JAVA_SETUP_BASE + """
+          cache: 'gradle'""",
+}