======Java Primer======

=====Maps=====

====Hash Maps====

<code>
HashMap<Integer, String> hmap = new HashMap();
</code>

  * O(l) lookup and insertion.
  * Can have one null key and multiple null values

====TreeMaps====

  * are 0(logn) lookup and insertion. 
  * But, **keys are ordered**!
  * No null keys
  * keySet()and values() return in ascending order

====LinkedHashMap====

**An OrderedDict!**

Same as hashMap but preserves **insertion order**. O(1) insertion and lookup.

   * Can have one null key and multiple null values
   * O(l) lookup and insertion.


map.getOrDefault(key, default_value);

====HashSet====

<code>
HashSet<String> h = new HashSet<String>(); 

h.add"(a");
h.add("b");
Iterator<String> i = h.iterator(); 
while (i.hasNext()) {
   System.out.println(i.next()); 
}</code>

contains(), add(), isEmpty(), size(), clone()
====Map Iteration=====

<code>
for ( Map.Entry<Integer, Integer> entry : dups.entrySet() )
{
    Integer key = entry.getKey();
    Integer value = entry.getValue();
}
</code>

Or, loop through keys:

<code>
for (String key : map.keySet()) {
    // ...
}
</code>

Or, loop through values

<code>
for (Object value : map.values()) {
    // ...
}
</code>

Remove Map element based on key value:

<code>
     map.keySet().removeIf(e->(e>2));
</code>

<code>
     map.entrySet().removeIf(entry -> entry.getValue().equals("test"));
</code>

=====ArrayList Iteration=====

<code>
    Iterator<Integer> iter = dups.iterator();
    while (iter.hasNext()) {
       System.out.println(iter.next());
    }
</code>

=====HashSet Iteration=====

<code>
     Iterator<String> it = hset.iterator();
     while(it.hasNext()){
        System.out.println(it.next());
     }
</code>

or

<code>
     for (String temp : hset) {
        System.out.println(temp);
     }
</code>

=====Stacks=====

<code>import java.util.*
Stack<Integer> stack = new Stack<>();;
</code>

pop(), peek(), push(), empty(), search()

=====Queue=====

<code>
import java.util.LinkedList; 
import java.util.Queue;
Queue<Integer> q = new LinkedList<>();
</code>

=====PriorityQueue=====

https://www.geeksforgeeks.org/priority-queue-class-in-java-2/

poll(), remove(), add()



<code>
class The_Comparator implements Comparator<String> { 
    public int compare(String str1, String str2) 
    { 
        String first_Str; 
        String second_Str; 
        first_Str = str1; 
        second_Str = str2; 
        return second_Str.compareTo(first_Str); 
    } 
} 

PriorityQueue<String> queue = new PriorityQueue<String>(new The_Comparator()); 
        
</code>
=====DFS=====

====Traversing====

<code>
TreeNode cur = root;
int min = Integer.MAX_VALUE;
int max = Integer.MIN_VALUE;

while(cur != null ||
</code>


=====NOTES=====

  * Vector is the same as ArrayList, but Vector is synchronized. Removing from Vector or ArrayList in O(n).
  * LinkedList has O(1) remove, LinkedList is a double linked list. ArrayList is single.
  * LinkedList is better with add(), remove. 
  * ArrayList better with get(), set().

  * Char to digit: s.charAt(num2Idx) - '0'


=====TRICKS=====

====Log and division====

  * a / b = Math.exp(Math.log(a) - Math.log(b))

====Random====

<code>
//Random number from 0 to 5
Random rand = new Random(); 
int r = rand.nextInt(6); 
</code>

or

<code>
//Number between 0.0 and 1.0;
Math.random(); 
</code>