Java Map Interface: Choosing the Right Map for Your Needs

⚡ 10+ Approaches to Find Max or Min Value in Java 8 Streams — Master It Like a Pro 💪 Working with Java 8 Streams? Here are 10 powerful and elegant ways to find the maximum or minimum value from a list — all clean, modern, and interview-ready 👇 🧩 Sample Data List<Integer> myList = Arrays.asList(10, 15, 8, 49, 25, 98, 98, 32, 15); 🔥 Find Maximum Value — 10 Approaches List<Integer> myList = Arrays.asList(10,15,8,49,25,98,98,32,15); 1️⃣ Using instance comparator (compareTo on elements) myList.stream().max(Integer::compareTo).get(); 2️⃣ Using static comparator (Integer.compare) myList.stream().max(Integer::compare).get(); 3️⃣ Using IntStream for primitive comparison myList.stream().mapToInt(Integer::intValue).max().getAsInt(); 4️⃣ Using reduce() with Integer::max myList.stream().reduce(Integer::max).get(); 5️⃣ Using Collectors.summarizingInt() for all stats myList.stream().collect(Collectors.summarizingInt(i -> i)).getMax(); 6️⃣ Using Comparator.comparingInt() (good for objects too) myList.stream().max(Comparator.comparingInt(Integer::intValue)).get(); 7️⃣ Using Comparator.naturalOrder() for clean syntax myList.stream().max(Comparator.naturalOrder()).get(); 8️⃣ Using Comparable::compareTo (generic Comparable) myList.stream().max(Comparable::compareTo).get(); 9️⃣ Using custom lambda comparator (manual compare logic) myList.stream().max((a,b) -> a>b ? 1 : (a<b ? -1 : 0)).get(); 🔟 Using summaryStatistics() for one-line numeric max myList.stream().mapToInt(Integer::intValue).summaryStatistics().getMax(); 🕚 Using sorted() + skip() to pick last element myList.stream().sorted().skip(myList.size()-1).findFirst().get(); 🌙 Same Approaches for Find Minimum Value List<Integer> myList = Arrays.asList(10, 15, 8, 49, 25, 98, 98, 32, 15); 1️⃣ myList.stream().min(Integer::compareTo).get(); 2️⃣ myList.stream().min(Integer::compare).get(); 3️⃣ myList.stream().mapToInt(Integer::intValue).min().getAsInt(); 4️⃣ myList.stream().reduce(Integer::min).get(); 5️⃣ myList.stream().collect(Collectors.summarizingInt(i -> i)).getMin(); 6️⃣ myList.stream().min(Comparator.comparingInt(Integer::intValue)).get(); 7️⃣ myList.stream().min(Comparator.naturalOrder()).get(); 8️⃣ myList.stream().min(Comparable::compareTo).get(); 9️⃣ myList.stream().min((a, b) -> a > b ? 1 : (a < b ? -1 : 0)).get(); 🔟 myList.stream().mapToInt(Integer::intValue).summaryStatistics().getMin(); 🕚 myList.stream().sorted().findFirst().get(); 💡 Quick Summary for Efficiency 🧠 For numeric lists → mapToInt().max() or summaryStatistics() 🚀 For objects → Comparator.comparing() 📊 For analytics → Collectors.summarizingInt() 💪 For readability → reduce() or naturalOrder() ⚙️ For demos → sorted().skip() (less efficient) 👉 Follow me for more Java 8, Streams, and interview-ready code tips! 🔖 #Java #Java8 #Streams #CodingTips #FunctionalProgramming #InterviewPreparation #CleanCode #Developers #LinkedInLearning #CodeNewbie

Strings methods in Java 1️⃣ length() Definition: Returns the number of characters in a string (including spaces). 💡 Why it matters: Useful for checking input length (like passwords, usernames) or controlling loops. Example: String name = "Rakshitha"; System.out.println(name.length()); // Output: 9 2️⃣ charAt() Definition: Returns the character at a given index (index starts from 0). 💡 Why it matters: Helps to access or check specific characters, like the first letter of a name. Example: String word = "Java"; System.out.println(word.charAt(2)); // Output: v 3️⃣ toUpperCase() / toLowerCase() Definition: Converts all letters in a string to uppercase or lowercase. 💡 Why it matters: Useful for ignoring case in comparisons or displaying consistent text. Example: String text = "Java"; System.out.println(text.toUpperCase()); // JAVA System.out.println(text.toLowerCase()); // java 4️⃣ equals() / equalsIgnoreCase() Definition: equals() compares two strings exactly, while equalsIgnoreCase() ignores case differences. 💡 Why it matters: Used to compare user inputs like login IDs or names, case-sensitive or not. Example: String a = "Java"; String b = "java"; System.out.println(a.equals(b)); // false System.out.println(a.equalsIgnoreCase(b)); // true 5️⃣ contains() Definition: Checks if a string contains a certain sequence of characters. 💡 Why it matters: Used to search or validate text (like checking if an email contains “@”). Example: String email = "rakshitha@gmail.com"; System.out.println(email.contains("@gmail.com")); // true Awesome 👍 Here are the next 5 common String methods in Java — explained simply with definition, why it matters, and example 👇 6️⃣ substring() Definition: Extracts a part of the string between given start and end indexes. 💡 Why it matters: Used to get a specific portion of text, like extracting username from an email. Example: String word = "JavaDeveloper"; System.out.println(word.substring(0, 4)); // Output: Java 7️⃣ replace() Definition: Replaces all occurrences of a character or substring with another value. 💡 Why it matters: Useful for correcting text, filtering data, or formatting user input. Example: String text = "I love Java"; System.out.println(text.replace("Java", "Python")); // Output: I love Python 8️⃣ split() Definition: Splits a string into multiple parts based on a given delimiter and returns an array. 💡 Why it matters: Used to break text into pieces, such as splitting CSV data or words in a sentence. Example: String data = "apple,banana,grape"; String[] fruits = data.split(","); System.out.println(fruits[1]); // Output: banana 9️⃣ trim() Definition: Removes all leading and trailing spaces from a string. 💡 Why it matters: Essential for cleaning user input before saving or comparing values. Example: String name = " Rakshitha "; System.out.println(name.trim()); // Output: Rakshitha #Java #CoreJava #JavaProgramming #LearnJava #JavaDeveloper

🚀 𝗨𝗻𝗱𝗲𝗿𝘀𝘁𝗮𝗻𝗱𝗶𝗻𝗴 𝘁𝗵𝗲 𝗝𝗮𝘃𝗮 𝗟𝗶𝘀𝘁 𝗜𝗻𝘁𝗲𝗿𝗳𝗮𝗰𝗲 — 𝗧𝗵𝗲 𝗛𝗲𝗮𝗿𝘁 𝗼𝗳 𝗢𝗿𝗱𝗲𝗿𝗲𝗱 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻𝘀 In Java’s 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗶𝗼𝗻 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸, the List interface represents an ordered, index-based collection that allows duplicate elements. It’s like your digital to-do list — you can add, remove, or access any task by its position. 𝗞𝗲𝘆 𝗶𝗺𝗽𝗹𝗲𝗺𝗲𝗻𝘁𝗮𝘁𝗶𝗼𝗻𝘀: 𝗔𝗿𝗿𝗮𝘆𝗟𝗶𝘀𝘁 → 𝘥𝘺𝘯𝘢𝘮𝘪𝘤 𝘢𝘳𝘳𝘢𝘺𝘴, 𝘨𝘳𝘦𝘢𝘵 𝘧𝘰𝘳 𝘧𝘢𝘴𝘵 𝘳𝘢𝘯𝘥𝘰𝘮 𝘢𝘤𝘤𝘦𝘴𝘴 𝗟𝗶𝗻𝗸𝗲𝗱𝗟𝗶𝘀𝘁 → 𝘱𝘦𝘳𝘧𝘦𝘤𝘵 𝘧𝘰𝘳 𝘧𝘳𝘦𝘲𝘶𝘦𝘯𝘵 𝘪𝘯𝘴𝘦𝘳𝘵𝘪𝘰𝘯𝘴 𝘢𝘯𝘥 𝘥𝘦𝘭𝘦𝘵𝘪𝘰𝘯𝘴 𝗩𝗲𝗰𝘁𝗼𝗿 → 𝘭𝘦𝘨𝘢𝘤𝘺 𝘵𝘩𝘳𝘦𝘢𝘥-𝘴𝘢𝘧𝘦 𝘷𝘦𝘳𝘴𝘪𝘰𝘯 (𝘯𝘰𝘵 𝘤𝘰𝘮𝘮𝘰𝘯𝘭𝘺 𝘶𝘴𝘦𝘥 𝘵𝘰𝘥𝘢𝘺) 𝗦𝘁𝗮𝗰𝗸 → 𝘤𝘭𝘢𝘴𝘴𝘪𝘤 𝘓𝘐𝘍𝘖 𝘥𝘢𝘵𝘢 𝘴𝘵𝘳𝘶𝘤𝘵𝘶𝘳𝘦 𝘣𝘶𝘪𝘭𝘵 𝘰𝘯 𝘝𝘦𝘤𝘵𝘰𝘳 Each serves a specific purpose depending on whether you value speed, memory efficiency, or thread safety. 𝗘𝘅𝗮𝗺𝗽𝗹𝗲 𝗖𝗼𝗱𝗲 import java.util.*; public class ListExamples {   public static void main(String[] args) {     // 𝗔𝗿𝗿𝗮𝘆𝗟𝗶𝘀𝘁 𝗘𝘅𝗮𝗺𝗽𝗹𝗲     List<String> arrayList = new ArrayList<>();     arrayList.add("Java");     arrayList.add("Python");     arrayList.add("C++");     arrayList.add("Python"); // duplicates allowed     System.out.println("ArrayList: " + arrayList);     // 𝗟𝗶𝗻𝗸𝗲𝗱𝗟𝗶𝘀𝘁 𝗘𝘅𝗮𝗺𝗽𝗹𝗲     List<String> linkedList = new LinkedList<>();     linkedList.add("Spring");     linkedList.add("Hibernate");     linkedList.addFirst("Java EE");     System.out.println("LinkedList: " + linkedList);     // 𝗩𝗲𝗰𝘁𝗼𝗿 𝗘𝘅𝗮𝗺𝗽𝗹𝗲     Vector<Integer> vector = new Vector<>();     vector.add(10);     vector.add(20);     vector.add(30);     System.out.println("Vector: " + vector);     // 𝗦𝘁𝗮𝗰𝗸 𝗘𝘅𝗮𝗺𝗽𝗹𝗲     Stack<String> stack = new Stack<>();     stack.push("Apple");     stack.push("Banana");     stack.push("Cherry");     System.out.println("Stack before pop: " + stack);     stack.pop();     System.out.println("Stack after pop: " + stack);   } } 𝗢𝘂𝘁𝗽𝘂𝘁: 𝘈𝘳𝘳𝘢𝘺𝘓𝘪𝘴𝘵: [𝘑𝘢𝘷𝘢, 𝘗𝘺𝘵𝘩𝘰𝘯, 𝘊++, 𝘗𝘺𝘵𝘩𝘰𝘯] 𝘓𝘪𝘯𝘬𝘦𝘥𝘓𝘪𝘴𝘵: [𝘑𝘢𝘷𝘢 𝘌𝘌, 𝘚𝘱𝘳𝘪𝘯𝘨, 𝘏𝘪𝘣𝘦𝘳𝘯𝘢𝘵𝘦] 𝘝𝘦𝘤𝘵𝘰𝘳: [10, 20, 30] 𝘚𝘵𝘢𝘤𝘬 𝘣𝘦𝘧𝘰𝘳𝘦 𝘱𝘰𝘱: [𝘈𝘱𝘱𝘭𝘦, 𝘉𝘢𝘯𝘢𝘯𝘢, 𝘊𝘩𝘦𝘳𝘳𝘺] 𝘚𝘵𝘢𝘤𝘬 𝘢𝘧𝘵𝘦𝘳 𝘱𝘰𝘱: [𝘈𝘱𝘱𝘭𝘦, 𝘉𝘢𝘯𝘢𝘯𝘢] 💡 In real-world applications, Lists manage user records, logs, orders, and much more. Choosing the right implementation can make a big difference in performance. #Java #OOP #CollectionFramework #ArrayList #LinkedList #Stack #Vector #JavaDeveloper

In Java, when we want to work with a unique set of data, say String, the Set data structure comes readily to mind. There’s one subtle thing about the Set data structure that if care is not taken, might lead you to begin to debug an inexistent issue. One subtle thing that’s quick to forget about HashSet is that the order of insertion isn’t guaranteed. I was left chasing my tail recently only to remember the nature of HashSet in Java. Say we did the below: Set<String> names = Set.of(“Promise”, “Oberoro”, “Akeni”); If you: System.out.println(names); A couple of times, you would get different outcomes not consistent in the way you added the data. Same as using a HashSet and adding data to it. In my case, I wanted to use the Set in the order in which the data were inserted but while debugging, I would be seeing the last inserted data first 😄. I thought someone was jinxing me until I remembered that orderliness isn’t guaranteed in Set. Oops 😬 poor me! If you want orderliness and uniqueness then go for LinkedHashSet. Set<String> names = new LinkedHashSet<>(); names.add(“Promise”); names.add(“Oberoro”); names.add(“Akeni”); This way, the order of insertion will always be guaranteed and you don’t have to be fooling around like I did. But if order of insertion isn’t important to you then you can use HashSet without issues. The fact that the HashSet isn’t ordered is not a weakness, it’s a design decision made to optimize for speed, which makes insertion, deletion, and look up much faster than its counterparts(LinkedHashset and Treeset) as those would have the overheads of maintaining additional data structure. It’s also worth noting that HashSet under the hood uses Hash table, that’s how it’s able to achieve uniqueness. LinkedHashSet uses hash table + linked list. TreeSet uses Red-Black tree to ensure data are sorted in natural or specified order. Ever had the experience of debugging something that when you eventually figured it out, made you want to punch yourself in the face? Kindly share let’s learn from you 👇 #softwareengineering #programming #coding

In Java, there are several ways to create and run threads, Spring Boot also have @Async annotation to run method code as thread. 1. Extending the Thread class You can create a subclass of Thread and override the run() method. ✅ Example: class MyThread extends Thread { @Override public void run() { System.out.println("Thread running " + Thread.currentThread().getName()); } } public class Main { public static void main(String[] args) { MyThread t1 = new MyThread(); t1.start(); } } 🧩 2. Implementing the Runnable interface ✅ Example: class MyRunnable implements Runnable { @Override public void run() { System.out.println("Thread running using Runnable interface: " + Thread.currentThread().getName()); } } public class Main { public static void main(String[] args) { Thread t1 = new Thread(new MyRunnable()); t1.start(); } } 🟢 Why preferred: Allows you to extend another class (since Java supports only single inheritance). ⚡ 3. Using Anonymous Class You can create and start a thread in one line using an anonymous inner class. ✅ Example: public class Main { public static void main(String[] args) { Thread t1 = new Thread(new Runnable() { @Override public void run() { System.out.println("Thread running using Anonymous class"); } }); t1.start(); } } 💡 4. Using Lambda Expression (Java 8+) ✅ Example: public class Main { public static void main(String[] args) { Thread t1 = new Thread(() -> { System.out.println("Thread running using Lambda expression"); }); t1.start(); } } ⚙️ 5. Using ExecutorService (Thread Pool) For multiple or managed threads, use an Executor Service. ✅ Example: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class Main { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(2); executor.submit(() -> System.out.println("Thread 1 using ExecutorService")); executor.submit(() -> System.out.println("Thread 2 using ExecutorService")); executor.shutdown(); } } 🟢 Advantages: Reuses threads (avoids overhead of creating new threads repeatedly) Supports async tasks and better error handling 🧠 6. Using Callable and Future (for return values) Callable is like Runnable, but can return a value and throw exceptions. ✅ Example: import java.util.concurrent.*; public class Main { public static void main(String[] args) throws Exception { ExecutorService executor = Executors.newSingleThreadExecutor(); Callable<String> task = () -> { return "Result from thread: " + Thread.currentThread().getName(); }; Future<String> future = executor.submit(task); System.out.println(future.get()); executor.shutdown(); } }

𝐉𝐚𝐯𝐚 𝐌𝐞𝐦𝐨𝐫𝐲 𝐌𝐚𝐧𝐚𝐠𝐞𝐦𝐞𝐧𝐭: 𝐒𝐭𝐚𝐜𝐤, 𝐇𝐞𝐚𝐩 𝐚𝐧𝐝 𝐆𝐚𝐫𝐛𝐚𝐠𝐞 𝐂𝐨𝐥𝐥𝐞𝐜𝐭𝐢𝐨𝐧 Memory is fundamental for Java applications. To handle data effectively, Java divides its memory into two main areas: 𝑡ℎ𝑒 𝑠𝑡𝑎𝑐𝑘 and 𝑡ℎ𝑒 ℎ𝑒𝑎𝑝. Each plays a specific role in storing and managing data, impacting both performance.   1. 𝗦𝘁𝗮𝗰𝗸 𝗠𝗲𝗺𝗼𝗿𝘆 The stack is a special area of memory used for temporary data and method calls. Every time a method is called in Java, the JVM creates a stack frame to hold the method’s local variables, parameters and references to objects stored in the heap.   𝑾𝒉𝒆𝒏 𝒊𝒔 𝒊𝒕 𝒖𝒔𝒆𝒅? 🔸For storing primitive types 🔸For storing references to objects in the heap   𝑾𝒉𝒂𝒕 𝒊𝒔 𝒔𝒕𝒐𝒓𝒆𝒅 𝒊𝒏 𝒕𝒉𝒆 𝒔𝒕𝒂𝒄𝒌? 🔸Local variables 🔸Method parameters 🔸Return addresses 🔸References to heap objects   𝑬𝒙𝒂𝒎𝒑𝒍𝒆: 𝑝𝑢𝑏𝑙𝑖𝑐 𝑐𝑙𝑎𝑠𝑠 𝑆𝑡𝑎𝑐𝑘𝐸𝑥𝑎𝑚𝑝𝑙𝑒 {    𝑝𝑢𝑏𝑙𝑖𝑐 𝑠𝑡𝑎𝑡𝑖𝑐 𝑣𝑜𝑖𝑑 𝑚𝑎𝑖𝑛(𝑆𝑡𝑟𝑖𝑛𝑔[] 𝑎𝑟𝑔𝑠) {        𝑖𝑛𝑡 𝑎 = 10;          // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑖𝑛𝑡 𝑏 = 20;          // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑖𝑛𝑡 𝑠𝑢𝑚 = 𝑎 + 𝑏;     // 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 𝑠𝑡𝑎𝑐𝑘        𝑆𝑦𝑠𝑡𝑒𝑚.𝑜𝑢𝑡.𝑝𝑟𝑖𝑛𝑡𝑙𝑛(𝑠𝑢𝑚);    } } 𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Stack memory is fast, working in LIFO (Last In, First Out) order. 🔸Data is temporary — once the method finishes, the stack frame is removed automatically. 🔸Stack size is limited, so too many method calls can cause a StackOverflowError.   2. 𝗛𝗲𝗮𝗽 𝗠𝗲𝗺𝗼𝗿𝘆  While the stack stores temporary data and method calls, the heap is where Java objects and instance variables live. Every time you create a new object using the new keyword, Java allocates space for it in the heap.   𝑬𝒙𝒂𝒎𝒑𝒍𝒆: 𝑃𝑒𝑟𝑠𝑜𝑛 𝑝𝑒𝑟𝑠𝑜𝑛 = 𝑛𝑒𝑤 𝑃𝑒𝑟𝑠𝑜𝑛("𝐽𝑜ℎ𝑛"); // 𝑜𝑏𝑗𝑒𝑐𝑡 𝑠𝑡𝑜𝑟𝑒𝑑 𝑖𝑛 ℎ𝑒𝑎𝑝 Here, the variable person is stored on the stack, while the actual Person object resides in the heap. Heap memory is slower because managing dynamic memory is more complex, but Garbage Collector automatically frees unreferenced objects.   𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Heap stores objects and instance variables 🔸Data can live longer than the method that created it   𝗚𝗮𝗿𝗯𝗮𝗴𝗲 𝗖𝗼𝗹𝗹𝗲𝗰𝘁𝗼𝗿 In Java, the Garbage Collector (GC) automatically removes objects in the heap that are no longer referenced. This means you don’t have to manually free memory. 𝑲𝒆𝒚 𝒑𝒐𝒊𝒏𝒕𝒔: 🔸Frees memory for unused objects 🔸Runs in background, letting developers focus on code   In conclusion, having a clear understanding of Java’s memory structure helps developers make better decisions when optimizing applications. 𝑇ℎ𝑒 𝑠𝑡𝑎𝑐𝑘 manages temporary data and method calls, while 𝑡ℎ𝑒 ℎ𝑒𝑎𝑝 stores objects and instance variables, managed automatically by the Garbage Collector. Understanding how these memory areas work helps developers write more stable and memory-safe programs.

Record class in Java A record in Java is a special kind of class introduced to reduce boilerplate code when you need an immutable data carriers. Automatically generates: private final fields A canonical constructor equals(), hashCode() toString() accessor methods (getters without get prefix) --- Example: Traditional Employee Class (Before Java 14) public class Employee { private int id; private String name; private double salary; public Employee(int id, String name, double salary) { this.id = id; this.name = name; this.salary = salary; } public int getId() { return id; } public String getName() { return name; } public double getSalary() { return salary; } @Override public String toString() { return "Employee{id=" + id + ", name='" + name + "', salary=" + salary + "}"; } @Override public boolean equals(Object o) { // } @Override public int hashCode() { // } } . Too much boilerplate (getters, constructor, toString, equals, hashCode). --- Example: Employee Record (After Java 16) public record Employee(int id, String name, double salary) { } That’s it! Java automatically generates: Constructor Getters (id(), name(), salary()) equals(), hashCode() toString() --- Example usage: public class Main { public static void main(String[] args) { Employee emp = new Employee(101, "Sreenu", 55000); System.out.println(emp.name()); // Output: Sreenu System.out.println(emp); // Output: Employee[id=101, name=Sreenu, salary=55000.0] } } --- Canonical Constructor (Full Constructor) Records provide a canonical constructor automatically, but you can define it manually if you need validation: public record Employee(int id, String name, double salary) { public Employee { if (salary < 0) throw new IllegalArgumentException("Salary must be positive"); } } --- Compact Constructor Example public record Employee(int id, String name, double salary) { public Employee { if (name == null || name.isBlank()) { throw new IllegalArgumentException("Name cannot be blank"); } } } -- Entity Example (JPA) Usually, JPA entities are mutable, so records are not recommended for entities that Hibernate modifies. But you can use them as read-only projections: public record EmployeeEntity(Long id, String name, Double salary) { } Or use a traditional entity and record DTO for response. Example: @Entity @Table(name = "employees") public class EmployeeEntity { @Id private Long id; private String name; private Double salary; // getters, setters, constructors } Then convert it into DTO using record: public record EmployeeDTO(Long id, String name, Double salary) { } EmployeeDTO dto = new EmployeeDTO(entity.getId(), entity.getName(), entity.getSalary());

☕💻 JAVA THREADS CHEAT SHEET 🔹 🧠 What is a Thread? 👉 The smallest unit of execution in a process. Each thread runs independently but shares memory & resources with others. 🧩 Enables multitasking and parallel execution. 🔹 ⚙️ What is a Process? 👉 An executing instance of a program. Each process has its own memory space and can run multiple threads. 🧵 Types of Threads 👤 1️⃣ User Threads ✅ Created by users or apps. ✅ JVM waits for them before exit. 💡 Example: Thread t = new Thread(() -> System.out.println("User Thread")); t.start(); 👻 2️⃣ Daemon Threads ⚙️ Background threads (e.g., Garbage Collector). ❌ JVM doesn’t wait for them. 💡 Example: Thread d = new Thread(() -> {}); d.setDaemon(true); d.start(); 🚀 Creating Threads 🔸 Extending Thread: class MyThread extends Thread { public void run(){ System.out.println("Running..."); } } new MyThread().start(); 🔸 Implementing Runnable: new Thread(() -> System.out.println("Runnable running...")).start(); 🔄 Thread Lifecycle 🧩 NEW → RUNNABLE → RUNNING → WAITING/BLOCKED → TERMINATED 🕹️ Common Thread Methods 🧩 Method ⚡ Use start() Start a thread run() Thread logic sleep(ms) Pause execution join() Wait for thread interrupt() Interrupt thread setDaemon(true) Make daemon thread 🔒 Synchronization Prevents race conditions when multiple threads share data. synchronized void increment() { count++; } 💬 Thread Communication Use wait(), notify(), and notifyAll() for coordination. 🧠 Must be called inside a synchronized block. ⚡ Executor Framework (Thread Pooling) Efficient thread reuse for better performance. ExecutorService ex = Executors.newFixedThreadPool(3); ex.submit(() -> System.out.println("Task executed")); ex.shutdown(); 🏁 Pro Tips ✅ Prefer Runnable / ExecutorService ✅ Handle InterruptedException ✅ Avoid deprecated methods (stop(), suspend()) ✅ Use java.util.concurrent for safe multithreading 📢 Boost Your Skills 🚀 #Java #Threads #Multithreading #Concurrency #JavaDeveloper #JavaInterview #JavaCoding #JavaProgrammer #CodeNewbie #ProgrammingTips #DeveloperCommunity #CodingLife #LearnJava #JavaCheatSheet #ThreadPool #TechInterview #SoftwareEngineer #CodeWithMe #JavaExperts #BackendDeveloper #JavaLearning #JavaBasics #OOP #CodeDaily #CodingJourney #DevCommunity #JavaLovers #TechCareers #CodeSmarter #100DaysOfCode

💾 𝑻𝒉𝒆 𝑮𝒓𝒆𝒂𝒕 𝑱𝒂𝒗𝒂 𝑺𝒆𝒓𝒊𝒂𝒍𝒊𝒛𝒂𝒕𝒊𝒐𝒏 𝑴𝒚𝒔𝒕𝒆𝒓𝒚 aka “When your 𝐏𝐎𝐉𝐎 refuse to leave home” 🎬 𝑺𝒄𝒆𝒏𝒆 𝑺𝒆𝒕𝒖𝒑 Friday evening at Office a dev happily sends a User object from one microservice to another. All seems peaceful…until suddenly 🚨 𝐣𝐚𝐯𝐚.𝐢𝐨.𝐍𝐨𝐭𝐒𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐛𝐥𝐞𝐄𝐱𝐜𝐞𝐩𝐭𝐢𝐨𝐧: 𝐜𝐨𝐦.𝐦𝐢𝐜𝐫𝐨𝐬𝐨𝐟𝐭.𝐚𝐩𝐩.𝐦𝐨𝐝𝐞𝐥𝐬.𝐔𝐬𝐞𝐫 That’s the moment when coffee stopped helping, and debugging began. ☕💻 🧠 𝑾𝒉𝒂𝒕’𝒔 𝑹𝒆𝒂𝒍𝒍𝒚 𝑮𝒐𝒊𝒏𝒈 𝑶𝒏? #𝐒𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐭𝐢𝐨𝐧→ Converting your Java object into bytes so it can travel (across a network, file, or queue). #𝐃𝐞𝐬𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐭𝐢𝐨𝐧 → Rebuilding that object from bytes. 𝑰𝒏 𝒔𝒉𝒐𝒓𝒕: Your object: “I’m heading to Azure Service Bus 🌩️” JVM: “Hold on! Where’s your Serializable passport? 🛂” ⚙️ 𝑻𝒉𝒆 𝑪𝒍𝒂𝒔𝒔𝒊𝒄 𝑩𝒖𝒈 class 𝐔𝐬𝐞𝐫{ private String name; private String email; } When this travels across services 💣 Boom NotSerializableException ✅ 𝑻𝒉𝒆 𝑹𝒆𝒔𝒄𝒖𝒆 𝑷𝒍𝒂𝒏 import java.io.Serializable; class User implements Serializable { 𝒑𝒓𝒊𝒗𝒂𝒕𝒆 𝒔𝒕𝒂𝒕𝒊𝒄 𝒇𝒊𝒏𝒂𝒍 𝒍𝒐𝒏𝒈 𝒔𝒆𝒓𝒊𝒂𝒍𝑽𝒆𝒓𝒔𝒊𝒐𝒏𝑼𝑰𝑫 = 1𝑳; private String name; private String email; } Now your POJO can safely journey through REST APIs, Kafka, or message queues like a pro. 🚀 🌿 𝑩𝒐𝒏𝒖𝒔: 𝑺𝒑𝒓𝒊𝒏𝒈𝑩𝒐𝒐𝒕 𝑹𝑬𝑺𝑻 Spring Boot uses Jackson under the hood for automatic 𝐉𝐒𝐎𝐍 (𝒅𝒆)𝒔𝒆𝒓𝒊𝒂𝒍𝒊𝒛𝒂𝒕𝒊𝒐𝒏. @𝐆𝐞𝐭𝐌𝐚𝐩𝐩𝐢𝐧𝐠("/user") public 𝐔𝐬𝐞𝐫 𝐠𝐞𝐭𝐔𝐬𝐞𝐫() { return new 𝐔𝐬𝐞𝐫("abc", "abc@gmail.com"); } 𝑱𝒂𝒄𝒌𝒔𝒐𝒏 𝒉𝒂𝒏𝒅𝒍𝒆𝒔 𝒕𝒉𝒆 𝑱𝑺𝑶𝑵 𝒎𝒂𝒈𝒊𝒄 - 𝑩𝒖𝒕 𝒃𝒆𝒘𝒂𝒓𝒆 𝒐𝒇 𝒇𝒆𝒘 𝒕𝒓𝒂𝒑𝒔 ⚠️ 🔁 Circular references (bidirectional JPA relationships) 🙈 Missing @𝑱𝒔𝒐𝒏𝑰𝒈𝒏𝒐𝒓𝒆 for sensitive data 🔍 Debugging Checklist ✅ Verify if class implements Serializable 🔗 Check nested objects for serialization support 🧩 Ensure 𝒔𝒆𝒓𝒊𝒂𝒍𝑽𝒆𝒓𝒔𝒊𝒐𝒏𝑼𝑰𝑫 is consistent after class changes 📜 Enable 𝒔𝒑𝒓𝒊𝒏𝒈.𝒋𝒂𝒄𝒌𝒔𝒐𝒏.𝒔𝒆𝒓𝒊𝒂𝒍𝒊𝒛𝒂𝒕𝒊𝒐𝒏 logs ⚡ Use @𝑱𝒔𝒐𝒏𝑰𝒈𝒏𝒐𝒓𝒆 smartly to avoid recursion 🧾 𝑩𝒆𝒔𝒕 𝑷𝒓𝒂𝒄𝒕𝒊𝒄𝒆𝒔 𝑺𝒖𝒎𝒎𝒂𝒓𝒚 ☑️ Implement 𝐒𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐛𝐥𝐞 for persistent/transmittable objects ☑️ Always include a 𝐬𝐞𝐫𝐢𝐚𝐥𝐕𝐞𝐫𝐬𝐢𝐨𝐧𝐔𝐈𝐃 ☑️ Prefer 𝐃𝐓𝐎𝐬 over Entities in APIs ☑️ Mark confidential fields as 𝐭𝐫𝐚𝐧𝐬𝐢𝐞𝐧𝐭 ☑️ Validate 𝐉𝐒𝐎𝐍 mapping via 𝐎𝐛𝐣𝐞𝐜𝐭𝐌𝐚𝐩𝐩𝐞𝐫 💬 𝑨 𝑸𝒖𝒐𝒕𝒆 𝒇𝒓𝒐𝒎 𝒕𝒉𝒆 𝑫𝒆𝒗 𝑹𝒐𝒐𝒎 “My #𝐏𝐎𝐉𝐎 refused to travel until I gave it a passport turns out that passport was #𝐒𝐞𝐫𝐢𝐚𝐥𝐢𝐳𝐚𝐛𝐥𝐞!” 😂 #JavaDeveloper #BackendDeveloper #FullStackDeveloper #SoftwareEngineering #TechInterview #CodingInterview #InterviewPreparation #TechCareer #ProgrammerLife #ITJobs #SpringBoot #SpringFramework #JavaProgramming #CoreJava #AdvancedJava #Microservices #RESTAPI #SpringSecurity #JavaTips #JavaCommunity #Docker #Kubernetes #Containerization #DevOpsTools #CI_CD #TechInnovation Tushar Desai

Decoding Data: A Simple Guide to Java Data Types 📊 Understanding data types is foundational for writing effective and efficient Java code. They tell the compiler what kind of values a variable can hold and what operations can be performed on it. In Java, data types are broadly categorized into two groups: Primitive and Non-Primitive (Reference) types. Let's break them down! 1. Primitive Data Types (The Building Blocks) These are the most basic data types, directly supported by the language. They hold simple values and are always stored in memory where the variable is declared (on the stack). Numbers: byte, short, int, long: For whole numbers (integers) of increasing size. (int is the most commonly used!) float, double: For numbers with decimal points (floating-point numbers). (double is generally preferred for precision.) Characters: char: For single characters, like 'A', 'b', or '5'. Booleans: boolean: For true or false values. Essential for logic and control flow! 2. Non-Primitive Data Types (The References / Objects) Also known as "Reference Types," these are more complex. They don't store the actual values directly but rather references (memory addresses) to objects that store the data. They are created by the programmer or defined by Java. String: A sequence of characters (e.g., "Hello, World!"). While it looks like a primitive, String is actually a class in Java and thus a non-primitive type. Arrays: A collection of values of the same data type (e.g., int[] numbers = {1, 2, 3};). Classes & Interfaces: These are custom data types you define yourself (e.g., Car, Employee). They allow you to create complex objects that encapsulate data and behavior. Why does this matter? Choosing the right data type helps optimize memory usage, prevent errors, and ensures your program behaves as expected. For instance, using an int for an age makes more sense than a double. What data type do you find yourself using most often? Share your thoughts! #Java #Programming #DataTypes #SoftwareDevelopment #TechBasics #CodingTips #Developers