CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-commons--commons-lang3

Apache Commons Lang provides essential Java utility classes for string manipulation, object operations, array handling, date/time processing, reflection utilities, and more.

—

Pending
Overview
Eval results
Files

string-utilities.mddocs/

String Utilities

Apache Commons Lang provides comprehensive string manipulation utilities through several key classes. The StringUtils class alone offers 233 static methods for null-safe string operations, making it one of the most essential utility classes for Java developers.

Core Classes

StringUtils - Comprehensive String Operations

The primary string utility class with 233 static methods covering every aspect of string manipulation:

import org.apache.commons.lang3.StringUtils;

Null Safety and Basic Checks

// Null safety
public static boolean isEmpty(CharSequence cs)
public static boolean isNotEmpty(CharSequence cs)
public static boolean isBlank(CharSequence cs)
public static boolean isNotBlank(CharSequence cs)

// Default value handling
public static String defaultString(String str)
public static String defaultString(String str, String defaultStr)
public static String defaultIfEmpty(String str, String defaultStr)
public static String defaultIfBlank(String str, String defaultStr)

Usage Examples:

// Null and empty checks
boolean empty = StringUtils.isEmpty(null);           // true
boolean empty2 = StringUtils.isEmpty("");            // true
boolean empty3 = StringUtils.isEmpty(" ");           // false

boolean blank = StringUtils.isBlank(null);           // true
boolean blank2 = StringUtils.isBlank("");            // true
boolean blank3 = StringUtils.isBlank(" ");           // true
boolean blank4 = StringUtils.isBlank("  \t\n  ");    // true

// Default values
String result1 = StringUtils.defaultString(null);              // ""
String result2 = StringUtils.defaultString(null, "default");   // "default"
String result3 = StringUtils.defaultIfEmpty("", "default");    // "default"
String result4 = StringUtils.defaultIfBlank("  ", "default");  // "default"

String Cleaning and Trimming

// Trimming operations
public static String trim(String str)
public static String trimToNull(String str)
public static String trimToEmpty(String str)
public static String strip(String str)
public static String stripToNull(String str)
public static String stripToEmpty(String str)

// Advanced cleaning
public static String deleteWhitespace(String str)
public static String normalizeSpace(String str)
public static String clean(String str)

Usage Examples:

// Basic trimming
String trimmed = StringUtils.trim("  hello  ");           // "hello"
String trimNull = StringUtils.trimToNull("   ");          // null
String trimEmpty = StringUtils.trimToEmpty("   ");        // ""

// Whitespace operations
String noWhitespace = StringUtils.deleteWhitespace("a b c");  // "abc"
String normalized = StringUtils.normalizeSpace("a  b   c");   // "a b c"

String Comparison and Matching

// Case-sensitive comparison
public static boolean equals(CharSequence cs1, CharSequence cs2)
public static boolean equalsAny(CharSequence string, CharSequence... searchStrings)
public static int compare(String str1, String str2)

// Case-insensitive comparison
public static boolean equalsIgnoreCase(CharSequence str1, CharSequence str2)
public static boolean equalsAnyIgnoreCase(CharSequence string, CharSequence... searchStrings)
public static int compareIgnoreCase(String str1, String str2)

// Pattern matching
public static boolean startsWith(CharSequence str, CharSequence prefix)
public static boolean startsWithIgnoreCase(CharSequence str, CharSequence prefix)
public static boolean endsWith(CharSequence str, CharSequence suffix)
public static boolean endsWithIgnoreCase(CharSequence str, CharSequence suffix)

Usage Examples:

// Null-safe comparison
boolean equal = StringUtils.equals(null, null);                    // true
boolean equal2 = StringUtils.equals("abc", "abc");                 // true
boolean anyMatch = StringUtils.equalsAny("abc", "xyz", "abc");     // true

// Case-insensitive comparison
boolean equalIgnore = StringUtils.equalsIgnoreCase("ABC", "abc");  // true
boolean anyIgnore = StringUtils.equalsAnyIgnoreCase("ABC", "xyz", "abc"); // true

// Prefix/suffix checking
boolean starts = StringUtils.startsWith("filename.txt", "file");   // true
boolean ends = StringUtils.endsWith("filename.txt", ".txt");       // true

String Searching and Indexing

// Basic searching
public static int indexOf(CharSequence seq, CharSequence searchSeq)
public static int lastIndexOf(CharSequence seq, CharSequence searchSeq)
public static boolean contains(CharSequence seq, CharSequence searchSeq)
public static boolean containsIgnoreCase(CharSequence str, CharSequence searchStr)

// Advanced searching
public static int indexOfAny(CharSequence cs, char... searchChars)
public static int indexOfAnyBut(CharSequence cs, char... searchChars)
public static boolean containsAny(CharSequence cs, char... searchChars)
public static boolean containsNone(CharSequence cs, char... searchChars)
public static boolean containsOnly(CharSequence cs, char... valid)

Usage Examples:

// Basic search operations
int index = StringUtils.indexOf("hello world", "world");           // 6
boolean contains = StringUtils.contains("hello", "ell");           // true
boolean containsIgnore = StringUtils.containsIgnoreCase("Hello", "ELLO"); // true

// Character set operations
int anyIndex = StringUtils.indexOfAny("hello", 'a', 'e', 'i');     // 1
boolean hasVowels = StringUtils.containsAny("hello", "aeiou");     // true
boolean onlyLetters = StringUtils.containsOnly("hello", "abcdefghijklmnopqrstuvwxyz"); // true

String Manipulation and Formatting

// Case conversion
public static String upperCase(String str)
public static String lowerCase(String str)
public static String capitalize(String str)
public static String uncapitalize(String str)
public static String swapCase(String str)

// Padding and centering
public static String leftPad(String str, int size)
public static String leftPad(String str, int size, char padChar)
public static String rightPad(String str, int size)
public static String rightPad(String str, int size, char padChar)
public static String center(String str, int size)
public static String center(String str, int size, char padChar)

Usage Examples:

// Case operations
String upper = StringUtils.upperCase("hello");              // "HELLO"
String lower = StringUtils.lowerCase("HELLO");              // "hello"
String cap = StringUtils.capitalize("hello world");         // "Hello world"
String uncap = StringUtils.uncapitalize("Hello");           // "hello"
String swap = StringUtils.swapCase("Hello World");          // "hELLO wORLD"

// Padding operations
String leftPad = StringUtils.leftPad("123", 5, '0');        // "00123"
String rightPad = StringUtils.rightPad("123", 5, '0');      // "12300"
String centered = StringUtils.center("hello", 9, '-');      // "--hello--"

String Abbreviation and Truncation

// Abbreviation
public static String abbreviate(String str, int maxWidth)
public static String abbreviate(String str, int offset, int maxWidth)
public static String abbreviate(String str, String abbrevMarker, int maxWidth)
public static String abbreviateMiddle(String str, String middle, int length)

// Truncation
public static String truncate(String str, int maxWidth)
public static String truncate(String str, int offset, int maxWidth)

Usage Examples:

// Abbreviation with ellipsis
String abbrev1 = StringUtils.abbreviate("This is a long string", 10);  // "This is..."
String abbrev2 = StringUtils.abbreviate("This is a long string", 5, 15); // "...long..."
String abbrev3 = StringUtils.abbreviateMiddle("This is a very long string", "...", 15); // "This...string"

// Simple truncation
String trunc = StringUtils.truncate("This is too long", 10);          // "This is to"

String Joining and Splitting

// Joining operations
public static String join(Object[] array)
public static String join(Object[] array, char separator)
public static String join(Object[] array, String separator)
public static String join(Iterable<?> iterable, String separator)

// Splitting operations  
public static String[] split(String str)
public static String[] split(String str, char separatorChar)
public static String[] split(String str, String separatorChars)
public static String[] splitByWholeSeparator(String str, String separator)

Usage Examples:

// Joining collections and arrays
String joined1 = StringUtils.join(new String[]{"a", "b", "c"}, ",");     // "a,b,c"
String joined2 = StringUtils.join(Arrays.asList("x", "y", "z"), " | ");  // "x | y | z"

// Splitting strings
String[] parts1 = StringUtils.split("a,b,c", ",");                      // ["a", "b", "c"]
String[] parts2 = StringUtils.split("one two three");                   // ["one", "two", "three"]
String[] parts3 = StringUtils.splitByWholeSeparator("a::b::c", "::");   // ["a", "b", "c"]

CharUtils - Character Operations

Provides 25 methods for character validation and manipulation:

import org.apache.commons.lang3.CharUtils;

Character Classification

// ASCII character validation
public static boolean isAscii(char ch)
public static boolean isAsciiPrintable(char ch)
public static boolean isAsciiControl(char ch)

// Character type checking
public static boolean isAsciiAlpha(char ch)
public static boolean isAsciiAlphaUpper(char ch)
public static boolean isAsciiAlphaLower(char ch)
public static boolean isAsciiNumeric(char ch)
public static boolean isAsciiAlphanumeric(char ch)

Usage Examples:

// Character validation
boolean isAscii = CharUtils.isAscii('A');              // true
boolean isPrintable = CharUtils.isAsciiPrintable('\t'); // false
boolean isAlpha = CharUtils.isAsciiAlpha('Z');         // true
boolean isNumeric = CharUtils.isAsciiNumeric('5');     // true
boolean isAlphaNum = CharUtils.isAsciiAlphanumeric('A'); // true

Character Conversion

// Character conversion
public static char toChar(Character ch)
public static char toChar(Character ch, char defaultValue)
public static char toChar(String str)
public static char toChar(String str, char defaultValue)

// Character constants
public static final char LF = '\n'
public static final char CR = '\r'  
public static final char NUL = '\0'

Usage Examples:

// Safe character conversion
char ch1 = CharUtils.toChar("A");                    // 'A'
char ch2 = CharUtils.toChar(null, 'X');              // 'X'
char ch3 = CharUtils.toChar("", 'Y');                // 'Y'

// Using character constants
String lineEnding = "" + CharUtils.CR + CharUtils.LF;  // "\r\n"

CharSetUtils - Character Set Operations

Provides operations on character sets for advanced string manipulation:

import org.apache.commons.lang3.CharSetUtils;

Character Set Operations

// Character set testing and manipulation
public static boolean containsAny(String str, String... set)
public static int count(String str, String... set)
public static String delete(String str, String... set)
public static String keep(String str, String... set)
public static String squeeze(String str, String... set)

Usage Examples:

// Character set operations
boolean hasVowels = CharSetUtils.containsAny("hello", "aeiou");        // true
int vowelCount = CharSetUtils.count("hello world", "aeiou");           // 3
String noVowels = CharSetUtils.delete("hello", "aeiou");               // "hll"
String onlyVowels = CharSetUtils.keep("hello", "aeiou");               // "eo"
String squeezed = CharSetUtils.squeeze("bookkeeper", "kep");           // "bokeper"

RegExUtils - Regular Expression Utilities

Provides convenient methods for common regex operations:

import org.apache.commons.lang3.RegExUtils;

Regex Operations

// Pattern matching and replacement
public static String removeAll(String text, String regex)
public static String removeFirst(String text, String regex)
public static String replaceAll(String text, String regex, String replacement)
public static String replaceFirst(String text, String regex, String replacement)
public static String replacePattern(String source, String regex, String replacement)

Usage Examples:

// Regex-based text processing
String noDigits = RegExUtils.removeAll("abc123def456", "\\d+");          // "abcdef"
String noFirstDigit = RegExUtils.removeFirst("abc123def456", "\\d+");    // "abcdef456"
String replaced = RegExUtils.replaceAll("foo123bar456", "\\d+", "X");    // "fooXbarX"
String firstOnly = RegExUtils.replaceFirst("foo123bar456", "\\d+", "X"); // "fooXbar456"

Advanced String Processing

String Escaping

For escaping strings for various formats:

import org.apache.commons.lang3.StringEscapeUtils;

// Various escaping methods
public static String escapeHtml4(String input)
public static String unescapeHtml4(String input)  
public static String escapeXml10(String input)
public static String unescapeXml(String input)
public static String escapeJava(String input)
public static String unescapeJava(String input)
public static String escapeJson(String input)
public static String unescapeJson(String input)
public static String escapeCsv(String input)
public static String unescapeCsv(String input)

Usage Examples:

// HTML escaping
String htmlEscaped = StringEscapeUtils.escapeHtml4("Tom & Jerry");    // "Tom &amp; Jerry"
String htmlUnescaped = StringEscapeUtils.unescapeHtml4("Tom &amp; Jerry"); // "Tom & Jerry"

// JSON escaping
String jsonEscaped = StringEscapeUtils.escapeJson("He said \"Hello\"");   // "He said \\\"Hello\\\""
String javaEscaped = StringEscapeUtils.escapeJava("Path: C:\\temp");      // "Path: C:\\\\temp"

Performance Considerations

Memory Efficiency

  • StringUtils methods avoid unnecessary object creation
  • Operations on null strings return appropriate defaults without exceptions
  • String building operations use efficient internal buffers

Thread Safety

All string utility methods are thread-safe and stateless, making them suitable for concurrent use.

Common Patterns

// Safe string processing pipeline
public String processUserInput(String input) {
    return StringUtils.trimToEmpty(input)           // Remove whitespace
        .toLowerCase()                              // Normalize case
        .replaceAll("[^a-z0-9]", "_")              // Replace invalid chars
        .replaceAll("_+", "_");                    // Collapse multiple underscores
}

// Null-safe string comparison
public boolean areEqual(String str1, String str2) {
    return StringUtils.equals(str1, str2);  // Handles null values correctly
}

// Building user-friendly messages
public String formatMessage(String template, Object... args) {
    if (StringUtils.isBlank(template)) {
        return StringUtils.EMPTY;
    }
    return String.format(template, args);
}

Integration with Other Libraries

Spring Framework Integration

@Component
public class StringProcessingService {
    
    public String sanitizeInput(@NotNull String input) {
        Validate.notNull(input, "Input cannot be null");
        
        return StringUtils.trimToEmpty(input)
            .toLowerCase()
            .replaceAll("\\s+", " ");
    }
    
    public List<String> parseCommaSeparated(String input) {
        if (StringUtils.isBlank(input)) {
            return Collections.emptyList();
        }
        
        return Arrays.stream(StringUtils.split(input, ','))
            .map(StringUtils::trim)
            .filter(StringUtils::isNotBlank)
            .collect(Collectors.toList());
    }
}

Validation Integration

public class UserValidator {
    
    public void validateUser(User user) {
        Validate.notNull(user, "User cannot be null");
        
        String name = StringUtils.trimToNull(user.getName());
        Validate.notNull(name, "Name cannot be blank");
        
        String email = StringUtils.trimToNull(user.getEmail());
        Validate.notNull(email, "Email cannot be blank");
        Validate.isTrue(StringUtils.contains(email, "@"), "Invalid email format");
    }
}

The string utilities in Apache Commons Lang provide a comprehensive, null-safe, and performant foundation for all string processing needs in Java applications.

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-commons--commons-lang3

docs

array-utilities.md

builders.md

concurrent-utilities.md

date-time-utilities.md

exception-utilities.md

index.md

math-utilities.md

object-utilities.md

string-utilities.md

validation-utilities.md

tile.json