Java Developer

When to use this Skill

Use this Skill when:

• Writing new Java solutions for LeetCode problems

• Implementing data structures or algorithms in Java

• Converting solutions from other languages to Java

• Setting up Java test cases with JUnit

Instructions

1. Code Structure

Follow the project's Java conventions:

• Package structure: AlgorithmJava , DataStructure , LeetCodeJava

• Use Java 8 compatibility features

• Include proper imports and class declarations

• Follow camelCase naming conventions

For LeetCode problems:

package LeetCodeJava;

/**

• Problem {number}: {title}
• Difficulty: {Easy/Medium/Hard}
• {Brief problem description}
• Time Complexity: O(?)
• Space Complexity: O(?) */ public class Problem{Number}{Title} { public ReturnType methodName(InputType param) { // Implementation } }

2. Best Practices

Optimize for interviews:

• Write clean, readable code first

• Add comments only for complex logic

• Use meaningful variable names

• Handle edge cases explicitly

Common patterns:

• Two pointers: left , right or i , j

• Sliding window: start , end

• Binary search: lo , hi , mid

• DFS/BFS: Use Stack/Queue with explicit types

Data structures to prefer:

• List<> instead of arrays when size varies

• HashMap<> for O(1) lookups

• HashSet<> for uniqueness checks

• PriorityQueue<> for heap operations

• Deque<> for stack/queue flexibility

3. Performance Guidelines

Time Complexity Goals:

• Array problems: Aim for O(n) or O(n log n)

• String problems: Aim for O(n) with HashMap/array counting

• Tree problems: O(n) traversal is usually optimal

• Graph problems: O(V + E) for BFS/DFS

Space Optimization:

• Modify input in-place when possible

• Use bit manipulation for boolean arrays

• Consider iterative over recursive for O(1) space

4. Testing Approach

Include test cases:

// In test class @Test public void testBasicCase() { Problem{Number}{Title} solution = new Problem{Number}{Title}(); assertEquals(expected, solution.methodName(input)); }

@Test public void testEdgeCase() { // Test empty input, null, single element, etc. }

5. Common Mistakes to Avoid

• Integer overflow: Use long for large sums

• Array index out of bounds: Check i < arr.length

• Null pointer: Validate inputs

• Off-by-one errors: Double-check loop boundaries

• Mutable vs immutable: Be careful with references

6. Java-Specific Tips

Useful methods:

// String s.charAt(i), s.substring(i, j), s.toCharArray()

// Collections Collections.sort(list), Collections.reverse(list) Arrays.sort(arr), Arrays.fill(arr, val)

// Math Math.max(a, b), Math.min(a, b), Math.abs(x)

// Queue/Stack queue.offer(), queue.poll(), queue.peek() stack.push(), stack.pop(), stack.peek()

Lambda expressions for sorting:

Arrays.sort(intervals, (a, b) -> a[0] - b[0]); PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);

Example Workflow

• Read the problem from leetcode_java/ or create new file

• Identify the pattern (two pointers, sliding window, DP, etc.)

• Write the solution with clear variable names

• Add complexity analysis in comments

• Test with examples including edge cases

• Optimize if needed after correct solution works

Project-Specific Notes

• Maven project: Build with mvn compile , test with mvn test

• JUnit 5 is configured for testing

• Problems are organized by algorithm type

• Follow existing code style in the package