package stackexample;

public class Main {
    public static void main(String[] args) {
        Stack stk = new Stack(10);
        stk.push(10);
        stk.push(11);
        stk.push(12);
        stk.pop();
        stk.isEmpty();
        System.out.println(stk.top());
    }
}
Copy

package stackexample;

class Stack {
    private int[] store;
    private int top;
    private int max_len;

    public Stack(int size) {
        this.store = new int[size];
        this.max_len = size - 1;
        this.top = -1;
    }

    public void push(int item) {
        if (this.top == this.max_len) {
            System.out.println("Stack Overflow");
        } else {
            this.top++;
            this.store[this.top] = item;
        }
    }

    public void pop() {
        if (this.top == -1) {
            System.out.println("Stack Underflow");
        } else {
            System.out.println("Popped: " + this.store[this.top]);
            this.top--;
        }
    }

    public int top() {
        return this.store[this.top];
    }

    public void isEmpty() {
        if (this.top == -1) {
            System.out.println("Stack is empty");
        } else {
            System.out.println("Stack is not empty");
        }
    }
}
Copy

What is instance variable in Java? Instance variables in Java are non-static variables which are defined in a class outside any method, constructor or a block.

• The interface will be public as we want others to be able to access it.
• All methods defined in an interface should be implemented in the class implementing the interface.
• @Override is used to override the method defined in an interface through a method defined in a class implementing the interface.
• The access specifiers used with classes are private, protected and public. While in Interface only one specifier is used- Public.

• input will not govern the output
• 
• 

Example of tight coupling :

• Accessor and Mutator (top() in Stack is accessor, push() is mutator)
• this keyword
• abstract method : https://docs.oracle.com/javase/tutorial/java/IandI/abstract.html
• Method Overloading
• Variable Arguments (VarArgs) : 02. Basics of JAVA > Variable Arguments (VarArgs)
• extending the interface

package collegeWDA.vararguments;

public class VarArgs {

    static void varTest(int ...a) {
        System.out.println("Number of parameters: " + a.length);

        for (int i : a) {
            System.out.print(i + " ");
        }
    }

    public static void main(String[] args) {
        // meth1(a)
        // meth1(a,b)
        // meth1(a,b,c)
        varTest(1,2,3,4,5);
        // or
        VarArgs testing = new VarArgs();
        testing.varTest(8,9,10);
    }
}
Copy

• this implements polymorphism

• ArrayList is a dynamic array implementation of the List interface.
• It allows elements to be added or removed dynamically, and it automatically resizes itself when needed.
• Elements can be accessed by their index.
• It is not synchronized, so it's not thread-safe for concurrent access.
• Offers fast element retrieval (O(1)) but slower insertion and deletion in the middle (O(n)).

• LinkedList is a doubly linked list implementation of the List interface.
• It consists of nodes where each node contains a data element and references to the next and previous nodes.
• Allows for fast insertion and deletion at any position by simply updating references.
• Elements can be accessed sequentially or by index, but random access is slower compared to ArrayList.
• Not synchronized, so not thread-safe for concurrent access.

• HashSet is an implementation of the Set interface that uses a hash table for storage.
• It does not allow duplicate elements, and it does not guarantee the order of elements.
• Offers constant-time performance for basic operations (add, remove, contains) on average.
• Not synchronized, so not thread-safe for concurrent access.
• The iteration order is not guaranteed and may change over time.

• TreeSet is an implementation of the SortedSet interface that uses a self-balancing binary search tree (Red-Black Tree) for storage.
• Elements are stored in sorted order (natural ordering or by a specified comparator).
• Does not allow duplicate elements.
• Offers guaranteed log(n) time cost for basic operations (add, remove, contains).
• Not synchronized, so not thread-safe for concurrent access.

• HashMap is an implementation of the Map interface that stores key-value pairs.
• It uses a hash table for storage and allows null keys and values (except in concurrent environments).
• Offers constant-time performance for basic operations (put, get, remove) on average.
• Not synchronized, so not thread-safe for concurrent access, but you can use Collections.synchronizedMap() to create a synchronized map.
• Iteration order is not guaranteed and may change over time.

• TreeMap is an implementation of the SortedMap interface that uses a self-balancing binary search tree (Red-Black Tree) for storage.
• Elements are stored in sorted order based on their keys.
• Does not allow duplicate keys.
• Offers guaranteed log(n) time cost for basic operations (put, get, remove).
• Not synchronized, so not thread-safe for concurrent access.

package collegeWDA.Collections;

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

public class Main {

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<String>();
        List<Integer> intList = new ArrayList<>(); // don't use <int>

        System.out.println(stringList.size());
        System.out.println(stringList);
        stringList.add("Hello");
        stringList.add("World");
        stringList.add(1, "in Between");
        System.out.println(stringList); // → [Hello, in Between, World]
        stringList.remove(1);
        System.out.println(stringList.indexOf("World")); // → 1
        System.out.println(stringList.contains("Hello")); // → true
        stringList.add("bruh");
        stringList.add("dawg");
        // list now contains: [Hello, World, bruh, dawg]

        List<String> subList = stringList.subList(1, 2);
        System.out.println(subList); // → [World]

        // labmda function
        // s is an iterator here
        stringList.forEach((s) -> {
            if (s.endsWith("g"))
                System.out.println(s); // → dawg
        });

        /* ------------------------------------------------------ */

        // converting ArrayList to Array, (array is much faster than a list)
        List<Integer> aLi = new ArrayList<>();
        aLi.add(1);
        aLi.add(2);
        aLi.add(3);

        Integer[] arr = new Integer[aLi.size()];
        arr = aLi.toArray(arr); // converting ArrayList to Array
        System.out.println(Arrays.toString(arr)); // → [1, 2, 3]

        /* ------------------------------------------------------ */
        // we can convert an array to a list as well

        List<Integer> convertedList = new ArrayList<>(); // or // List<Integer> convertedList;
        convertedList = Arrays.asList(arr);
        System.out.println(convertedList); // → [1, 2, 3]

        /* ------------------------------------------------------ */
        // another variant of a for loop

        for(int it: convertedList) {
            System.out.println(it); // it denotes the element and not the index of the element
        }
    }
}
Copy

package com.hitarth.IIITL2024;

import java.util.*;

// Binary Search
public class temp {

    public static <HashMapD> void main(String[] args) {
        /* ------------------------------------------------------ */
        // ArrayList
        List<String> aL = new ArrayList<>();

        System.out.println("The size of list aL: " + aL.size()); // → 0

        aL.add("asd");
        aL.add("ASD");
//        aL.add(2, "123"); // is also possible
        aL.add("123");

        for (String item : aL) {
            System.out.print(item + " ");
        }
        System.out.println("The size of list aL: " + aL.size()); // → 3
        aL.remove(1);
        System.out.println("updated list aL: " + aL); // → [asd, 123]
        System.out.println(" Index of d: " + aL.indexOf("123")); // → 1

        List<String> subLst = aL.subList(0, 1); // .subList(fromIndex, toIndex) → [fromIndex, toIndex)
        System.out.println("Sublist: " + subLst); // → [asd]

        aL.forEach(item -> System.out.print(item + " ")); // → asd 123

        aL.forEach(item -> {
            if (item.endsWith("3")) {
                System.out.println(" " + item + " "); // → 123
            }
        });
        /* ------------------------------------------------------ */
//ArrayList to Array (faster operations)

        List<Integer> aL1 = new ArrayList<>();
        aL1.add(1);
        aL1.add(2);
        aL1.add(3);
        aL1.add(4);

        Integer[] arr = new Integer[aL1.size()];
        arr = aL1.toArray(arr);

        for (int it : arr) {
            System.out.print(it + " "); // → 1 2 3 4
        }

        /* ------------------------------------------------------ */
//Array to ArrayList
        List<Integer> cL = new ArrayList<>();
        cL = Arrays.asList(arr);

        /* ------------------------------------------------------ */
//Set
        Set<String> names = new HashSet<>();
        names.add("bruh");
        names.add("bruh");
        names.add("dawg");
        names.add("lmao");

        System.out.println(names); // → [lmao, bruh, dawg]
        names.forEach(name -> System.out.print(name + " ")); // → lmao bruh dawg
        /* ------------------------------------------------------ */
//Map
        Map<String, Integer> tm = new TreeMap<>();
        tm.put("Alice1", 1);
        tm.put("Alice2", 2);
        tm.put("Alice3", 3);
        System.out.println(tm); // → {Alice1=1, Alice2=2, Alice3=3}
        tm.replace("Alice1", 4);
        System.out.println(tm); // → {Alice1=4, Alice2=2, Alice3=3}
        System.out.println(tm.get("Alice1")); // → 4

        /* ------------------------------------------------------ */
    }
}
Copy

package tempPackage;

import java.util.HashMap;
import java.util.Map;

public class Main {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8};
        twoSUm(arr, 10);
    }

    public static void twoSUm(int[] arr, int x)
    {
        Map<Integer, Integer> h = new HashMap<>();
        for(int i=0; i< arr.length; i++)
        {
            int complement = x-arr[i];
            if(h.containsKey(complement))
            {
                System.out.println(arr[i] + " + " + complement + " = " + x);
                System.out.println("Indexes = " + i + " & " + h.get(complement));
            }
            h.put(arr[i], i);
        }
    }
}
Copy

• Study : Jagged stair/diagonal array

package collegeWDA;

// jagged diagonal array take row length from user
public class Array2 {
    public static void main(String[] args) {

        java.util.Scanner sc = new java.util.Scanner(System.in);
        int row = sc.nextInt();

        int[][] arr = new int[row][];
        for (int i = 0; i < arr.length; i++) {
            arr[i] = new int[i + 1];
        }

        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                arr[i][j] = count++;
            }
        }

        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr[i].length; j++) {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
Copy