Collections Deep Dive — Set (HashSet/TreeSet) & Map (HashMap/TreeMap) (సెట్ & మ్యాప్ ఆర్కిటెక్చర్)

import java.util.*;

public class SetDeduplicationAndTreeSetBenchmark {
    public static void main(String[] args) {
        System.out.println("=== 1. HASHSET DEDUPLICATION DEMO ===");
        
        // సిస్టమ్‌లోకి వచ్చిన లాగిన్ ఐడీలు (ఇందులో తీవ్రమైన డూప్లికేట్లు ఉన్నాయి)
        List<String> incomingUserIds = List.of(
            "USR-101", "USR-205", "USR-101", "USR-304", 
            "USR-205", "USR-500", "USR-101"
        );
        System.out.println("మొత్తం ఇన్కమింగ్ రిక్వెస్ట్‌లు: " + incomingUserIds.size());

        // HashSet లోకి చేర్చడం ద్వారా క్షణంలో డూప్లికేట్లను తొలగించడం
        Set<String> uniqueUsers = new HashSet<>(incomingUserIds);
        System.out.println("డూప్లికేట్లు తొలగించబడిన యునిక్ యూజర్లు: " + uniqueUsers);
        System.out.println("యునిక్ యూజర్ల సంఖ్య: " + uniqueUsers.size());

        System.out.println("
=== 2. TREESET NAVIGABLE SET DEMO ===");
        // గేమింగ్ లీడర్‌బోర్డ్ స్కోర్లు (ఆటోమేటిక్ సార్టింగ్ మరియు రేంజ్ క్వెరీలు)
        TreeSet<Integer> highScores = new TreeSet<>();
        highScores.addAll(List.of(850, 420, 990, 710, 310, 950, 600));

        System.out.println("సహజంగా క్రమబద్ధీకరించబడిన స్కోర్లు: " + highScores);
        System.out.println("అత్యల్ప స్కోరు (first): " + highScores.first());
        System.out.println("అత్యధిక స్కోరు (last): " + highScores.last());

        int targetCutoff = 710;
        System.out.println("
--- టార్గెట్ స్కోర్ చుట్టూ నావిగేషన్: " + targetCutoff + " ---");
        System.out.println("Target కంటే తక్కువైన స్కోరు (lower): " + highScores.lower(targetCutoff));
        System.out.println("Target కు సమానమైన లేదా తక్కువైన స్కోరు (floor): " + highScores.floor(targetCutoff));
        System.out.println("Target కు సమానమైన లేదా ఎక్కువైన స్కోరు (ceiling): " + highScores.ceiling(targetCutoff));
        System.out.println("Target కంటే కచ్చితంగా ఎక్కువైన స్కోరు (higher): " + highScores.higher(targetCutoff));

        // సబ్‌సెట్ రేంజ్ క్వెరీ: 400 నుండి 900 మధ్య స్కోర్లు
        SortedSet<Integer> midTier = highScores.subSet(400, 900);
        System.out.println("400 నుండి 900 మధ్య స్కోర్లు (subSet): " + midTier);
    }
}

import java.util.*;

public class HashMapCollisionAndTreeificationDemo {

    // ఉద్దేశపూర్వకంగా ఒకే స్థిరమైన హాష్‌కోడ్ (Zero) ఇచ్చే బ్యాడ్ కీ క్లాస్
    static class BadHashKey implements Comparable<BadHashKey> {
        final String keyName;
        final int id;

        public BadHashKey(String keyName, int id) {
            this.keyName = keyName;
            this.id = id;
        }

        @Override
        public int hashCode() {
            return 42; // ప్రతి ఆబ్జెక్టుకు ఒకే స్థిరమైన హాష్‌కోడ్! తీవ్రమైన కొలీజన్!
        }

        @Override
        public boolean equals(Object obj) {
            if (this == obj) return true;
            if (!(obj instanceof BadHashKey other)) return false;
            return this.id == other.id && Objects.equals(this.keyName, other.keyName);
        }

        @Override
        public int compareTo(BadHashKey o) {
            return Integer.compare(this.id, o.id);
        }

        @Override
        public String toString() {
            return keyName + "(id=" + id + ")";
        }
    }

    public static void main(String[] args) {
        System.out.println("=== 1. HASH COLLISION & BUCKET CHAINING TEST ===");
        Map<BadHashKey, String> collisionMap = new HashMap<>();

        // 10 ఎలిమెంట్లను ఒకే బకెట్ ఇండెక్స్‌లోకి బలవంతంగా ఇన్సర్ట్ చేస్తున్నాం
        for (int i = 1; i <= 10; i++) {
            collisionMap.put(new BadHashKey("KeyItem", i), "Payload-Data-" + i);
        }
        System.out.println("మొత్తం ఇన్సర్ట్ చేయబడిన కొలీజన్ ఎలిమెంట్లు: " + collisionMap.size());

        // హాష్‌కోడ్ ఒకటే అయినా equals() సరిగ్గా ఉండటం వల్ల సరైన డేటా లభిస్తుంది
        BadHashKey searchKey = new BadHashKey("KeyItem", 7);
        String foundValue = collisionMap.get(searchKey);
        System.out.println("Search Key [KeyItem, id=7] లభించిన డేటా: " + foundValue);

        System.out.println("
=== 2. LINKEDHASHMAP LRU CACHE (MAX 3 ITEMS) ===");
        // 3 ఎంట్రీలు మించగానే అతి తక్కువగా వాడిన ఎంట్రీని ఆటోమేటిక్‌గా తొలగించే LRU క్యాష్
        Map<String, String> lruCache = new LinkedHashMap<>(16, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(Map.Entry<String, String> eldest) {
                return size() > 3; // పరిమితి 3 ఐటెమ్స్
            }
        };

        lruCache.put("token1", "User-Balaji");
        lruCache.put("token2", "User-Suresh");
        lruCache.put("token3", "User-Kavitha");
        System.out.println("ప్రారంభ క్యాష్ (3 ఐటెమ్స్): " + lruCache.keySet());

        // token1 ను యాక్సెస్ చేస్తున్నాం (దీనివల్ల ఇది ఇటీవల వాడినదిగా మారి చివరికి వెళుతుంది)
        lruCache.get("token1");
        System.out.println("token1 ను యాక్సెస్ చేసిన తర్వాత ఆర్డర్: " + lruCache.keySet());

        // ఇప్పుడు 4వ ఐటెమ్‌ను ఇన్సర్ట్ చేస్తున్నాం (అప్పుడు అతి పాతదైన token2 ఆటోమేటిక్‌గా తొలగిపోతుంది)
        lruCache.put("token4", "User-Ramesh");
        System.out.println("కొత్త token4 చేర్చిన తర్వాత క్యాష్: " + lruCache.keySet());
        System.out.println("token2 తొలగించబడిందా? " + (!lruCache.containsKey("token2")));
    }
}

import java.time.Instant;
import java.util.*;

public class EnterpriseUserSessionCacheEngine {

    // ఆధునిక Java 21 ఇమ్యూటబుల్ రికార్డ్: యూజర్ సెషన్ వివరాలు
    public record UserSession(
        String sessionId,
        String username,
        String role,
        Set<String> permissions,
        Instant createdAt
    ) {}

    // ఎంటర్‌ప్రైజ్ లెవల్ సెషన్ అడ్మినిస్ట్రేటర్
    public static class SessionRegistry {
        // Fast O(1) Session Lookup Cache
        private final Map<String, UserSession> activeSessions = new HashMap<>();
        
        // యూజర్ పేరు ఆధారంగా వారి అన్ని యాక్టివ్ సెషన్లను ట్రాక్ చేసే మ్యాప్
        private final Map<String, Set<String>> userToSessionIndex = new HashMap<>();

        // 1. కొత్త సెషన్‌ను నమోదు చేయడం
        public void registerSession(String username, String role, Set<String> incomingRoles) {
            String sessionId = "SESS-" + UUID.randomUUID().toString().substring(0, 8).toUpperCase();
            
            // HashSet ద్వారా రోల్ పర్మిషన్లలో ఏ విధమైన డూప్లికేట్లు లేకుండా చేయడం
            Set<String> sanitizedPermissions = new HashSet<>(incomingRoles);
            
            UserSession session = new UserSession(sessionId, username, role, sanitizedPermissions, Instant.now());
            activeSessions.put(sessionId, session);

            // Java 8 computeIfAbsent తో యూజర్ ఇండెక్స్‌ను అప్‌డేట్ చేయడం
            userToSessionIndex.computeIfAbsent(username, k -> new HashSet<>()).add(sessionId);

            System.out.printf("✅ [REGISTERED] User: %-10s | Session: %s | Permissions: %s%n", 
                username, sessionId, sanitizedPermissions);
        }

        // 2. సెషన్ టోకెన్‌ను ప్రామాణీకరించడం & అనుమతిని పరిశీలించడం
        public boolean authorize(String sessionId, String requiredPermission) {
            UserSession session = activeSessions.get(sessionId);
            if (session == null) {
                System.out.println("❌ [DENIED] చెల్లని సెషన్ ఐడీ: " + sessionId);
                return false;
            }
            
            boolean hasAccess = session.permissions().contains(requiredPermission);
            System.out.printf("🔍 [AUTH CHECK] User: %-10s | Req: %-15s | Granted: %b%n", 
                session.username(), requiredPermission, hasAccess);
            return hasAccess;
        }

        // 3. యూజర్ లాగౌట్ లేదా ఫోర్స్ ఎక్స్‌పైరీ
        public void revokeUserSessions(String username) {
            Set<String> sessions = userToSessionIndex.remove(username);
            if (sessions != null) {
                for (String sid : sessions) {
                    activeSessions.remove(sid);
                }
                System.out.println("🚫 [REVOKED] యూజర్ '" + username + "' యొక్క " + sessions.size() + " సెషన్‌లు క్లోజ్ చేయబడ్డాయి.");
            }
        }

        public void printTelemetry() {
            System.out.println("
📊 --- REAL-TIME ENGINE TELEMETRY ---");
            System.out.println("యాక్టివ్ సెషన్ల మొత్తం సంఖ్య (Total Active Sessions): " + activeSessions.size());
            System.out.println("యాక్టివ్ యూజర్ల సంఖ్య (Active Distinct Users): " + userToSessionIndex.size());
        }
    }

    public static void main(String[] args) {
        System.out.println("=== ENTERPRISE CLOUD AUTH & SESSION ENGINE ===");
        SessionRegistry authEngine = new SessionRegistry();

        // డూప్లికేట్ పర్మిషన్లతో కూడిన ఇన్కమింగ్ డేటా
        Set<String> adminPerms = new HashSet<>(List.of("READ", "WRITE", "DELETE", "READ", "AUDIT"));
        Set<String> userPerms = new HashSet<>(List.of("READ", "READ", "PROFILE_EDIT"));

        // సెషన్లను రిజిస్టర్ చేయడం
        authEngine.registerSession("balaji_lead", "ADMIN", adminPerms);
        authEngine.registerSession("balaji_lead", "ADMIN", adminPerms); // రెండవ పరికరం నుండి లాగిన్
        authEngine.registerSession("kavitha_dev", "USER", userPerms);

        authEngine.printTelemetry();

        // మొదటి యాక్టివ్ సెషన్‌ను వెతకడం
        String sampleAdminSession = authEngine.activeSessions.keySet().iterator().next();
        System.out.println("
--- AUTHORIZATION AUDIT ---");
        authEngine.authorize(sampleAdminSession, "DELETE");
        authEngine.authorize(sampleAdminSession, "SUPER_ROOT_KILL");

        // యూజర్ సెషన్లను రద్దు చేయడం
        System.out.println("
--- LOGOUT OPERATION ---");
        authEngine.revokeUserSessions("balaji_lead");
        authEngine.printTelemetry();
    }
}