Misc Topics

public class Test {
    public static void main(String[] args) {
        System.out.print("foo");
    }

    static { System.out.print("bar"); }
}

// Output: "barfoo"

Integer a = 127;
Integer b = 127;
System.out.println(a == b);     // true; uses cached integer object ref for both

Integer a = 128;
Integer b = 128;
System.out.println(a == b);     // false; uses diff refs

/* For Integer objects, Java caches instances of Integer values in the range of -128 to 127. This is known as the "Integer Cache". 
When you create an Integer within this range, Java will return a reference to an existing cached object rather than creating a new one. */

// operator association
System.out.println("Asd" + 10 + 20);    // "Asd1020"
System.out.println(10 + 20 + "Asd");    // "30Asd"


// string immutability
String str = "Arya";
str.replace("A", "x");
System.out.println(str);    // "Arya"

str = str.replace("A", "x");
System.out.println(str);    // "xrya"
str.toUpperCase();          // same as above

Set<String> countries = new HashSet<String>() {
        {
           add("India");
           add("USSR");
           add("USA");
        }
};

// define Anonymous Class
// run code inside Instance Initializer Block

// normal GC scenario
String s1 = new String("Foo");
s1 = new String("Bar");
// String object with value "Foo" isn't referenced anywhere from GC root; hence its GC'ed later

// Island of Isolation
public class Test {
   Test ib;    
   public static void main(String [] str){
       Test t1 = new Test();
       Test t2 = new Test();
       t1.ib = t2; 	// t1 points to t2
       t2.ib = t1; 	// t2 points to t1
       t1 = null;
       t2 = null;
       
       /* 
       * t1 and t2 objects refer to each other 
       * but have no references from GC root
       * these 2 objects form an Island of Isolation and are eligible for GC
       */
   }
}

Mon object = new Mon();

// in waiting class
synchronized(object){ 
    object.wait();
}

// in notifying class
synchronized(object){
    object.notify();
}

List<Integer> list = new ArrayList<>();

ListIterator<Integer> it = list.listIterator();

it.next();
it.previous();
it.add(1);
it.set(2);

// List and ArrayList have two remove methods overloaded
List<Integer> list = new ArrayList<>(List.of(1, 2, 3));
list.remove(2);     // calls remove(int index); closest without autoboxing
System.out.println(list);

// Output: [1, 2]


Collection<Integer> list = new ArrayList<>(List.of(1, 2, 3));
list.remove(2);     // calls remove(Object o) of Collection interface
System.out.println(list);

// Output: [1, 3]

var list1 = new ArrayList<>();       // ArrayList<Object>
var list2 = new ArrayList<String>(); // ArrayList<String>

var list3 = List.of("foo", "bar");   // List<String> (Java infers it automatically!)

// a generic method using a superclass ref
public void process(FlyableAndSwimmable animal) {
    animal.fly();
    animal.swim();
}

// same generic method with a intersection type
public <T extends Flyable & Swimmable> void process(T animal) {
    animal.fly();
    animal.swim();
}

// Benefit: saves the effort for creating a new interface just to get a new combined type to use.

var list = List.of(2, "foo");   // List<Serializable & Comparable<...> & Constable & ConstantDesc>

// note that JVM could've taken the type as List<Object> but it didn't and used an intersection type instead.

Set<Student> set = new HashSet<>();

set.add(new Student(1, "A"));
set.add(new Student(1, "A"));

System.out.println(set.size());     // 2

// Ex - overriding for Student class
@Override
public boolean equals(Object obj){
    if(this == obj){
        return true;
    }

    Student studentObj = (Student) obj;     // explicit cast (Object to Student)

    if(this.id == studentObj.id && this.name.equals(studentObj.name)){
        return true;
    }

    return false;
}

@Override
public int hashCode(){
    return Objects.hash(this.id, this.name);    // utility class; varargs and handles null implicitly
}

Set<String> st = new HashSet<>();
st.add("ABC");
st.add("ABC");
System.out.println(st.size());     // 1

V put(K key, V value){
    int hash = hash(key);       // calc hash

    putVal(hash, key, value);   // puts data in linked list
}

int hash(K key){
    key.hashCode() % 16;      // same but using bitwise operation
}

┌────────────────┬──────────────────┬─────────────────┬─────────────────┐
│    key         │       value      │      hash       │       next      │
└────────────────┴──────────────────┴─────────────────┴─────────────────┘

Map<Integer, String> mp = new HashMap<>();
mp.put(null, "ABC");
System.out.println(mp.get(null));   // prints "ABC"

static final Object PRESENT = new Object();

public HashSet() {
    map = new HashMap<>();
}

public boolean add(E e) {
    return map.put(e, PRESENT) == null;
}

public boolean remove(Object o) {
    return map.remove(o) == PRESENT;
}

public class LinkedhashMap extends HashMap implements Map { }

// constructors
LinkedhashMap();    // default; capacity = 16, LF = 0.75, order = insertion

LinkedhashMap(int capacity);    // LF = 0.75

LinkedhashMap(int capacity, float loadFactor, boolean accessOrder); // true = accessOrder; false = insertion order

┌──────────────┬──────────────┬──────────────┬─────────────┬──────────────┬──────────────┐
│      key     │     value    │     hash     │    next     │    before    │     after    │
└──────────────┴──────────────┴──────────────┴─────────────┴──────────────┴──────────────┘

Map<String, String> identityHashMap = new IdentityHashMap<>();
identityHashMap.put(new String("foo"), "John");
identityHashMap.put(new String("bar"), "Doe");

identityHashMap.put(new String("foo"), "Alice");     // adding duplicate key

System.out.println(identityHashMap.size());         // 3; would've been 2 if any other HashMap type

// Pattern matching using instanceof

// object "o" is checked if its of type String
// if it is, then its put in a new reference variable "s" and we can call "length()" method in it
// otherwise calling "length()" method on object "o" would be a compiler error

Object o = "foobar";

if (o instanceof String s){
    System.out.println("This is a String of length " + s.length());
} else {
    System.out.println("This is not a String");
}

// Pattern matching using switch expression

Object o = ...;     // any object

String formatter = switch(o) {
    case Integer i -> String.format("int %d", i);
    case Long l    -> String.format("long %d", l);
    case Double d  -> String.format("double %f", d);
    case Object o  -> String.format("Object %s", o.toString());
}

record Point(int x, int y) {}

Object o = ...;     // any object

if (o instanceof Point(int x)) {     // compiler-error
}

msg := "foobar"

// iterate over the string using a for loop and ignore the index
for _, c := range msg {
    fmt.Printf("%c\n", c)
}

for (var _ : nums) {
    cnt++;
    if (cnt > limit) {
        // side effects; doesn't use _ loop variable in business logic
    }
}

int age = 69;

String s1 = "I am " + age + " years old";
String s2 = String.format("I am %d years old", age);

log.info("I am {} years old", age);              // SLF4J Logger
System.out.printf("I am %d years old", age);     // prints to STDOUT

// String Interpolation using String Template
String s3 = STR."I am \{age} years old";

public Test(){
    System.out.println("foobar");    // valid
    super();
}