Java Arrays: Reference vs Clone Explained

Day 15 Java Practice: Find Product with Maximum Total Quantity While practicing Java, I worked on a small problem involving strings, arrays, and maps. 👉 Given product data with quantity like: {"xyz 19","abc 30","xyz 21","abc 23"} The goal was to: Sum the quantities for the same product Find which product has the maximum total quantity 🧠 Approach: Split each string to get product name and quantity Store and add quantities using a HashMap Traverse the map to find the maximum value ============================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online import java.util.*; class Main {   public static void main(String[] args) {          String a []={"xyz 19","abc 30","xyz 21","abc 23"};     Map<String,Integer>hmap=new HashMap<String,Integer>();          for(String s : a)     {       String data []=s.split(" ");       String name=data[0];       int value=Integer.parseInt(data[1]);       hmap.put(name,hmap.getOrDefault(name,0)+value);                          }          int max=0;     String result="";     for(Map.Entry<String,Integer>entry:hmap.entrySet())     {       if(entry.getValue()>max)       {         max=entry.getValue();         result=entry.getKey();       }     }          System.out.println(result+" "+max);        } } Output: abc 53 #JavaDeveloper #AutomationEngineer #CodingPractice #Collections #ProblemSolving #Learning

✨ Most Useful Keywords In Java✨ ➡️final : The final keyword can be applied to classes, variables, methods, and blocks. Once assigned, it cannot be changed. A final class cannot be extended, a final variable cannot be reassigned, and a final method cannot be overridden. ➡️static : The static keyword can be applied to variables, methods, and blocks. Static members can be accessed using the class name without creating an object. Static methods cannot be overridden. ➡️abstract : Used to create a class or method that is incomplete and must be implemented by sub-classes ➡️assert : Used for debugging to test assumptions during runtime ➡️boolean : Represents a logical data type with values true or false ➡️break : Terminates a loop or switch statement immediately ➡️byte : Data type to store 8-bit integer values ➡️case : Defines a branch in a switch statement ➡️catch : Handles exceptions raised in a try block ➡️char : Stores a single character ➡️class : Used to declare a class ➡️continue : Skips the current loop iteration and continues with the next one ➡️default : Executes when no case matches in switch Defines default methods in interfaces ➡️do : Used in a do-while loop (executes at least once) ➡️double : Stores 64-bit decimal numbers ➡️else : Executes when an if condition is false ➡️enum :Defines a fixed set of constants ➡️extends : Used by a subclass to inherit another class ➡️finally : Block that always executes, used for cleanup ➡️float : Stores 32-bit decimal values ➡️for : Used for loop execution with initialization, condition, and increment ➡️if : Executes code when a condition is true ➡️implements : Used by a class to implement an interface ➡️import : Allows access to classes defined in other packages ➡️instanceof : Checks whether an object belongs to a specific class ➡️int : Stores 32-bit integer values ➡️interface : Used to declare a contract that classes must follow ➡️long : Stores 64-bit integer values ➡️new : Creates an object or instance ➡️package : Groups related classes and interfaces ➡️return : Sends a value back from a method and exits it ➡️short : Stores 16-bit integer values ➡️static : Belongs to the class, not object ➡️super : Refers to parent class object or constructor ➡️switch : Selects execution paths based on an expression ➡️synchronized : Controls thread access to prevent data inconsistency ➡️this : Refers to the current object ➡️throw : Explicitly throws an exception ➡️throws : Declares exceptions that a method may pass upward ➡️transient : Prevents variable from being serialized ➡️try : Wraps code that may generate exceptions ➡️void : Indicates a method returns no value ➡️volatile : Ensures variable value is read from main memory, not cache ➡️while: Executes a loop while condition remains true ➡️var: var enables local variable type inference ➡️record: record is a special immutable class used to store data only #javafeatures #oops #opentowork #fresher #softwareengineer #hiring #javadeveloper

🚀 Java Wrapper Classes: Hidden Behaviors That Trip Up Even Senior Developers Most developers know wrapper classes. Very few understand what happens under the hood — and that’s exactly where top companies separate candidates. Here’s a deep dive into the concepts that actually matter 1. Integer Caching Integer a = 4010; Integer b = 4010; System.out.println(a == b); // false Integer c = 127; Integer d = 127; System.out.println(c == d); // true Q.Why? Java caches Integer values in the range -128 to 127. Inside range → same object (cached) Outside range → new object (heap) 💡 Pro Insight: You can even extend this range using: -XX:AutoBoxCacheMax=<size> 2. == vs .equals() — Silent Bug Generator System.out.println(a == b); // false → reference comparison System.out.println(a.equals(b)); // true → value comparison Using == with wrapper objects is one of the most common production bugs. Rule: == → checks memory reference .equals() → checks actual value 3. hashCode() vs identityHashCode() System.out.println(a.hashCode()); System.out.println(System.identityHashCode(a)); Two objects can have: Same value → same hashCode() Different memory → different identityHashCode() 4. Silent Overflow in Primitive Conversion Integer a = 4010; byte k = a.byteValue(); // -86 What actually happens: byte range = -128 to 127 4010 % 256 = 170 170 interpreted as signed → -86 No error. No warning. This is how real-world bugs sneak into systems. 5. Powerful Utility Methods (Underrated) Integer.toBinaryString(4010); Integer.toHexString(4010); Integer.bitCount(4010); Integer.numberOfLeadingZeros(4010); Useful in: Bit manipulation Competitive programming Low-level optimization 6. Character & Boolean — Also Cached Boolean b1 = true; Boolean b2 = true; System.out.println(b1 == b2); // true Boolean → fully cached Character → cached in ASCII range 7. Character Utilities = Clean Code Character.isLetter('a'); Character.isDigit('3'); Character.isWhitespace('\t'); Character.toUpperCase('a'); The Big Picture Wrapper classes are NOT just primitives with methods. They reveal how Java handles: Memory optimization Object identity Autoboxing behavior Performance trade-offs A big thanks to my mentors Syed Zabi Ulla, peers, and the amazing developer community Oracle for continuously pushing me to go beyond basics and truly understand concepts at a deeper level. #Java #JVM #CoreJava #CodingInterview #FAANG #SoftwareEngineering #BackendDevelopment #ProgrammingTips

Day 11 ⛰️ Java Practice: Check if an Array is a Mountain Array While practicing Java, I came across an interesting array problem: A Mountain Array means: -> Elements first strictly increase -> Reach a peak -> Then strictly decrease -> And the array length must be greater than 2 Example: {5,7,10,14,12,4,2,1} ✅ Mountain Array To solve this, Instead of using extra variables or collections, I solved it using a single index and two while loops — one for climbing up and one for coming down. This approach keeps the logic simple and efficient. ================================================= // Online Java Compiler // Use this editor to write, compile and run your Java code online import java.util.*; class Main {   public static void main(String[] args) {           int a[]={5,7,10,14,12,4,2,1};           System.out.println(mountainArrayCheck(a));   }       public static boolean mountainArrayCheck(int a [])   {     //1).Length of the Array must be greater than 2      if(a.length<3)     {       return false ;     }           int i=0;           //2).Elements must be increasing order !!!     while(i+1<a.length && a[i]<a[i+1])     {       i++;     }           //2).When we reached at peack elements must be decreasing order !!!     while(i+1<a.length && a[i]>a[i+1])     {       i++;     }           if(a.length-1 ==i)     {       return true ;     }     else     {       return false ;     }       } } output : true #AutomationTestEngineer #Selenium #Java #InterviewPreparation #CodingPractice

...........🅾🅾🅿🆂 !!! 𝑷𝒍𝒂𝒕𝒇𝒐𝒓𝒎 卩卂尺 𝑺𝒊𝒎𝒓𝒂𝒏 𝙎𝙚 𝕄𝕦𝕝𝕒𝕜𝕒𝕥 🅷🆄🅸, but 🆁🅾🅱🆄🆂🆃 𝔸𝕣𝕦𝕟 nikla D͓̽i͓̽l͓̽ ka 🅳🆈🅽🅰🅼🅸🅲......!!!.............. Guys you must be wondering, what nonsense things am I writing...."kuch shaayar likhna hai toa kaahi aur likh, linkedin pe kiyu"??? But guess what.....the above phrase represents features of java: 🅾🅾🅿🆂:- 𝗢𝗯𝗷𝗲𝗰𝘁 𝗢𝗿𝗶𝗲𝗻𝘁𝗲𝗱 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴 ....'S' is just a connect letter...don't consider it... 𝑷𝒍𝒂𝒕𝒇𝒐𝒓𝒎:- 𝗣𝗹𝗮𝘁𝗳𝗼𝗿𝗺 𝗶𝗻𝗱𝗲𝗽𝗲𝗻𝗱𝗲𝗻𝘁.....java apps doesn't need to be recoded if you change the operating system😇😇😇 卩卂尺:- the word "par" sounds similiar to "por" and you can then call it 𝗣𝗼𝗿𝘁𝗮𝗯𝗹𝗲...Definitely platform independence makes java portable 𝑺𝒊𝒎𝒓𝒂𝒏:- Either you can say Simran sounds similiar to simple, hence 𝗦𝗶𝗺𝗽𝗹𝗲 is another feature....or say Simran is a very 𝗦𝗶𝗺𝗽𝗹𝗲 girl... 𝕄𝕦𝕝𝕒𝕜𝕒𝕥:- To say Mulakat, you need to say "Mul"...and at the end you are also using a "t"......guess it guess it.....yes it is 𝑴𝒖𝒍𝒕𝒊 𝑻𝒉𝒓𝒆𝒂𝒅𝒊𝒏𝒈....you will love smaller tasks in your programs into individual threads and then executing them concurrently to save your time.... 🅷🆄🅸:- doesn't "Hui" sound almost similiar to "high" I know there is a lot difference but say you are requiring same energy....just you can say "Hui" se 𝙃𝙞𝙜𝙝 𝙋𝙚𝙧𝙛𝙤𝙧𝙢𝙖𝙣𝙘𝙚.....ofcourse java gives a High level of performance as it is 𝑱𝒖𝒔𝒕 𝒊𝒏 𝒕𝒊𝒎𝒆 𝒄𝒐𝒎𝒑𝒊𝒍𝒆𝒅.... 🆁🅾🅱🆄🆂🆃:- Yes ofcourse java is 𝗥𝗼𝗯𝘂𝘀𝘁 because of its strong memory management..... 𝔸𝕣𝕦𝕟:- Arun contains "A" and "N".....Arun se 𝘼𝙧𝙘𝙝𝙞𝙩𝙚𝙘𝙩𝙪𝙧𝙖𝙡 𝙉𝙚𝙪𝙩𝙧𝙖𝙡....right??? Size of all data types in java is same for both 32 bit compiler as well as 64 bit compiler D͓̽i͓̽l͓̽ :- "Dil" had "DI" and "DI" se 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱...java Applications can be distributed and run at the same time on diff computers in same network 🅳🆈🅽🅰🅼🅸🅲:- Yes Java is also 𝗗𝘆𝗻𝗮𝗺𝗶𝗰 due to it's Dynamic class loading feature.... Just repeat the above phrase 2 to 3 times and you will be ablte to retain all the features of java untill you take your last breath.......100% guarantee....

I didn't like JAVA Until.. I found this Java Ultimate Resources Sheet 0. Complete Interview prep for Java Backend Engineer  - https://lnkd.in/dTvYVutD 1. Java Basics:   - Data types, keywords, variables, operators, loops: https://lnkd.in/dr8fYigm  - String: https://lnkd.in/dA2nn79A  - Array: https://lnkd.in/dMDTpPm2 2. Java OOPs:   - abstraction, encapsulation, inheritance, polymorphism: https://lnkd.in/djNeVRex  - Constructor: https://lnkd.in/d_W6Dd8D 3. Java Collections:  - Map, Queue, List, Set: https://lnkd.in/dJPdQhXK  - https://lnkd.in/dtdQsFgj 4. JVM architecture:  - https://lnkd.in/dEEAasFa 5. Java Memory Model:  - https://lnkd.in/dV_WAEHr  - https://lnkd.in/dADTTYJG  - https://lnkd.in/dr8XmbrD  - https://lnkd.in/d7nkrKii 6. Garbage Collections:  - https://lnkd.in/d--bgKvK 7. Exception Handling:  - https://lnkd.in/d7pgMRCJ  - https://lnkd.in/dE7MCH8j 8. Generics:   - https://lnkd.in/dwD7Bzss  - https://lnkd.in/d9Bb9fb7 9. Serialization:  - https://lnkd.in/dGm2mjwy  - https://lnkd.in/dFNepNW9 10. Reflection API:  - https://lnkd.in/dBXdHSD7  - https://lnkd.in/dXsfPWUp 11. File Handling:  - https://lnkd.in/d8g8f45b  - https://lnkd.in/dyCwzkhp 12. Java Functional Programming:   - https://lnkd.in/dPk5vszt  - https://lnkd.in/dVzpUvXn  - https://lnkd.in/d_7pzZuh  - https://lnkd.in/dS9x8SnA 13. Java multi-threading:   - https://lnkd.in/ddKr9rgz  - https://lnkd.in/d6uFXkce  - https://lnkd.in/dK32XAuV  - https://lnkd.in/dP39ZYgT 14. Java Regex:   - https://lnkd.in/dRJf5nX4 15. Java 8 Features:  - https://lnkd.in/dMqx4dve  - https://lnkd.in/dfFkbkmc 16. Java All Remaining Features:   - https://lnkd.in/dSc6MqfA  - https://lnkd.in/drMWeGKw 𝗞𝗲𝗲𝗽𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗶𝗻 𝗺𝗶𝗻𝗱, 𝗜 𝘄𝗲𝗻𝘁 𝗱𝗲𝗲𝗽 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗚𝘂𝗶𝗱𝗲. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗴𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dfhsJKMj keep learning, keep sharing ! #java #backend #javaresources

I didn't like JAVA Until.. I found this Java Ultimate Resources Sheet 0. Complete Interview prep for Java Backend Engineer  - https://lnkd.in/dTvYVutD 1. Java Basics:   - Data types, keywords, variables, operators, loops: https://lnkd.in/dr8fYigm  - String: https://lnkd.in/dA2nn79A  - Array: https://lnkd.in/dMDTpPm2 2. Java OOPs:   - abstraction, encapsulation, inheritance, polymorphism: https://lnkd.in/djNeVRex  - Constructor: https://lnkd.in/d_W6Dd8D 3. Java Collections:  - Map, Queue, List, Set: https://lnkd.in/dJPdQhXK  - https://lnkd.in/dtdQsFgj 4. JVM architecture:  - https://lnkd.in/dEEAasFa 5. Java Memory Model:  - https://lnkd.in/dV_WAEHr  - https://lnkd.in/dADTTYJG  - https://lnkd.in/dr8XmbrD  - https://lnkd.in/d7nkrKii 6. Garbage Collections:  - https://lnkd.in/d--bgKvK 7. Exception Handling:  - https://lnkd.in/d7pgMRCJ  - https://lnkd.in/dE7MCH8j 8. Generics:   - https://lnkd.in/dwD7Bzss  - https://lnkd.in/d9Bb9fb7 9. Serialization:  - https://lnkd.in/dGm2mjwy  - https://lnkd.in/dFNepNW9 10. Reflection API:  - https://lnkd.in/dBXdHSD7  - https://lnkd.in/dXsfPWUp 11. File Handling:  - https://lnkd.in/d8g8f45b  - https://lnkd.in/dyCwzkhp 12. Java Functional Programming:   - https://lnkd.in/dPk5vszt  - https://lnkd.in/dVzpUvXn  - https://lnkd.in/d_7pzZuh  - https://lnkd.in/dS9x8SnA 13. Java multi-threading:   - https://lnkd.in/ddKr9rgz  - https://lnkd.in/d6uFXkce  - https://lnkd.in/dK32XAuV  - https://lnkd.in/dP39ZYgT 14. Java Regex:   - https://lnkd.in/dRJf5nX4 15. Java 8 Features:  - https://lnkd.in/dMqx4dve  - https://lnkd.in/dfFkbkmc 16. Java All Remaining Features:   - https://lnkd.in/dSc6MqfA  - https://lnkd.in/drMWeGKw 𝗞𝗲𝗲𝗽𝗶𝗻𝗴 𝘁𝗵𝗶𝘀 𝗶𝗻 𝗺𝗶𝗻𝗱, 𝗜 𝘄𝗲𝗻𝘁 𝗱𝗲𝗲𝗽 𝗮𝗻𝗱 𝗱𝗼𝗰𝘂𝗺𝗲𝗻𝘁𝗲𝗱 𝗲𝘃𝗲𝗿𝘆𝘁𝗵𝗶𝗻𝗴 𝗶𝗻𝘁𝗼 𝗮 𝗝𝗮𝘃𝗮 𝗕𝗮𝗰𝗸𝗲𝗻𝗱 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿 𝗚𝘂𝗶𝗱𝗲. 𝗚𝗲𝘁 𝘁𝗵𝗲 𝗚𝘂𝗶𝗱𝗲 𝗵𝗲𝗿𝗲: https://lnkd.in/dTvYVutD Use SDE20 to get 20% off. Stay Hungry, Stay FoolisH!

Java Program: Write a program to check given strings are Anagrams or not. 1. The Core Logic: "Sort and Compare." The fundamental idea behind this approach is that if two strings are anagrams, they must contain the exact same characters with the exact same frequencies. By sorting the characters of both strings alphabetically, any differences in the original "arrangement" are removed. If the sorted results are identical, the strings are anagrams. 2. Step-by-Step Breakdown s1.toCharArray(): Strings in Java are immutable objects. To manipulate or sort the individual characters, we first convert the string into a primitive char[] array. "listen" becomes ['l', 'i', 's', 't', 'e', 'n'] Arrays.sort(char1): This method uses a Dual-Pivot Quicksort algorithm. It rearranges the characters in the array into ascending order based on their Unicode values. ['l', 'i', 's', 't', 'e', 'n'] becomes ['e', 'i', 'l', 'n', 's', 't'] ['s', 'i', 'l', 'e', 'n', 't'] also becomes ['e', 'i', 'l', 'n', 's', 't'] Arrays.equals(char1, char2): This is a utility method that checks two things: Do the arrays have the same length? Does every element at index i in the first array match the element at index i in the second array? If both conditions are met, it returns true. 3. Missing Requirements for Production While this snippet works for the hardcoded values, a robust version of this code should include two additional checks: Length Check: Before sorting, you should check if s1.length() == s2.length(). If the lengths are different, they cannot be anagrams, and you can return false immediately without wasting time sorting. Imports: To make this code compile, you must import the java.util.Arrays utility at the top of your file: import java.util.Arrays;

⏳Day 32 – 1 Minute Java Clarity – Comparable vs Comparator** Both sort. But who controls the sorting logic? ⚡ 📌 Core Difference: Comparable = object sorts itself (natural order). Comparator = external class defines custom sort logic. 📌 Code Comparison: import java.util.*; // Comparable – natural order (by age) class Student implements Comparable<Student> {   String name;   int age;   Student(String name, int age) {     this.name = name; this.age = age;   }   public int compareTo(Student other) {     return this.age - other.age; // sort by age ascending   }   public String toString() { return name + "(" + age + ")"; } } // Comparator – custom order (by name) class NameComparator implements Comparator<Student> {   public int compare(Student a, Student b) {     return a.name.compareTo(b.name); // sort by name   } } public class SortingDemo {   public static void main(String[] args) {     List<Student> students = Arrays.asList(       new Student("Charlie", 22),       new Student("Alice", 20),       new Student("Bob", 21)     );     Collections.sort(students);            // Comparable → by age     System.out.println(students);           // [Alice(20), Bob(21), Charlie(22)]     students.sort(new NameComparator());        // Comparator → by name     System.out.println(students);           // [Alice(20), Bob(21), Charlie(22)]     // Java 8 Lambda Comparator     students.sort((a, b) -> b.age - a.age);      // sort by age descending     System.out.println(students);   } } 📌 Head-to-Head Comparison: | Feature | Comparable | Comparator | |---|---|---| | Package | java.lang | java.util | | Method | compareTo() | compare() | | Sort logic location | Inside the class | Outside the class | | Multiple sort orders | ❌ One only | ✅ Multiple | | Modifies class | ✅ Yes | ❌ No | 💡 Real-time Example: 👨🎓 Student Leaderboard : Comparable → Default sort by marks (fixed rule) Comparator → Sort by name, age, or rank depending on view ⚠️ Interview Trap: Can you use both Comparable and Comparator together? 👉 Yes! Comparable sets the default order. 👉 Comparator overrides it when passed explicitly. 📌 Pro Tip: // Java 8 Comparator chaining: students.sort(   Comparator.comparing((Student s) -> s.age)        .thenComparing(s -> s.name) ); // sort by age, then by name ✅ 💡 Quick Summary: ✔ Comparable → natural sort, modifies the class ✔ Comparator → custom sort, external, flexible ✔ Comparable uses compareTo(), Comparator uses compare() ✔ Use Comparator when you can't modify the class ✔ Java 8+ → prefer lambda Comparators ✅ 🔹 Next Topic → Java 8 Streams Introduction Did you know you can chain multiple Comparators in Java 8 with thenComparing()? Drop 🔥 if this was new to you! #Java #Comparable #Comparator #Sorting #JavaCollections #CoreJava #1MinuteJavaClarity #JavaDeveloper #100DaysOfCode

🚀 Java Strings — Part 3: Immutability You’ve heard it a hundred times: 👉 “Strings are immutable in Java” But interviews don’t stop there… they go deeper: 👉 Why? How? What actually happens internally? Let’s break it down 👇 --- ### 🔹 What does “Immutable” really mean? 👉 Once a String object is created, its value cannot be changed java String s = "Hello"; s.concat(" World"); System.out.println(s); // Hello ❗ The original object is untouched --- ### 🔹 What actually happens in memory? java String s = "Hello"; s = s.concat(" World"); 👉 Step-by-step: 1. "Hello" created in SCP 2. "Hello World" created as a new object 3. Reference s now points to new object 💡 Old object is still there (eligible for GC later) --- ### 🔹 Internal Structure (Very Important 🔥) In Java, String is backed by: java private final byte[] value; 👉 Key points: - final → reference cannot change - No setter methods → cannot modify content 💡 That’s what enforces immutability --- ### 🔹 Why Immutability is Needed? #### ✅ 1. Security - Used in: - DB URLs - File paths - Network connections 👉 Prevents accidental/malicious changes --- #### ✅ 2. Thread Safety - No synchronization needed - Multiple threads can share same String safely --- #### ✅ 3. Performance (String Pool 🔥) - Reuse of objects in SCP - Saves memory --- #### ✅ 4. Caching (HashCode) java String s = "abc"; s.hashCode(); // cached internally 👉 Hashcode is calculated once and reused --- ### 🔹 Interview Trap Questions ⚠️ ⚠️ Q1: Is String really immutable? 👉 Yes (value is immutable) 👉 But reference can change java String s = "Hello"; s = "World"; // new object --- ⚠️ Q2: Can we break immutability? (Advanced) 👉 Yes, using Reflection (not recommended) java // Modifying internal value via reflection (hacky) 💡 This is why immutability is “by design”, not absolute enforcement --- ⚠️ Q3: Why StringBuilder is mutable but String is not? 👉 String → safety + caching 👉 StringBuilder → performance (fast modifications) --- ### 🔹 Common Mistakes Developers Make ❌ Assuming concat() modifies original String ❌ Using String in loops (performance issue) ❌ Not understanding memory impact --- ### 🔥 Real Interview Insight 👉 If interviewer asks “Why String is immutable?” Don’t just say definition ❌ Say this instead ✅: ✔ Security ✔ Thread safety ✔ Performance via String Pool ✔ Hashcode caching --- ### 🔥 Final Takeaway ✔ String immutability = design decision ✔ Every modification → new object ✔ Core reason behind many Java optimizations ✔ Frequently asked in interviews (with twists!) #Java #SDET #AutomationTesting #JavaInterview #Immutability #Programming #TechLearn