BestHub
Sign in
Tagged articles
101 articles
Page 1 of 2
Su San Talks Tech
Su San Talks Tech
May 6, 2026 · Backend Development

11 Essential Redis Use Cases Every Backend Engineer Should Know

This article walks through eleven practical Redis scenarios—from classic caching and distributed locks to rate limiting, leaderboards, timelines, social graph operations, lightweight queues, Bloom filters, hash‑based object storage, unique‑counting, and delayed tasks—providing code samples, advantages, drawbacks, and when to apply each pattern.

Sorted SetStreambloom-filter
0 likes · 15 min read
11 Essential Redis Use Cases Every Backend Engineer Should Know
Architect
Architect
Dec 29, 2025 · Backend Development

Can Redis Replace Kafka? Comparing List, Pub/Sub, and Stream Queues

This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data structures, comparing their features, limitations, and durability against professional brokers like Kafka and RabbitMQ, and offering practical usage guidelines.

Message QueueStreampub/sub
0 likes · 18 min read
Can Redis Replace Kafka? Comparing List, Pub/Sub, and Stream Queues
Java Architect Essentials
Java Architect Essentials
Aug 29, 2025 · Backend Development

Simplify Java Stream Operations with JDFrame: A Semantic DataFrame API

This article introduces JDFrame/SDFrame, a JVM‑level DataFrame library that provides a more semantic and concise API for Java 8 stream processing, showcases quick start steps, detailed API categories such as filtering, aggregation, grouping, sorting, joining, and explains the differences between SDFrame and JDFrame with practical code examples.

Backend DevelopmentJDFrameJava
0 likes · 19 min read
Simplify Java Stream Operations with JDFrame: A Semantic DataFrame API
Architect
Architect
Aug 18, 2025 · Backend Development

Simplify Java Stream with JDFrame: A DataFrame‑Style API for Cleaner Code

This article introduces JDFrame/SDFrame, a JVM‑level DataFrame‑style library that provides a more semantic and concise API for Java 8 Stream processing, covering dependency setup, quick start, filtering, aggregation, distinct, grouping, sorting, joining, and advanced features such as percent conversion, partitioning, ranking, and missing‑data replenishment.

APIDataProcessingJDFrame
0 likes · 16 min read
Simplify Java Stream with JDFrame: A DataFrame‑Style API for Cleaner Code
macrozheng
macrozheng
Aug 18, 2025 · Backend Development

Simplify Java Stream Processing with JDFrame: A Semantic DataFrame Alternative

This article introduces JDFrame/SDFrame, a JVM‑level DataFrame‑style library that offers a more semantic and concise API for Java 8 streams, provides quick‑start instructions, detailed code examples, and a comprehensive overview of its SQL‑like operations such as filtering, aggregation, distinct, grouping, joining, and pagination.

BackendJDFrameJava
0 likes · 13 min read
Simplify Java Stream Processing with JDFrame: A Semantic DataFrame Alternative
macrozheng
macrozheng
Jun 10, 2025 · Backend Development

Simplify Java Stream Processing with JDFrame: A Semantic DataFrame API

This article introduces JDFrame/SDFrame, a JVM‑level DataFrame‑style library that provides semantic, chainable APIs for Java 8 streams, covering quick start, dependency setup, example use cases, and detailed API categories such as matrix view, filtering, aggregation, distinct, grouping, sorting, joining, slicing, parameter settings, percentage conversion, partitioning, row‑number generation, and data replenishment, all illustrated with concise code snippets.

JDFrameJavaSDFrame
0 likes · 16 min read
Simplify Java Stream Processing with JDFrame: A Semantic DataFrame API
Architecture Digest
Architecture Digest
Apr 15, 2025 · Backend Development

JDFrame/SDFrame Java DataFrame Library: API Guide and Usage Examples

This article introduces the JDFrame and SDFrame Java libraries that provide DataFrame‑like, semantic stream processing APIs, demonstrates how to add Maven dependencies, shows quick‑start examples, detailed CRUD, filtering, grouping, sorting, joining, pagination, and other advanced operations with full code snippets for developers.

APIJDFrameJava
0 likes · 13 min read
JDFrame/SDFrame Java DataFrame Library: API Guide and Usage Examples
Cognitive Technology Team
Cognitive Technology Team
Apr 12, 2025 · Backend Development

Using CompletableFuture with Streams for Parallel Execution in Java

The article explains how to correctly combine Java's CompletableFuture with Stream API to achieve true asynchronous parallelism, highlights common pitfalls that lead to sequential execution, and provides the proper pattern of creating a CompletableFuture stream followed by a terminal operation.

CompletableFutureJavaParallelism
0 likes · 3 min read
Using CompletableFuture with Streams for Parallel Execution in Java
Top Architecture Tech Stack
Top Architecture Tech Stack
Mar 13, 2025 · Backend Development

JDFrame/SDFrame: A JVM‑Level DataFrame‑like API for Simplified Stream Processing in Java

This article introduces JDFrame/SDFrame, a Java library that provides a DataFrame‑style, semantic API for JVM‑level stream processing, demonstrates quick start with Maven dependency, and showcases extensive examples covering filtering, aggregation, distinct, grouping, sorting, joining, partitioning, ranking, and data replenishment, helping developers write concise, readable data‑processing code.

APIJDFrameJava
0 likes · 17 min read
JDFrame/SDFrame: A JVM‑Level DataFrame‑like API for Simplified Stream Processing in Java
Sohu Tech Products
Sohu Tech Products
Mar 12, 2025 · Databases

Understanding Redis Streams: Core Commands and SpringBoot Integration

The article introduces Redis Streams as a Kafka‑like messaging structure, explains its fundamental concepts and seven core commands (XADD, XRANGE, XREAD, XGROUP CREATE, XREADGROUP, XACK, XTRIM), demonstrates integration with Spring Boot, and evaluates its fit for lightweight, low‑backlog queue scenarios.

Redis CommandsSpringBootStream
0 likes · 14 min read
Understanding Redis Streams: Core Commands and SpringBoot Integration
Java Architect Essentials
Java Architect Essentials
Mar 6, 2025 · Backend Development

When Java Streams and Lambdas Turn Into a Burden: Pitfalls and Best Practices

This article examines how the misuse of Java Stream and Lambda APIs can make code harder to read and maintain, and provides practical techniques such as proper line breaks, function extraction, careful filter logic, correct Optional usage, and cautious parallel stream adoption to keep code both elegant and efficient.

Code OptimizationJavaLambda
0 likes · 10 min read
When Java Streams and Lambdas Turn Into a Burden: Pitfalls and Best Practices
Top Architect
Top Architect
Feb 27, 2025 · Backend Development

Avoiding the Pitfalls of Java Stream and Lambda: Tips for Clean and Maintainable Code

This article examines how Java Stream and Lambda, while powerful for concise data processing, can become cumbersome when misused, and provides practical tips such as proper line breaks, function extraction, careful filter logic, safe Optional handling, and cautious use of parallel streams to keep code readable and maintainable.

Code OptimizationJavaLambda
0 likes · 10 min read
Avoiding the Pitfalls of Java Stream and Lambda: Tips for Clean and Maintainable Code
Top Architect
Top Architect
Feb 11, 2025 · Backend Development

Avoiding the Pitfalls of Java Stream and Lambda: Best Practices and Optimizations

The article examines how Java Stream and Lambda, while powerful for concise code, can become cumbersome when overused, and offers practical tips such as proper line breaks, function extraction, predicate reuse, cautious Optional handling, and mindful use of parallel streams to maintain readability and performance.

BestPracticesCodeOptimizationJava
0 likes · 11 min read
Avoiding the Pitfalls of Java Stream and Lambda: Best Practices and Optimizations
Selected Java Interview Questions
Selected Java Interview Questions
Jan 16, 2025 · Backend Development

Ten Reasons to Prefer Traditional for Loop Over Stream.forEach for List Traversal in Java

Through benchmark tests, memory analysis, and code examples, this article presents ten compelling reasons why using a traditional for loop to traverse Java Lists often outperforms Stream.forEach in terms of performance, memory usage, control flow, exception handling, mutability, debugging, readability, and state management.

BenchmarkDebuggingJava
0 likes · 16 min read
Ten Reasons to Prefer Traditional for Loop Over Stream.forEach for List Traversal in Java
ITPUB
ITPUB
Nov 22, 2024 · Backend Development

Master Java Collection Conversions with 10 Stream Utility Methods

This article presents a set of ten Java Stream‑based utility methods that simplify converting between Collection, List, Set, and Map types, showing practical examples, test cases, and reusable implementations for common data‑mapping scenarios.

CollectionConversionJava
0 likes · 11 min read
Master Java Collection Conversions with 10 Stream Utility Methods
Top Architect
Top Architect
Sep 6, 2024 · Backend Development

JDFrame/SDFrame: A JVM‑Level DataFrame API for Simplified Java Stream Processing

This article introduces JDFrame and SDFrame, two Java libraries that provide a DataFrame‑style, semantic API for simplifying stream operations, including dependency setup, quick‑start examples, matrix viewing, filtering, aggregation, deduplication, grouping, sorting, joining, pagination, window functions, and a comparison of their execution models, along with links to the source code and documentation.

APIJDFrameJava
0 likes · 18 min read
JDFrame/SDFrame: A JVM‑Level DataFrame API for Simplified Java Stream Processing
DaTaobao Tech
DaTaobao Tech
Aug 23, 2024 · Fundamentals

Common Java Pitfalls and Their Solutions

The article outlines frequent Java pitfalls—including BigDecimal precision loss, immutable lists from Arrays.asList, double division by zero returning Infinity, null values in switch statements, stream filters mutating original objects, and autoboxing nulls causing NullPointerExceptions—and provides clear explanations and practical fixes to enhance code reliability.

Arrays.asListAutoboxingBigDecimal
0 likes · 5 min read
Common Java Pitfalls and Their Solutions
macrozheng
macrozheng
Jul 11, 2024 · Backend Development

Mastering Java Stream toMap: Handling Duplicate Keys and Null Values

This article explains how to convert a list of Java objects into a Map using Stream's toMap collector, addresses duplicate key exceptions, demonstrates providing a merge function, handling null values with Optional, and compares alternative approaches such as manual loops, offering complete code examples.

CollectorsDuplicate KeyStream
0 likes · 7 min read
Mastering Java Stream toMap: Handling Duplicate Keys and Null Values
Code Ape Tech Column
Code Ape Tech Column
Jul 2, 2024 · Backend Development

How to Use Java Stream toMap with Duplicate Keys and Null Values

This article demonstrates how to convert a list of Java objects into a Map using Stream's toMap collector, addresses duplicate key exceptions by providing a merge function, handles null values with Optional, and compares stream-based solutions with traditional for-loop approaches.

DuplicateKeyJavaStream
0 likes · 6 min read
How to Use Java Stream toMap with Duplicate Keys and Null Values
Su San Talks Tech
Su San Talks Tech
Apr 14, 2024 · Backend Development

Avoid These 3 Common Pitfalls When Using Arrays.asList in Java

This article explains three hidden traps when converting arrays to lists with Arrays.asList—issues with primitive arrays, unsupported add/remove operations, and shared‑array side effects—and provides practical solutions using wrapper types, streams, or creating a new ArrayList.

ArraysBackendPitfalls
0 likes · 5 min read
Avoid These 3 Common Pitfalls When Using Arrays.asList in Java
Java Tech Enthusiast
Java Tech Enthusiast
Feb 22, 2024 · Backend Development

Common Pitfalls of Arrays.asList in Java

When converting arrays to lists in Java, Arrays.asList cannot handle primitive arrays (treating them as a single element), returns a fixed‑size view that disallows add or remove operations, and shares its backing array so modifications affect both structures, so developers should use boxed streams or copy into a new ArrayList.

Arrays.asListJavaList
0 likes · 4 min read
Common Pitfalls of Arrays.asList in Java
Architecture Digest
Architecture Digest
Jan 19, 2024 · Backend Development

Assembling Hierarchical Tree Structures with Java Streams, Caching and Message Queues

This article demonstrates how to efficiently build department and regional hierarchical trees in Java by fetching all records in a single database query, using Stream API, Lambda expressions, in‑memory grouping, Redis caching and RocketMQ for asynchronous updates, achieving sub‑second response times even with tens of thousands of nodes.

BackendJavaRocketMQ
0 likes · 11 min read
Assembling Hierarchical Tree Structures with Java Streams, Caching and Message Queues
ITPUB
ITPUB
Jan 6, 2024 · Databases

Beyond Caching: How Redis Powers Distributed Locks, Queues, and More

This article explores Redis's capabilities beyond simple caching, detailing its use for distributed locks, rate limiting, session storage, complex business scenarios, and various messaging patterns—including List‑based queues, blocking commands, Pub/Sub, and the Stream data structure—while highlighting practical limitations and best‑practice recommendations.

Message QueueStreamdistributed-lock
0 likes · 7 min read
Beyond Caching: How Redis Powers Distributed Locks, Queues, and More
IT Services Circle
IT Services Circle
Nov 20, 2023 · Databases

Redis Beyond Caching: Distributed Locks, Rate Limiting, Message Queues and More

This article explains how Redis can be used for distributed locks, rate limiting, various message‑queue patterns, delayed queues, distributed sessions and complex business scenarios, while also discussing the limitations of using Redis as a message queue and recommending dedicated solutions like RocketMQ or Kafka.

Streamdistributed-lockpub/sub
0 likes · 7 min read
Redis Beyond Caching: Distributed Locks, Rate Limiting, Message Queues and More
Architect's Tech Stack
Architect's Tech Stack
Aug 3, 2023 · Fundamentals

Performance Comparison of Different Java List Deduplication Methods

This article examines several Java deduplication techniques—including List.contains, HashSet, double-loop removal, and Stream.distinct—by providing sample code, measuring execution time on a 20,000‑element list, and analyzing their time complexities to guide developers toward efficient duplicate‑removal strategies.

CollectionsJavaStream
0 likes · 7 min read
Performance Comparison of Different Java List Deduplication Methods
Programmer DD
Programmer DD
Jun 13, 2023 · Backend Development

Why list.contains Is So Slow: Java Deduplication Performance Showdown

This article compares several Java duplicate‑removal techniques—including list.contains, HashSet, double‑loop removal, and Stream.distinct—by generating a 20 000‑element test list, measuring execution time, and explaining the underlying algorithmic complexities that make some approaches dramatically faster than others.

ListStreamdeduplication
0 likes · 7 min read
Why list.contains Is So Slow: Java Deduplication Performance Showdown
macrozheng
macrozheng
Apr 17, 2023 · Fundamentals

How to Efficiently Split Large Java Lists into Smaller Chunks

This article explains why MySQL’s SQL length limit can cause batch‑insert failures and demonstrates five practical ways to partition a large Java List—using Guava, Apache Commons, Hutool, JDK Stream, and custom subList—complete with code examples and execution results.

Apache CommonsGuavaJava
0 likes · 9 min read
How to Efficiently Split Large Java Lists into Smaller Chunks
Programmer DD
Programmer DD
Mar 14, 2023 · Backend Development

Stream.toList vs Collectors.toList: Which Java List Conversion Is Faster?

This article compares Java's Stream.toList(), Collectors.toList(), and Collectors.toUnmodifiableList() by explaining their differences, showing benchmark code, presenting performance results for both 1,000 and 10,000 element streams, and concluding which method offers superior speed and efficiency.

BenchmarkCollectorsStream
0 likes · 8 min read
Stream.toList vs Collectors.toList: Which Java List Conversion Is Faster?
Top Architect
Top Architect
Mar 9, 2023 · Backend Development

Handling NullPointerExceptions in Java: Practices, Tools, and Code Examples

This article explains common null pointer scenarios in Java, how to diagnose them using logs and Arthas, and presents defensive checks, early‑return patterns, strict validation, and Java 8 Optional usage, while also comparing Stream map and flatMap methods with practical code examples.

ArthasJavaStream
0 likes · 7 min read
Handling NullPointerExceptions in Java: Practices, Tools, and Code Examples
php Courses
php Courses
Mar 2, 2023 · Backend Development

Downloading Remote Files in PHP Using fopen and Stream

This article explains how to use PHP's fopen function and stream handling to download remote files efficiently without loading the entire file into memory, provides a complete code example, outlines important considerations, and also includes a notice for an upcoming PHP training class.

Streambackend-developmentfile-download
0 likes · 4 min read
Downloading Remote Files in PHP Using fopen and Stream
macrozheng
macrozheng
Feb 20, 2023 · Fundamentals

8 Reliable Ways to Remove Elements from a Java List (And Why Some Fail)

This article examines eight common techniques for deleting elements from a Java List, explains why certain loop‑based approaches cause errors or unexpected results, and highlights the three reliable methods—including reverse for‑loops, iterator.remove, and Stream filtering—that work correctly.

/loopCollectionConcurrentModificationException
0 likes · 9 min read
8 Reliable Ways to Remove Elements from a Java List (And Why Some Fail)
Alibaba Cloud Developer
Alibaba Cloud Developer
Nov 22, 2022 · Fundamentals

Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics

This article delves into the internal design and execution of Java 8 lambda expressions, dissecting the Stream API pipeline—from source creation through intermediate operations like map and filter to terminal actions such as collect and sum—while illustrating each step with concrete code examples.

CodeExampleJavaLambda
0 likes · 14 min read
Unveiling Java 8 Lambda: Inside the Stream Pipeline Mechanics
Sanyou's Java Diary
Sanyou's Java Diary
Nov 7, 2022 · Backend Development

Is Redis a Viable Message Queue? List, Pub/Sub, and Stream Compared

This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data types, comparing their features, performance, and limitations, and ultimately guiding readers on suitable use cases versus professional queue solutions.

Backend DevelopmentListMessage Queue
0 likes · 27 min read
Is Redis a Viable Message Queue? List, Pub/Sub, and Stream Compared
dbaplus Community
dbaplus Community
Sep 3, 2022 · Backend Development

Can Redis Streams Replace Kafka for Your Messaging Needs?

The article explains how Redis Streams offers a lightweight, memory‑based alternative to Kafka, detailing its features, consumer‑group model, performance advantages, and suitable use cases while acknowledging scenarios where a full‑featured message queue remains preferable.

BackendKafkaMessage Queue
0 likes · 7 min read
Can Redis Streams Replace Kafka for Your Messaging Needs?
Sohu Tech Products
Sohu Tech Products
Aug 24, 2022 · Backend Development

What Is Reactive Programming and Its Application in Backend Development

This article explains the fundamentals of reactive programming as a declarative, data‑stream‑based paradigm, describes its core concepts such as streams, events, and operators, and demonstrates how to replace traditional imperative Java code with RxJava‑based reactive implementations for a backend service that processes MQ messages, fetches data, and updates a cache while handling errors, request deduplication, and rate limiting.

BackendRxJavaStream
0 likes · 19 min read
What Is Reactive Programming and Its Application in Backend Development
HelloTech
HelloTech
Jul 11, 2022 · Databases

Redis Internal Data Structures: Ziplist, Skiplist, Intset, Quicklist, Zipmap, and Stream

The article explains Redis’s internal low‑level structures—ziplist, skiplist, intset, quicklist, zipmap, and stream—detailing their memory‑efficient layouts, operations, use cases, and how they combine (e.g., quicklist merging linked lists with ziplists) to deliver high performance in the in‑memory database.

Data StructuresMemory OptimizationQuicklist
0 likes · 27 min read
Redis Internal Data Structures: Ziplist, Skiplist, Intset, Quicklist, Zipmap, and Stream
FunTester
FunTester
Jul 8, 2022 · Backend Development

How to Benchmark Redis Stream Java APIs with Dynamic Threads and QPS

This article walks through designing three Redis Stream performance test cases—adding, reading, and add‑delete—using dynamic thread and dynamic QPS models in Java, provides complete Groovy‑based test code, and shows sample console output for evaluating throughput and latency.

Dynamic ThreadsJavaJedis
0 likes · 8 min read
How to Benchmark Redis Stream Java APIs with Dynamic Threads and QPS
FunTester
FunTester
Jun 10, 2022 · Databases

Using Redis Stream with Jedis: Basic Operations and Code Examples

This article introduces Redis Stream—a persistent message queue added in Redis 5.0—and demonstrates how to set up dependencies, use Java Jedis to perform core operations such as XADD, XTRIM, XDEL, XLEN, XREAD, and XRANGE, with complete code examples for each.

JavaJedisMessage Queue
0 likes · 9 min read
Using Redis Stream with Jedis: Basic Operations and Code Examples
macrozheng
macrozheng
May 31, 2022 · Backend Development

Can Redis Streams Replace Kafka? A Practical Comparison

This article compares Redis Streams with Kafka, highlighting Redis's simplicity, performance, and built‑in features like consumer groups, while discussing when each solution is appropriate for different project scales and requirements.

Backend DevelopmentKafkaStream
0 likes · 7 min read
Can Redis Streams Replace Kafka? A Practical Comparison
Java Backend Technology
Java Backend Technology
May 27, 2022 · Backend Development

Why Redis Streams Can Replace Kafka for Your Message Queue Needs

The article explains how Redis Streams, a lightweight in‑memory data structure, can serve as a low‑cost, high‑performance alternative to Kafka for many projects, outlining its features, benefits, and practical usage scenarios while acknowledging when a dedicated MQ is still preferable.

Kafka AlternativeMessage QueueStream
0 likes · 6 min read
Why Redis Streams Can Replace Kafka for Your Message Queue Needs
Youzan Coder
Youzan Coder
Mar 29, 2022 · Databases

Redis Internals: Data Structures, Skip Lists, Dictionaries, Streams, and Thread Model

The article details Redis’s internal architecture, explaining how strings use SDS structures, sorted sets rely on skip‑lists, integers are stored in compact intsets, hash tables employ incremental rehashing, ziplist and listpack provide memory‑efficient encodings, the RAX radix tree underpins key lookup and streams, and the threading model has evolved from a single‑threaded event loop to multithreaded I/O for improved concurrency.

Skip ListStreamThread Model
0 likes · 35 min read
Redis Internals: Data Structures, Skip Lists, Dictionaries, Streams, and Thread Model
Selected Java Interview Questions
Selected Java Interview Questions
Feb 19, 2022 · Backend Development

Implementing a Lightweight Redis‑Based Message Queue: Environment Setup, List, Pub/Sub, and Stream Solutions

This article details the research background, environment preparation, and three Redis‑based message‑queue implementations—using List structures, Pub/Sub, and Stream APIs—along with code examples, design considerations, testing strategies, and deployment tips for building a lightweight messaging component in Java Spring Boot.

BackendJavaMessage Queue
0 likes · 17 min read
Implementing a Lightweight Redis‑Based Message Queue: Environment Setup, List, Pub/Sub, and Stream Solutions
Code Ape Tech Column
Code Ape Tech Column
Jan 29, 2022 · Backend Development

Using IntelliJ IDEA Stream Trace to Debug Java Streams

IntelliJ IDEA's Stream Trace feature allows developers to visualize each step of Java Stream operations during debugging, showing element counts, intermediate results, and object details, with split and flat modes, demonstrated through a sample code that filters strings by length.

BackendDebuggingIntelliJ IDEA
0 likes · 3 min read
Using IntelliJ IDEA Stream Trace to Debug Java Streams
Java Backend Technology
Java Backend Technology
Dec 11, 2021 · Backend Development

Master Java 8 Streams: 20 Real‑World Examples to Boost Your Coding Efficiency

This tutorial introduces Java 8 Stream API, explains its core concepts, shows how to create streams from collections and arrays, and demonstrates 20 practical examples covering filtering, mapping, reducing, collecting, grouping, sorting and parallel processing to dramatically improve development productivity.

CollectionsFunctionalProgrammingJava
0 likes · 22 min read
Master Java 8 Streams: 20 Real‑World Examples to Boost Your Coding Efficiency
FunTester
FunTester
Nov 24, 2021 · Backend Development

Mastering Java Stream Collectors: Practical Examples and Code Walkthrough

This article provides a hands‑on guide to Java 8 Stream Collectors, demonstrating how to use toList, toSet, toCollection, toMap, summingInt, joining, groupingBy, partitioningBy and related collectors with clear code examples and output results.

BackendCollectorsDataAggregation
0 likes · 11 min read
Mastering Java Stream Collectors: Practical Examples and Code Walkthrough
MaGe Linux Operations
MaGe Linux Operations
Jul 16, 2021 · Fundamentals

Master Go’s io Package: Readers, Writers, and Stream I/O Explained

This article introduces Go's standard library io package, explains the io.Reader and io.Writer interfaces, demonstrates how to use them with built‑in types, shows how to implement custom Readers and Writers, and covers related utilities such as io.Copy, pipes, buffered I/O, and file operations.

ReaderStreamWriter
0 likes · 18 min read
Master Go’s io Package: Readers, Writers, and Stream I/O Explained
Programmer DD
Programmer DD
Jun 9, 2021 · Backend Development

Visualize Java Stream Debugging: Turn Complex Streams into Clear Views

This article shows how to use visual debugging tools to step through Java Stream operations, providing screenshots and code examples that illustrate both simple and complex stream pipelines, enabling developers to quickly understand intermediate results and troubleshoot unexpected behavior.

Stream
0 likes · 4 min read
Visualize Java Stream Debugging: Turn Complex Streams into Clear Views
Selected Java Interview Questions
Selected Java Interview Questions
May 25, 2021 · Fundamentals

Understanding and Leveraging Java Optional: Creation, Access, Default Values, Exceptions, Transformations, Filtering, and Java 9 Enhancements

This article provides a comprehensive guide to Java's Optional class, covering its purpose for avoiding NullPointerExceptions, how to create and access Optional instances, default‑value methods, exception handling, value transformation, filtering, method chaining, and new features introduced in Java 9.

JavaJava9Stream
0 likes · 13 min read
Understanding and Leveraging Java Optional: Creation, Access, Default Values, Exceptions, Transformations, Filtering, and Java 9 Enhancements
Architecture Digest
Architecture Digest
Apr 16, 2021 · Backend Development

Five Methods to Remove Duplicates from a Java ArrayList

This article presents five distinct techniques for eliminating duplicate elements from a Java ArrayList, including using LinkedHashSet, Java 8 Stream distinct, HashSet with order preservation, manual contains checks, and a double‑for‑loop approach, each accompanied by complete code examples and output results.

ArrayListCollectionsJava
0 likes · 6 min read
Five Methods to Remove Duplicates from a Java ArrayList
Tencent Music Tech Team
Tencent Music Tech Team
Mar 26, 2021 · Mobile Development

Reactive Programming and LiveData Extensions for Android Development

The article explains reactive programming fundamentals, shows why traditional OO assignments struggle with dynamic data relationships, and introduces the LiveData Extensions library that leverages MediatorLiveData to create lifecycle‑aware, chainable operators (map, filter, merge, etc.), dramatically reducing boilerplate and improving code metrics in Android apps.

AndroidKotlinLiveData
0 likes · 9 min read
Reactive Programming and LiveData Extensions for Android Development
Programmer DD
Programmer DD
Feb 19, 2021 · Backend Development

Mastering Lazy Initialization and Stream Laziness in Java 8

This article explains the difference between eager and lazy evaluation, shows when and how to use lazy initialization in Java, demonstrates Supplier‑based lazy loading, virtual proxy patterns, and stream laziness with infinite streams and prime number generation, all with concrete code examples.

JavaStreamSupplier
0 likes · 12 min read
Mastering Lazy Initialization and Stream Laziness in Java 8
Beike Product & Technology
Beike Product & Technology
Jan 31, 2021 · Mobile Development

Flutter Widget Communication and State Management: Techniques and Principles

This article explains Flutter widget communication techniques—direct value passing, function callbacks, key modification, and GlobalKey—and explores state management solutions including InheritedWidget, Stream, EventBus, Bloc, Scoped_model, Provider, and Redux for cross-widget/page communication, and discusses their underlying principles and usage scenarios.

FlutterInheritedWidgetProvider
0 likes · 9 min read
Flutter Widget Communication and State Management: Techniques and Principles
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Dec 25, 2020 · Backend Development

Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams

This article explains how Redis can be used to build lightweight, high‑performance message queues by leveraging lists for simple queues, sorted sets for delayed delivery, Pub/Sub for multicast, and the Stream data structure for durable, scalable messaging, while also covering practical PHP implementations, acknowledgment, retry, graceful restart, and rate‑limiting techniques.

Message QueuePHPPubSub
0 likes · 19 min read
Implementing Message Queues with Redis: Lists, Zsets, Pub/Sub, and Streams
Programmer DD
Programmer DD
Nov 28, 2020 · Backend Development

5 Simple Ways to Remove Duplicates from a Java ArrayList

This article demonstrates five distinct techniques for eliminating duplicate entries from a Java ArrayList, including using LinkedHashSet, Java 8 streams, HashSet with order preservation, manual contains checks, and nested loops, each accompanied by complete code examples and output results.

ArrayListCollectionsStream
0 likes · 5 min read
5 Simple Ways to Remove Duplicates from a Java ArrayList
Selected Java Interview Questions
Selected Java Interview Questions
Nov 2, 2020 · Backend Development

Java Stream API Overview and Practical Usage Examples

This article provides a comprehensive guide to Java 8 Stream API, covering its core characteristics, creation methods, essential interfaces, and common operations such as filtering, mapping, reducing, collecting, grouping, and sorting, with clear code examples for each concept.

APICollectionsFunctionalProgramming
0 likes · 23 min read
Java Stream API Overview and Practical Usage Examples
Top Architect
Top Architect
Jul 6, 2020 · Backend Development

10 Java One‑Liners Using Lambda, Stream, and Try‑with‑Resources

This article presents ten independent Java 8 one‑liner examples that demonstrate how to perform common tasks such as mapping, summing, string matching, file reading, conditional output, grouping, XML parsing, min/max calculations, parallel processing, and LINQ‑style queries using Lambda, Stream, try‑with‑resources and related APIs.

JavaLambdaOne-liner
0 likes · 7 min read
10 Java One‑Liners Using Lambda, Stream, and Try‑with‑Resources
Java Captain
Java Captain
Jan 29, 2020 · Backend Development

Understanding Java Lambda Expressions: Concepts, Usage, and Simplifications

This article explains Java Lambda expressions, covering their definition as functional interface implementations, how they enable assigning code blocks to variables, their advantages over traditional anonymous classes, and step‑by‑step simplifications using built‑in functional interfaces, streams, method references, and Optional for cleaner, more expressive backend code.

FunctionalInterfaceJavaLambda
0 likes · 6 min read
Understanding Java Lambda Expressions: Concepts, Usage, and Simplifications
Programmer DD
Programmer DD
Oct 26, 2019 · Backend Development

Java Stream vs For Loop: Which Is Faster? A Performance Benchmark

This article benchmarks Java 8 Stream against traditional for‑loops across primitive, object, and complex‑object scenarios, revealing that while for‑loops excel on simple primitive tasks, parallel Stream often outperforms both sequential Stream and loops, especially on multi‑core systems.

BenchmarkCollectionsJava
0 likes · 8 min read
Java Stream vs For Loop: Which Is Faster? A Performance Benchmark
Senior Brother's Insights
Senior Brother's Insights
Oct 13, 2019 · Fundamentals

Master Java 8 Lambda Expressions: From Anonymous Classes to Functional Interfaces

This guide explains Java 8’s Lambda expressions, covering their purpose, syntax, functional interfaces, method references, and practical examples such as thread creation, event handling, collection processing, and Stream API usage, while comparing them to traditional anonymous classes and highlighting compilation differences.

Functional InterfaceJavaLambda
0 likes · 13 min read
Master Java 8 Lambda Expressions: From Anonymous Classes to Functional Interfaces
Architecture Digest
Architecture Digest
Sep 6, 2019 · Backend Development

Designing a Scalable Feed Stream System Architecture

This article explains the fundamentals, data model, storage options, synchronization strategies, metadata handling, and scaling considerations for building a high‑performance feed‑stream system used in social platforms such as micro‑blogs, friend circles, and short‑video feeds.

ScalabilityStreamSynchronization
0 likes · 19 min read
Designing a Scalable Feed Stream System Architecture
FunTester
FunTester
Aug 8, 2019 · Fundamentals

ConsoleTable: A Simple Java Utility for Formatted Console Grid Output

This article introduces a lightweight Java class, ConsoleTable, that formats map and list data into a neatly aligned console grid resembling SQL client output, explains its usage, provides full source code, and discusses stream-based implementations and potential enhancements.

CLIJavaStream
0 likes · 5 min read
ConsoleTable: A Simple Java Utility for Formatted Console Grid Output
FunTester
FunTester
Jul 13, 2019 · Backend Development

How to Build an SQL‑Style Console Table Utility in Java

The article presents a Java ConsoleTable class that formats Map and List data into a tidy, SQL‑client‑like grid for console output, explains its implementation details, shows usage examples, and discusses the use of Java Stream APIs.

DebuggingJavaStream
0 likes · 5 min read
How to Build an SQL‑Style Console Table Utility in Java
Java Captain
Java Captain
Apr 20, 2019 · Fundamentals

Understanding Java Lambda Expressions, Functional Interfaces, Streams, and Optional

This article explains how Java 8 lambda expressions let you assign blocks of code to variables, how they are tied to functional interfaces, and demonstrates step‑by‑step simplifications using built‑in functional interfaces, forEach, stream(), method references, and Optional for elegant null handling.

Functional InterfaceJavaJava 8
0 likes · 6 min read
Understanding Java Lambda Expressions, Functional Interfaces, Streams, and Optional
Node Underground
Node Underground
Nov 29, 2018 · Backend Development

Boost Node.js Performance: 8 Proven Techniques for Faster Apps

This article presents eight practical strategies—including upgrading Node.js, leveraging fast-json-stringify, optimizing promises, tuning V8 GC, using streams correctly, and employing node‑clinic tools—to dramatically improve the performance and scalability of Node.js applications.

BenchmarkJSONNode.js
0 likes · 21 min read
Boost Node.js Performance: 8 Proven Techniques for Faster Apps
Java Captain
Java Captain
Aug 19, 2018 · Fundamentals

Performance Comparison of Java forEach, C‑Style Loop, and Stream API

This article examines Java's forEach syntax, C‑style for loops, and Stream API by benchmarking their execution times on large collections, explaining the underlying mechanisms that cause performance differences and identifying the most efficient traversal method for Sets.

/loopBenchmarkingStream
0 likes · 7 min read
Performance Comparison of Java forEach, C‑Style Loop, and Stream API
Meituan Technology Team
Meituan Technology Team
Jul 15, 2016 · Backend Development

Understanding Node.js Stream API: Types, Back‑Pressure, and Object Mode

The article explains Node.js’s Stream API by detailing the four core stream classes—Readable, Writable, Duplex, and Transform—showing how to implement them, manage back‑pressure, enable objectMode, and apply these concepts in real‑world tools like Gulp, Browserify, and a Git‑changelog generator.

DuplexNode.jsObjectMode
0 likes · 6 min read
Understanding Node.js Stream API: Types, Back‑Pressure, and Object Mode
Meituan Technology Team
Meituan Technology Team
Jul 15, 2016 · Backend Development

Node.js Stream Internals: Data Production, Consumption, and Back‑pressure

The article explains Node.js stream internals, showing how readable, writable, and transform streams manage data production and consumption, the roles of _read, read, push, and doRead, the two operating modes, and how pipe implements back‑pressure via high‑water marks to ensure memory‑safe, efficient processing.

Node.jsPipeStream
0 likes · 22 min read
Node.js Stream Internals: Data Production, Consumption, and Back‑pressure