Java 21: Record Patterns for Cleaner Code

💡𝗝𝗮𝘃𝗮 𝗧𝗶𝗽/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐓𝐢𝐩 - 𝗜𝗻𝘀𝘁𝗮𝗻𝗰𝗲𝗼𝗳 𝗣𝗮𝘁𝘁𝗲𝗿𝗻 𝗠𝗮𝘁𝗰𝗵𝗶𝗻𝗴 🔥 💎 𝗪𝗵𝗮𝘁 𝗶𝘀 𝗶𝘁? Pattern matching with instanceof (Java 16+) lets you test an object's type AND declare a new variable in one step. When the pattern matches, the variable is automatically cast and assigned. This eliminates redundant casting and makes your code more concise. ✅ 𝗞𝗲𝘆 𝗕𝗲𝗻𝗲𝗳𝗶𝘁𝘀 ◾ Combines type checking and variable declaration in a single expression. ◾ Eliminates explicit casting and reduces boilerplate code. ◾ Prevents ClassCastException with compile-time safety. ⚡ 𝗖𝗼𝗺𝗺𝗼𝗻 𝗨𝘀𝗲 𝗖𝗮𝘀𝗲𝘀 ◾ Type checking in if statements: if (obj instanceof String str). ◾ Switch expressions with pattern matching (Java 21+). ◾ Processing collections with different element types. 🤔 Do you use pattern matching in your code? #java #springboot #programming #softwareengineering #softwaredevelopment

📌 Day 33/100 – Check If Digits Are Equal in String After Operations (LeetCode 3461) 🔹 Problem: Given a string s consisting of digits, repeatedly replace it by a new string formed by taking the sum (mod 10) of every pair of adjacent digits until only two digits remain. Return true if the final two digits are the same, otherwise false. 🔹 Approach: Iteratively built a new string using adjacent digit sums modulo 10. Repeated the process until the string length reduced to 2, then compared the final digits. Used StringBuilder for efficient construction of intermediate strings. 🔹 Key Learning: Reinforced clean looping and string handling patterns in Java. 🔹 Complexity: Time: O(n²) — Each iteration processes a smaller string. Space: O(n) for intermediate string storage. #100DaysOfCode #LeetCode #Java #StringManipulation #DSA #ProblemSolving #CodingPatterns #Iteration #ModularArithmetic

🚀 Let’s dive deeper into Java Sealed Classes: The permits keyword! Yesterday we talked about what sealed classes are and why they’re useful. Today, we’ll explore how to control inheritance using permits. What is permits? The permits keyword specifies exactly which classes are allowed to extend a sealed class. This ensures the hierarchy is strictly controlled and prevents unexpected or unwanted subclassing. Important Rule: Any class listed in the permits clause must be declared as one of the following: - final → cannot be subclassed further - sealed → can have its own limited set of subclasses - non-sealed → removes the restriction, allowing open inheritance ✅ Key takeaway: The permits keyword combined with final, sealed, or non-sealed lets you design safe, predictable, and maintainable class hierarchies. #Java #Java17 #SealedClasses #PermitsKeyword #OOP #CleanCode #ProgrammingTips #SoftwareDevelopment

 Option 1: Concise & Achievement-Focused Solved a classic Linked List problem: "Remove Nth Node From End of List" (LeetCode #19)! Successfully implemented the Java solution. This exercise was a great review of using a dummy node and the two-pointer approach to handle linked list operations efficiently. Option 2: Detailed & Technical Insight Deep dive into Linked Lists today! Just wrapped up the LeetCode problem "19. Remove Nth Node From End of List." Key takeaway from the solution: The most robust approach involves: Using a dummy node to simplify edge cases (like removing the head). Employing the two-pointer technique (slow/fast or previous/current) to find the target node in a single pass. The challenge is positioning the 'previous' pointer correctly so that when the fast pointer hits the end, the previous pointer is exactly one node before the node to be removed. Great practice for improving pointer manipulation skills! Option 3: Simple & Direct Happy to share a successful solution for LeetCode 19: Remove Nth Node From End of List! https://lnkd.in/d5TRq5b9

Recently, I shared a deep dive into how Spring, Lombok, and Mockito manipulate bytecode from inside the JVM. But I didn’t stop there. The next logical step was to put that knowledge into practice: I built a working example that shows how to modify a running Java application — without restarts, without redeployments, and without touching a single line of the original source code. In my new article, I walk through: ✅ How to attach to a live JVM using the Attach API ✅ How to load a Java agent and gain full access to Instrumentation ✅ How to redefine a method body at runtime ✅ Common pitfalls and practical solutions This isn’t just theory — it’s a fully functional implementation you can run and adapt to your own use cases. After reading both articles — the one on how popular frameworks work under the hood, and this one on dynamic JVM instrumentation — you’ll be able to stop seeing the JVM as a black box. Instead, you’ll start seeing it as a flexible platform that can be programmed from the outside, even while your application is already running. 👉 Full article on TProger (in Russian, with code): https://lnkd.in/epVsA8Rq #Java #JVM #Bytecode #HotSwap #Instrumentation #SoftwareEngineering #ByteBuddy #APM #Performance #Programming

🚀 Day 43 of #100DaysOfCode – Striver’s DSA Sheet 🚀 ✅ Topic Covered Today: Queue – Basic Implementation Using Java JCF 💡 Lesson of the Day (Approach-Focused): 🧠 Basic Queue Implementation (Java JCF) Today, I revised how queues work internally and how Java’s Queue interface helps implement FIFO operations efficiently using LinkedList. 🔹 Operations Covered: add() → Insert element at the rear poll() → Remove element from the front peek() → Access the front element isEmpty() → Check if the queue is empty size() → Get current size of queue All operations follow the FIFO Principle (First In, First Out). 🔹 Approach & Understanding: Queue does not support indexing → traversal happens sequentially. LinkedList is commonly used because insertion and deletion at ends are O(1). Helps build intuition for problems like sliding window, BFS, task scheduling, and producer-consumer logic. 🧮 Time Complexity: Enqueue (add): O(1) Dequeue (poll): O(1) Peek: O(1) Traversal: O(n) 💾 Space Complexity: O(n) for storing elements in queue. 💭 Learning: Revisiting how Queue works through JCF helped reinforce the fundamentals of FIFO behavior, which is essential before diving into advanced queue-based problems. #100DaysOfCode #DSA #StriversSheet #Java #Queue #JCF #ProblemSolving #CodingJourney #LogicBuilding #Consistency

💡 𝗝𝗮𝘃𝗮/𝐒𝐩𝐫𝐢𝐧𝐠 𝐁𝐨𝐨𝐭 𝐂𝐥𝐞𝐚𝐧 𝐂𝐨𝐝𝐞 𝗧𝗶𝗽 🔥 💎 𝗢𝗽𝘁𝗶𝗼𝗻𝗮𝗹.𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() 𝗳𝗼𝗿 𝗡𝘂𝗹𝗹 𝗦𝗮𝗳𝗲𝘁𝘆 ✅ The 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() method is a powerful feature introduced in 𝗝𝗮𝘃𝗮 𝟵 that takes null safety to the next level. It allows you to handle both present and absent values elegantly in a single expression, eliminating the need for verbose null checks and improving code readability. 💡 While 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁() from Java 8 only handles the present case, 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() extends this capability by accepting two parameters: a Consumer for when the value exists and a Runnable for when it's absent. This functional approach makes your code more expressive and less error-prone than traditional if-null patterns. 🔥 𝗔𝗱𝘃𝗮𝗻𝘁𝗮𝗴𝗲𝘀 𝗼𝗳 𝘂𝘀𝗶𝗻𝗴 𝗶𝗳𝗣𝗿𝗲𝘀𝗲𝗻𝘁𝗢𝗿𝗘𝗹𝘀𝗲() ◾Eliminates repetitive if-null checks, making your code more concise and elegant. ◾Prevents NullPointerException errors by forcing explicit handling of absent values. ◾Supports functional programming style with lambda expressions and method references. ◾Works seamlessly with Optional chains using map, filter, and flatMap operations. 🤔 What's your opinion on using Optional in modern Java? #java #springboot #programming #softwareengineering #softwaredevelopment

Just published today: a practical guide to Java Streams—creating from collections, lazy vs. terminal ops, map vs. flatMap, collectors (toList, groupingBy, joining), optional chaining, and when not to use streams. https://lnkd.in/d9gdZFht

📚 𝐃𝐨𝐜𝐬 𝐭𝐡𝐚𝐭 𝐝𝐞𝐯𝐬 𝐚𝐜𝐭𝐮𝐚𝐥𝐥𝐲 𝐫𝐞𝐚𝐝 (𝐚𝐧𝐝 𝐝𝐨𝐧’𝐭) Let’s be honest: ✅ Devs read: API docs with a 3-line example “How to run locally in 60 seconds” Migration notes with copy-paste commands Error code lists (when things explode) ❌ Devs don’t read: 40-page PDFs called “System Architecture Vision 2030” Meeting notes disguised as documentation Confluence pages last updated in 2017 Step 1: “Install Java 6…” Docs aren’t homework. They’re tools. The trick? Write them like the stuff you go back to when you’re stuck.

Skimmed this handy roundup of Java 25—and it’s a strong LTS jump for everyday coding. Record patterns, sequenced collections, and (preview) string templates clean up routine code, while module import declarations + compact source files cut boilerplate; on the runtime side, structured concurrency, scoped values, and new JFR profiling round out the upgrade. If you’re still on 21 LTS, which feature would tip you to 25 first? #womenwhocode #softwaredeveloper #softwareengineer https://lnkd.in/ep_8qpP3