[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 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 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()

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<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

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<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<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 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.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.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

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";

{

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);

}