This article explains the differences between Java's HashMap and TreeMap, covering their underlying implementations, performance characteristics, ordering behavior, and how to use a custom comparator to achieve descending order, helping developers choose the appropriate map based on ordering and efficiency needs.
This article provides a comprehensive overview and source‑code dissection of Java's ArrayList, covering its inheritance hierarchy, fields, constructors, addition, removal, modification, traversal, serialization, sorting, array conversion, thread‑safety considerations, and practical usage tips.
This article provides a concise overview of Hulu's 2020 campus recruitment, including company FAQs, detailed descriptions of four programming problems with input/output specifications, sample cases, and step‑by‑step solution analyses to help candidates prepare for the online coding test.
This article explains the fundamentals of red‑black trees, a self‑balancing binary search tree, covering their properties, recolor and rotation operations, step‑by‑step insertion cases, and practical questions such as Java 8 HashMap usage and deletion rules.
This article introduces Redis's fundamental and advanced data structures, explains how each is represented internally, and provides detailed examples of essential commands such as KEYS, EXISTS, DEL, EXPIRE, TTL, and TYPE, highlighting their usage, complexity, and best‑practice considerations.
This tutorial introduces Python by defining the language, explaining why it’s popular, and walking through core fundamentals such as variables, conditional statements, loops, lists, dictionaries, classes, encapsulation, getters/setters, and inheritance with clear code examples.
This article offers a clear, visual introduction to red‑black trees, covering binary search tree fundamentals, the four balancing rules, insertion cases with recolor and rotation steps, and step‑by‑step animated examples, helping readers grasp and remember the concepts through images and analogies.
The article examines the risks of using the dangerous FLUSHDB command in Redis, explores common alternatives like SCAN, async deletion, and expiration, and proposes a secondary‑index solution using sets and sorted sets to efficiently invalidate only the affected cache entries without blocking the service.
This article explains how library indexing inspires database indexing, introduces binary search trees, AVL trees, B‑Tree and B+Tree structures, and details InnoDB and MyISAM storage mechanisms, page organization, clustered versus non‑clustered indexes, and practical index‑optimization advice.
This article explains why Redis achieves exceptional performance by using pure in‑memory operations, a single‑threaded model, efficient data structures like SDS, skip‑list, ziplist, and various encoding and rehash optimizations that reduce memory allocation and CPU overhead.
This article summarizes a variety of practical methods—including Bloom filters, hashing, bit‑maps, heaps, bucket partitioning, database indexes, inverted indexes, external sorting, tries, and MapReduce—that can be used to efficiently handle and analyze extremely large data volumes in real‑world scenarios.
This article explains how Redis relies on hash tables as the underlying dictionary structure for its databases and data types, detailing the dict layout, collision handling, progressive rehash algorithms, and the safe and unsafe iterator mechanisms used to traverse the hash table.
This article presents 35 comprehensive multiple‑choice and essay questions covering VLANs, system calls, IP addressing, TCP/UDP, algorithmic puzzles, data structures, DNS, traceroute, and related reference answers, offering a solid self‑test for core computer‑science concepts.
This article explains Redis' core data types—strings, lists, sets, hashes, sorted sets, and more—detailing their characteristics, common commands, practical use‑cases such as caching, counters, distributed locks, and ranking, and provides best‑practice tips for key design and performance.
This article introduces Redis as an open‑source in‑memory store, outlines its core data structures—strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes—and provides concrete command examples, application scenarios, and best‑practice guidelines for effective usage.
This guide walks through Python’s fundamental data structures—strings, lists, tuples, dictionaries, and sets—showing how to create, manipulate, and query them with clear code examples for operations such as slicing, joining, sorting, and set mathematics.
This article explains how Redis stores all values as byte arrays, clarifies the five primary data structures, describes cluster slot mapping and node‑key relationships, and covers single‑threaded execution, transactions, pipelines, and the Redis protocol in detail.
This article explains why Redis delivers exceptional performance by examining its pure in‑memory operations, single‑threaded design, efficient data structures such as SDS, dictionaries, skip‑lists, zip‑lists, and the encoding and rehash strategies that keep latency low even under heavy load.
This article introduces recursion by outlining its three essential elements—function purpose, base case, and recurrence relation—and demonstrates each step with clear Java/C examples such as factorial, Fibonacci, frog‑jump, and linked‑list reversal, while also covering common pitfalls and optimization techniques.
This article introduces Scala arrays, covering their declaration, element access, multidimensional arrays, common operations such as iteration, summation, finding maximum values, concatenation, range creation, and a comprehensive list of array methods, all illustrated with clear code examples.
The article shares a developer’s experience interviewing at over 30 Chinese tech firms, breaking down three main interview focuses—data structures and algorithms, operating‑system and core‑technology knowledge, and project experience—while also offering practical advice on networking questions, open‑source tools, and how to evaluate a company's interview process.
The article shares the author’s interview experiences at over 30 companies and provides a comprehensive guide covering data‑structure and algorithm questions, core C++ concepts, operating‑system fundamentals, networking protocols, open‑source tools, project‑experience expectations, and practical advice for evaluating both technical and non‑technical aspects of potential employers.
In this article, Redis creator Antirez explains the rationale behind upcoming features such as RESP3, fine‑grained ACLs, multithreading approaches, storage improvements, and new data structures, while emphasizing the lack of a fixed roadmap and the community‑driven nature of Redis development.
This article explains the thread‑safe, ordered Java collection ConcurrentSkipListSet, compares it with TreeSet, describes its skip‑list based internal structure, lists its full API, and provides a multithreaded example demonstrating correct concurrent usage versus the failure of TreeSet.
This article explains the inner workings of Java 8's ConcurrentHashMap, covering how the table is initialized, how linked‑list bins are converted to red‑black trees, the resizing logic with tryPresize, and the multi‑threaded transfer process that moves entries to a larger table.
This article provides an in‑depth tutorial on Java 8’s HashMap and ConcurrentHashMap implementations, explaining their internal structures, red‑black tree conversion, resizing mechanisms, and step‑by‑step code analysis of put, get, and initialization processes, essential for interview preparation.
This article provides a comprehensive, step‑by‑step explanation of Java 7 HashMap and ConcurrentHashMap internals, covering their data structures, put/get algorithms, array initialization, resizing, segment locking, rehashing, and the concurrency considerations that ensure thread‑safe access.
This article introduces the Java JUC concurrent collection classes, detailing the thread‑safe List and Set implementations, the concurrent Map variants, and the various Queue types, while providing diagrams and brief explanations of their usage and characteristics.
Dan Abramov announced revised interview expectations for front‑end engineers, emphasizing practical JavaScript skills, performance awareness, core data structures, and a solid grasp of language fundamentals without requiring specific library knowledge, to help candidates better prepare for Facebook‑style interviews.
This article provides a comprehensive overview of Java's LinkedList class, covering its definition, internal node structure, constructors, element addition and removal methods, traversal techniques, iterator behavior, and concurrency considerations, all illustrated with complete source code examples.
This article provides a comprehensive overview of Java's ArrayList, covering its internal structure, key fields, constructors, core operations such as adding, removing, and searching elements, traversal techniques, fail‑fast behavior, and a comparison with Vector, all illustrated with original source code snippets.
This article guides beginners through the essentials of Python, covering why to learn it, how to get started, core data types, operators, functions, classes, modules, and advanced features, while offering motivational advice to persist through early challenges.
This guide outlines the ten core competencies—from data structures and version control to IDEs, databases, Unix, Excel, programming languages, networking, and scripting—that every new or aspiring software developer should master to build a successful career.
This article explains how Redis stores and encodes its five data types by using various in‑memory data structures such as SDS strings, linked lists, quicklists, hash tables, skip‑lists, intsets and zip‑lists, and it also covers object mapping, expiration policies, LRU eviction, and the RDB/AOF persistence mechanisms.
This article outlines eight actionable strategies—including investing in education, leveraging existing libraries, mastering data structures, using powerful IDEs, writing clean code, continuous learning, disciplined planning, and humility—to help programmers become more outstanding in their careers.
This article explains the concept of a priority queue, presents a interview‑style problem requiring O(log n) enqueue and dequeue operations, and shows how to implement the solution efficiently using a binary heap with detailed step‑by‑step illustrations and a complete JavaScript code example.
This article provides a detailed overview of Redis as an open‑source, in‑memory data store, covering its core features, common use cases such as caching and leaderboards, high‑performance characteristics, essential data structures and commands, configuration options, and practical recommendations for production deployment.
This article introduces several practical algorithmic tricks—using array indices as counters, applying modulo for circular traversal, employing two‑pointer methods for linked‑list problems, leveraging bit‑shift and bitwise operations, adding sentinel nodes, and optimizing recursive solutions with memoization and bottom‑up DP—each illustrated with Java code examples.
This article explains Redis's core data types—String, Hash, List, Set, and Sorted Set—its internal object model, persistence options (RDB and AOF) with their pros and cons, transaction characteristics, master‑slave replication mechanisms, and common caching scenarios and design considerations.
This comprehensive guide explains Redis fundamentals, its rich data structures and common commands, then dives into performance optimization, replication, and clustering, offering practical examples and best‑practice recommendations for building reliable, high‑performance Redis deployments.
This article introduces sorting algorithms, distinguishing internal and external sorting, listing major internal sorts, explaining their time‑complexity categories and stability properties, and providing visual illustrations for each algorithm along with a reference to an open‑source implementation.
Redis and Memcached differ significantly in data structure support, memory efficiency, performance, memory management, persistence options, and clustering capabilities, with Redis offering richer data types, server‑side operations, configurable persistence, and native clustering, while Memcached provides simpler key‑value storage, slab allocation, and client‑side distribution.
This article explains five practical techniques—list storage, in‑memory set, MD5 hashing, bitmap compression, and Bloom filter—to efficiently deduplicate URLs during large‑scale Python web crawling, highlighting their trade‑offs in speed, memory usage, and collision risk.
This article provides a detailed introduction to sorting algorithms, covering internal and external sorts, their time complexities and stability characteristics, and presents step‑by‑step Java implementations for bubble sort, selection sort, insertion sort, shell sort, merge sort, quick sort, heap sort, counting sort, bucket sort, and radix sort, accompanied by visual illustrations.
This comprehensive guide introduces Redis fundamentals, explores its diverse data structures and essential commands, and delves into advanced topics such as persistence, memory management, pipelining, transactions, clustering, and Java client choices, offering practical tips for deployment, optimization, and architectural decisions.
CopyOnWriteArrayList is a thread‑safe variant of ArrayList that achieves read‑write separation by copying the underlying array on each mutative operation, using a ReentrantLock for writes, making it ideal for read‑heavy, write‑light scenarios, and it differs from ArrayList in safety, performance, and concurrency behavior.
This comprehensive guide explores essential strategies for handling massive datasets, covering hash-based structures, bucket partitioning, heap and quicksort techniques, trie trees, Bloom filters, external sorting, and MapReduce, and demonstrates how to efficiently solve common interview problems such as top‑K queries and duplicate removal.
The article explains that machine‑learning programs rely on the same fundamental data structures as other software—especially arrays for linear algebra—but mastering their implementation, dynamic behavior, and alternatives such as linked lists, trees, heaps, stacks, queues, and hash maps is crucial for scaling and optimizing complex AI tasks.
This article explains the classic Linux kernel list linked‑list data structure, covering its definition, file locations, core operations such as initialization, insertion, deletion, replacement, moving, splitting and merging, the list_entry macro, usage examples, and important multithreading considerations.
An interview question about checking whether a new integer belongs to a set of 4 billion numbers leads to a discussion of distributed loading across eight machines, bitmap representation using 500 MB of memory, and interval‑based external sorting, illustrating practical big‑data algorithm design.
This article explains Python's frozenset type, detailing its immutable nature, creation syntax, differences from mutable sets, supported operations, membership testing, and practical code examples illustrating set algebra and method usage.
This article explains how to monitor Redis memory usage with the INFO command, interprets key metrics such as used_memory, used_memory_rss, and mem_fragmentation_ratio, and dives into Redis's internal memory layout, including allocators, redisObject, SDS, and the various object types and their encodings.
This article provides a comprehensive overview of Python, covering its nature as an interpreted, interactive, object‑oriented language, key benefits, coding conventions, memory management, debugging tools, core concepts like decorators, data structures, namespaces, lambda functions, testing, and many practical programming details for newcomers.
This article explains the fundamental principles of Java's HashMap, covering hash basics, time‑complexity of operations, the role of load factor and initial capacity, the resize algorithm without full rehashing, and the treeification of long buckets, illustrated with JDK 1.8 source code examples.
This article systematically explains common Java collection classes—including LinkedList, ArrayList, Stack, Queue, HashMap, and LinkedHashMap—highlighting their internal structures, key operations, performance characteristics, and JDK 8 differences, and it provides animated illustrations and full code snippets for each concept.
This article provides a comprehensive overview of the Java Collections Framework, detailing its core interfaces, common implementations such as List, Set, Queue, and Map, their underlying data structures, performance characteristics, and usage examples including legacy classes and specialized collections like PriorityQueue and LinkedHashMap.
This comprehensive guide explains what Redis is, its advantages over memcached, supported data structures, eviction policies, clustering options, persistence mechanisms, memory optimization techniques, and practical use‑cases such as caching, queues, leaderboards, and pub/sub, providing essential knowledge for developers and architects.
This article explains the fundamentals of binary operations, why hashCode is used, how Java's String hashCode is implemented, the rationale behind using the multiplier 31, and the detailed workings of HashMap's hash function, index calculation, capacity choices, and custom sizing recommendations.
This article provides a comprehensive overview of Redis, covering why it is used, its performance advantages, data structures, expiration and eviction strategies, cache‑database consistency, handling cache penetration and avalanche, and approaches to concurrent key competition.
The article explains Git’s fundamental architecture, describing how trees, blobs, and commits are stored as objects identified by hashes, how version history forms a linked list, and how optimizations such as directory sharding and garbage collection fit into this design.
This article explains how database indexes are implemented using B+ trees, describing their structure, advantages such as shallow depth and ordered leaf nodes, and how they reduce disk I/O, illustrating calculations of node capacity and emphasizing the importance of index size for performance.
This article explains the performance characteristics and implementation details of common linear data structures such as arrays, hash maps, sets, lists, linked lists, stacks, and queues, showing their time complexities, code examples, and how to choose the right structure for efficient programming.
This article explains the core design of Java's HashMap—including its hash function, array storage, and linked‑list collision handling—and walks through creating a simplified MiniHashMap implementation with interfaces, constructors, put/get methods, resizing, and testing.
Meitu Technology’s technical salon on June 9, 2018 in Xiamen showcased how its AI‑driven deep ranking, video‑clustering, and data‑structure‑based optimization techniques improve personalization, recommendation and economic‑focused problem solving for billions of mobile users, targeting mid‑senior R&D and algorithm engineers.
The article shares a seasoned Java developer’s journey from superficial framework use to deep source‑code study, emphasizing solid fundamentals such as HashMap internals, concurrency mechanisms, and performance‑oriented coding practices to build a robust J2EE skill set.
This guide walks through Python’s core data structures—strings, lists, tuples, dictionaries, and sets—detailing their creation, common built‑in methods, slicing, updating, and iteration with clear code examples, helping readers master essential operations for effective data manipulation.
This article provides a comprehensive analysis of Java's HashMap implementation, covering its class signature, inheritance hierarchy, hash function design, core operations such as get, put, and remove, internal data structures, resizing logic, iterator behavior, and serialization details, all illustrated with original source code snippets.
This article provides a high‑level overview of Java’s Collections Framework, explaining its core design principles, the top‑level Collection and Map interfaces, their sub‑interfaces such as List, Set, Queue, and Map, and the typical implementation naming conventions, helping developers understand and analyze collection classes.
This article explains Redis’s memory model—including memory statistics, allocation, object structures, internal encodings, and practical optimization strategies—providing detailed insights into how Redis stores data, manages memory fragmentation, and how developers can estimate and reduce memory usage for high‑performance deployments.
This article provides an overview of Java's ArrayList class, explaining its dynamic array implementation, thread-safety considerations, key interfaces, constructors, capacity management, core methods, and internal mechanisms such as ensureCapacity, trimToSize, and serialization, accompanied by detailed source code excerpts and practical insights.
This article presents a comprehensive collection of Python performance‑boosting techniques—from choosing optimal data structures and using copy versus deepcopy, to leveraging generators, join, efficient string formatting, loop optimizations, C‑based modules, parallel programming, and the PyPy JIT—each illustrated with concrete code examples and benchmark results.
Binary Search Trees (BST) are dynamic, ordered binary trees that enable fast search, insertion, and deletion; this guide explains their definition, properties, traversal methods, and core operations—including search, minimum/maximum, successor/predecessor, insertion, and deletion—complete with pseudocode and illustrative examples.
This article provides concise explanations of core Java and system concepts—including JVM class loading, HashMap implementation, concurrency utilities, IPC mechanisms, garbage collection, sorting algorithms, networking protocols, Linux scheduling, deadlock conditions, hashing techniques, and database normalization—useful for technical interviews and foundational study.
This article explains the evolution from binary search trees to AVL and red‑black trees, introduces B and B+ trees, compares their properties and performance, and clarifies why B+ trees are the preferred indexing structure for MySQL databases.
This tutorial introduces Python by explaining what it is, why to learn it, and then walks through core fundamentals such as variables, conditional statements, loops, lists, dictionaries, iteration techniques, and object‑oriented concepts like classes, encapsulation, and inheritance, all illustrated with clear code examples.
This article explains the fundamentals of hash tables, covering their basic concepts, construction methods, various collision‑resolution techniques such as open addressing and chaining, and compares several widely used hash functions with performance insights.
This article explains the stack data structure, its Python interface, and demonstrates practical algorithms such as bracket matching, maze solving, postfix expression evaluation, and the knapsack problem, providing clear code examples and visual illustrations for each concept.
This comprehensive guide introduces Redis fundamentals, covering its core data structures and essential commands, then delves into performance optimization, high‑availability setups with replication and Sentinel, and scaling strategies using Redis Cluster, providing practical examples and best‑practice recommendations for robust in‑memory data management.
This article provides a comprehensive overview of Python fundamentals—including its interpreted nature, dynamic typing, OOP support, memory management, key tools like PEP8 and linters, core data structures, and common features such as decorators, generators, and slicing—offering a solid foundation for both beginners and seasoned programmers.
This article compiles an extensive collection of Java interview questions covering core concepts, language features, data structures, concurrency, JVM internals, exception handling, I/O, design patterns, and practical coding exercises, providing a comprehensive study guide for developers preparing for technical interviews.
This article presents a concise collection of twelve fundamental Python techniques—including regex substitution, directory walking, list sorting and deduplication, dictionary sorting, conversions between dict/list/string, time manipulation, getopt argument parsing, formatted printing, numeral base conversion, executing system commands, handling Ctrl+C/Ctrl+D signals, and file reading/writing—each illustrated with ready‑to‑run code snippets.
This article provides a comprehensive overview of Python fundamentals, covering its interpreted nature, interactivity, object‑oriented features, benefits, coding standards like PEP8, serialization with pickle, memory management, debugging tools, decorators, data structures, namespaces, lambda functions, testing, and more.
This article explains Java HashMap internals by walking through a concrete Country‑key example, illustrating how keys are hashed, stored in an internal Entry array, and how the put and get methods handle collisions using linked lists, complemented by full source code snippets.
This article explains the key distinctions between Java's HashMap and Hashtable, covering thread safety, synchronization, null handling, iterator behavior, performance implications, and how to achieve synchronization for HashMap, helping readers prepare for interview questions on the Java collections framework.
This tutorial walks through Python list fundamentals, showing how to define a list, retrieve elements by index, update a specific item, remove an element, and append new items, while explaining the underlying indexing rules and the benefits of using a single container for multiple strings.
Redis is an open-source, in-memory data store offering versatile structures and commands; this guide explains its fundamentals, key data types, essential commands, practical examples, performance optimization techniques, replication, clustering, and Java client choices to help you design robust, high-performance Redis solutions.
This article explains the concept of linked lists versus sequential array storage, why JavaScript developers might need them, and provides step‑by‑step code to implement singly and doubly linked lists, custom array‑like APIs, and a circular list, along with performance trade‑offs and a GitHub reference.
This comprehensive tutorial walks you through Python fundamentals—from defining variables, booleans, strings, and numbers to using conditional statements, while and for loops, manipulating lists and dictionaries, and building classes with objects, encapsulation, and inheritance—providing clear code examples for each concept.
Redis introduced the Streams data type to address limitations of sorted sets, lists, and Pub/Sub for handling continuous data flows, offering features like field-value entries, efficient range queries, and client blocking with ID tracking, and the article explains its design, commands, and usage examples.
This article visually explains key Java fundamentals—including string immutability, the difference between equals() and hashCode(), exception and collection hierarchies, synchronization, aliasing, heap vs. stack memory, and the JVM runtime data area—using concise diagrams and code examples.
This article explains the Java collection class diagram, distinguishes concrete classes, abstract classes, and interfaces, describes Iterator and ListIterator behavior, and provides detailed code demonstrations of HashSet, ArrayList, ListIterator, and WeakHashMap usage along with their outputs.
This article dissects Java 8’s LinkedList class, explaining its double‑linked node structure, key fields, constructors, and core methods such as add, remove, clear, get, and set, while contrasting its performance characteristics with ArrayList for insertion, deletion, and random access.
This article explores Java's ArrayList implementation in depth, covering its core interfaces, member variables, constructors, and the most commonly used methods, while illustrating how the internal array expands and how each operation manipulates the underlying data structure.
This article introduces newcomers to programming by explaining why Python is an ideal first language and walks through its core syntax, data types, operators, functions, classes, modules, and advanced features, offering practical guidance and motivational advice to help beginners confidently start coding.
This article discusses memory optimization in Android apps by addressing excessive object allocations caused by autoboxing Long values, leading to performance issues during feed scrolling. The solution involves implementing a custom data structure to reduce memory usage and improve application responsiveness.
This comprehensive guide introduces Redis fundamentals, explores its rich data structures and essential commands, delves into performance optimization techniques, explains replication and clustering strategies, and compares popular Java clients, providing practical examples and best‑practice recommendations for reliable, high‑performance deployments.
This article provides a comprehensive overview of the Java Collections Framework, detailing the characteristics, usage, and conversion methods of arrays, single‑threaded collections such as Lists, Queues, Maps, Sets, as well as concurrent collections, including key utility methods and code examples.
This article provides a comprehensive overview of Java's collection framework, covering the core Collection interface, List, Set, and Map interfaces, their common implementations such as ArrayList, LinkedList, Vector, Stack, Hashtable, and HashMap, and demonstrates traversal using the Iterator pattern with code examples.
This guide explains how ES6 Set creates collections of unique values, covering basic methods, handling of arrays, objects, and strings, iteration techniques like for…of, and the interchangeable keys and values methods with practical code examples.
This article explains the internal structure and encoding of Redis's ziplist (compressed list), describes its memory layout and node format, and analyzes how Redis leverages this data structure across different types such as lists, hashes, and sorted sets to reduce memory usage and fragmentation.
