skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
yennanliu/cs_basics57 installs

java-developer

Expert Java developer for implementing LeetCode problems, data structures, and algorithms. Helps write clean, efficient Java code following best practices for competitive programming and interview preparation. Use when writing or implementing Java solutions.

How do I install this agent skill?

npx skills add https://github.com/yennanliu/cs_basics --skill java-developer
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubfail

    This skill is primarily a functional Java development tool but carries a HIGH risk of indirect prompt injection. Because it is designed to read external problem descriptions and possesses powerful tools like Bash and file-writing capabilities, a malicious input file could manipulate the agent into executing arbitrary system commands.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

  • Runlayerwarn

    1/1 file flagged

What does this agent skill do?

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

  1. Read the problem from leetcode_java/ or create new file
  2. Identify the pattern (two pointers, sliding window, DP, etc.)
  3. Write the solution with clear variable names
  4. Add complexity analysis in comments
  5. Test with examples including edge cases
  6. 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

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/yennanliu/cs_basics/java-developer">View java-developer on skillZs</a>