This article shares a step‑by‑step troubleshooting guide for IntelliJ IDEA performance issues, covering vmoptions adjustments, disabling inspections, removing unused plugins, selecting the proper JDK version, and fixing a problematic infinite loop in Java code to reduce CPU consumption.
This roundup covers recent Java ecosystem developments, including the promotion of the Value Objects (Preview) JEP to candidate status, release notes for JDK 18 and early‑access JDK 19 builds, multiple Spring project updates such as Spring Boot 2.7.0‑M1, Spring Data 3.0‑M2 with ListCrudRepository, Spring Security enhancements, as well as Quarkus 2.7.2.Final and a new early‑access version of JReleaser adding Windows resources to jpackage.
This article explains how to modify Spring's @Async annotation so that its value attribute can resolve placeholders or SpEL expressions, demonstrates a working demo, shows the required code changes using EmbeddedValueResolver, and shares debugging tricks and related Java language features.
This article explains Java HashMap's internal structure, including the array‑linked list and red‑black tree design, load factor, collision resolution methods, resizing process, key selection, thread‑safety concerns, and the hash calculation algorithm, providing detailed insights for developers.
This article demonstrates how to use the JDK’s native command‑line and graphical utilities—such as jps, jinfo, jvisualvm, jconsole, jstat, jstack and jcmd—to observe JVM metrics, troubleshoot memory and thread issues, and verify JVM parameters in Java applications.
Recent Java news highlights early‑access builds of JDK 18 and JDK 19, the 2022 Java roadmap, Spring Framework 5.3.15 and 6.0.0‑M2 releases, Spring Data milestones, Quarkus 2.6.2.Final, Micronaut 3.2.5/3.2.6, Piranha 22.1.0, JobRunr 4.0.6, Eclipse Jifa, Micrometer 2.0.0‑M1 and Tracing 1.0.0‑M1, plus the Foojay mid‑year status report.
This article provides concise English explanations for 33 common Java interview questions, covering the differences between JDK/JRE/JVM, the main method signature, OOP principles, memory management, access modifiers, collections, and many other core Java concepts.
This article explains what Java annotations are, how to define custom annotations, the built‑in meta‑annotations, annotation attributes, common built‑in annotations, and practical usage scenarios, providing code examples and runtime reflection details for developers.
This article examines Java's Random performance limitations, explains how ThreadLocalRandom leverages the Unsafe class for per‑thread seed management, analyzes the underlying native methods, discusses safety concerns and memory layout, and shares practical code examples and insights for high‑concurrency applications.
The article demystifies Java’s Arrays.sort by tracing its call to TimSort.sort, explaining how the hybrid Timsort algorithm blends merge and insertion sorts, determines minimum run lengths, partitions and merges runs, addresses implementation bugs such as stack allocation and comparator misuse, and celebrates its elegant, efficient design.
This article presents five common Java String interview questions, explains the output of each code snippet, analyzes the behavior of the == operator and equals method, and illustrates memory allocation in the string constant pool and heap with diagrams and detailed explanations.
This article compiles a comprehensive list of frequently asked Java interview questions, covering topics such as the relationship between JDK/JRE/JVM, object creation methods, differences between == and equals, hashCode, String variants, synchronization mechanisms, lock implementations, collections, concurrency utilities, thread pools, and I/O models, providing concise explanations for each.
The article walks through five common Java String interview questions, providing code snippets, execution results, and in‑depth analysis of reference equality, object creation in the constant pool, and the impact of the '+' operator, illustrated with memory diagrams to clarify each answer.
This tutorial explains Java's proxy design pattern, bytecode manipulation, static proxies using AspectJ and JDK, dynamic proxies with JDK and CGLIB, and demonstrates how Spring AOP selects between these mechanisms, providing complete code examples for each approach.
The article clarifies that the modCount field in java.util.HashMap is used to implement the fail‑fast iterator behavior, explains why the field was volatile in early JDK versions but not in later ones, and shows that ConcurrentModificationException can be thrown even in single‑threaded scenarios when the iterator detects structural changes.
This article provides a comprehensive overview of Java versions 11 through 17, highlighting major language enhancements, new garbage collectors, security updates, preview features, and tooling improvements that developers can leverage to write more efficient, secure, and modern Java applications.
This article explains why Spring AOP proxies are not applied when a bean invokes its own methods via the this reference, compares JDK and CGLIB proxy mechanisms, and shows how to enable proxy exposure or use AopContext to achieve the desired AOP behavior.
This article explains Java 17’s new long‑term‑support release, Oracle’s free JDK licensing, and presents OptaPlanner benchmark results comparing JDK 11, 16 and 17 with G1GC and ParallelGC, highlighting performance gains and migration considerations for developers in production.
This article introduces Huawei's open-source Bisheng JDK 8, outlines its supported features such as Flight Recorder and fast serialization, provides step‑by‑step installation instructions for Linux/AArch64, and shares the project repository and related interview resources.
This article demonstrates how to combine Linux top with -H -p options and jstack to correlate Java thread IDs with their logical names, explains the underlying JDK thread‑naming bug, and provides practical recommendations for performance debugging on different JDK versions.
This article provides a concise walkthrough of the most important Java 9‑16 language enhancements—including private methods in interfaces, diamond support for anonymous classes, enhanced try‑with‑resources, var type inference, switch expressions, text blocks, records, improved NullPointerException messages, foreign‑memory APIs, sealed classes and new garbage collectors—illustrated with clear code examples.
Learn a step‑by‑step method to configure Java 17 at the project level in IntelliJ IDEA, including JDK installation, setting language and bytecode levels, and leveraging the new Record feature, all without affecting other projects or global environment settings.
This article explains the internal data structures, hashing mechanisms, resizing behavior, and concurrency strategies of Java's HashMap and ConcurrentHashMap, covering their evolution from JDK 1.7 to 1.8, the use of linked lists, red‑black trees, and lock implementations.
This article provides a comprehensive overview of Java fundamentals, covering the relationship between JVM, JRE and JDK, the execution model, bytecode advantages, Java 8 language enhancements, core OOP principles, exception handling, reference types, and practical code examples for developers.
This article explains how Tomcat customizes Java’s ThreadPoolExecutor for I/O‑intensive web workloads, detailing the key parameters, the custom task queue and thread factory, the overridden execute logic, and the role of the submittedCount variable in preventing thread starvation under high concurrency.
An overview of the release dates and notable new features for each major Java version from 1.1 through 13, highlighting language enhancements, library updates, garbage collection improvements, and platform changes to help developers choose the appropriate JDK for their projects.
After upgrading MySQL Connector/J from 8.0.18 to 8.0.20 on IBM JDK 1.8, SSL handshake failures occur due to mismatched cipher suite naming, and the article details analysis of MySQL and IBM JSSE2 TLS settings, packet captures, and multiple remediation strategies including JVM parameters and JDK upgrades.
This article explains the Service Provider Interface (SPI) concept, demonstrates its use in plain JDK, Dubbo, and Spring frameworks with code examples, compares their strengths and limitations, and shows how SPI enhances extensibility and modularity in Java applications.
This guide explores why Java remains a top‑demand skill, offers practical advice on choosing the right JDK, explains keepAliveTime behavior in thread pools, and shares insider interview strategies from Alibaba experts to help developers secure offers.
This article provides an in‑depth tutorial on Java's String class, covering primitive data types, official documentation, common usage examples, detailed source‑code walkthrough of constructors and key methods, as well as typical interview questions and performance considerations for backend development.
This article quickly walks through the major language and JVM enhancements introduced in Java 9 through Java 16—including private interface methods, var type inference, switch expressions, records, sealed classes, new garbage collectors, and tooling updates—so developers can stay current and write more concise, efficient code.
The 2021 JVM ecosystem report, based on responses from over 2,000 Java developers, highlights the current state of JDK adoption, Java version upgrades, the rise of Kotlin, dominant IDEs and build tools, and Spring's continued dominance in the Java landscape.
This step‑by‑step tutorial shows how to enable security groups, configure firewall ports, install the BT panel or use the command line to set up a Linux server, then install JDK, Tomcat, and Docker CE with all required commands and configurations.
This article explains the differences between static and dynamic proxies in Java, details the role of Proxy, InvocationHandler, and the invoke method, and walks through the JDK dynamic proxy creation process with code examples and step‑by‑step analysis.
This article explains the origin of Java’s for(;;) infinite loop syntax, compares it with while(true), shows how both compile to identical bytecode in JDK 8, and concludes that performance differences depend on the JVM implementation rather than the source construct.
This article explains the Template Method design pattern, illustrating its structure with Java drink‑making examples, discussing hook methods, and showing real‑world usages in JDK’s Comparable and Spring’s ApplicationContext, while highlighting advantages, drawbacks, and practical scenarios.
This guide explains where Java's command‑line tools reside, why they are small wrappers around tools.jar, and provides detailed usage, options, and examples for the most common diagnostics utilities—including jps, jstat, jinfo, jmap, jhat, and jstack—helping developers monitor and troubleshoot JVM processes effectively.
This article explores the purpose and inner workings of Java's String.intern method, detailing how it interacts with the string constant pool across JDK versions, illustrating memory layout differences, code examples, and practical guidelines for when to apply intern for performance gains.
The article details a systematic investigation of a sudden performance drop in JD.com's calendar SOA service, revealing a Spring MimeTypeUtils LRU‑cache bug and a ConcurrentLinkedQueue removal bug in the JDK, and explains how upgrading Spring and applying JDK fixes restored service stability.
This article examines Java's StringJoiner class, explaining why it was introduced, how it builds on StringBuilder, detailing its constructors, methods such as add, merge, length, and toString, and provides code examples and analysis of its design choices and practical usage.
This article explains the Observer pattern, compares it with the Publish‑Subscribe model, showcases Java's built‑in Observable and Observer classes, provides complete code examples, and discusses practical considerations such as memory leaks and performance optimizations.
This article reveals frequent JDK pitfalls such as missing null checks in String.valueOf, fragile Integer.parseInt conversions, BigDecimal division errors, unmodifiable Collections.emptyList, and unsafe list iteration, providing concrete code examples and safe handling recommendations for Java developers.
This article explores the core mechanics of Java's Map implementations—detailing automatic resizing, lazy initialization, hash computation, bitwise operations, and the evolution of concurrency control from pessimistic to optimistic locking—while illustrating each concept with source‑code excerpts and diagrams.
This article compiles the most frequently asked questions about OpenJDK, covering Oracle's open‑source strategy, licensing details, compatibility testing, contribution guidelines, and the relationship between OpenJDK and Oracle JDK, providing clear answers for developers and organizations.
The article reports Java 16’s official release, reveals that 1,897 JDK issues were fixed worldwide—with Oracle handling 1,397 and major contributions from Red Hat, SAP, Tencent and ARM—highlights Tencent’s open‑source Kona JDK 11, and invites readers to vote on the strongest Chinese Java company.
The article explains why many developers continue to use Java 8, detailing Oracle's post‑8u211 commercial licensing, the last free JDK builds, the role of OpenJDK, and how to locate the final free Oracle JDK 8 version.
The article announces the official release of Java 16, outlines its new language and JVM enhancements, incubator and preview APIs, tooling updates, platform ports, and highlights the extensive community contributions that helped deliver the update.
Java 16 has been officially released, bringing 17 major enhancements—including new language features like pattern matching for instanceof and records, JVM improvements such as ZGC thread handling and elastic metaspace, new tools, incubator APIs, and broader community contributions—while maintaining backward compatibility and a predictable six‑month release cadence.
Java 16 has been officially released, introducing a host of enhancements such as the incubating Vector API, new C++14 support, migration to Git and GitHub, the ZGC collector, Unix‑domain socket channels, Alpine Linux port, foreign linker and memory APIs, pattern‑matching instanceof, records, sealed classes, and more.
This article challenges common objections to Lombok—JDK compatibility, forced adoption, readability concerns, increased coupling, and cost‑benefit trade‑offs—by presenting counter‑arguments and suggesting alternative viewpoints for Java developers.
The article systematically refutes typical criticisms of Lombok—such as JDK compatibility, forced adoption, reduced readability, increased coupling, and technical debt—by arguing that these concerns are overstated and that Lombok remains a valuable tool for Java backend development.
TencentKona 8.0.4 introduces an SM2/SM3/SM4 JCE provider for Chinese national cryptographic algorithms, parallel G1 Full GC, parallel heap inspection, and various performance enhancements, all demonstrated with a micro‑service encryption example and detailed curl commands for practical use.
This article explains why the original StringBuilder is limited, demonstrates how to use StringJoiner for comma‑separated strings, and provides a detailed analysis of the JDK source code including member fields, constructors, element addition, toString, length, merge, and empty‑value handling.
In 2020 Tencent's KonaJDK team enhanced Java memory analysis by parallelizing jmap heap scans across multiple garbage collectors, achieving 2‑8× speedups, adding gzipped heap dump support, and contributing dozens of patches and commits to the OpenJDK community.
This article explains the proxy pattern in Java, compares static and dynamic proxy implementations, provides complete code examples for JDK dynamic proxies, CGLIB, Javassist, and ASM proxies, and discusses their characteristics, performance considerations, and practical usage scenarios.
This guide walks you through preparing a CentOS 7.4 environment with JDK 1.8, installing Jenkins via yum, configuring Jenkins to communicate with GitHub using webhooks and personal access tokens, and creating a freestyle job that pulls source code, builds, and runs automatically.
This article provides a comprehensive analysis of Java's ConcurrentHashMap, covering its historical evolution, key internal fields, the thread‑safe put and remove operations, the complex resizing and transfer mechanisms, and auxiliary methods such as size, get, and clear, all illustrated with original source code.
This article analyzes the internal workflow of Java's ThreadPoolExecutor, focusing on how worker threads are reclaimed under both normal RUNNING conditions and after shutdown, detailing the runWorker loop, getTask() null returns, and the role of CAS and interrupt handling.
This article explains the meaning of "stack" in Java, examines the JDK's Stack class implementation—including its inheritance from Vector and core methods—provides full source code, demonstrates array manipulation with System.arraycopy, and explores common stack applications such as browser navigation, function call stacks, and complexity analysis.
This article explains the functions and storage locations of Java's runtime constant pool, string constant pool, and static constant pool across different JDK versions, illustrating JVM memory layout, constant pool structures, and how they evolve from PermGen to Metaspace.
This step‑by‑step guide shows how to enable security groups, install the BT control panel, configure firewall rules, deploy JDK and Tomcat, and install Docker on a Linux server, including all required commands and troubleshooting tips.
This step‑by‑step tutorial shows how to enable security groups, configure a BT panel or command‑line environment, install JDK, Tomcat, and Docker on an Alibaba Cloud Linux server, and verify firewall and service status for a production‑ready setup.
This article explores a JDK 8 bug in ConcurrentHashMap’s computeIfAbsent method that can cause an infinite loop, explains how the issue was discovered, reproduces it with test code, analyzes the root cause, and shows the fix introduced in JDK 9.
An in‑depth investigation reveals how a long‑standing JDK bug in ConcurrentLinkedQueue causes memory leaks and performance degradation in Jetty’s QueuedThreadPool, illustrated with code demos, visual monitoring tools, and the eventual fix introduced in later JDK releases.
This article examines a JDK bug causing memory leaks in Jetty's QueuedThreadPool due to improper removal in ConcurrentLinkedQueue, demonstrates the issue with a long‑running demo, analyzes heap growth using jconsole, VisualVM and jmc, and shows how newer JDK versions fix the problem.
This article provides a detailed examination of the JDK 1.8 LinkedList class, covering its internal fields, constructors, node structure, and core methods for adding, retrieving, and removing elements, while highlighting performance characteristics and differences from ArrayList.
This guide walks through downloading and extracting JDK 8, setting up Android SDK tools, installing Gradle, configuring environment variables, and using sdkmanager commands on a Linux system to prepare a complete mobile development environment.
This article provides a detailed analysis of JDK 1.8’s FutureTask implementation, explaining its purpose, usage examples, internal structure, state transitions, key methods such as run, get, cancel, and the concurrency mechanisms like volatile fields, CAS operations, and thread‑waiting queues.
This article documents a real‑world troubleshooting session of an Oracle JDK bug that caused a massive increase in CLOSE_WAIT connections, detailing the problem analysis, code inspection, reproduction steps, and the subsequent bug report to Oracle.
This article explains the concepts, implementation mechanisms, performance considerations, and practical code examples of Java static and dynamic proxies, covering both JDK's proxy based on interfaces and CGLIB's subclass‑based proxy, and compares their suitable use cases.
This article walks through five common Java String interview questions, showing code examples, output results, and detailed memory‑layout analyses to explain why each comparison behaves as it does, helping readers master string handling in Java.
This article explains the internal structure and working principles of Java's HashMap and ConcurrentHashMap, covering hash calculations, collision handling, resizing, the transition to red‑black trees, differences with TreeMap, LinkedHashMap, Hashtable, and performance‑related lock mechanisms in JDK 7 and JDK 8.
This article introduces essential JDK command‑line tools such as jps, jinfo, jstat, jmap, jhat and jstack, explaining their options, usage examples, and how they help developers monitor, diagnose and troubleshoot Java applications in production environments.
This article examines five common Java String interview questions, detailing why each equality check yields true or false by exploring the behavior of the == operator, the equals method, constant pool usage, object creation, and runtime concatenation, all illustrated with code and memory diagrams.
The author investigates the common advice against using the += operator for string concatenation by writing two Java programs, examining their bytecode with javap, and comparing results on Oracle JDK 8 and OpenJDK 14, revealing that JDK version and implementation affect whether a StringBuilder is automatically used.
This guide explains how to install JDK 8, Android SDK Tools, and Gradle on a Linux system, including downloading packages, extracting them, configuring environment variables, verifying installations, and using sdkmanager to list, install, or uninstall Android platform packages.
When deploying a Spring Boot application on CentOS, MySQL connections may throw CommunicationsException or SSLHandshakeException due to JDK mismatches, socket path errors, SSL settings, timeout defaults, or configuration issues, and this guide explains each cause and provides concrete fixes.
This article explains the proxy design pattern, shows how to implement static proxies in Java with concrete code examples, discusses their limitations, and then demonstrates JDK dynamic proxies using InvocationHandler and Proxy classes, including generated proxy class details.
A comprehensive survey of Java developers reveals current JDK vendor preferences, payment habits, version adoption, upgrade motivations, language distribution, Spring framework usage, IDE and build tool popularity, code repository choices, and role demographics across the industry.
This article explains the design principles of thread pools, when Java's ThreadPoolExecutor triggers rejection policies, details the four built‑in JDK policies with code examples, and explores additional strategies from Dubbo, Netty, ActiveMQ and Pinpoint, helping developers choose the right approach for their workloads.
This article explains Java 8's commercial licensing, highlights Java 11's performance gains, outlines major language and API enhancements from Java 8 to 11, provides code examples, discusses HTTP client usage, removed components, container support, and recommends Amazon Corretto as a free JDK alternative.
This article explains how to use JDK’s Future and FutureTask for asynchronous computation, walks through their APIs, internal state machine, core methods like run(), get(), cancel(), and highlights their limitations while introducing CompletableFuture as a more powerful alternative.
This article explains why Java remains a popular, easy-to-learn, and career‑boosting programming language, outlines its real‑world advantages, and provides a step‑by‑step roadmap with core concepts, tools, and practice tips for beginners.
This article explains the internal workings of Java reflection, from obtaining Method objects via getMethod and getDeclaredMethod to the invoke process, and details why reflection incurs significant performance overhead due to argument boxing, visibility checks, parameter validation, lack of inlining, and JIT optimization limits.
This article explains the seven Java garbage collectors available up to JDK 1.8, compares their strengths and weaknesses, and shows how to select and tune the appropriate collector—Serial, Parallel, CMS, or G1—based on application characteristics and deployment environments.
Java 13 introduced five new features, with Text Blocks gaining the most attention, while the upcoming Java 14 Early‑Access preview highlights three potential enhancements: improved NullPointerExceptions, a new non‑volatile memory mapped byte buffer mode, and the stabilization of Switch Expressions with pattern‑matching syntax.
This article summarizes the major JDK 11‑13 updates, including switch expression simplifications, multi‑line text block literals, dynamic AppCDS archives, ZGC memory‑release enhancements, a modernized socket API, new FileSystems methods, bulk NIO ByteBuffer operations, the Reiwa era in java.time, Unicode 12.1 support, and several deprecated features that have been removed.
This tutorial explains how to download and install JDK 8, set up Android SDK tools, install Gradle, and configure environment variables on a Linux system, including verification commands and a brief FAQ for common issues.
This article provides a comprehensive overview of core Java concepts for interview preparation, covering object‑oriented programming fundamentals, differences between OOP and procedural programming, detailed explanations of JVM, JDK, JRE, comparisons with C++, string handling, constructors, inheritance, polymorphism, threading, garbage collection, and related code examples.
This guide explains how a Spark Streaming job failed due to an incorrect JDK version, demonstrates how to identify the mismatch from ApplicationMaster logs, and provides the correct Spark‑submit configuration to set JAVA_HOME for both driver and executor so the job runs successfully.
Alibaba’s Dragonwell JDK 8.0.0‑GA, now GA‑ready for production, syncs the latest OpenJDK 8u212‑b04 updates, adds security patches, fixes critical Alibaba‑specific bugs, and introduces proprietary features such as JWarmUp, JFR enhancements, and the upcoming ElasticHeap, with detailed installation steps and performance results.
This article provides a comprehensive tutorial on installing Apache Tomcat, setting up the required JDK, configuring environment variables, adjusting server ports, and applying performance optimizations such as disabling AJP, switching to NIO, enabling external thread pools, and tuning JVM options for production use.
After five years of Java development, this guide outlines the essential knowledge areas—including JDK source code, JVM internals, concurrency utilities, blocking queues, thread pools, and major frameworks such as Spring, MyBatis, Dubbo, and ElasticSearch—to help developers build a comprehensive expertise foundation.
This article explains Java 11's new features, Oracle's licensing changes, the shift to time‑driven releases, and provides practical guidance for enterprise IT decision‑makers on choosing between commercial JDKs, OpenJDK, or staying on Java 8.
The article analyzes an arbitrary URL redirect flaw caused by unchecked returnUrl parameters, demonstrates how Java's URL.getHost() can be misused through backslash and hash bypasses, and provides a robust validation code snippet that works across JDK versions.
This article presents a curated set of 208 Java interview questions, focusing on the Java Basics module, and provides detailed explanations, code examples, and analyses of concepts such as JDK vs JRE, == vs equals, hashCode, final, abstract classes, and common String operations.
This article outlines JD's attempts and explorations in customizing the JDK for HDFS, describing the background, limitations of Oracle JDK 1.8, the adoption of OpenJDK 11 with G1GC, a series of JVM and GC optimizations, performance results, and future development plans.
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 provides a comprehensive overview of Java's HashMap, covering its purpose as a key‑value store, the evolution of its internal data structures from JDK 1.7 to JDK 1.8, detailed explanations of core methods such as hash, put, get, resize, and practical example code illustrating common operations.
ZGC is a scalable, low‑latency Java garbage collector designed to keep pause times under 10 ms regardless of heap size, supporting up to 4 TB, and leveraging concurrent, region‑based, compacting, NUMA‑aware techniques, colored pointers, and load barriers, with detailed compilation and tuning guidance.
