Tech Jargon - Decoded

🔥Solve LeetCode Problems Daily 👉https://t.me/+9BYfwzAg1dQzODQ1

String Immutability vs. StringBuilder Mutability

public class ImmutabilityExample {
 public static void main(String[] args) {
 String str = "Hello";
 String str2 = str;
 str = str + " World";
 System.out.println("String 1: " + str);
 System.out.println("String 2: " + str2);

 StringBuilder sb = new StringBuilder("Hello");
 StringBuilder sb2 = sb;
 sb.append(" World");
 System.out.println("StringBuilder 1: " + sb);
 System.out.println("StringBuilder 2: " + sb2);
 }
}

Modifying Object Fields Through References

class Box {
    int width;
    int height;

    Box(int w, int h) {
        this.width = w;
        this.height = h;
    }
}

public class ReferenceModification {
    static void modifyBox(Box b) {
        b.width = 20;
        b.height = 30;
    }

    public static void main(String[] args) {
        Box myBox = new Box(10, 15);
        System.out.println("Original width: " + myBox.width + ", height: " + myBox.height);
        modifyBox(myBox);
        System.out.println("Modified width: " + myBox.width + ", height: " + myBox.height);
    }
}

Wrapper Classes and NullPointerException

public class WrapperNull {
    public static void main(String[] args) {
        Integer num = null;
        try {
            int value = num;
            System.out.println("Value: " + value);
        } catch (NullPointerException e) {
            System.out.println("⚠️ NullPointerException caught!");
        }
    }
}

ArrayList of Integers with Auto-boxing

import java.util.ArrayList;

public class ArrayListInteger {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(10);
        numbers.add(20);
        numbers.add(30);

        for (Integer num : numbers) {
            System.out.println(num);
        }
    }
}

🔥Solve LeetCode Problems Daily 👉https://t.me/+9BYfwzAg1dQzODQ1

Primitive to Wrapper and Wrapper to Primitive Conversion

public class WrapperExample {
 public static void main(String[] args) {
 int primitiveInt = 10;
 
 Integer wrapperInteger = Integer.valueOf(primitiveInt); 
 System.out.println("Wrapper Integer: " + wrapperInteger);
 
 int primitiveIntValue = wrapperInteger.intValue();
 System.out.println("Primitive int value: " + primitiveIntValue);

 double primitiveDouble = 5.5;
 Double wrapperDouble = Double.valueOf(primitiveDouble);
 System.out.println("Wrapper Double: " + wrapperDouble);

 double primitiveDoubleValue = wrapperDouble.doubleValue();
 System.out.println("Primitive double value: " + primitiveDoubleValue);

 boolean primitiveBoolean = true;
 Boolean wrapperBoolean = Boolean.valueOf(primitiveBoolean);
 System.out.println("Wrapper Boolean: " + wrapperBoolean);

 boolean primitiveBooleanValue = wrapperBoolean.booleanValue();
 System.out.println("Primitive boolean value: " + primitiveBooleanValue);
 }
}

Comparing Integer Objects in Java

public class IntegerComparison {
    public static void main(String[] args) {
        Integer num1 = 100;
        Integer num2 = 100;
        Integer num3 = new Integer(100);

        System.out.println("num1 == num2: " + (num1 == num2));
        System.out.println("num1.equals(num2): " + num1.equals(num2));
        System.out.println("num1 == num3: " + (num1 == num3));
        System.out.println("num1.equals(num3): " + num1.equals(num3));
    }
}

Wrapper Classes: Integer and Boolean

public class WrapperExample {
    public static void main(String[] args) {
        Integer num1 = Integer.valueOf(10); 
        Integer num2 = 20; 

        System.out.println("num1: " + num1); 
        System.out.println("num2: " + num2); 

        int sum = num1 + num2; 
        System.out.println("Sum: " + sum); 

        Boolean flag1 = Boolean.TRUE; 
        Boolean flag2 = new Boolean(false);

        System.out.println("flag1: " + flag1); 
        System.out.println("flag2: " + flag2); 

        boolean andResult = flag1 && flag2; 
        System.out.println("flag1 && flag2: " + andResult); 
    }
}

Auto-boxing and Unboxing Demonstration

public class AutoBoxingUnboxing {
 public static void main(String[] args) {
 Integer intObject = 10; 
 System.out.println("Integer object: " + intObject);

 int intPrimitive = intObject; 
 System.out.println("Integer to int: " + intPrimitive);

 Double doubleObject = 3.14; 
 System.out.println("Double object: " + doubleObject);

 double doublePrimitive = doubleObject; 
 System.out.println("Double to double: " + doublePrimitive);

 Character charObject = 'A'; 
 System.out.println("Character object: " + charObject);

 char charPrimitive = charObject; 
 System.out.println("Character to char: " + charPrimitive);
 }
}

Modify Object Inside a Method Using References

class Dog {
    String name;

    Dog(String name) {
        this.name = name;
    }

    void setName(String newName) {
        this.name = newName;
    }

    String getName() {
        return this.name;
    }
}

public class ModifyObject {
    public static void changeDogName(Dog dog, String newName) {
        dog.setName(newName);
    }

    public static void main(String[] args) {
        Dog myDog = new Dog("Buddy");
        System.out.println("Original name: " + myDog.getName());

        changeDogName(myDog, "Max");
        System.out.println("New name: " + myDog.getName());
    }
}

Pass-by-Value with Primitives in Java

public class PassByValuePrimitive {

    public static void modifyValue(int x) {
        x = x + 10;
        System.out.println("Inside modifyValue: x = " + x);
    }

    public static void main(String[] args) {
        int num = 5;
        System.out.println("Before modifyValue: num = " + num);
        modifyValue(num);
        System.out.println("After modifyValue: num = " + num);
    }
}

Okay, let's dive into understanding "Pointers Alternative in Java: References & Wrapper Classes" and how Java handles memory! 🧠 Java doesn't have explicit pointers like C or C++. Instead, it uses **references**. Think of a reference as a nickname or an alias for an object in memory. It's like having a phone number that leads you to a specific person (the object). You don't *directly* manipulate the memory address, but you use the reference to access and modify the object. So, what does this mean? When you create an object in Java: 1. Memory is allocated on the heap to store the object's data. 2. The reference variable stores the *address* (though you don't see it directly) of that memory location. 3. When you assign one reference variable to another, you're *not* creating a copy of the object. You're simply creating another reference that points to the *same* object in memory. Imagine you have a balloon 🎈 named "balloon1". If you say "balloon2 = balloon1", you now have two names ("balloon1" and "balloon2") for the *same* balloon. If you let go of "balloon1", "balloon2" also floats away because they both refer to the same actual balloon! ✅ Now, let's talk about **Wrapper Classes**. 🎁 In Java, there's a distinction between primitive data types (like `int`, `boolean`, `double`) and objects. Primitives are stored directly as values, while objects are accessed via references. But sometimes, you need to treat primitive data types like objects -> this is where wrapper classes come in handy! Wrapper classes are classes that "wrap" around primitive data types. For example: - `Integer` wraps `int` - `Boolean` wraps `boolean` - `Double` wraps `double` Why are they useful? 🤔 - **Collections:** Java Collections (like `ArrayList`, `HashMap`) can only store objects, not primitives directly. So, if you want to store integers in an `ArrayList`, you need to use `Integer` objects. - **Null Values:** References can be `null` -> meaning they don't point to any object. This is useful when a value might be absent. Primitives cannot be `null` directly, but their wrapper class counterparts can. For example, `Integer myInt = null;` is valid. - **Utility Methods:** Wrapper classes provide useful methods for converting between data types (e.g., `Integer.parseInt("123")`) and other operations. Autoboxing and Unboxing: ➡️ Java provides a feature called autoboxing and unboxing to make working with wrapper classes more convenient. - **Autoboxing:** Automatically converting a primitive type to its corresponding wrapper class. Example: `Integer myInt = 5;` (The `int` 5 is automatically converted to an `Integer` object). - **Unboxing:** Automatically converting a wrapper class object to its corresponding primitive type. Example: `int x = myInt;` (The `Integer` object `myInt` is automatically converted to an `int`). ⚠️ Be careful with autoboxing/unboxing because it can introduce `NullPointerException` if you try to unbox a `null` wrapper object. Example:

Integer num = null;
int x = num; // This will throw a NullPointerException!

💡 **Key takeaways:** - Java uses references instead of explicit pointers. - References are like aliases for objects in memory. - Wrapper classes allow you to treat primitive types as objects. - Autoboxing and unboxing make working with wrapper classes easier, but be mindful of potential `NullPointerException`s. Understanding memory management and references is fundamental to writing efficient and bug-free Java code! 🎉

Sort ArrayList in Descending Order

import java.util.ArrayList;
import java.util.Collections;

public class SortDescending {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(1);
        numbers.add(9);
        numbers.add(2);

        Collections.sort(numbers, Collections.reverseOrder());

        System.out.println(numbers);
    }
}

LinkedList Operations

import java.util.LinkedList;
import java.util.Collections;

public class LinkedListOperations {
    public static void main(String[] args) {
        LinkedList<String> myList = new LinkedList<>();

        myList.add("Apple");
        myList.add("Banana");
        myList.add("Cherry");

        System.out.println("Original List: " + myList);

        myList.addFirst("Avocado");
        myList.addLast("Date");

        System.out.println("List after adding first and last: " + myList);

        myList.removeFirst();
        myList.removeLast();

        System.out.println("List after removing first and last: " + myList);

        Collections.sort(myList);

        System.out.println("Sorted List: " + myList);
    }
}

Merge Two ArrayLists

import java.util.ArrayList;
import java.util.Collections;

public class MergeArrayLists {
    public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();
        list1.add("Apple");
        list1.add("Banana");

        ArrayList<String> list2 = new ArrayList<>();
        list2.add("Orange");
        list2.add("Grapes");

        ArrayList<String> mergedList = new ArrayList<>();
        mergedList.addAll(list1);
        mergedList.addAll(list2);

        System.out.println("Merged List: " + mergedList);
    }
}

ArrayList Contains Element Check

import java.util.ArrayList;

public class ArrayListContains {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Orange");

        String searchElement = "Banana";

        boolean contains = list.contains(searchElement);

        System.out.println("List contains '" + searchElement + "': " + contains);
    }
}

ArrayList and Array Conversion

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ArrayListArrayConverter {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Cherry");

        String[] array = arrayList.toArray(new String[0]);

        System.out.println("Array: " + Arrays.toString(array));

        List<String> arrayList2 = new ArrayList<>(Arrays.asList(array));

        System.out.println("ArrayList: " + arrayList2);
    }
}

Safe Removal of Elements During ArrayList Iteration

import java.util.ArrayList;
import java.util.Iterator;

public class ArrayListRemoval {
    public static void main(String[] args) {
        ArrayList<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eve");

        Iterator<String> iterator = names.iterator();
        while (iterator.hasNext()) {
            String name = iterator.next();
            if (name.startsWith("C")) {
                iterator.remove();
            }
        }

        System.out.println(names);
    }
}

Find Maximum and Minimum in a List

import java.util.ArrayList;
import java.util.Collections;

public class MinMaxList {
    public static void main(String[] args) {
        ArrayList<Integer> numbers = new ArrayList<>();
        numbers.add(5);
        numbers.add(2);
        numbers.add(8);
        numbers.add(1);
        numbers.add(9);

        int max = Collections.max(numbers);
        int min = Collections.min(numbers);

        System.out.println("Maximum: " + max);
        System.out.println("Minimum: " + min);
    }
}