Java Development Best Practices

// Poor naming
public List<Usr> getUsrs() {
    List<Usr> l = new ArrayList<>();
    for (Usr u : this.usrMap.values()) {
        if (u.act == true) {
            l.add(u);
        }
    }
    return l;
}

// Better naming
public List<User> getActiveUsers() {
    List<User> activeUsers = new ArrayList<>();
    for (User user : this.userRepository.values()) {
        if (user.isActive()) {
            activeUsers.add(user);
        }
    }
    return activeUsers;
}

/**
 * Processes customer payment for an order.
 *
 * @param orderId The unique identifier of the order
 * @param paymentDetails Payment information including method and amount
 * @return PaymentResult containing transaction ID and status
 * @throws PaymentProcessingException If payment processing fails
 * @throws InvalidOrderException If order doesn't exist or is in invalid state
 */
public PaymentResult processPayment(String orderId, PaymentDetails paymentDetails) 
    throws PaymentProcessingException, InvalidOrderException {
    // Implementation
}

// Imperative approach
List<String> filtered = new ArrayList<>();
for (String name : names) {
    if (name.length() > 3) {
        String upperCase = name.toUpperCase();
        filtered.add(upperCase);
    }
}

// Functional approach
List<String> filtered = names.stream()
    .filter(name -> name.length() > 3)
    .map(String::toUpperCase)
    .collect(Collectors.toList());

// Problematic null checking
User findUser(String userId) {
    // implementation that might return null
}

void processUser(String userId) {
    User user = findUser(userId);
    if (user != null) {
        // Process user
    } else {
        // Handle null case
    }
}

// Better approach with Optional
Optional<User> findUser(String userId) {
    // implementation that returns Optional
}

void processUser(String userId) {
    findUser(userId).ifPresentOrElse(
        user -> { /* Process user */ },
        () -> { /* Handle empty case */ }
    );
}

// Traditional POJO with a lot of boilerplate
public class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    @Override
    public String toString() {
        return "Point[x=" + x + ", y=" + y + "]";
    }
}

// Using records
public record Point(int x, int y) {}

// Poor exception handling
try {
    // Something that might throw different exceptions
    processFile(path);
} catch (Exception e) {
    e.printStackTrace();  // Bad practice
}

// Better exception handling
try (InputStream inputStream = Files.newInputStream(path)) {
    processFile(inputStream);
} catch (IOException e) {
    log.error("Failed to process file: {}", path, e);
    throw new FileProcessingException("Could not process file: " + path, e);
} catch (InvalidDataException e) {
    log.warn("File contains invalid data: {}", path, e);
    return ProcessResult.invalid();
}

// Poor logging
try {
    // Operation
} catch (Exception e) {
    log.error("Error: " + e.getMessage());  // Loses stack trace
}

// Better logging
try {
    // Operation
} catch (Exception e) {
    log.error("Failed to process payment for order {}", orderId, e);  // Includes exception
}

// Good log level usage
log.trace("Entering method with parameters: {}", params);  // Development/debugging
log.debug("Processing record with id: {}", recordId);     // Detailed troubleshooting
log.info("Payment processed successfully for order {}", orderId);  // Normal operation
log.warn("Retry attempt {} for operation {}", attempt, operation);  // Potential issues
log.error("Database connection failed", exception);  // Errors requiring attention

// Initialize with expected capacity
Map<String, User> userMap = new HashMap<>(expectedSize);

// Choose the right collection type
// For fast iteration and insertion at end
List<Task> tasks = new ArrayList<>();

// For fast insertion/deletion at both ends
Deque<Task> taskQueue = new ArrayDeque<>();

// For maintaining insertion order
Map<String, Object> attributes = new LinkedHashMap<>();

// For frequent contains/lookup operations
Set<String> uniqueIds = new HashSet<>();

// For sorting
NavigableSet<Event> events = new TreeSet<>();

// Inefficient string concatenation in a loop
String result = "";
for (int i = 0; i < 1000; i++) {
    result += items[i];  // Creates many temporary objects
}

// Better approach with StringBuilder
StringBuilder result = new StringBuilder(expectedLength);
for (int i = 0; i < 1000; i++) {
    result.append(items[i]);
}
String finalResult = result.toString();

// Even better with String.join for simple cases
String finalResult = String.join("", items);

@Test
void calculateTotal_WithValidItems_ReturnsCorrectSum() {
    // Arrange
    OrderCalculator calculator = new OrderCalculator();
    List<OrderItem> items = List.of(
        new OrderItem("item1", new BigDecimal("10.50"), 2),
        new OrderItem("item2", new BigDecimal("25.75"), 1)
    );
    
    // Act
    BigDecimal total = calculator.calculateTotal(items);
    
    // Assert
    assertEquals(new BigDecimal("46.75"), total);
}

@Test
void findUser_WithNonExistentId_ReturnsEmpty() {
    // Arrange
    UserRepository repository = new UserRepository();
    String nonExistentId = "user-999";
    
    // Act
    Optional<User> result = repository.findById(nonExistentId);
    
    // Assert
    assertTrue(result.isEmpty());
}

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    
    @Mock
    private PaymentGateway paymentGateway;
    
    @Mock
    private OrderRepository orderRepository;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    void processOrder_WithValidPayment_CompletesOrder() {
        // Arrange
        Order order = new Order("order-1", new BigDecimal("125.00"));
        PaymentRequest request = new PaymentRequest(order.getId(), order.getTotal());
        
        when(orderRepository.findById(order.getId())).thenReturn(Optional.of(order));
        when(paymentGateway.processPayment(any(PaymentRequest.class)))
            .thenReturn(new PaymentResult(true, "transaction-123"));
        
        // Act
        OrderResult result = orderService.processOrder(order.getId());
        
        // Assert
        assertTrue(result.isSuccess());
        assertEquals(OrderStatus.COMPLETED, order.getStatus());
        
        // Verify interactions
        verify(paymentGateway).processPayment(request);
        verify(orderRepository).save(order);
    }
}

@SpringBootTest
class UserControllerIntegrationTest {
    
    @Autowired
    private MockMvc mockMvc;
    
    @Autowired
    private ObjectMapper objectMapper;
    
    @Autowired
    private UserRepository userRepository;
    
    @BeforeEach
    void setup() {
        userRepository.deleteAll();
    }
    
    @Test
    void createUser_WithValidData_ReturnsCreated() throws Exception {
        // Arrange
        UserDto userDto = new UserDto("John Doe", "john@example.com");
        
        // Act & Assert
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content(objectMapper.writeValueAsString(userDto)))
            .andExpect(status().isCreated())
            .andExpect(jsonPath("$.id").exists())
            .andExpect(jsonPath("$.name").value("John Doe"))
            .andExpect(jsonPath("$.email").value("john@example.com"));
        
        assertEquals(1, userRepository.count());
    }
}

// Validate all user inputs
public void processUserRegistration(UserRegistrationRequest request) {
    // Validate email format
    if (!EmailValidator.isValid(request.getEmail())) {
        throw new ValidationException("Invalid email format");
    }
    
    // Validate password strength
    if (request.getPassword().length() < 8) {
        throw new ValidationException("Password must be at least 8 characters");
    }
    
    // Sanitize input for XSS prevention
    String sanitizedName = HtmlUtils.htmlEscape(request.getName());
    
    // Create user with sanitized data
    User user = new User(sanitizedName, request.getEmail());
    userRepository.save(user);
}

// Preventing SQL Injection
// Bad approach (vulnerable)
String query = "SELECT * FROM users WHERE username = '" + username + "'";
Statement stmt = connection.createStatement();
ResultSet rs = stmt.executeQuery(query);

// Good approach (using prepared statements)
String query = "SELECT * FROM users WHERE username = ?";
PreparedStatement stmt = connection.prepareStatement(query);
stmt.setString(1, username);
ResultSet rs = stmt.executeQuery();

// Preventing Log Injection
// Bad approach (vulnerable)
logger.info("User login: " + username);  // Could contain CRLF characters

// Good approach
logger.info("User login: {}", username);  // Parameter substitution is safe

// Constructor injection (preferred)
@Service
public class ProductService {
    private final ProductRepository productRepository;
    private final PricingService pricingService;
    
    // Spring will automatically inject dependencies
    public ProductService(ProductRepository productRepository, 
                        PricingService pricingService) {
        this.productRepository = productRepository;
        this.pricingService = pricingService;
    }
    
    // Service methods
}