add interview cheatsheet

Author: armankhondker

interviewJavaCheatsheet.java

@@ -0,0 +1,252 @@
+/******************** String, char, Integer conversion ***************/
+[String to int]:     Integer.parseInt(s);        // return int primitive
+[String to Integer]: Integer.valueOf(s); 	     // return an Integer Object
+[int to String]:     String.valueOf(int)
+[char[] to String]:  String str = new String(chArray);
+[list to array]:     String[] arr = list.toArray(new String[list.size()]);
+[array to list]:     List<String> list = Arrays.asList(arr); 
+
+/********************** String ***************************/
+String s = “a*b*c”;
+s.charAt(i);
+s.length();
+s.substring(0, 1);            // [0, 1)
+s.substring(1);               //[1, s.length)
+s.equals(“b”);
+s.compareTo(“b*c*d”);         // return -1 because s comes first in lexicographical order
+s.trim(); 	                  // remove tailing and padding spaces
+s.indexOf(“a”);               // return first index of substring “a”   indexOf(substring)
+s.indexOf(‘a’, 2);            // indexOf(int ch, fromIndex), indexOf(String str, fromIndex)
+s.lastIndexOf(‘a’);           // also we can use s.lastIndexOf(String str)
+s.replaceAll(substr, target); // replace all substr to target in s
+
+char[] arr = s.toCharArray();
+String[] arr = s.split("\\*") // when delimiter is '*'
+String[] arr = s.split("\\.") // when delimiter is '.'
+String res = String.join(String delimiter, List<String> data); // use the delimiter to concatenate the string in data.
+Objects.equals(Object a, Object b); // (1)if both parameters are null return true
+                                    // (2)if exactly one parameter is null return false
+                                    // (3)return the result of invoking the equals() method of the first parameter passing it the second parameter
+                                    // This behaviour means it is "null safe".
+                                    
+/********************** StringBuilder ***************************/
+StringBuilder sb = new StringBuilder();
+sb.append(“a”);
+sb.insert(0, “a”);            // sb.insert(int offset, char c) or sb.insert(offset, str)
+sb.deleteCharAt(int index);
+sb.reverse();
+sb.toString();
+sb.length();                  // return the number of characters in sb, similar to str.length()
+
+/********************** Array ***************************/
+int[] arr = new int[10];
+Arrays.sort(arr);
+Arrays.fill(arr, -1);           // initialize all array elements with value -1
+public void helper(int[] nums);
+helper(new int[]{1, 2});        // initialize array in method
+
+/********************** HashMap (TreeMap), HashSet (TreeSet)***********************/
+HashMap<Character, Integer> map = new HashMap<Character, Integer>();
+map.put('c', 1);
+map.get('c');
+map.getOrDefault(key, defaultValue);                         // if key exists return value, else return default value
+map.remove(‘c’);                                             // remove key and its value
+map.computeIfAbsent(key, mappingFunction);                   // if key exists return value, else create a value by mappingFunction
+map.computeIfAbsent(key, k -> new HashSet<>()).add(val);
+map.computeIfAbsent(key, k -> new ArrayList<>()).add(val);   // RECOMMENDED !!!
+if (map.containsKey('c')) {                                  // check if key exists
+}
+if (map.containsValue(1)) {                                  // check if value exists
+}
+for (Character d : map.keySet()) {                           // traverse key set
+}
+for (Integer i : map.values()) {                             // traverse value set
+}
+for(Map.Entry<Character, Integer> entry : map.entrySet()){   // traverse key-value pair
+    entry.getKey();
+    entry.getValue();
+}
+map.forEach((k,v) -> System.out.println("key: "+k+" value:"+v)); // traverse key-value pair using lamda expression to print out info
+
+map.isEmpty();
+map.size();
+HashSet<Integer> set = new HashSet<Integer>();
+set.add(10);
+set.remove(10);
+if(set.contains(10)){
+}
+set.size();
+set.isEmpty();
+setA.retainAll(setB); // setA keeps the intersection of original setA and setB;
+setB.removeAll(setC); // Removes from this set all of its elements that are contained in the specified collection (setB - setC)
+setC.addAll(setD);    // union two sets of setC and setD
+setC.containsAll(setD); // Returns true if this set contains all of the elements of specified collection
+Object[] arr = setA.toArray(); // Returns an array containing all of the elements in this set.
+
+TreeMap<Integer, String> map = new TreeMap<>();             // key’s ascending order (default)
+map.put(2, “b”);
+map.put(1, “a”);
+map.put(3, “c”);
+for(String str : map.values())                              // traverse in “a” “b” “c” order
+for(Integer num : map.keySet())			                    // traverse in  1, 2, 3 order
+
+TreeMap<String, Integer> treeMap = new TreeMap<>();             // sorted in lexicographical order
+TreeMap<Integer, Integer> treeMap = new TreeMap<>(Collections.reverseOrder()); // descending order
+
+treeMap.lowerKey(k);                                        // return the max key that < k 
+treeMap.floorKey(k);                                        // return the min key that >= k
+treeMap.higherKey(k);                                       // return the min key that > k 
+treeMap.ceilingKey(k);                                      // return the max key that <= k
+treeMap.firstKey();                                         // returns the first (lowest) key currently in this map.
+SortedMap<K,V> portionOfTreeMap = treeMap.headMap(K toKey); // Returns a view of the portion of this map whose keys are strictly less than toKey.
+NavigableMap<K,V> map = treeMap.headMap(toKey, true);       // Returns a view of the portion of this map whose keys are less than or equal to toKey.
+
+Set<Integer> treeSet = new TreeSet<>();                     // sort in ascending order by default
+treeSet.lower(Integer e);	                                // return greatest element that is < e, or null if no such element
+treeSet.floor(Integer e);	                                // return greatest element that is <= e, or null if no such element
+treeSet.ceiling(Integer e);                                 // return smallest element that is >= e, or null if no such element
+treeSet.higher(Integer e);                                  // return smallest element that is > e, or null if no such element
+treeSet.first();                                            // return the first element in the treeset (if min set, return minimum element)
+treeSet.last();                                             // return the last element in the treeset
+
+/********************** LinkedHashMap, LinkedHashSet *************/
+Map<Integer,String> map = new LinkedHashMap<>();
+map.put(1, "first");
+map.put(2, "second");
+map.put(3, "third");           
+for(Map.Entry<Integer,String> entry : map.entrySet())
+    System.out.println(entry.getKey(), entry.getValue());   // print order: 1, 2, 3
+Set<Integer> set = new LinkedHashSet<>();
+
+/********************** List, ArrayList, LinkedList *************/
+List<Integer> list = new ArrayList<>();
+list.add(14);
+list.add(0, 10);                			            // list.add(int index, int value);
+list.get(int index);
+list.remove(list.size() - 1);
+list.set(int index, int val);                     // replaces element at index and returns original
+list.indexOf(Object o);                           // return first index of occurrence of specified element in the list; -1 if not found
+list.subList(int fromIndex, int toIndex);         // return a sublist within range [fromIndex, toIndex)
+Collections.sort(list);				                    // ascending order by default
+Collections.sort(list, Collections.reverseOrder());         // descending order
+Collections.sort(list, new Comparator<Integer>() {
+   @Override
+   public int compare(Integer o1, Integer o2) {             // the Integer can be any Object instead
+   return o1 ‐ o2;// 0‐>1
+   // return o2‐o1; 1‐>0
+   }
+});
+list.forEach(num -> system.out.println(num));   // traverse the list and print out by using lamda function
+
+/********************** Stack, Queue, PriorityQueue, Deque ***********************/
+Stack<Integer> stack = new Stack<Integer>();
+stack.push(10);
+stack.pop();
+stack.peek();
+stack.isEmpty();
+stack.size();
+Queue<Integer> q = new LinkedList<Integer>();
+q.offer(10);    					                                          // q.add() is also acceptable
+q.poll();
+q.peek();
+q.isEmpty();
+q.size();
+PriorityQueue<Integer> pq = new PriorityQueue<>();                            // minimum Heap by default
+PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());  // change to maximum Heap
+pq.add(10);
+pq.poll();
+pq.peek();
+pq.isEmpty();
+pq.size();
+class Node implements Comparable<Node>{
+    int x;
+    int y;
+    public Node(int x, int y){
+        this.x = x;
+        this.y = y;
+    }
+    @Override
+    public int compareTo(Node that){
+        return this.x - that.x;                            // ascending order / minimum Heap
+        // return that.x - this.x;			               // descending order / maximum Heap
+    }
+}
+PriorityQueue<Node> pq = new PriorityQueue<>();
+
+import java.util.Deque; 
+Deque<Integer> dq = new LinkedList<Integer>();    // Deque is usually used to implement monotone queue
+dq.addFirst();  //  dq.offerFirst();
+dq.addLast();   //  dq.offerLast();
+dq.peekFirst(); // 
+dq.peekLast();
+dq.pollFirst(); //  dq.removeFirst();
+dq.pollLast();  //  dq.removeLast();
+
+/************************** Random method *****************************/
+Random rand =new Random();    // initialize Random object
+int i = rand.nextInt(100);    // generate random number in [0, 100)
+float f = rand.nextFloat();   // generate float value in [0, 1)
+double d = rand.nextDouble(); // generate double value in [0.0, 1.0)
+
+/************************** Math *****************************/
+Math.pow(double x, double y); // return x^y 
+Math.round(float a);          // returns the closest int to the argument
+Math.abs(int/float/doubld val);
+Math.sqrt();
+Math.sin(double rad);         // input is rad not angle
+Math.PI;
+Math.E;
+
+/************************** Collections/Object *****************************/
+Collections.nCopies(100, new Object[]{true});// return an immutable list which contains n copies of given object
+getClass()                                   // Returns the runtime class of this {@code Object}
+Collections.singletonList()                  // use it to replace Arrays.asList() when there is only one element
+Collections.unmodifiableSet(new HashSet<>()) // returns an unmodifiable view of the specified set. Note that, changes in specified set will be reflected in unmodifieable set. 
+                                             // Also, any modification on unmodifiableSet is not allowed, which triggers exception.
+Collections.swap(List, int i, int j);        // swap the ith and jth element in list 
+   
+/********************* std input/output  file read/write ************************/
+import java.io.*;
+import java.net.*;
+Scanner in = new Scanner(System.in);
+int n = in.nextInt();
+while(in.hasNext()){
+    String str = in.nextLine();
+}
+
+String inputfile="in.txt";
+String outputfile="out.txt";
+try
+{
+    BufferedReader in = new BufferedReader(new FileReader(inputfile));
+    line = in.readLine();
+    while (line!=null)
+    {
+        // do something with line
+        line=in.readLine();
+    }
+    in.close();              // close the file
+} catch (IOException e)
+{
+    e.printStackTrace();
+}
+
+try{
+    BufferedWriter out = new BufferedWriter(new FileWriter(outputfile));
+    for(String str : map.keySet()){
+         out.write(str + " " + map.get(str));
+         out.newLine();
+    }
+    out.close();           // close the file
+}catch (IOException e)
+{
+    e.printStackTrace();
+}
+
+URL wordlist = new URL("http://foo.com/wordlist.txt");
+BufferedReader in = new BufferedReader(new InputStreamReader(wordlist.OpenStream()));
+String inputLine = null;
+List<String> res = new ArrayList<>();
+while((inputLine = in.readLine()) != null){
+    res.add(inputLine);
+}