java_for_algorithms.md

java_for_algorithms.md

Java Algorithm Cheat Sheet.

• Variables
• Math
• Random
• Conditionals
• Arrays
• Lists
• Loops
• Queues and Stacks
• HashSet
• HashMap
• Heap

Variables

// String
String str = "var";
str.length();

// Numbers
Integer num = 13;
int num = 13;
float decimal = 1.0f;

// PARSE
var str = String.valueOf(300);
var num = Integer.valueOf("300") // throws NumberFormatException
var num = Float.valueOf("3.45") // throws NumberFormatException

Math

import java.lang.Math;

Math.abs(-1); // 1
Math.min(2, 1); // 1
Math.max(9, 10); // 1   
Math.floor(3/2); // 1.0
Math.ceil(3/2); // 2.0
Math.sqrt(25); // 5.0
Math.pow(2, 3); // 8.0

Random

import java.util.Random;

// Create a Random object
Random random = new Random();
int randomInt = random.nextInt(100);
double randomDouble = random.nextDouble();
float randomFloat = random.nextFloat();

Conditionals

if (true && false || true) {
    // true
} else if (12.0f == 12) {
    // true
} else if (null == null) {
    // true
} else {
    // else
}

Arrays

import java.util.Arrays;

// ARRAYS
Integer[] myIntArray = { 1, 2, 3, 4 };
var myArray = new Integer[] { 1, 2, 3 };
var myArray = new String[] { "1", "2", "3" };
myArray.length

Arrays.sort(myArray, (n1, n2) -> n1 - n2);
Arrays.sort(myArray, (n1, n2) -> Integer.valueOf(n1) - Integer.valueOf(n2));

Arrays.sort(myArray);
Arrays.sort(myArray, Collections.reverseOrder());

// to list
var list1 = Arrays.asList(myArray);

Lists

import java.util.ArrayList;

var list = new ArrayList<Integer>();
list.add(1); // [1]
list.add(2); // [1, 2]
// (index, value)
list.add(2, 1); // [0, 1] trows IndexOutOfBoundsException
list.get(1); // 2
list.indexOf(0); // -1
if (list.contains(1)) {
    list.remove(1); // returns bool : return at index
}
list.size();

// sort
list.sort(null);
list.sort(Collections.reverseOrder());
Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());
Collections.sort(list, (a, b) -> a - b);

Loops

import java.util.Array;
import java.util.Iterator;

var list = Arrays.asList("Alice", "Bob", "Charlie")

for (String name : list) {
    System.out.println(list);
}

list.forEach((n) -> {
    System.out.println(n);
});

for (int i = 0; i < list.size(); i++) {
    System.out.println(list.get(i));
}

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String name = iterator.next();
}

list.stream()
    .forEach(name -> System.out.println(name));

Queues and Stacks

import java.util.Stack;

// STACK
var stack = new Stack<Integer>();
stack.push(0);
stack.push(1);
stack.push(2);
stack.peek(); // 2
stack.pop(); // 2

stack.empty(); // false
stack.size(); // 2

while (!stack.empty()) {
    int a = stack.pop();
    System.out.println(a);
}

// QUEUE
import java.util.ArrayDeque;

var queue = new ArrayDeque<Integer>();
queue.add(0);
queue.add(1);
queue.add(2);
queue.remove(); // 0 throws NoSuchElementException if empty
queue.poll(); // 1 returns null if empty 
queue.peek(); // 2
queue.size(); // 1

while (!queue.isEmpty()) {
    int a = queue.poll();
    System.out.println(a);
}

HashSet

import java.util.HashSet;

var set = new HashSet<Integer>();
set.add(0);
if (set.contains(0)) {
    set.remove(0); // true
}

set.clear();
set.isEmpty(); // true

for (int num: set) {
    System.out.println(num);
}

HashMap

import java.util.HashMap;

var map = new HashMap<String, Integer>();
map.put("key1", 2);
map.get("key1"); // 2
map.getOrDefault("key2", 0); // 0

map.isEmpty(); // false
map.clear();
map.size(); // 1
map.remove("key"); // return value and removes it
if (map.containsKey("key1")) {
    map.get("key1");
}

// Set<String> keys = map.keySet();
for (String key : map.keySet()) {
    map.get(key);
}

Heap

import java.util.PriorityQueue;

var minHeap = new PriorityQueue<Integer>();
minHeap.add(1);
minHeap.add(4);
minHeap.peek(); // 1
minHeap.poll(); // 1
minHeap.isEmpty(); // false
for (Integer num : minHeap) {
    System.out.println(num);
}

var maxHeap = new PriorityQueue<Integer>(Comparator.reverseOrder());
maxHeap.add(3);
maxHeap.add(1);
maxHeap.peek(); // 3
maxHeap.poll(); // 3
maxHeap.isEmpty(); // false
for (Integer num : maxHeap) {
    System.out.println(num);
}

// from array
Integer[] array = { 3, 1, 5, 7, 2, 9 };
var minHeap = new PriorityQueue<Integer>(Arrays.asList(array));
var maxHeap = new PriorityQueue<Integer>(Comparator.reverseOrder());
maxHeap.addAll(Arrays.asList(array));

// to array
Integer[] maxHeapArray = maxHeap.toArray(new Integer[maxHeap.size()]);