Java practice

Demo/app/src/main/java/com/krunal/demo/javaPractice/CollectionsDemo.java

@@ -0,0 +1,79 @@
+package com.krunal.demo.javaPractice;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class CollectionsDemo {
+    public static void main(String[] args) {
+        // List
+        List<Integer> numList = Arrays.asList(1, 7, 5, 2, 0);
+//        numList.add(5); UnsupportedOperationException
+        numList.set(1, 9);
+        System.out.println(numList.getClass().getName() + " " + numList);
+
+        final List<Integer> newNumList = new LinkedList<>(numList);
+        newNumList.remove(0);
+        System.out.println(newNumList.getClass().getName() + " " + newNumList);
+        newNumList.clear();
+        newNumList.add(3);
+        newNumList.add(2);
+        newNumList.add(4);
+        newNumList.add(0);
+
+        System.out.println("4 at" + newNumList.indexOf(4));
+        Iterator<Integer> iterator = newNumList.iterator();
+        while (iterator.hasNext()) {
+            System.out.print(iterator.next() + " ");
+        }
+        System.out.println();
+
+        for (int n: numList) {
+            System.out.print(n + " ");
+        }
+        System.out.println();
+
+        newNumList.addAll(numList);
+
+        // Map - calculate occurrence
+        Map<Character, Integer> map = new HashMap<>();
+        Character[] arr = {'a', 'b', 'a', 'c', 'd', 'c', 'c', 'c'};
+        Arrays.stream(arr).forEach(ch -> {
+           if (map.containsKey(ch)) {
+               map.put(ch, map.get(ch) + 1);
+           } else {
+               map.put(ch, 1);
+           }
+        });
+        System.out.println(map);
+        map.remove('c');
+        map.remove('b', 4);
+        System.out.println("keys: " + map.keySet());
+        System.out.println("values: " + map.values());
+
+        System.out.println(map.getOrDefault('h', 0));
+        map.computeIfAbsent('h', character -> {
+            System.out.println(character + " is absent");
+            return 6;
+        });
+        map.putIfAbsent('h', 5);
+
+        // Set
+        Set<Integer> set = new HashSet<>(Arrays.asList(1, 2, 2, 3, 1, 0));
+        System.out.println(set);
+
+        // Collection methods
+        System.out.println("max: " + Collections.min(newNumList));
+        Collections.shuffle(newNumList);
+        System.out.println(newNumList);
+        Collections.sort(newNumList);
+        System.out.println(newNumList);
+    }
+}

Demo/app/src/main/java/com/krunal/demo/javaPractice/Conditions.java

@@ -0,0 +1,44 @@
+package com.krunal.demo.javaPractice;
+
+import java.util.Random;
+
+public class Conditions {
+
+    public static void main(String[] args) {
+        if (false) {
+            if (4 >= 5) {
+                System.out.println("4 > 5");
+            } else {
+                System.out.println("5 > 4");
+            }
+        } else if (new Random().nextBoolean()) {
+            System.out.println("In else-if");
+        } else {
+            System.out.println("In else");
+        }
+
+        isVowel('a');
+        isVowel('E');
+        isVowel('0');
+    }
+
+    public static void isVowel(char ch) {
+        switch (ch) {
+            case 'a':
+            case 'e':
+            case 'i':
+            case 'o':
+            case 'u':
+                System.out.println("small case");
+            case 'A':
+            case 'E':
+            case 'I':
+            case 'O':
+            case 'U':
+                System.out.println("Vowel");
+                break;
+            default:
+                System.out.println("Constant");
+        }
+    }
+}

Demo/app/src/main/java/com/krunal/demo/javaPractice/DifferentObjCreation.java

@@ -0,0 +1,59 @@
+package com.krunal.demo.javaPractice;
+
+import androidx.annotation.NonNull;
+
+import java.io.FileInputStream;
+import java.io.ObjectInputStream;
+import java.io.Serializable;
+
+public class DifferentObjCreation {
+
+    public static void main(String[] args) {
+        System.out.println("Hello World");
+        createObjs();
+    }
+
+    public static void createObjs() {
+        Demo2 obj = new Demo2();
+
+        try {
+            obj = (Demo2) Class.forName("com.krunal.demo.javaPractice.Demo2").newInstance();
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+
+        try {
+            Demo2 obj2 = (Demo2) obj.clone();
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+
+        try {
+            ObjectInputStream is = new ObjectInputStream(new FileInputStream("demo2"));
+            Demo2 obj4 = (Demo2) is.readObject();
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+        }
+    }
+}
+
+class Demo2 implements Serializable, Cloneable {
+
+    static {
+        System.out.println("Class initialized");
+    }
+
+    {
+        System.out.println("Class obj initialized");
+    }
+
+    Demo2() {
+        System.out.println("Demo2 constructor");
+    }
+
+    @NonNull
+    @Override
+    protected Object clone() throws CloneNotSupportedException {
+        return super.clone();
+    }
+}

Demo/app/src/main/java/com/krunal/demo/javaPractice/DummyPackage.java

@@ -0,0 +1,8 @@
+package com.krunal.demo.notExist.javaPractice;
+
+public class DummyPackage {
+
+    public DummyPackage() {
+        System.out.println("Dummy Package constructed");
+    }
+}

Demo/app/src/main/java/com/krunal/demo/javaPractice/Enums.java

@@ -0,0 +1,78 @@
+package com.krunal.demo.javaPractice;
+
+public class Enums {
+
+    public static void main(String[] args) {
+        Signal sig = Signal.valueOf("GREEN");
+        checkSignal(sig);
+        sig = sig.next();
+        checkSignal(sig);
+        sig = sig.next();
+        checkSignal(sig);
+    }
+
+    public static void checkSignal(Signal sig) {
+        switch (sig) {
+            case GREEN:
+                System.out.println("\u001B[32m" + sig.action);
+                break;
+            case YELLOW:
+                System.out.println("\u001B[33m" + sig.action);
+                break;
+            case RED:
+                System.out.println("\u001B[31m" + sig.action);
+                break;
+        }
+    }
+}
+
+enum Signal {
+
+    GREEN("Go"),
+    YELLOW("Slow down"),
+    RED("Stop");
+
+    final String action;
+
+    Signal(String action) {
+        this.action = action;
+    }
+
+    public Signal next() {
+        switch (this) {
+            case GREEN:
+                return YELLOW;
+            case YELLOW:
+                return RED;
+            case RED:
+                return GREEN;
+        }
+        return null;
+    }
+}
+
+// Internal implementation of enum
+
+class SignalClass {
+
+    public static final SignalClass GREEN = new SignalClass("Go");
+    public static final SignalClass YELLOW = new SignalClass("Slow down");
+    public static final SignalClass RED = new SignalClass("Stop");
+
+    final String action;
+
+    SignalClass(String action) {
+        this.action = action;
+    }
+
+    public SignalClass next() {
+        if (GREEN.equals(this)) {
+            return YELLOW;
+        } else if (YELLOW.equals(this)) {
+            return RED;
+        } else if (RED.equals(this)) {
+            return GREEN;
+        }
+        return null;
+    }
+}