Apache Commons Lang 3.18.0

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.18.0</version>
</dependency>

// String utilities
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.CharUtils;

// Array utilities  
import org.apache.commons.lang3.ArrayUtils;

// Object utilities
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.ClassUtils;
import org.apache.commons.lang3.BooleanUtils;

// Math utilities
import org.apache.commons.lang3.math.NumberUtils;

// Builder pattern utilities
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;

// Validation
import org.apache.commons.lang3.Validate;

// Date/Time utilities
import org.apache.commons.lang3.time.DateUtils;
import org.apache.commons.lang3.time.StopWatch;

// Exception handling
import org.apache.commons.lang3.exception.ExceptionUtils;

// Null-safe string operations
String result = StringUtils.defaultString(null, "default");  // "default"
boolean empty = StringUtils.isEmpty(null);                   // true
boolean blank = StringUtils.isBlank("  ");                   // true
String clean = StringUtils.trimToNull("  text  ");          // "text"

// String formatting and manipulation
String abbrev = StringUtils.abbreviate("Long text here", 10); // "Long te..."
String padded = StringUtils.leftPad("123", 5, '0');          // "00123"
String joined = StringUtils.join(Arrays.asList("a", "b"), ","); // "a,b"

// Array creation and manipulation
int[] array = ArrayUtils.add(new int[]{1, 2}, 3);           // [1, 2, 3]
boolean contains = ArrayUtils.contains(array, 2);            // true
int[] reversed = ArrayUtils.reverse(array);                 // [3, 2, 1]
String[] subarray = ArrayUtils.subarray(new String[]{"a", "b", "c"}, 1, 3);

// Null-safe operations
boolean isEmpty = ArrayUtils.isEmpty(null);                  // true
int length = ArrayUtils.getLength(array);                   // 3

// Null-safe operations
String result = ObjectUtils.defaultIfNull(null, "default"); // "default"
String first = ObjectUtils.firstNonNull(null, null, "value"); // "value"
boolean allNull = ObjectUtils.allNull(null, null);          // true

// Object comparison and cloning
int comparison = ObjectUtils.compare("a", "b");             // -1
Object cloned = ObjectUtils.clone(originalObject);

// Argument validation
Validate.notNull(object, "Object cannot be null");
Validate.notEmpty(collection, "Collection cannot be empty");
Validate.inclusiveBetween(1, 10, value, "Value must be between 1 and 10");
Validate.isTrue(condition, "Condition must be true");

import org.apache.commons.lang3.*;
import org.apache.commons.lang3.builder.*;
import org.apache.commons.lang3.math.*;

public class CommonsLangExample {
    public void demonstrateUsage() {
        // String operations
        String input = null;
        String safe = StringUtils.defaultString(input, "N/A");
        
        // Array operations  
        String[] array = {"apple", "banana", "cherry"};
        boolean hasApple = ArrayUtils.contains(array, "apple");
        
        // Number parsing
        int number = NumberUtils.toInt("123", 0);
        
        // Validation
        Validate.notEmpty(array, "Array cannot be empty");
        
        // Builder pattern
        String description = new ToStringBuilder(this)
            .append("safe", safe)
            .append("hasApple", hasApple)
            .append("number", number)
            .toString();
    }
}

// Defensive programming with null checks
String result = StringUtils.trimToNull(input);
if (StringUtils.isNotBlank(result)) {
    // Process non-blank string
}

// Fluent validation
Validate.notNull(user, "User cannot be null")
    .notEmpty(user.getName(), "Name cannot be empty");

// Builder pattern for complex objects
String description = ToStringBuilder.reflectionToString(object, 
    ToStringStyle.SHORT_PREFIX_STYLE);

@Component
public class UserService {
    
    public User createUser(String name, String email) {
        Validate.notBlank(name, "Name is required");
        Validate.notBlank(email, "Email is required");
        
        String cleanName = StringUtils.trim(name);
        String normalizedEmail = StringUtils.lowerCase(email);
        
        return new User(cleanName, normalizedEmail);
    }
}

@Test
public void testUserValidation() {
    // Using ArrayUtils for test data
    String[] validNames = {"John", "Jane", "Bob"};
    String[] invalidNames = {null, "", "  "};
    
    for (String name : validNames) {
        assertDoesNotThrow(() -> userService.createUser(name, "test@example.com"));
    }
    
    for (String name : invalidNames) {
        assertThrows(IllegalArgumentException.class, 
            () -> userService.createUser(name, "test@example.com"));
    }
}