0
# Basic Utilities
1

2
Essential utilities for common programming tasks including string manipulation, preconditions, null handling, and functional programming support.
3

4
## Package: com.google.common.annotations
5

6
### Annotation Types
7

8
Annotations for API compatibility, testing visibility, and platform compatibility.
9

10
```java { .api }
11
import com.google.common.annotations.*;
12

13
// Beta API annotation - indicates subject to incompatible changes
14
@Beta
15
public class ExperimentalFeature {
16
    // This class might change in future releases
17
}
18

19
// GWT compatibility annotations
20
@GwtCompatible(serializable = true, emulated = true)  
21
public class SerializableUtility {
22
    // Compatible with Google Web Toolkit
23
}
24

25
@GwtIncompatible("Uses reflection not supported in GWT")
26
public class ReflectionUtility {
27
    // Cannot be used with GWT
28
}
29

30
// Kotlin transpilation compatibility
31
@J2ktIncompatible("Uses Java-specific features")
32
public class JavaOnlyUtility {
33
    // Cannot be used with J2kt (Kotlin transpilation)
34
}
35

36
// Testing visibility
37
public class InternalService {
38
    
39
    @VisibleForTesting
40
    protected void resetInternalState() {
41
        // This method is only visible for testing purposes
42
        // Would normally be private
43
    }
44
}
45
```
46

47
**Key Annotations:**
48

49
- `@Beta` - Signifies that a public API is subject to incompatible changes or removal in future releases
50
- `@GwtCompatible` - Indicates that a type may be used with Google Web Toolkit (GWT)
51
  - `serializable()` - indicates if type is GWT serializable  
52
  - `emulated()` - indicates if type is emulated in GWT
53
- `@GwtIncompatible` - Indicates that an API may not be used with Google Web Toolkit (GWT)
54
  - `value()` - optional description of why element is incompatible
55
- `@J2ktIncompatible` - Indicates that an API may not be used with J2kt (Kotlin transpilation)
56
- `@VisibleForTesting` - Annotates elements that exist or are more visible than necessary only for test code
57

58
## Package: com.google.common.base
59

60
### Preconditions
61

62
Static convenience methods for checking method preconditions, arguments, and object state.
63

64
```java { .api }
65
import com.google.common.base.Preconditions;
66

67
// Argument validation
68
public void setAge(int age) {
69
    Preconditions.checkArgument(age >= 0, "Age must be non-negative: %s", age);
70
    this.age = age;
71
}
72

73
// State validation  
74
public void withdraw(double amount) {
75
    Preconditions.checkState(isOpen(), "Account is closed");
76
    Preconditions.checkArgument(amount > 0, "Amount must be positive");
77
    this.balance -= amount;
78
}
79

80
// Null checking
81
public void setName(String name) {
82
    this.name = Preconditions.checkNotNull(name, "Name cannot be null");
83
}
84

85
// Index validation
86
public T get(int index) {
87
    Preconditions.checkElementIndex(index, size(), "Index out of bounds");
88
    return elements[index];
89
}
90

91
// Range validation
92
public List<T> subList(int start, int end) {
93
    Preconditions.checkPositionIndexes(start, end, size());
94
    return new SubList(start, end);
95
}
96
```
97

98
**Key Methods:**
99
- `checkArgument(boolean, String, Object...)` - Validates method arguments
100
- `checkState(boolean, String, Object...)` - Validates object state  
101
- `checkNotNull(T, String, Object...)` - Validates non-null references
102
- `checkElementIndex(int, int, String)` - Validates array/list element indexes
103
- `checkPositionIndex(int, int, String)` - Validates array/list position indexes
104
- `checkPositionIndexes(int, int, int)` - Validates start/end index ranges
105

106
### Strings
107

108
Static utility methods for working with String instances, including null-safe operations and common string manipulations.
109

110
```java { .api }
111
import com.google.common.base.Strings;
112

113
// Null safety
114
String safe = Strings.nullToEmpty(null); // ""
115
String nullable = Strings.emptyToNull(""); // null
116
boolean empty = Strings.isNullOrEmpty(""); // true
117
boolean empty2 = Strings.isNullOrEmpty(null); // true
118

119
// Padding
120
String padded = Strings.padStart("42", 5, '0'); // "00042"
121
String right = Strings.padEnd("hello", 10, '!'); // "hello!!!!!"
122

123
// Repetition
124
String repeated = Strings.repeat("hi", 3); // "hihihi"
125

126
// Common prefixes and suffixes
127
String prefix = Strings.commonPrefix("foobar", "foobaz"); // "fooba"
128
String suffix = Strings.commonSuffix("foobar", "bazbar"); // "bar"
129
```
130

131
**Key Methods:**
132
- `nullToEmpty(String)` - Returns empty string for null input
133
- `emptyToNull(String)` - Returns null for empty string input  
134
- `isNullOrEmpty(String)` - Checks if string is null or empty
135
- `padStart(String, int, char)` - Pads string at beginning
136
- `padEnd(String, int, char)` - Pads string at end
137
- `repeat(String, int)` - Repeats string specified number of times
138
- `commonPrefix(String, String)` - Finds longest common prefix
139
- `commonSuffix(String, String)` - Finds longest common suffix
140

141
### Joiner
142

143
Joins pieces of text (arrays, Iterables, varargs) with a separator, with options for handling nulls.
144

145
```java { .api }
146
import com.google.common.base.Joiner;
147

148
// Basic joining
149
Joiner joiner = Joiner.on(", ");
150
String result = joiner.join("a", "b", "c"); // "a, b, c"
151

152
// Joining collections
153
List<String> list = Arrays.asList("apple", "banana", "cherry");
154
String fruits = joiner.join(list); // "apple, banana, cherry"
155

156
// Handling nulls - skip them
157
String withNulls = Joiner.on(", ").skipNulls().join("a", null, "b", "c"); // "a, b, c"
158

159
// Handling nulls - substitute
160
String substituted = Joiner.on(", ").useForNull("missing").join("a", null, "b"); // "a, missing, b"
161

162
// Map joining
163
Map<String, String> map = ImmutableMap.of("key1", "value1", "key2", "value2");
164
String mapString = Joiner.on(", ").withKeyValueSeparator("=").join(map); // "key1=value1, key2=value2"
165
```
166

167
**Key Methods:**
168
- `on(String)` - Creates Joiner with separator
169
- `join(Object...)` - Joins varargs elements
170
- `join(Iterable<?>)` - Joins iterable elements
171
- `join(Iterator<?>)` - Joins iterator elements
172
- `skipNulls()` - Returns joiner that skips null elements
173
- `useForNull(String)` - Returns joiner that substitutes nulls with given string
174
- `withKeyValueSeparator(String)` - Returns MapJoiner for joining maps
175

176
### Splitter
177

178
Splits strings into parts using various delimiters and provides options for trimming and filtering results.
179

180
```java { .api }
181
import com.google.common.base.Splitter;
182

183
// Basic splitting
184
Splitter splitter = Splitter.on(',');
185
List<String> parts = splitter.splitToList("a,b,c"); // ["a", "b", "c"]
186

187
// Character-based splitting
188
List<String> chars = Splitter.on(' ').splitToList("hello world"); // ["hello", "world"]
189

190
// Regular expression splitting
191
List<String> regex = Splitter.onPattern("\\s+").splitToList("a  b   c"); // ["a", "b", "c"]
192

193
// Trimming results
194
List<String> trimmed = Splitter.on(',')
195
    .trimResults()
196
    .splitToList("a, b , c "); // ["a", "b", "c"]
197

198
// Omitting empty strings
199
List<String> filtered = Splitter.on(',')
200
    .omitEmptyStrings()
201
    .splitToList("a,,b,"); // ["a", "b"]
202

203
// Limiting splits
204
List<String> limited = Splitter.on(',')
205
    .limit(2)
206
    .splitToList("a,b,c,d"); // ["a", "b,c,d"]
207

208
// Fixed-width splitting
209
List<String> fixedWidth = Splitter.fixedLength(3).splitToList("abcdef"); // ["abc", "def"]
210

211
// Key-value splitting
212
Map<String, String> keyValue = Splitter.on('&')
213
    .withKeyValueSeparator('=')
214
    .split("key1=value1&key2=value2"); // {key1=value1, key2=value2}
215
```
216

217
**Key Methods:**
218
- `on(char)` - Creates splitter on character delimiter
219
- `on(String)` - Creates splitter on string delimiter
220
- `onPattern(String)` - Creates splitter on regex pattern
221
- `fixedLength(int)` - Creates splitter on fixed length
222
- `splitToList(CharSequence)` - Splits to List
223
- `split(CharSequence)` - Splits to Iterable
224
- `trimResults()` - Trims whitespace from results
225
- `omitEmptyStrings()` - Omits empty strings from results
226
- `limit(int)` - Limits number of splits
227
- `withKeyValueSeparator(char)` - Creates MapSplitter for key-value pairs
228

229
### CharMatcher
230

231
Determines a true or false value for any Java char value and provides text processing methods based on character matching. Ideal for string cleaning, validation, and transformation.
232

233
```java { .api }
234
import com.google.common.base.CharMatcher;
235

236
// Predefined matchers
237
CharMatcher digits = CharMatcher.digit();
238
CharMatcher letters = CharMatcher.javaLetter();
239
CharMatcher whitespace = CharMatcher.whitespace();
240
CharMatcher ascii = CharMatcher.ascii();
241

242
// Character-based text processing
243
String input = "Hello, World! 123";
244

245
// Remove unwanted characters
246
String lettersOnly = CharMatcher.javaLetter().retainFrom(input); // "HelloWorld"
247
String noDigits = CharMatcher.digit().removeFrom(input); // "Hello, World! "
248

249
// Replace characters
250
String cleaned = CharMatcher.whitespace().replaceFrom(input, '_'); // "Hello,_World!_123"
251

252
// Collapse consecutive characters
253
String collapsed = CharMatcher.whitespace()
254
    .collapseFrom("a  b   c", ' '); // "a b c"
255

256
// Trim characters from ends
257
String trimmed = CharMatcher.whitespace().trimFrom("  hello  "); // "hello"
258

259
// Check character patterns
260
boolean allAscii = CharMatcher.ascii().matchesAllOf(input);
261
boolean hasDigits = CharMatcher.digit().matchesAnyOf(input);
262
int digitCount = CharMatcher.digit().countIn(input); // 3
263

264
// Find positions
265
int firstDigit = CharMatcher.digit().indexIn(input); // 14
266
int lastDigit = CharMatcher.digit().lastIndexIn(input); // 16
267

268
// Custom matchers
269
CharMatcher vowels = CharMatcher.anyOf("aeiouAEIOU");
270
CharMatcher notVowels = vowels.negate();
271
CharMatcher consonants = CharMatcher.javaLetter().and(notVowels);
272

273
// Range-based matchers
274
CharMatcher numbers = CharMatcher.inRange('0', '9');
275
CharMatcher upperCase = CharMatcher.inRange('A', 'Z');
276

277
// Combining matchers
278
CharMatcher alphanumeric = CharMatcher.javaLetter().or(CharMatcher.digit());
279
CharMatcher specialChars = CharMatcher.ascii().and(alphanumeric.negate());
280
```
281

282
**Static Factory Methods:**
283
- `any()` - Matches any character
284
- `none()` - Matches no characters
285
- `whitespace()` - Matches whitespace characters
286
- `breakingWhitespace()` - Matches whitespace characters that break text lines
287
- `ascii()` - Matches ASCII characters (0-127)
288
- `digit()` - Matches ASCII digits (0-9)
289
- `javaDigit()` - Matches characters for which Character.isDigit() returns true
290
- `javaLetter()` - Matches characters for which Character.isLetter() returns true
291
- `javaLetterOrDigit()` - Matches letters or digits
292
- `javaUpperCase()` - Matches uppercase characters
293
- `javaLowerCase()` - Matches lowercase characters
294
- `javaIsoControl()` - Matches ISO control characters
295
- `invisible()` - Matches invisible characters (whitespace, control chars, etc.)
296
- `singleWidth()` - Matches single-width characters (excludes double-width CJK)
297
- `is(char)` - Matches exactly one character
298
- `isNot(char)` - Matches any character except the specified one
299
- `anyOf(CharSequence)` - Matches any character in the sequence
300
- `noneOf(CharSequence)` - Matches any character not in the sequence
301
- `inRange(char, char)` - Matches characters in the inclusive range
302
- `forPredicate(Predicate<Character>)` - Matches characters accepted by predicate
303

304
**Instance Methods:**
305
- `matches(char)` - Tests if character matches this matcher
306
- `matchesAnyOf(CharSequence)` - Tests if any character in sequence matches
307
- `matchesAllOf(CharSequence)` - Tests if all characters in sequence match
308
- `matchesNoneOf(CharSequence)` - Tests if no characters in sequence match
309
- `indexIn(CharSequence)` / `indexIn(CharSequence, int)` - First match index
310
- `lastIndexIn(CharSequence)` - Last match index
311
- `countIn(CharSequence)` - Count of matching characters
312
- `removeFrom(CharSequence)` - Remove matching characters
313
- `retainFrom(CharSequence)` - Retain only matching characters
314
- `replaceFrom(CharSequence, char)` - Replace matching chars with character
315
- `replaceFrom(CharSequence, CharSequence)` - Replace matching chars with string
316
- `trimFrom(CharSequence)` - Trim matching characters from both ends
317
- `trimLeadingFrom(CharSequence)` - Trim matching characters from start
318
- `trimTrailingFrom(CharSequence)` - Trim matching characters from end
319
- `collapseFrom(CharSequence, char)` - Collapse consecutive matches to single char
320
- `trimAndCollapseFrom(CharSequence, char)` - Trim then collapse matches
321

322
**Combining Operations:**
323
- `negate()` - Returns matcher that matches opposite characters
324
- `and(CharMatcher)` - Returns matcher that matches both matchers
325
- `or(CharMatcher)` - Returns matcher that matches either matcher
326
- `precomputed()` - Returns optimized version for repeated use
327

328
### Objects and MoreObjects
329

330
Helper methods for Object instances including equality, hashing, and string representation.
331

332
```java { .api }
333
import com.google.common.base.Objects;
334
import com.google.common.base.MoreObjects;
335

336
// Null-safe equality
337
public boolean equals(Object obj) {
338
    if (obj instanceof Person) {
339
        Person other = (Person) obj;
340
        return Objects.equal(this.name, other.name) &&
341
               Objects.equal(this.age, other.age);
342
    }
343
    return false;
344
}
345

346
// Hash code generation
347
public int hashCode() {
348
    return Objects.hashCode(name, age, address);
349
}
350

351
// String representation
352
public String toString() {
353
    return MoreObjects.toStringHelper(this)
354
        .add("name", name)
355
        .add("age", age)
356
        .omitNullValues()
357
        .toString(); // "Person{name=John, age=30}"
358
}
359

360
// First non-null value
361
String name = MoreObjects.firstNonNull(primaryName, secondaryName, "Unknown");
362
```
363

364
**Objects Methods:**
365
- `equal(Object, Object)` - Null-safe equality comparison  
366
- `hashCode(Object...)` - Generates hash codes from multiple fields
367
- `toStringHelper(Object)` - Creates ToStringHelper for the object
368

369
**MoreObjects Methods:**
370
- `toStringHelper(Class)` - Creates ToStringHelper for class
371
- `toStringHelper(String)` - Creates ToStringHelper with custom class name
372
- `firstNonNull(T, T)` - Returns first non-null argument
373

374
### Optional
375

376
Immutable object that may contain a non-null reference (predecessor to java.util.Optional).
377

378
```java { .api }
379
import com.google.common.base.Optional;
380
import com.google.common.base.Function;
381

382
// Creating Optional instances
383
Optional<String> present = Optional.of("hello");
384
Optional<String> absent = Optional.absent();
385
Optional<String> nullable = Optional.fromNullable(getString()); // null -> absent
386

387
// Checking presence
388
if (optional.isPresent()) {
389
    String value = optional.get();
390
    System.out.println(value);
391
}
392

393
// Providing defaults
394
String value = optional.or("default");
395
String lazy = optional.or(new Supplier<String>() {
396
    public String get() { return computeDefault(); }
397
});
398

399
// Transformation
400
Optional<Integer> length = optional.transform(new Function<String, Integer>() {
401
    public Integer apply(String input) {
402
        return input.length();
403
    }
404
});
405

406
// Converting to java.util.Optional (if needed)
407
java.util.Optional<String> javaOptional = optional.toJavaUtil();
408
```
409

410
**Key Methods:**
411
- `absent()` - Creates absent Optional
412
- `of(T)` - Creates Optional with non-null value
413
- `fromNullable(T)` - Creates Optional from nullable value
414
- `isPresent()` - Tests if value is present
415
- `get()` - Gets the value (throws if absent)
416
- `or(T)` - Returns value or provided default
417
- `or(Supplier<T>)` - Returns value or supplier result
418
- `orNull()` - Returns value or null
419
- `transform(Function<T, V>)` - Transforms value if present
420

421
### Functional Interfaces
422

423
Core functional interfaces for composing operations (note: prefer java.util.function interfaces in Java 8+).
424

425
```java { .api }
426
import com.google.common.base.Function;
427
import com.google.common.base.Predicate;
428
import com.google.common.base.Supplier;
429

430
// Function - transforms input to output
431
Function<String, Integer> length = new Function<String, Integer>() {
432
    public Integer apply(String input) {
433
        return input.length();
434
    }
435
};
436

437
// Predicate - tests input for boolean property
438
Predicate<String> notEmpty = new Predicate<String>() {
439
    public boolean apply(String input) {
440
        return !input.isEmpty();
441
    }
442
};
443

444
// Supplier - provides instances on demand
445
Supplier<String> timestamp = new Supplier<String>() {
446
    public String get() {
447
        return new Date().toString();
448
    }
449
};
450
```
451

452
### Utility Classes for Functional Interfaces
453

454
Static utility methods for creating and composing functional interfaces.
455

456
```java { .api }
457
import com.google.common.base.Functions;
458
import com.google.common.base.Predicates;
459
import com.google.common.base.Suppliers;
460

461
// Function utilities
462
Function<Object, String> toString = Functions.toStringFunction();
463
Function<String, String> identity = Functions.identity();
464
Function<String, Integer> composed = Functions.compose(length, toUpperCase);
465
Function<String, String> constant = Functions.constant("default");
466

467
Map<String, Integer> map = ImmutableMap.of("a", 1, "b", 2);
468
Function<String, Integer> mapLookup = Functions.forMap(map, 0); // default value 0
469

470
// Predicate utilities  
471
Predicate<Object> alwaysTrue = Predicates.alwaysTrue();
472
Predicate<Object> alwaysFalse = Predicates.alwaysFalse();
473
Predicate<Object> isNull = Predicates.isNull();
474
Predicate<Object> notNull = Predicates.notNull();
475

476
Predicate<String> combined = Predicates.and(notEmpty, longerThan5);
477
Predicate<String> either = Predicates.or(isEmpty, startsWithA);
478
Predicate<String> negated = Predicates.not(isEmpty);
479

480
// Supplier utilities
481
Supplier<String> constant = Suppliers.ofInstance("constant value");
482
Supplier<String> memoized = Suppliers.memoize(expensiveComputation);
483
Supplier<String> withTimeout = Suppliers.memoizeWithExpiration(
484
    computation, 10, TimeUnit.MINUTES);
485
```
486

487
### Exception Utilities
488

489
Static utility methods for working with exceptions and stack traces.
490

491
```java { .api }
492
import com.google.common.base.Throwables;
493

494
try {
495
    riskyOperation();
496
} catch (Exception e) {
497
    // Propagate specific exception types
498
    Throwables.throwIfInstanceOf(e, IOException.class);
499
    Throwables.throwIfUnchecked(e);
500
    
501
    // Or wrap in RuntimeException
502
    throw new RuntimeException(e);
503
}
504

505
// Exception analysis
506
Throwable root = Throwables.getRootCause(exception);
507
List<Throwable> chain = Throwables.getCausalChain(exception);
508
String stackTrace = Throwables.getStackTraceAsString(exception);
509
```
510

511
**Key Methods:**
512
- `throwIfInstanceOf(Throwable, Class<X>)` - Propagates if exception is instance of type
513
- `throwIfUnchecked(Throwable)` - Propagates if exception is RuntimeException or Error
514
- `getRootCause(Throwable)` - Gets the root cause of exception chain
515
- `getCausalChain(Throwable)` - Gets list of causes from exception to root
516
- `getStackTraceAsString(Throwable)` - Converts stack trace to string
517

518
### Other Utilities
519

520
Additional utilities for common programming tasks.
521

522
```java { .api }
523
import com.google.common.base.Verify;
524
import com.google.common.base.Stopwatch;
525
import com.google.common.base.Charsets;
526
import java.util.concurrent.TimeUnit;
527

528
// Verification (similar to Preconditions but throws VerifyException)
529
public void processResults(List<String> results) {
530
    Verify.verify(!results.isEmpty(), "Results cannot be empty");
531
    Verify.verifyNotNull(results.get(0), "First result cannot be null");
532
}
533

534
// Timing operations
535
Stopwatch stopwatch = Stopwatch.createStarted();
536
doWork();
537
long elapsed = stopwatch.elapsed(TimeUnit.MILLISECONDS);
538
System.out.println("Work took: " + stopwatch);
539

540
// Standard charsets (prefer java.nio.charset.StandardCharsets in Java 7+)
541
Charset utf8 = Charsets.UTF_8;
542
Charset ascii = Charsets.US_ASCII;
543

544
// Case format conversion
545
import com.google.common.base.CaseFormat;
546
String camelCase = CaseFormat.LOWER_UNDERSCORE.to(CaseFormat.LOWER_CAMEL, "hello_world"); // "helloWorld"
547
String constantCase = CaseFormat.LOWER_CAMEL.to(CaseFormat.UPPER_UNDERSCORE, "helloWorld"); // "HELLO_WORLD"
548
```
549

550
**Additional Classes:**
551
- `Verify` - Similar to Preconditions but throws VerifyException for internal invariants
552
- `Stopwatch` - Measures elapsed time with nanosecond precision
553
- `CaseFormat` - Converts between ASCII case formats (camelCase, snake_case, etc.)
554
- `Charsets` - Standard charset constants (prefer java.nio.charset.StandardCharsets)
555
- `Ascii` - Utilities for ASCII character operations
556
- `Defaults` - Default values for primitive and reference types
557

558
### Advanced Utilities
559

560
Additional utility classes for specialized operations.
561

562
```java { .api }
563
import com.google.common.base.Converter;
564
import com.google.common.base.Equivalence;
565
import com.google.common.base.Ticker;
566
import com.google.common.base.StandardSystemProperty;
567
import com.google.common.base.Defaults;
568
import com.google.common.base.Enums;
569

570
// Bidirectional conversion between types
571
public abstract class Converter<A, B> {
572
    // Convert A to B
573
    protected abstract B doForward(A a);
574
    
575
    // Convert B to A  
576
    protected abstract A doBackward(B b);
577
    
578
    // Public conversion method
579
    public final B convert(A a) {
580
        return doForward(a);
581
    }
582
    
583
    // Get reverse converter
584
    public Converter<B, A> reverse() {
585
        return new ReverseConverter<>(this);
586
    }
587
}
588

589
// Example: String to Integer converter
590
Converter<String, Integer> stringToInt = new Converter<String, Integer>() {
591
    @Override
592
    protected Integer doForward(String str) {
593
        return Integer.valueOf(str);
594
    }
595
    
596
    @Override
597
    protected String doBackward(Integer integer) {
598
        return integer.toString();
599
    }
600
};
601

602
// Equivalence strategy (alternative to equals/hashCode)
603
Equivalence<String> caseInsensitive = new Equivalence<String>() {
604
    @Override
605
    protected boolean doEquivalent(String a, String b) {
606
        return a.equalsIgnoreCase(b);
607
    }
608
    
609
    @Override
610
    protected int doHash(String s) {
611
        return s.toLowerCase().hashCode();
612
    }
613
};
614

615
// System properties with null-safe access
616
String javaVersion = StandardSystemProperty.JAVA_VERSION.value();
617
String javaHome = StandardSystemProperty.JAVA_HOME.value();
618
String osName = StandardSystemProperty.OS_NAME.value();
619

620
// Default values for types
621
Object defaultObject = Defaults.defaultValue(Object.class); // null
622
int defaultInt = Defaults.defaultValue(int.class); // 0
623
boolean defaultBoolean = Defaults.defaultValue(boolean.class); // false
624

625
// Enum utilities
626
Optional<DayOfWeek> day = Enums.getIfPresent(DayOfWeek.class, "MONDAY");
627
Converter<String, DayOfWeek> dayConverter = Enums.stringConverter(DayOfWeek.class);
628

629
// Time source abstraction
630
public abstract class Ticker {
631
    public abstract long read(); // Current time in nanoseconds
632
    
633
    public static Ticker systemTicker() {
634
        return SYSTEM_TICKER;
635
    }
636
}
637
```
638

639
**Advanced Classes:**
640

641
- `Converter<A,B>` - Abstract class for bidirectional conversion between types A and B
642
- `Equivalence<T>` - Strategy for determining equivalence between instances (alternative to equals/hashCode)  
643
- `Ticker` - Abstract source of nanosecond-precision time values
644
- `StandardSystemProperty` - Enum providing null-safe access to standard system properties
645
- `Defaults` - Utility for getting default values of primitive and reference types
646
- `Enums` - Utility methods for working with Enum instances