Java Collections Utility Class — Sorting, Searching and Real-World Patterns

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Random;

public class SortingDemo {

    public static void main(String[] args) {

        // --- 1. Natural (ascending) sort on a list of integers ---
        List<Integer> scores = new ArrayList<>(List.of(42, 7, 99, 23, 56));
        Collections.sort(scores);                         // sorts in-place, ascending
        System.out.println("Ascending scores : " + scores);

        // --- 2. Reverse the sorted list to get descending order ---
        Collections.reverse(scores);                      // reverses in-place, O(n)
        System.out.println("Descending scores: " + scores);

        // --- 3. Sort strings by length, then alphabetically for ties ---
        List<String> productNames = new ArrayList<>(
                List.of("USB Hub", "Monitor", "Keyboard", "Mouse", "Webcam"));

        // Comparator chain: primary = length, secondary = natural alphabetical
        Comparator<String> byLengthThenAlpha =
                Comparator.comparingInt(String::length)   // primary sort key
                          .thenComparing(Comparator.naturalOrder()); // tie-breaker

        Collections.sort(productNames, byLengthThenAlpha);
        System.out.println("Products by name length: " + productNames);

        // --- 4. Shuffle with a seeded Random for reproducible results ---
        List<String> questionPool = new ArrayList<>(
                List.of("Q1", "Q2", "Q3", "Q4", "Q5"));
        Collections.shuffle(questionPool, new Random(42)); // seed = 42 -> same order every run
        System.out.println("Shuffled quiz order : " + questionPool);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SearchAndStatsDemo {

    public static void main(String[] args) {

        // --- 1. binarySearch — list MUST be sorted first ---
        List<Integer> sortedTemperatures = new ArrayList<>(
                List.of(12, 15, 18, 21, 25, 30, 33));
        // List is already sorted, so binarySearch is safe to call
        int index = Collections.binarySearch(sortedTemperatures, 21);
        System.out.println("Temperature 21°C found at index: " + index); // index 3

        int missingIndex = Collections.binarySearch(sortedTemperatures, 20);
        // Returns negative value when not found: -(insertion point) - 1
        System.out.println("Temperature 20°C result     : " + missingIndex);

        // --- 2. min and max with a Comparator on Strings ---
        List<String> cityNames = new ArrayList<>(
                List.of("Rome", "Los Angeles", "Berlin", "Ho Chi Minh City", "Oslo"));

        // Find the city with the shortest name
        String shortestCity = Collections.min(cityNames,
                (a, b) -> Integer.compare(a.length(), b.length()));
        // Find the city with the longest name
        String longestCity = Collections.max(cityNames,
                (a, b) -> Integer.compare(a.length(), b.length()));

        System.out.println("Shortest city name: " + shortestCity);
        System.out.println("Longest  city name: " + longestCity);

        // --- 3. frequency — count occurrences without a loop ---
        List<String> logLevels = new ArrayList<>(
                List.of("INFO", "ERROR", "INFO", "WARN", "ERROR", "ERROR", "INFO"));

        int errorCount = Collections.frequency(logLevels, "ERROR");
        int infoCount  = Collections.frequency(logLevels, "INFO");

        System.out.println("ERROR entries: " + errorCount);
        System.out.println("INFO  entries: " + infoCount);
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class DefensiveCollectionsDemo {

    // Simulate a service that owns its internal state
    private final List<String> adminUsers = new ArrayList<>(List.of("alice", "bob", "carol"));

    // Expose a read-only VIEW — callers cannot add or remove entries
    public List<String> getAdminUsers() {
        return Collections.unmodifiableList(adminUsers); // wraps, does not copy
    }

    // Adding a new admin is only possible through this controlled method
    public void addAdmin(String username) {
        if (username != null && !username.isBlank()) {
            adminUsers.add(username);                   // modifies the backing list
        }
    }

    public static void main(String[] args) {

        DefensiveCollectionsDemo service = new DefensiveCollectionsDemo();

        List<String> publicView = service.getAdminUsers();
        System.out.println("Admins before: " + publicView);

        // This controlled addition works fine
        service.addAdmin("dave");
        // The unmodifiable view reflects the change in the backing list
        System.out.println("Admins after addAdmin: " + publicView);

        // --- emptyList() — the right way to signal 'no results' ---
        List<String> noResults = Collections.emptyList(); // immutable, reuses same instance
        System.out.println("No results list is empty: " + noResults.isEmpty());

        // --- singletonList() — a one-item immutable list ---
        List<String> singleAdmin = Collections.singletonList("superadmin");
        System.out.println("Singleton admin list: " + singleAdmin);

        // --- Attempting to mutate the unmodifiable list throws immediately ---
        try {
            publicView.add("hacker");                   // this will throw
        } catch (UnsupportedOperationException e) {
            System.out.println("Mutation blocked: UnsupportedOperationException thrown");
        }
    }
}

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class UtilityMethodsDemo {

    public static void main(String[] args) {

        // --- 1. fill() — reset every slot to the same value ---
        List<String> gameBoard = new ArrayList<>(List.of("X", "O", "X", "O", "X"));
        System.out.println("Board before fill: " + gameBoard);
        Collections.fill(gameBoard, "-");              // replace all with empty marker
        System.out.println("Board after fill : " + gameBoard);

        // --- 2. nCopies() — build a list of repeated values efficiently ---
        // Useful for generating test data or default-valued lists
        List<Integer> defaultScores = new ArrayList<>(Collections.nCopies(5, 0));
        System.out.println("Default scores   : " + defaultScores);
        defaultScores.set(2, 100);                     // nCopies result is immutable; wrap in ArrayList first
        System.out.println("After update     : " + defaultScores);

        // --- 3. copy() — destination MUST have enough pre-existing elements ---
        List<String> source      = List.of("alpha", "beta", "gamma");
        List<String> destination = new ArrayList<>(Collections.nCopies(source.size(), ""));
        Collections.copy(destination, source);         // overwrites in-place
        System.out.println("Copied list      : " + destination);

        // --- 4. disjoint() — check if two groups share no members ---
        List<String> userRoles      = List.of("viewer", "commenter");
        List<String> adminOnlyRoles = List.of("admin", "super-admin", "moderator");
        List<String> mixedRoles     = List.of("viewer", "admin");

        boolean isRegularUser = Collections.disjoint(userRoles, adminOnlyRoles);
        boolean hasAdminAccess = !Collections.disjoint(mixedRoles, adminOnlyRoles);

        System.out.println("User has no admin roles : " + isRegularUser);
        System.out.println("Mixed roles has admin  : " + hasAdminAccess);
    }
}