Preparing Java Interviews

Java
// Standard interview template - create immediately
public class Solution {
    public String solve(String input) {
        // 1. Parse input and validate
        if (input == null || input.trim().isEmpty()) {
            throw new IllegalArgumentException("Input cannot be null or empty");
        }
        
        // 2. Core algorithm
        String result = processInput(input);
        
        // 3. Return result
        return result;
    }
    
    private String processInput(String input) {
        // Implementation here
        return input.toLowerCase();
    }
}

// Corresponding test
@Test
public void testSolve() {
    Solution solution = new Solution();
    
    // Happy path
    assertEquals("hello", solution.solve("Hello"));
    
    // Edge cases
    assertThrows(IllegalArgumentException.class, 
                 () -> solution.solve(null));
    assertThrows(IllegalArgumentException.class, 
                 () -> solution.solve("   "));
}

Setup (First 5 minutes):

• Create Gradle project with JDK 17+
• Add JUnit 5 and any needed dependencies
• Read problem statement twice, identify key requirements
• Ask clarifying questions about edge cases and constraints

Development Loop (25-50 minutes):

• Write failing test for simplest case
• Implement minimal solution to pass test
• Refactor for clarity
• Add more tests for edge cases
• Extend implementation
• Document trade-offs and assumptions

Final Review (5 minutes):

• Run all tests
• Check code formatting
• Add javadocs for public methods
• Prepare to explain design decisions

Example 1: API Design Problem Input: "Build a REST endpoint for user management"

Java
@RestController
@RequestMapping("/api/users")
public class UserController {
    
    private final UserService userService;
    
    @PostMapping
    public ResponseEntity<UserDto> createUser(@Valid @RequestBody CreateUserRequest request) {
        UserDto user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDto> getUser(@PathVariable UUID id) {
        return userService.findById(id)
                .map(user -> ResponseEntity.ok(user))
                .orElse(ResponseEntity.notFound().build());
    }
}

Example 2: Data Structure Problem Input: "Implement LRU Cache"

Java
public class LRUCache<K, V> {
    private final int capacity;
    private final Map<K, Node<K, V>> cache;
    private final Node<K, V> head, tail;
    
    public LRUCache(int capacity) {
        this.capacity = capacity;
        this.cache = new HashMap<>();
        this.head = new Node<>();
        this.tail = new Node<>();
        head.next = tail;
        tail.prev = head;
    }
    
    public V get(K key) {
        Node<K, V> node = cache.get(key);
        if (node == null) return null;
        
        moveToHead(node);
        return node.value;
    }
    
    // Include helper methods and Node class
}