Java Custom Exception Handling with User Defined RadiusException

Discover Java 11 features like HTTP Client, var in lambdas, new String methods, and file I/O updates with code and JEP links.

📌 HttpClient in Java 11 – Finally, a Modern Way to Make HTTP Calls 🚀 If you're still using HttpURLConnection in Java… It’s time to upgrade. 👉 Introduced in Java 11 👉 Part of java.net.http package 👉 Modern replacement for HttpURLConnection And yes — it’s much cleaner. 🤯 The Old Way (HttpURLConnection) - Verbose - Hard to read - Manual stream handling - Not very intuitive Making a simple GET request felt complicated. 🚀 The Modern Way (HttpClient – Java 11) HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder()     .uri(URI.create("https://example.com"))     .GET()     .build(); HttpResponse<String> response =     client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println(response.body()); Clean. Readable. Modern. 🔥 What Makes It Powerful? - Supports HTTP/2 - Built-in asynchronous calls - CompletableFuture support - WebSocket support - Cleaner API design 🧠 Async Example client.sendAsync(request, HttpResponse.BodyHandlers.ofString())    .thenApply(HttpResponse::body)    .thenAccept(System.out::println); No third-party libraries needed. #Java #Java11 #BackendDevelopment #SoftwareEngineering #InterviewPreparation

✅ Java Features – Step 16: Java 11 HttpClient API 🌐 Before Java 11, making HTTP calls often required external libraries like Apache HttpClient or OkHttp. Java 11 introduced a modern built-in HTTP client. Example: HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://lnkd.in/gRt8avVb")) .GET() .build(); HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println(response.body()); Why this matters Built directly into Java Supports HTTP/1.1 and HTTP/2 Works with synchronous and asynchronous requests Cleaner and more modern API This removed the need for many external HTTP libraries in simple cases. Key takeaway Java keeps evolving to reduce dependency on external libraries while improving developer productivity. Next up: Java 14 – Switch Expressions ⚡

What is a List in Java? A List in Java is an ordered collection that allows:
-> Duplicate elements
-> Null values
-> Index-based access It is part of the Java Collections Framework and is mainly used when order matters. Types of List in Java -> ArrayList
Fast for reading data, slower for insert/delete in the middle. -> LinkedList
Better for frequent insertions & deletions. -> Vector
Thread-safe version of ArrayList (rarely used today). -> Stack
Legacy class that follows LIFO (Last In First Out). Common Uses -> Storing ordered data
-> Managing dynamic collections
-> Iterating through elements
-> Handling duplicate values
-> Frequently used in APIs & data processing Disadvantages -> Slower search (O(n))
-> Not ideal for key-value access
-> ArrayList resizing overhead
-> LinkedList consumes more memory Lists are simple — but choosing the right implementation makes a big performance difference. #Java #Collections #JavaDeveloper #BackendDevelopment #Programming #DataStructures #TechLearning #SoftwareEngineering

Core Java Fundamentals :Key Traits of Metaspace Permanent Generation in Java PermGen (Permanent Generation) was a memory area in the Java Virtual Machine (JVM) used before Java 8 to store class metadata, interned strings, and static variables. It was part of the JVM heap space and had a fixed size, making it difficult to manage memory efficiently. Fixed and Hard-to-Tune Size in PermGen PermGen had a fixed maximum size, which was often too small for applications with many classes. Correct Tuning was Tricky Even though it was configurable using -XX:MaxPermSize, tuning it correctly was difficult. PermGen was not dynamically expanding Unlike Metaspace, on the other hand, dynamically expands using native memory, eliminating manual tuning issues. OutOfMemoryError If class metadata exceeded 256MB, the application would crash with OutOfMemoryError: PermGen space. Key Features of Metaspace Stores Class Metadata It holds information about classes, methods, and their runtime representations (like method bytecode and field details). Unlike PermGen, it does not store Java objects (which reside in the heap). Uses Native Memory Unlike PermGen, which had a fixed maximum size, Metaspace dynamically expands using native memory(outside the heap), reducing Out of memory errors. Automatic Growth & GC Handling The JVM automatically manages Metaspace size based on the application’s needs. Class metadata is garbage collected when classes are no longer needed (such as when an application uses dynamic class loading). Configurable Maximum Size -XX:MaxMetaspaceSize=256m // Limits Metaspace to 256MB -XX:MetaspaceSize=128m // Initial size before expanding ☕ If this helped you — support my work: 👉 Buy Me a Coffee -https://lnkd.in/ebXVUJn2 #JVMInternals #JavaPerformance #MemoryManagement #SpringBoot #Microservices #SystemDesign

🚀 Java Series – Day 17 📌 File Handling in Java (I/O) 🔹 What is it? File handling in Java allows us to read from and write to files using input and output streams. 🔹 Why do we use it? It helps in storing and retrieving data from external sources like text files, logs, or configuration files. For example: In a real-world application, we use file handling to store user data, logs, or system configurations. 🔹 Example: import java.io.*; public class Main { public static void main(String[] args) { try { BufferedReader reader = new BufferedReader(new FileReader("test.txt")); String data = reader.readLine(); System.out.println("Read: " + data); reader.close(); } catch (IOException e) { System.out.println(e.getMessage()); } } } 💡 Key Takeaway: File handling is essential for data persistence and real-world application development. What do you think about this? 👇 #Java #JavaIO #FileHandling #JavaDeveloper #Programming #BackendDevelopment

Day - 14 : Linkedlist in java Linkedlist : The Linkedlist class in java is a part of the collection framework and implements the list interface. Unlike an arraylist which uses the dynamic array to store the elements, a Linkedlist stores elements as nodes in a doubly linked list . This provides different performance characteristics and usage scenarios compared to arraylist. A Linkedlist is a linear data structure where each element is a separate object called a node. ● Each node contains two parts : 1) Data : The value stored in the node 2) Pointers : Two pointers , one pointing to the next node , another pointing to the the previous node. ● Performance consideration : Linkedlist has two different performance characteristics compared to arraylist. 1) Insertion and deletion : Linkedlist is better for frequent Insertion and deletion in the middle of the list because it does not require shifting elements as in arraylist. 2) Random Access : Linkedlist has an slower random access compared to arraylist, because it has to traverse the list from the beginning to reach the desired index. 3) Memory overhead : Linkedlist requires more memory than arraylist because each node in a Linkedlist list requires extra Memory to store references to the next and previous nodes . #java #backend #programming #learning #advancedjava #Linkedlist #doublylinkedlist EchoBrains

✅ Java Features – Step 21: Pattern Matching for instanceof (Java 17) ⚡ Before Java 17, using instanceof required an extra cast. Example (old style): if (obj instanceof String) { String s = (String) obj; System.out.println(s.length()); } Java 17 simplifies this with pattern matching. if (obj instanceof String s) { System.out.println(s.length()); } Now the variable s is automatically created after the type check. Why this matters Less boilerplate code Safer type checking Improved readability Fewer casting mistakes Example Object value = "Java"; if (value instanceof String str) { System.out.println(str.toUpperCase()); } Key takeaway Pattern matching reduces repetitive casting and makes type-checking logic cleaner. This is part of Java’s effort to modernize the language. Next up: Recap – Key Features from Java 8 → Java 17 🚀

📄 On paper this looks like a small syntax tweak, ✨ but in real projects it feels like a relief. 🔧 DTO mapping, 📝 logging, or ⚙️ handling different event types in a backend system — we used to write instanceof checks followed by repetitive casts everywhere. ❌ It wasn’t just ugly, it was error‑prone. ✅ Now the flow is natural: if (event instanceof PaymentEvent pe) { auditLogger.log(pe.getTransactionId()); } 💡 This isn’t just saving a line of code. 👉 It’s about intent. 👥 When a teammate reads this, they immediately see what’s happening without being distracted by boilerplate. 🚀 In practice, these “small” changes: 🔓 reduce friction 👶 make onboarding easier for juniors 🎯 help teams focus on business logic instead of ceremony 📌 My takeaway: Code is not only for machines to run, but for humans to read, share, and maintain. Readability = productivity. This way your repost feels more personal, visually appealing, and relatable to everyday coding practice.

🚀 Java Series – Day 5 📌 Methods in Java 🔹 What is it? A method in Java is a block of code that performs a specific task and runs only when it is called. Methods help organize code into smaller, reusable pieces, making programs easier to read and maintain. A method generally includes: • Method name – identifies the method • Parameters – input values passed to the method • Return type – the value the method sends back (optional) 🔹 Why do we use it? Methods help avoid code repetition and make programs more structured. For example: In a banking application, a method can calculate interest, another method can check account balance, and another can process transactions. Instead of writing the same code multiple times, we simply call the method whenever needed. 🔹 Example: public class Main { // Method definition static void greetUser() { System.out.println("Welcome to the Java Program!"); } public static void main(String[] args) { // Method call greetUser(); } } 💡 Key Takeaway: Methods improve code reusability, readability, and modularity, which are essential for building scalable Java applications. What do you think about this? 👇 #Java #CoreJava #JavaDeveloper #Programming #BackendDevelopment