Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://github.com/jdereg/java-util below:

jdereg/java-util: Rare, hard-to-write utilities that are thoroughly tested

A collection of high-performance Java utilities designed to enhance standard Java functionality. These utilities focus on:

• Memory efficiency and performance optimization
• Thread-safety and concurrent operations
• Enhanced collection implementations
• Simplified common programming tasks
• Deep object graph operations

Available on Maven Central. This library has no dependencies on other libraries for runtime. The.jarfile is ~600K and works with JDK 1.8 through JDK 24. The .jar file classes are version 52 (JDK 1.8)

As of version 3.6.0 the library is built with the -parameters compiler flag. Parameter names are now retained for tasks such as constructor discovery (increased the jar size by about 10K.)

Experience the power of java-util with these popular utilities that solve common development challenges:

Perfect for testing and validation - handles cycles, collections, and deep nesting automatically:

// Compare complex test outputs without worrying about object cycles
List<User> expected = loadExpectedUsers();
List<User> actual = processUsers();

// Standard equals() fails with nested objects and cycles
// DeepEquals handles everything automatically
if (DeepEquals.deepEquals(expected, actual)) {
    System.out.println("Test passed!");
} else {
    // Get detailed diff for debugging
    Map<String, Object> options = new HashMap<>();
    DeepEquals.deepEquals(expected, actual, options);
    System.out.println("Differences: " + options.get("diff"));
}

Visual diff output makes debugging obvious:

// Object field mismatch - pinpoints exactly what's different
[field value mismatch] ▶ Person {name: "Jim Bob", age: 27} ▶ .age
  Expected: 27
  Found: 34

// Collection element differences with precise indexing  
[collection element mismatch] ▶ Container {strings: List(0..2), numbers: List(0..2)} ▶ .strings(0)
  Expected: "a"
  Found: "x"

// Complex nested structures with visual navigation
[array element mismatch] ▶ University {name: "Test University", departmentsByCode: Map(0..1)} ▶ 
  .departmentsByCode 《"CS" ⇨ Department {code: "CS", programs: List(0..2)}》.programs(0).requiredCourses
  Expected length: 2
  Found length: 3

// Map differences show key-value relationships clearly
[map value mismatch] ▶ LinkedHashMap(0..0) ▶ 《"user.email" ⇨ "old@example.com"》
  Expected: "old@example.com"  
  Found: "new@example.com"

Convert between any meaningful types with mind-bending intelligence:

// Multi-dimensional arrays ↔ nested collections (any depth, any size!)
String[][][] jagged = {
    {{"a", "b", "c"}, {"d"}},           // First sub-array: 3 elements, then 1 element  
    {{"e", "f"}, {"g", "h", "i", "j"}}, // Second sub-array: 2 elements, then 4 elements
    {{"k"}}                             // Third sub-array: just 1 element
};
List<List<List<String>>> nested = Converter.convert(jagged, List.class);  
// Result: [[[a, b, c], [d]], [[e, f], [g, h, i, j]], [[k]]]

char[][][] backToArray = Converter.convert(nested, char[][][].class);       // Preserves jagged structure perfectly!

// EnumSet magic - detects collections and creates EnumSet automatically  
String[] permissions = {"READ", "WRITE", "ADMIN"};  
EnumSet<Permission> perms = Converter.convert(permissions, Permission.class);  // Array → EnumSet<Permission>

List<String> statusList = Arrays.asList("ACTIVE", "PENDING", "COMPLETE");
EnumSet<Status> statuses = Converter.convert(statusList, Status.class);       // Collection → EnumSet<Status>

Map<String, Object> config = Map.of("DEBUG", true, "INFO", false, "WARN", true);
EnumSet<LogLevel> levels = Converter.convert(config, LogLevel.class);         // Map keySet() → EnumSet<LogLevel>

// UUID as 128-bit number - who even thinks of this?!
UUID uuid = UUID.randomUUID();
BigInteger bigInt = Converter.convert(uuid, BigInteger.class);
// Result: 340282366920938463463374607431768211456 (UUID as massive integer!)
UUID restored = Converter.convert(bigInt, UUID.class);                   // Back to UUID!

// Base64 string directly to ByteBuffer 
String base64Data = "SGVsbG8gV29ybGQ=";  // "Hello World" encoded
ByteBuffer buffer = Converter.convert(base64Data, ByteBuffer.class);
// Result: Ready-to-use ByteBuffer, no manual decoding!

// Map to Color - understands RGB semantics
Map<String, Object> colorMap = Map.of("red", 255, "green", 128, "blue", 0, "alpha", 200);
Color orange = Converter.convert(colorMap, Color.class);
// Result: java.awt.Color[r=255,g=128,b=0,a=200] - it even handles alpha!

// Calendar to atomic types - extracts time AND makes it thread-safe
Calendar cal = Calendar.getInstance(); 
AtomicLong atomicTime = Converter.convert(cal, AtomicLong.class);        // Thread-safe epoch millis
AtomicInteger atomicYear = Converter.convert(cal, AtomicInteger.class);  // Just the year, atomically

// Add your own exotic conversions
Converter converter = new Converter();
converter.addConversion(MyClass.class, String.class, obj -> obj.toJson());

// See ALL available conversions - the full power revealed!
Map<String, Set<String>> supported = Converter.getSupportedConversions();
// Result: {"String" -> ["Integer", "Long", "Date", "UUID", "BigInteger", ...], 
//          "UUID" -> ["String", "BigInteger", "Map", ...], ...}

Set<String> allConversions = Converter.allSupportedConversions();  
// Result: ["String -> Integer", "String -> Long", "UUID -> BigInteger", 
//          "Map -> Color", "Calendar -> AtomicLong", ...]

Beyond these 1000+ direct type conversions, Converter also handles:

• 📦 Collection ↔ Collection (List ↔ Set ↔ Queue, any combination)
• 📦 Collection ↔ Array (any collection to any array type, preserving elements)
• 📦 Collection → EnumSet (any collection to EnumSet<targetType> one-dimensional)
• 🧩 Array ↔ Array (int[] ↔ String[] ↔ Long[], automatic element conversion)
• 🧩 Array ↔ Collection (jagged arrays to nested collections, preserving structure)
• 🧩 Array → EnumSet (jagged arrays to nested collections, preserving structure)
• 🗺️ Map ↔ Map (HashMap ↔ LinkedHashMap ↔ ConcurrentHashMap, comparator-aware)
• 🗺️ Map → EnumSet (keySet() of Map to EnumSet<targetType>)
• 🌟 N-dimensional support (jagged arrays, nested collections, any depth)

High-performance maps that ignore case but preserve original key formatting:

// Default: acts like LinkedHashMap but case-insensitive
CaseInsensitiveMap<String, String> headers = new CaseInsensitiveMap<>();
headers.put("Content-Type", "application/json");
headers.put("User-Agent", "MyApp/1.0");

// Case-insensitive lookup, but keys retain original case
String contentType = headers.get("content-type");  // "application/json"
String userAgent = headers.get("USER-AGENT");      // "MyApp/1.0"

// Walking keySet() returns original case
for (String key : headers.keySet()) {
    System.out.println(key);  // "Content-Type", "User-Agent"
}

// Supports heterogeneous keys (String + non-String)
CaseInsensitiveMap<Object, String> mixed = new CaseInsensitiveMap<>();
mixed.put("StringKey", "value1");
mixed.put(42, "value2");           // Non-string keys work fine

// Use ConcurrentHashMap as backing implementation for thread-safety
Map<String, String> existingData = Map.of("Content-Type", "application/json");
Map<String, String> concurrent = new CaseInsensitiveMap<>(existingData, new ConcurrentHashMap<>());

The definitive solution for multi-dimensional lookups - outperforms all alternatives:

// Create a high-performance N-dimensional map
MultiKeyMap<String> productCatalog = new MultiKeyMap<>();

// Standard Map interface - single keys work perfectly
Map<Object, String> mapInterface = productCatalog;
mapInterface.put("electronics", "Electronics Department");
mapInterface.put(Arrays.asList("books", "fiction", "scifi"), "Sci-Fi Books");

// MultiKeyMap varargs API - requires MultiKeyMap variable type
MultiKeyMap<String> catalog = new MultiKeyMap<>();
catalog.putMultiKey("Electronics Department", "electronics");                               // 1D
catalog.putMultiKey("Science Fiction Books", "books", "fiction", "scifi");                  // 3D  
catalog.putMultiKey("Gaming Keyboards", "electronics", "computers", "keyboards", "gaming"); // 4D

// Flexible retrieval using matching dimensions
String dept = catalog.getMultiKey("electronics");                               // Electronics Department
String category = catalog.getMultiKey("books", "fiction", "scifi");            // Science Fiction Books
String product = catalog.getMultiKey("electronics", "computers", "laptops");   // Laptop Computers

// ConcurrentHashMap-level thread safety with lock-free reads
catalog.putMultiKey("Updated Value", "electronics", "computers", "laptops");   // Enterprise-grade concurrency
// Auto-tuned stripe locking: 8-32 stripes based on system cores for optimal write parallelism

// Advanced collection handling with CollectionKeyMode (affects Collections only, not Arrays)
MultiKeyMap<String> configMap = new MultiKeyMap<>(1024, CollectionKeyMode.COLLECTIONS_NOT_EXPANDED);
List<String> configPath = Arrays.asList("database", "connection", "pool");
configMap.put(configPath, "jdbc:mysql://localhost:3306/app");           // Collection tried as single key first
String dbUrl = configMap.get(configPath);                               // Retrieved as single key

// Arrays are ALWAYS expanded and elements are compared by equals(). This is a BIG feature for MultiKeyMap. 
// This is because you can't override equals/hashCode on arrays, as they compare with == (identity).
// Use another Map type if you want array to compare with identity. 
String[] arrayPath = {"database", "connection", "pool"};
configMap.put(arrayPath, "another-value");                                      // ALWAYS stored as 3D key
String arrayValue = configMap.getMultiKey("database", "connection", "pool");    // Retrieved as 3D key

// 🔥 N-DIMENSIONAL ARRAY EXPANSION - The Ultimate Power Feature
// Arrays and Collections expand with structure preservation - no limits on depth!

// ✅ EQUIVALENT (same flat structure, different containers - flattenDimensions = true):
String[] flatArray = {"a", "b", "c"};                    // → ["a", "b", "c"]
List<String> flatList = List.of("a", "b", "c");          // → ["a", "b", "c"]  
Object[] flatObject = {"a", "b", "c"};                   // → ["a", "b", "c"]
configMap.put(flatArray, "value");
// ALL of these work - cross-container equivalence:
String result1 = configMap.get(flatArray);               // ✅ Original String[]
String result2 = configMap.get(flatList);                // ✅ Equivalent List  
String result3 = configMap.get(flatObject);              // ✅ Equivalent Object[]
String result4 = configMap.getMultiKey("a", "b", "c");   // ✅ Individual elements

// ❌ NOT EQUIVALENT (different structures - flattenDimensions = false):
String[][] nested2D = {{"a", "b"}, {"c", "d"}};         // → [["a", "b"],["c", "d"]]
String[] flat1D = {"a", "b", "c", "d"};                 // → ["a", "b", "c", "d"]
// These create SEPARATE entries - different structures preserved!
configMap.put(nested2D, "2D_value");                    // Stored retaining structural info
configMap.put(flat1D, "flat_value");                    // Stored retaining structural info

// Perfect for complex lookups: user permissions, configuration trees, caches
MultiKeyMap<Permission> permissions = new MultiKeyMap<>();
permissions.putMultiKey(Permission.ADMIN, "user123", "project456", "resource789");
Permission userPerm = permissions.getMultiKey("user123", "project456", "resource789");

🔄 Cross-Container Equivalence (Ultimate Flexibility!):

MultiKeyMap treats equivalent structures as identical keys, regardless of container type:

MultiKeyMap<String> map = new MultiKeyMap<>();

// 🎯 ALL of these are equivalent (same flat structure):
String[] stringArray = {"user", "profile", "settings"};
Object[] objectArray = {"user", "profile", "settings"};  
int[] intArray = {1, 2, 3};                              // Different elements, same structure
List<String> stringList = List.of("user", "profile", "settings");
List<Object> objectList = List.of("user", "profile", "settings");
ArrayList<String> arrayList = new ArrayList<>(List.of("user", "profile", "settings"));
Set<String> set = Set.of("user", "profile", "settings"); // Even Sets work!

// Store with ANY container type:
map.put(stringArray, "stored-value");

// Retrieve with ANY equivalent container:
map.get(stringArray);      // ✅ "stored-value"
map.get(objectArray);      // ✅ "stored-value" 
map.get(stringList);       // ✅ "stored-value"
map.get(objectList);       // ✅ "stored-value"
map.get(arrayList);        // ✅ "stored-value"
// Only ONE entry exists in the map - they're all the same key!

// 🎯 Nested structures are also equivalent across containers:
List<List<String>> nestedList = List.of(List.of("a", "b"), List.of("c"));
Object[] nestedArray = {new String[]{"a", "b"}, new String[]{"c"}};
map.put(nestedList, "nested-value");
map.get(nestedArray);      // ✅ "nested-value" - same nested structure!

Why MultiKeyMap is the industry-leading solution:

Automatic expiration with optional size limits - supports null keys and values:

// Cache with 30-second TTL
TTLCache<String, User> userCache = new TTLCache<>(TimeUnit.SECONDS.toMillis(30));

// Add items - they auto-expire after TTL
userCache.put("user123", loadUser("123"));
userCache.put(null, defaultUser);  // Null keys supported

// Optional: Add LRU eviction with max size
TTLCache<String, String> sessionCache = new TTLCache<>(
    TimeUnit.MINUTES.toMillis(15),  // 15-minute TTL
    1000                            // Max 1000 items (LRU eviction)
);

// Use like any Map - items auto-expire
sessionCache.put("session-abc", "user-data");
String userData = sessionCache.get("session-abc");  // null if expired

// Perfect for caching expensive operations
TTLCache<String, Result> resultCache = new TTLCache<>(TimeUnit.MINUTES.toMillis(5));
public Result getExpensiveResult(String key) {
    return resultCache.computeIfAbsent(key, k -> performExpensiveOperation(k));
}

Why developers love these utilities:

• Zero dependencies - No classpath conflicts
• Null-safe - Handle edge cases gracefully
• High performance - Optimized for real-world usage
• JDK 8+ compatible - Works everywhere
• Production proven - Used in high-scale applications

java-util is engineered for performance-critical applications with optimizations that deliver measurable improvements:

CompactMap Dynamic Adaptation (it has one field):

• map.size() == 0 → Object field = null (Sentinel value)
• map.size() == 1 → Object field = Map.Entry<Key, Value>
• map.size() == 2 ... compactSize() → Object field = Object[2*size] containing keys (even) values (odd)
• map.size() > compactSize(): → Object field = map // delegates to wrapped map
• Great for applications with millions of small Maps

🎯 Zero Dependencies: Unlike Guava (Checker Framework, Error Prone, J2ObjC) or Eclipse Collections (JUnit, SLF4J), java-util has zero runtime dependencies - no classpath conflicts ever.

🔒 Null-Safe Concurrency: java-util is the only library providing thread-safe collections that handle null keys and values safely (ConcurrentHashMapNullSafe, ConcurrentSetNullSafe).

🧠 Smart Memory Management: CompactMap and CompactSet automatically adapt from array-based storage (small size) to hash-based storage (large size) - optimal memory usage at every scale.

🔄 Universal Conversion: Convert between any meaningful Java types - primitives, collections, dates, enums, custom objects. Other libraries require multiple dependencies to achieve the same coverage.

⚙️ Production Flexibility: 70+ runtime configuration options allow zero-downtime security hardening and environment-specific tuning that enterprise applications demand.

java-util provides comprehensive security controls designed for enterprise environments where security compliance and threat mitigation are critical:

Configurable Resource Limits:

// Prevent memory exhaustion attacks
System.setProperty("deepequals.max.collection.size", "1000000");
System.setProperty("stringutilities.max.repeat.total.size", "10485760");
System.setProperty("mathutilities.max.array.size", "1000000");

// Protect against ReDoS (Regular Expression Denial of Service)
System.setProperty("dateutilities.regex.timeout.enabled", "true");
System.setProperty("dateutilities.regex.timeout.milliseconds", "1000");

Block Access to Sensitive System Classes:

// Prevent reflection-based attacks
System.setProperty("reflectionutils.dangerous.class.validation.enabled", "true");
// Blocks: Runtime, ProcessBuilder, System, Unsafe, ScriptEngine

// Prevent sensitive field access
System.setProperty("reflectionutils.sensitive.field.validation.enabled", "true");  
// Blocks: password, secret, apikey, credential fields

Enforce Strong Crypto Parameters:

// PBKDF2 iteration requirements
System.setProperty("encryptionutilities.min.pbkdf2.iterations", "100000");
System.setProperty("encryptionutilities.max.pbkdf2.iterations", "1000000");

// Salt and IV size validation
System.setProperty("encryptionutilities.min.salt.size", "16");
System.setProperty("encryptionutilities.min.iv.size", "12");

Protocol and Host Validation:

// Restrict allowed protocols
System.setProperty("io.allowed.protocols", "https");
System.setProperty("urlutilities.allowed.protocols", "https");

// Prevent SSRF (Server-Side Request Forgery)
System.setProperty("urlutilities.allow.internal.hosts", "false");
System.setProperty("urlutilities.max.download.size", "104857600"); // 100MB limit

Comprehensive Logging:

// Enable detailed security logging
System.setProperty("io.debug", "true");
System.setProperty("io.debug.detailed.urls", "true");
System.setProperty("io.debug.detailed.paths", "true");

Production-Safe Configuration:

• Feature flags: Enable/disable security features without code changes
• Gradual rollout: Test security features in staging before production
• Environment-specific: Different limits for dev/staging/production
• Compliance ready: Meet OWASP, SOC 2, ISO 27001 requirements

Example: Progressive Security Enablement

# Development (permissive)
-Dreflectionutils.security.enabled=false

# Staging (warning mode)  
-Dreflectionutils.security.enabled=true
-Dreflectionutils.dangerous.class.validation.enabled=false

# Production (full security)
-Dreflectionutils.security.enabled=true
-Dreflectionutils.dangerous.class.validation.enabled=true
-Dreflectionutils.sensitive.field.validation.enabled=true

Default Secure: All security features are disabled by default for backward compatibility, but can be enabled system-wide with zero code changes.

This library is fully compatible with JPMS, commonly known as Java Modules. It includes a module-info.class file that specifies module dependencies and exports.

This library also supports OSGi environments. It comes with pre-configured OSGi metadata in the MANIFEST.MF file, ensuring easy integration into any OSGi-based application.

The jar already ships with all necessary OSGi headers and a module-info.class. No Import-Package entries for java.* packages are required when consuming the bundle.

To add the bundle to an Eclipse feature or any OSGi runtime simply reference it:

<plugin id="com.cedarsoftware.java-util" version="3.9.0"/>

Both of these features ensure that our library can be seamlessly integrated into modular Java applications, providing robust dependency management and encapsulation.

To include in your project:

implementation 'com.cedarsoftware:java-util:3.9.0'

<dependency>
  <groupId>com.cedarsoftware</groupId>
  <artifactId>java-util</artifactId>
  <version>3.9.0</version>
</dependency>

For comprehensive framework integration examples including Spring, Jakarta EE, Spring Boot Auto-Configuration, Microservices, Testing, and Performance Monitoring, see frameworks.md.

Key integrations include:

• Spring Framework - Configuration beans and case-insensitive property handling
• Jakarta EE/JEE - CDI producers and validation services
• Spring Boot - Auto-configuration with corrected cache constructors
• Microservices - Service discovery and cloud-native configuration
• Testing - Enhanced test comparisons with DeepEquals
• Monitoring - Micrometer metrics integration

Modern enterprise applications demand libraries that adapt to diverse security requirements, performance constraints, and operational environments. Following the architectural principles embraced by industry leaders like Google (with their extensive use of feature flags), Netflix (with their chaos engineering configurations), Amazon (with their service-specific tuning), and Meta (with their A/B testing infrastructure), java-util embraces a flexible feature options approach that puts control directly in the hands of developers and operations teams.

This approach aligns with current best practices in cloud-native development, including GitOps configurations, service mesh policies, and progressive delivery patterns that define the cutting edge of modern software architecture.

Rather than forcing a one-size-fits-all configuration, java-util provides granular control over every aspect of its behavior through system properties. This approach enables:

• Zero-downtime security hardening - Enable security features without code changes
• Environment-specific tuning - Different limits for development vs. production
• Gradual rollout strategies - Test new security features with feature flags
• Compliance flexibility - Meet varying regulatory requirements across deployments
• Performance optimization - Fine-tune resource limits based on actual usage patterns

All security features are disabled by default to ensure seamless upgrades, with the flexibility to enable and configure them per environment. This design philosophy allows java-util to serve both lightweight applications and enterprise-grade systems from the same codebase.

Note: All security features are disabled by default for backward compatibility. Most properties accepting 0 disable the feature entirely. Properties can be set via system properties (-D flags) or environment variables.

Because java-util has no dependencies on other libraries, java-util uses the Java built-in java.util.logging for all output. See the user guide for ways to route these logs to SLF4J or Log4j 2.

View detailed documentation on all utilities.

See changelog.md for revision history.

By: John DeRegnaucourt and Kenny Partlow

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4