java.util Package

// Creating ArrayLists
List<String> list1 = new ArrayList<>();
List<String> list2 = new ArrayList<>(100); // Initial capacity
List<String> list3 = new ArrayList<>(existingCollection);

// Adding elements
list1.add("first");
list1.add("second");
list1.add(0, "new first"); // Insert at position

// Accessing elements
String element = list1.get(1);
list1.set(1, "modified");

// Removing elements
list1.remove(0);              // Remove by index
list1.remove("second");       // Remove by value

// Iteration
for (String item : list1) {
    System.out.println(item);
}

// Capacity management
list1.ensureCapacity(1000);   // Pre-allocate capacity
list1.trimToSize();           // Reduce capacity to size

// Creating HashMaps
Map<String, Integer> map = new HashMap<>();
Map<String, Integer> map2 = new HashMap<>(100); // Initial capacity
Map<String, Integer> map3 = new HashMap<>(existingMap);

// Adding/updating entries
map.put("apple", 5);
map.put("banana", 3);
map.put("apple", 7);          // Overwrites previous value

// Conditional put
map.putIfAbsent("cherry", 2); // Only if key doesn't exist

// Retrieving values
Integer count = map.get("apple");           // 7
Integer defaultVal = map.getOrDefault("pear", 0); // 0

// Checking existence
boolean hasApple = map.containsKey("apple");   // true
boolean hasValue5 = map.containsValue(5);      // false

// Removing entries
map.remove("banana");
map.remove("apple", 7);       // Remove only if value matches

// Iteration
for (Map.Entry<String, Integer> entry : map.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

// Keys and values
Set<String> keys = map.keySet();
Collection<Integer> values = map.values();

// Advanced operations
map.compute("apple", (k, v) -> v == null ? 1 : v + 1);
map.merge("banana", 1, Integer::sum);

// From collections
List<String> list = Arrays.asList("a", "b", "c");
Stream<String> stream1 = list.stream();
Stream<String> parallelStream = list.parallelStream();

// From arrays
String[] array = {"x", "y", "z"};
Stream<String> stream2 = Arrays.stream(array);

// From values
Stream<String> stream3 = Stream.of("one", "two", "three");

// From builder
Stream<String> stream4 = Stream.<String>builder()
    .add("a")
    .add("b")
    .build();

// Generate infinite streams
Stream<Double> randoms = Stream.generate(Math::random);
Stream<Integer> numbers = Stream.iterate(0, n -> n + 1);

// From ranges
IntStream range = IntStream.range(1, 11);  // 1 to 10

List<Integer> list = new ArrayList<>(Arrays.asList(3, 1, 4, 1, 5));

// Sorting
Collections.sort(list);                    // [1, 1, 3, 4, 5]
Collections.sort(list, Collections.reverseOrder());

// Searching
int index = Collections.binarySearch(list, 3);

// Shuffling
Collections.shuffle(list);

// Min/Max
int min = Collections.min(list);
int max = Collections.max(list);

// Frequency
int count = Collections.frequency(list, 1); // Count of 1s

// Reverse
Collections.reverse(list);

// Fill
Collections.fill(list, 0);                 // Fill with zeros

// Synchronized wrappers
List<Integer> syncList = Collections.synchronizedList(list);
Map<String, Integer> syncMap = Collections.synchronizedMap(new HashMap<>());

// Unmodifiable wrappers
List<Integer> unmodifiable = Collections.unmodifiableList(list);

// Empty collections
List<String> empty = Collections.emptyList();
Set<String> emptySet = Collections.emptySet();
Map<String, Integer> emptyMap = Collections.emptyMap();

// Singleton
Set<String> singleton = Collections.singleton("only");

int[] numbers = {5, 2, 8, 1, 9};

// Sorting
Arrays.sort(numbers);              // [1, 2, 5, 8, 9]

// Binary search (array must be sorted)
int index = Arrays.binarySearch(numbers, 5);

// Fill
Arrays.fill(numbers, 0);           // All elements = 0

// Copy
int[] copy = Arrays.copyOf(numbers, numbers.length);
int[] partial = Arrays.copyOfRange(numbers, 0, 3);

// Equals
boolean same = Arrays.equals(numbers, copy);

// Convert to List
List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);

// Convert to String
String str = Arrays.toString(numbers);

// Stream
int sum = Arrays.stream(numbers).sum();

// Creating Optionals
Optional<String> present = Optional.of("value");
Optional<String> empty = Optional.empty();
Optional<String> nullable = Optional.ofNullable(possiblyNull);

// Checking presence
if (present.isPresent()) {
    String value = present.get();
}

// Alternative: ifPresent
present.ifPresent(value -> System.out.println(value));

// Default values
String value = empty.orElse("default");
String value2 = empty.orElseGet(() -> "computed default");

// Throw exception if empty
String value3 = empty.orElseThrow();
String value4 = empty.orElseThrow(IllegalStateException::new);

// Transforming
Optional<Integer> length = present.map(String::length);
Optional<String> upper = present.map(String::toUpperCase);

// Filtering
Optional<String> filtered = present.filter(s -> s.length() > 3);

// flatMap for nested Optionals
Optional<String> result = present.flatMap(this::findRelated);