Tagged articles
Java 8
89 articles · Page 1 of 1
This article shows how to eliminate repetitive database validation code by creating generic reusable methods using Java 8 functional interfaces and MyBatis Plus SFunction, demonstrating ensureColumnValueValid, validateColumnValueMatchesExpected, and validateColumnValueInExpectedList with before-and-after comparisons.
Functional InterfacesGenericsJava 8
0 likes · 14 min read

This tutorial explains how to install Java 7 and Java 8 on Windows, configure version-specific environment variables (JAVA_HOME7, JAVA_HOME8), set classpath and PATH dynamically, remove system Java executables, and verify the active JDK version using the command line.
JDKJavaJava 7
0 likes · 3 min read

This tutorial demonstrates Java Stream API for filtering and extracting collection data, covering stream creation from Lists, Sets, Maps, and arrays, key operations like filter, limit, skip, concat, distinct, and collecting results into List, Set, or Map with practical code examples.
JavaJava 8LINQ
0 likes · 13 min read

This article explains how Java 8's computeIfAbsent reduces HashMap grouping from three separate lookups (containsKey, put, get) to a single atomic operation, covering lazy evaluation, concurrency safeguards, null handling, nested grouping patterns, and when to prefer computeIfAbsent over Collectors.groupingBy for streaming data.
HashMapJava 8Map methods
0 likes · 7 min read

From its near‑death as the Oak set‑top‑box experiment, through a frantic code rewrite three days before the 1995 launch and a protracted legal fight with Microsoft, Java evolved into a cross‑platform powerhouse, later open‑sourced, modernized under Oracle, and now underpins billions of devices.
HotJavaJavaJava 8
0 likes · 18 min read

The article explains how Java 8 added default and static methods to interfaces—allowing method bodies, enabling backward‑compatible extensions, illustrating usage with code examples, handling multiple‑interface conflicts, and introducing Java 9 private methods, while summarizing common pitfalls and best‑practice guidelines.
JavaJava 8default method
0 likes · 9 min read

Java's String class is immutable and stored in a constant pool; the article explains the difference between == and equals, demonstrates common methods for inspection, transformation, splitting, and conversion, and shows best practices for concatenation with StringBuilder, thread‑safe StringBuffer, and newer utilities like join, repeat, format, and text blocks.
Equals vs ==JavaJava 8
0 likes · 10 min read

StampedLock, introduced in Java 8, provides three lock modes—including an optimistic read that uses a 64‑bit stamp—to achieve higher throughput than ReentrantReadWriteLock in read‑heavy workloads, and the article explains its internal state, usage patterns, code examples, and important limitations.
Java 8Java ConcurrencyReentrantReadWriteLock
0 likes · 7 min read

This article introduces a ServiceManager component that uses Lambda expressions to automatically inject services, handle logging, cache service metadata, and manage exceptions, allowing Spring Boot controllers to call service methods with a single line of code.
CacheException HandlingJava 8
0 likes · 15 min read

This comprehensive guide walks you through the evolution of Java from version 8 to 24, highlighting key language enhancements, new APIs, and performance improvements such as lambda expressions, Stream API, records, sealed classes, virtual threads, and the latest features that modernize Java development for today’s programmers.
JavaJava 8Records
0 likes · 46 min read

This article explains how LocalDateTime and DateTimeFormatter work together to represent, format, parse, and manipulate date‑time values in Java, covering creation methods, component extraction, arithmetic, custom patterns, timezone conversion, common pitfalls, and practical use cases with concrete code examples.
DateTimeFormatterJavaJava 8
0 likes · 13 min read

IDEA no longer offers Java 8 when creating Spring Boot projects because it relies on Spring Initializr, which now only supports Spring Boot 3.x and Java 17+, but you can still generate Java 8‑compatible projects by switching to alternative starter services like Alibaba Cloud’s start.aliyun.com.
Alibaba CloudIntelliJ IDEAJava 17
0 likes · 8 min read

This article introduces Java 8 Stream API, explains its core operations such as filter, map, sorted, forEach, collect, statistics, and parallelStream, and demonstrates their usage with a UserPo class through comprehensive code examples, while also noting unrelated promotional offers.
Code ExampleJavaJava 8
0 likes · 11 min read

This article explains how to log pre‑update data, compare old and new records, and use Java Stream operations such as filter, collect, anyMatch, noneMatch, and contains to identify differences between collections, including custom objects, with code examples and best‑practice recommendations.
Collection ComparisonJavaJava 8
0 likes · 13 min read

This article explores common pitfalls in Java date handling—such as non‑thread‑safe formatting and daylight‑saving‑time errors—and presents robust solutions using ThreadLocal, the Java 8 Date/Time API, zone‑aware calculations, caching, and global interceptor patterns to ensure correct, high‑performance time processing in backend systems.
BackendJava 8date-formatting
0 likes · 7 min read

This article introduces Java 8 Stream API, demonstrates filtering, mapping, sorting, collecting, and parallel streams with POJO examples, including code snippets, performance tips, and links to related resources, while also containing promotional messages for ChatGPT services.
JavaJava 8Stream API
0 likes · 11 min read

This article introduces Java 8's Stream API, explains how to create streams from collections and arrays, and demonstrates a wide range of intermediate and terminal operations with clear code examples to help developers write concise, efficient, and readable Java code.
JavaJava 8Stream API
0 likes · 9 min read

This article introduces Java 8's Stream API, explains its declarative data‑processing style with operations such as filter, map, sorted, forEach, collect, statistics and parallelStream, and provides complete example code demonstrating these concepts on a UserPo class.
Code ExampleJavaJava 8
0 likes · 12 min read

This article demonstrates how Java 8’s functional interfaces—such as Supplier, Consumer, Runnable, and Function—can replace repetitive if‑else statements for exception handling and branch logic, providing clear code examples, custom interfaces, and utility methods to simplify backend development.
BackendException HandlingFunctional Interface
0 likes · 9 min read

This article explains the core principles of Java Stream, covering its three main characteristics, pipeline construction, intermediate and terminal operations with code examples, and how lazy execution and sink generation produce results only when a terminal operation is invoked.
Java 8Stream APIbackend development
0 likes · 10 min read

This article explains why the legacy java.util.Date and Calendar APIs are problematic, demonstrates common bugs such as integer overflow, year‑format issues, and SimpleDateFormat thread‑safety, and shows how Java 8's immutable java.time classes like LocalDate, LocalDateTime and DateTimeFormatter provide clear, safe, and concise solutions with practical code examples.
DATETIMEJavaJava 8
0 likes · 21 min read

This article introduces eight ready‑to‑use Java Stream APIs—including Stream.ofNullable, Stream.iterate, collectingAndThen, dropWhile/takeWhile, IntStream, teeing, concat, and partitioningBy—showing how each can cleanly handle nulls, generate sequences, transform collections, and combine streams with concise code examples.
JavaJava 12Java 8
0 likes · 7 min read

Java 8’s Stream API introduces a declarative, lazy-processing model for collections, and this article details multiple ways to create streams—including from collections, arrays, static factory methods, files, generators, and iterators—providing code examples and explanations to help developers harness its expressive and efficient data‑handling capabilities.
JavaJava 8Stream API
0 likes · 5 min read

The article offers a thorough overview of Java 8 memory management, detailing JVM memory regions, object eligibility, major garbage‑collection algorithms and generational models, comparing Serial, Parallel, CMS and G1 collectors, and presenting practical heap‑dump analysis techniques for diagnosing leaks and performance issues.
GC algorithmsHeap AnalysisJVM
0 likes · 29 min read

This article introduces Java 8 Stream API, explains how to create streams from collections, demonstrates common intermediate operations such as filter, map, flatMap, limit, skip, distinct, sorted, peek, and shows terminal actions like forEach, count, max, min, findFirst, findAny, and match methods with practical code examples.
Intermediate OperationsJavaJava 8
0 likes · 17 min read

The article explains that Spring Boot 3.x drops support for Java 8, causing IntelliJ IDEA’s Spring Initializr to list only JDK 17 or higher, and shows how developers can still create Java 8 Spring Boot projects by switching the Initializr URL to Alibaba Cloud’s start service.
Alibaba StartIntelliJ IDEAJava 8
0 likes · 3 min read

This article explains why iterating a Java HashMap with keySet() results in two traversals, detailing the internal iterator creation, the role of KeyIterator and HashIterator classes, and how the do‑while loop in HashIterator’s constructor locates the first entry, with code examples and bytecode analysis.
HashIteratorHashMapJava
0 likes · 9 min read

This article reviews the most popular Java enhancements introduced since Java 8, covering local variable type inference, switch expressions, text blocks, records, pattern‑matching instanceof, sealed classes, and helpful NullPointerException messages, with examples and migration tips.
Java 8New Language FeaturesProgramming Guide
0 likes · 6 min read

This article reviews the most widely adopted Java language enhancements introduced after Java 8, covering features such as local variable type inference, switch expressions, text blocks, records, pattern matching for instanceof, sealed classes, and improved NullPointerException messages, helping developers decide which upgrades to adopt.
BackendJavaJava 8
0 likes · 6 min read

The article explains how to dramatically reduce the response time of an API that must call multiple downstream services by converting serial calls into parallel ones using Java 8's CompletableFuture, covering its relationship to Future, core APIs, task composition, exception handling, and practical best‑practice recommendations.
Asynchronous ProgrammingCompletableFutureConcurrency
0 likes · 20 min read

This tutorial explains Java 8's CompletableFuture, showing how to create, compose, and handle asynchronous tasks with methods like supplyAsync, thenApply, allOf, and anyOf, while emphasizing custom thread pools, non‑blocking patterns, and robust exception handling for real‑world concurrent programming.
Asynchronous ProgrammingCompletableFutureException Handling
0 likes · 17 min read

This comprehensive Java 8 Stream tutorial explains how Stream and Lambda simplify collection processing, walks through creating streams, intermediate and terminal operations, and provides twenty practical code examples covering filtering, aggregation, mapping, collecting, grouping, sorting, and parallel execution.
JavaJava 8Stream API
0 likes · 23 min read

This comprehensive tutorial explains Java 8's Stream API and Lambda expressions, demonstrating how to create streams from collections and arrays, perform intermediate operations like filter, map, flatMap, and sorted, and use terminal operations such as forEach, findFirst, reduce, and collect through twenty detailed code examples covering employee data processing, aggregation, grouping, and sorting.
JavaJava 8Stream API
0 likes · 21 min read

This article demonstrates four Java 8 Stream API techniques for comparing two List collections and retrieving the elements that differ, including simple filtering, concatenation, grouping by occurrence, and attribute‑based comparison with custom DTOs.
JavaJava 8List comparison
0 likes · 7 min read

An in‑depth comparison of Java 17 and Java 8 highlights new language features such as sealed classes, pattern‑matching switch, records, enhanced garbage collectors, JIT improvements, and updated collection APIs, while providing performance insights and runnable code examples to help developers choose the right version for modern applications.
Code ExamplesJavaJava 17
0 likes · 13 min read

This article demonstrates how to use Java 8’s java.time package to obtain the current date and time, extract components, create specific dates, compare dates, handle periodic dates, compute future and past dates, retrieve timestamps, check leap years, calculate differences, and format/parse date strings, with concrete code examples.
DATETIMEINSTANTJava
0 likes · 10 min read

This article explains Java functional interfaces, the java.util.function package, and provides an in‑depth look at the internal structure of the Stream API, including pipelines, intermediate and terminal operations, collectors, and the parallel execution model based on ForkJoin tasks.
Functional InterfacesJava 8Parallel Streams
0 likes · 23 min read

This article provides an in‑depth tutorial on Java 8 Stream operations—including creation, intermediate and terminal operations, parallel streams, reduction, collection, and conversion—followed by a detailed explanation of the Optional class with examples of creation, presence checks, default values, filtering, mapping, and practical usage patterns.
Java 8OptionalStream API
0 likes · 17 min read

The article introduces Java 8’s Stream API, showing how to create streams from collections, arrays, and static methods, and demonstrates common operations such as filter, map, flatMap, reduce, collect, grouping, sorting, and limiting, with concrete code examples that replace verbose loops and improve readability.
JavaJava 8Stream API
0 likes · 9 min read

Java SE 7 will lose extended support in July 2022, moving to sustaining support with no patches or security fixes, while Oracle recommends upgrading to supported long‑term versions like Java 8, 11, or 17 to stay secure and up‑to‑date.
End-of-LifeJavaJava 11
0 likes · 4 min read

This article explains Java 8 Stream fundamentals, compares intermediate and terminal operations, outlines its advantages over collections, and presents benchmark results showing when streams outperform iterator loops, especially with large data sets and parallel execution.
Java 8Java Streamiterator
0 likes · 12 min read

This article explains how to migrate from the deprecated Spring Security OAuth to Spring Authorization Server, covering Java 8 compatibility, extended grant types, Redis token storage, token formatting enhancements, custom authorization code handling, and resource server improvements, all demonstrated on the PIG microservice platform.
Java 8OAuth2authorization-server
0 likes · 6 min read

This article explains the difference between Java's Stream.toList() introduced in Java 16, which returns an unmodifiable list, and the traditional Collectors.toList() used in Java 8 that produces a mutable list, and shows how to achieve immutability across versions.
CollectorsImmutable ListJava
0 likes · 5 min read

This guide explains why Java Stream debugging can be challenging, introduces the built‑in Java Stream Debugger plugin for IntelliJ IDEA, and walks through a sample code snippet showing how to visualize each pipeline step to quickly identify issues.
IntelliJ IDEAJavaJava 8
0 likes · 4 min read

This article explains Java 8 Stream API concepts, showing how to filter, sort, map, and group collections with concise lambda expressions and functional operations, providing before‑and‑after code examples that reduce boilerplate and improve readability for common data‑processing tasks.
Code ExamplesJavaJava 8
0 likes · 14 min read

This article explains how Java 8 functional interfaces such as Function, Supplier, Consumer, and Runnable can be used to eliminate cluttered if‑else statements, showing practical examples for exception handling, branch processing, and null‑value handling with concise lambda‑based code.
BackendFunctional InterfaceJava
0 likes · 7 min read

This article explains how Java 8's functional interfaces such as Supplier, Consumer, Runnable and Function can be used to eliminate repetitive if…else code for exception handling and branching, providing clear examples and reusable utility methods.
Functional InterfaceJavaJava 8
0 likes · 8 min read


JavaEdgeOct 13, 2021 · Backend Development
The article examines how varied naming conventions and outdated coding practices in Java backend projects cause confusion, illustrates the problem with real code examples, and provides concrete refactoring steps—such as adopting Java 8 date‑time APIs and enforcing consistent service naming—to improve maintainability and team cohesion.
Best PracticesJavaJava 8
0 likes · 6 min read

This article introduces Java 8's new date‑time API, explains why the old java.util.Date and SimpleDateFormat were problematic, and provides eleven practical code examples that demonstrate how to obtain the current date, extract year/month/day, create specific dates, compare dates, work with time zones, and format or parse date strings.
DATETIMEJava 8code-examples
0 likes · 11 min read

This article explains Java 1.8 ConcurrentHashMap’s default capacity, null‑key/value restrictions, resizing behavior, internal array‑list‑tree structure, node fields, put and get processes, thread‑safety mechanisms, iterator consistency, and differences between JDK 7 and JDK 8 implementations.
ConcurrentHashMapJavaJava 8
0 likes · 9 min read

This tutorial walks through Java 8 Stream and Lambda features, explaining stream concepts, intermediate and terminal operations, and demonstrating twenty practical examples—including creation, filtering, mapping, reduction, collection, sorting, and combining—using an employee class to illustrate each operation.
JavaJava 8Stream API
0 likes · 27 min read

This article showcases an abstract Java 8 code snippet that tests developers' mastery of the language's advanced features, explains why such convoluted code is rarely used, and invites readers to share how long it took them to understand it.
BackendJavaJava 8
0 likes · 2 min read

This article provides an in‑depth tutorial on Java 8 Stream API, covering its concepts, creation methods, common operations such as filtering, mapping, reducing, collecting, sorting, and grouping, along with numerous runnable code examples that demonstrate how to process collections efficiently using streams.
JavaJava 8Stream API
0 likes · 24 min read

This article provides an in‑depth tutorial on Java 8 Stream API, covering creation, intermediate and terminal operations, filtering, mapping, reducing, collecting, grouping, sorting, and practical code examples for processing collections such as employee data.
JavaJava 8Programming Tutorial
0 likes · 21 min read

Learn how Java 8’s Optional class helps prevent NullPointerExceptions by providing a functional, expressive way to handle nullable values, covering creation, retrieval, default handling, exception throwing, transformation, filtering, chaining, and new Java 9 enhancements with practical code examples.
JavaJava 8NullPointerException
0 likes · 15 min read

This article explains Java 8's Stream API, showing how to replace verbose pre‑Java‑8 collection processing with concise, declarative stream operations, covering stream creation, intermediate and terminal operations, and practical examples such as filtering, sorting, mapping, grouping, and aggregation.
JavaJava 8Stream API
0 likes · 15 min read

This article introduces Java 8's new date‑time API, explains its advantages over the old java.util.Date and SimpleDateFormat, lists the essential classes such as Instant, LocalDate, LocalTime, ZonedDateTime, and provides step‑by‑step code examples for common operations like getting the current date, manipulating specific dates, handling time zones, and formatting.
INSTANTJavaJava 8
0 likes · 20 min read

This article shares practical Java 8 tips, covering how to use Optional responsibly, write concise and clear lambda expressions, design functional interfaces, and leverage the Stream API with debugging tricks, while warning about common pitfalls and performance considerations.
Best PracticesJavaJava 8
0 likes · 11 min read

This article explains how to use IntelliJ IDEA's Live Templates to create shortcuts for common Java Stream collectors, reducing repetitive code and improving productivity when working with lambda expressions and the Stream API.
IntelliJ IDEAJavaJava 8
0 likes · 6 min read

This article explains what a Java interface really is, how it serves as a communication protocol between modules, and demonstrates the concepts with a complete computer‑assembly example, covering interface definitions, implementations, default methods, static methods, and conflict‑resolution rules introduced in Java 8.
Default MethodsJavaJava 8
0 likes · 15 min read

This guide explains why Spring Boot's automatic parameter binding can fail, compares deprecated WebMvcConfigurerAdapter, WebMvcConfigurationSupport, and @EnableWebMvc approaches, and shows how to safely customize MVC settings using the WebMvcConfigurer interface.
ConfigurationJava 8MVC Customization
0 likes · 14 min read

This article explains Java lambda expressions (closures) introduced in Java 8, their concise syntax and optional features, demonstrates functional interfaces and practical code examples, and analyzes the generated bytecode and LambdaMetafactory mechanism that underlies their runtime behavior.
Functional InterfaceJavaJava 8
0 likes · 9 min read

This article explains Java's method reference feature, covering its four types, practical code examples for static methods, instance methods, constructors, and highlighting limitations compared to lambda expressions, helping developers write more readable and concise Java 8 code.
JavaJava 8Method References
0 likes · 7 min read

This article explains how Java 8’s StringJoiner simplifies concatenating delimited strings compared to StringBuilder/StringBuffer, covering basic usage, constructors, methods, prefix/suffix handling, empty value configuration, stream‑style chaining, and the related String.join() API with practical code examples.
JavaJava 8String
0 likes · 7 min read

This article explains the hidden traps of Java's SimpleDateFormat—such as confusing 'y' and 'Y', week‑year calculations, and thread‑safety issues—demonstrates failures with multithreaded parsing, and shows how to replace it with the modern, thread‑safe DateTimeFormatter, including practical code examples and conversion tips.
DateTimeFormatterJavaJava 8
0 likes · 10 min read

This article introduces Java 8’s key functional programming features—lambda expressions, functional interfaces, and the Stream API—explaining concepts such as lazy and eager evaluation, and demonstrating common operations like filter, map, flatMap, collect, reduce, and grouping with clear code examples.
CollectorsFunctional InterfacesJava 8
0 likes · 15 min read

This article introduces Java 8's method reference syntax and the Optional class, explaining static, instance, and constructor references, demonstrating their use with functional interfaces such as Function and BiFunction, and providing practical code examples to write more concise and null‑safe Java code.
Functional InterfacesJavaJava 8
0 likes · 8 min read

This article explains Java 8's method reference syntax—including static, instance, and constructor references—shows how to assign them to functional interfaces, introduces the Optional class for null‑safe programming, and demonstrates the static‑factory‑method (of) pattern with clear code examples.
Functional InterfacesJava 8Method References
0 likes · 8 min read

This article explains Java 8’s Map.merge() method, demonstrating how to replace traditional looping logic with concise functional code to aggregate student scores, includes full code examples, compares it with conventional approaches, and discusses related map methods and practical use cases.
Java 8Map.mergefunctional programming
0 likes · 6 min read

This article introduces Java 8’s powerful new features—including the Stream API, lambda expressions, and default methods—showing how they simplify code such as sorting collections, improve multithreaded performance, and help developers write more concise, efficient Java applications.
JavaJava 8Stream API
0 likes · 8 min read

This article explains how to streamline Java 8 Stream operations by creating IntelliJ IDEA live templates for common collectors like toList, toSet, joining, and groupingBy, reducing repetitive code and improving developer productivity.
IntelliJ IDEAJavaJava 8
0 likes · 8 min read

An extensive guide to Java 8’s new capabilities, covering lambda expressions, functional interfaces, streams, default methods, Optional, CompletableFuture, the new date‑time API, concurrency enhancements, and numerous language and library improvements, with detailed explanations and code examples.
CompletableFutureConcurrencyFunctional Interfaces
0 likes · 51 min read

Version 2.x of the Mica library, built on Java 8 and Spring Boot 2.2.x, introduces extensive optimizations, upgraded dependencies on Spring 5.x, Spring Boot 2.1.x, and Spring Cloud Greenwich, along with numerous bug fixes, documentation updates, and enhanced components such as mica-http and mica-boot.
Java 8Spring Cloudmica
0 likes · 4 min read

This article explains Java 8 interface default methods, demonstrates why the provided code fails to compile due to accessing a non‑existent instance field, and clarifies how adding fields to an interface affects compilation, concluding that option A is the correct answer.
Default MethodsJavaJava 8
0 likes · 5 min read

This article explains Java 8 Lambda expressions, functional interfaces, and how they enable concise code through streams, method references, and Optional for elegant null handling, providing step‑by‑step examples and visual illustrations to help developers modernize their Java code.
Functional InterfaceJavaJava 8
0 likes · 7 min read

This article introduces Java 8's Stream API, explains why functional streams improve code readability and performance, and provides detailed examples of common operations such as filter, map, flatMap, reduce, collect, Optional handling, parallel processing, and debugging techniques for efficient data processing.
JavaJava 8Stream API
0 likes · 16 min read

This tutorial explains how Java 8's Stream API's map and flatMap operations work, showing practical examples of extracting student ages from collections and demonstrating why flatMap is needed to flatten nested lists, with clear code snippets and diagrams.
BackendJavaJava 8
0 likes · 4 min read

This article explains the Java 8 Stream API's skip() and limit() intermediate operations, showing how they truncate streams, handling of edge cases, code examples, and key differences to help developers choose the right method for their data processing needs.
BackendJavaJava 8
0 likes · 4 min read

This article introduces Java 8 Stream API, explains its core concepts, shows how to generate streams, details intermediate and terminal operations with practical code examples, and provides a visual overview of the Stream hierarchy for developers seeking to write concise and efficient Java code.
JavaJava 8Stream API
0 likes · 16 min read


21CTOOct 23, 2019 · Mobile Development
This article explains the principles behind Java 8 lambda expressions and the invokedynamic bytecode instruction, then examines how Android indirectly supports these features through tools like RetroLambda, Jack & Jill, and the D8 dex compiler, detailing their desugaring processes and limitations.
AndroidD8Desugar
0 likes · 16 min read

The article explains how Java 8 lambda expressions rely on the invokedynamic bytecode instruction, and how Android compensates for its absence by desugaring lambdas through RetroLambda, the now‑deprecated Jack & Jill toolchain, and the modern D8 compiler, each generating synthetic classes for runtime execution.
AndroidD8Desugar
0 likes · 14 min read

This article introduces Java 8's lambda expressions and functional interfaces, demonstrates custom functional interfaces, and explains how to use the Stream API with lazy and eager evaluation for operations such as collect, filter, map, flatMap, max/min, count, reduce, and various collectors.
Functional InterfacesJavaJava 8
0 likes · 14 min read

This article introduces Java 8's Stream API, explains core concepts like streams, sources, and aggregation operations, and demonstrates common methods such as filter, map, limit, count, sorted, skip, and collect with practical code examples that build hierarchical permission trees.
BackendJavaJava 8
0 likes · 8 min read

This article introduces Java 8’s Stream API, explaining its purpose, key characteristics, how to create streams from collections or directly, and demonstrating common intermediate operations such as filter, map, limit, sorted, distinct, as well as terminal operations like forEach, count, and collect, with code examples.
Intermediate OperationsJavaJava 8
0 likes · 9 min read

This article introduces Java 8's Stream API, explains why functional streams improve code readability and performance, and walks through core operations such as filter, map, flatMap, reduce, collect, Optional handling, concurrency, and debugging techniques with clear examples and illustrations.
JavaJava 8Stream API
0 likes · 7 min read

This tutorial demonstrates how to configure Spring MVC in a Java web project by modifying web.xml, creating DispatcherServlet, implementing controllers and DTOs, setting up JSP pages with Bootstrap, handling JSTL date formatting using custom tags for Java 8 LocalDateTime, and integrating modular JavaScript for a seckill (flash sale) application.
JSPJSTLJava 8
0 likes · 17 min read

This guide walks C programmers through transitioning to Java, covering why Java is approachable, essential tools, coding standards, exception handling, core SDK libraries, object‑oriented fundamentals, and advanced topics like Effective Java, SOLID principles, design patterns, and functional programming with Java 8.
JavaJava 8c-programming
0 likes · 7 min read

Throughout 2014 Java cemented its status as a versatile, widely adopted language, highlighted by RedMonk’s popularity ranking, the Java 8 release with lambdas, Nashorn, and new Date/Time API, ARM64 support, a revitalized JCP, expanding OpenJDK membership, and growing community initiatives.
JavaJava 8OpenJDK
0 likes · 8 min read


ITPUBApr 15, 2014 · Backend Development
In this interview a veteran full‑stack engineer shares his career path, explains Java 8’s key features such as lambda expressions and JavaFX enhancements, offers practical advice for programmers, and discusses the complementary roles of NoSQL and relational databases, highlighting MongoDB’s strengths.
Java 8Lambda ExpressionsMongoDB
0 likes · 9 min read
