Java cheating sheet

Syntax and tricks

Array

//initial
var arr = new int[10];

int[] myIntArray = {1, 2, 3};

int[][] move = { { r - 1, c }, { r + 1, c }, { r, c - 1 } };

//add another array list into list.
List<List<String>> ans = new ArrayList<>();

//use List.of to build a list
List<String> arr = List.of("a", "b");
System.out.println(arr.size());
System.out.println(arr.get(0));

//length
var l = arr.length;

//sort
Arrays.sort(arr);

String and Char

//String length. call function
s.length();

//check if char is lower case or upper case
Character.isUpperCase(c)
Character.isLowerCase(c)

//loop through string by chars
for (int i=0; i<s.length(); i++) {
     var c = s.charAt(i);
}

//char to string
Character.toString(c);

//string to int
Integer.parseInt("09")

//int to string
var s = Integer.toString(98);

number char '9' to int

int v = '9' - '0';

map

//To get default value. assume key is int 6 and default value is 0
var val = map.getOrDefault(6, 0);

//can use ArrayList as map key
var map1 = new HashMap<List<Integer>, String>();

//can use array as map value
var map = new HashMap<Integer, int[]>();

//see if hash has key
if (map.containsKey(n)) continue;

//loop through
for (int k: map.keySet()) System.out.println(map.get(k));

//create a reverse order tree map
var map = new TreeMap<Integer, Integer>(Collections.reverseOrder());
 
 //empty map
 map.clear();

set

//add element
set.add(n);

//set size;
return set.size();

//contains key
set.contains(key)

//find intersection of two set
var set1 = new HashSet<Integer>();
var set2 = new HashSet<Integer>();
//copy elements.  So, elements in set1 and set2 will not change
var intersection = new HashSet<Integer>(set1);
intersection.retainAll(set2);

Stack

//pop or push
stack.pop()
stack.peek()
stack.push(c)

//stack can hold array
var stack = new Stack<int[]>();
int[] point = {1,2};
stack.push(point);

StringBuilder

var builder = new StringBuilder();
 for (char c: stack) builder.append(c);
        
return builder.toString();

Noted in code snippets below, some <type> is missing because of shortcoming of code highlight

var keyword in Java

The var keyword was introduced in Java 10. It does not make Java dynamically typed. Compiler will figure out type using information from the variable's initializer.

• var is used to declaring local variables and an initializer is required on the right-hand side
• var can not be used as fields, method parameters and method return type
• can not initiate with null

The below is a code snippet to use var. This is a solution for Leet code 2094

class Solution {
    public int[] findEvenNumbers(int[] digits) {
        var d =new int[10];
        for (var i: digits) d[i]=d[i]+1;
        
        var number= 100;
        
        
        var ans = new ArrayList<Integer>();
        
        while (number<999) {
            // find three digit to build this number
            var d1 = number/100;
            var d2 = (number-d1*100)/10;
            var d3 = number-d1*100-d2*10;
            
            //check if we get enough digits
            var check = Arrays.copyOf(d, 10);
         
            check[d1] = check[d1]-1;
            check[d2] = check[d2]-1;
            check[d3] = check[d3]-1;
           
            if (check[d1]>=0 && check[d2]>=0 && check[d3]>=0) ans.add(number);
               
            number=number+2;
        }
        
        var result = new int[ans.size()];
        for (var i=0; i<ans.size(); i++) result[i]=ans.get(i);
        
        return result;
        
    }
}

Can not find symbol var problem

Test.java:15: error: cannot find symbol var 

java -version
openjdk version "11.0.11" 2021-04-20

javap -verbose Test | grep "major"
 major version: 52
 //okay, not good. 52 =>JVM 8
 
 //install jdk-11 (before used sudo apt-get install default-java)
 sudo apt-get install openjdk-11-jdk

 //check. It is good now
 javap -verbose Test | grep "major"
  major version: 55

Lambda expression

import java.util.*;

class test3 {
	public static void main(String[] args) {
		List<String> names = Arrays.asList("leo", "winkey", "scott", "jeniffer");
		Collections.sort(names, (String a, String b) -> {
				return a.compareTo(b);
			}

		);

	}
}

The below is lambda expression

Lambda was introduced in Java 8

(String a, String b) -> {
	return a.compareTo(b);
}

For one line expression, can skip both return and curly brace

(String a, String b) ->  a.compareTo(b)

Java will figure out type here. Therefore the expression can be

(a,b)->a.compareTo(b)

//sort list of list
pairs.sort((l1, l2) -> l1.get(0).compareTo(l2.get(0)));

//sort arrayList
Collections.sort(list);

//sort array
Arrays.sort(need);

//use Lamda to sort array. Result is "yy", "ddd", "oldyy"
//if want to sort int array by lambda, array needs to be: var arr = new Integer(10)
 String[] hb = {"ddd", "yy", "oldyy"};
 Arrays.sort(hb, (a,b) ->a.length()-b.length());
 
 //sort that two dimension array
 Arrays.sort(nums, (a, b) -> b[1]-a[1]);
 
 //sort by two cols
 Arrays.sort(
      res,
      Comparator.<int[]>comparingInt(arr -> arr[0]).thenComparing(arr -> arr[1])
    );
 
 

Stream

local variable in the lambda function need to be final or effectively final. For object, if we do not change reference, it is effectively final. Then we can use StringBuilder object defined outside in the example below.

List<String> myList =
    Arrays.asList("ab", "cd", "cf", "ed");

myList
    .stream()
    .filter(s -> s.startsWith("c"))
    .map(String::toUpperCase)
    .sorted()
    .forEach(System.out::println);
    
//another example. chars return a int stream for string
StringBuilder sb = new StringBuilder("");
        
s.chars().forEach(i->sb.append(Character.toLowerCase((char)i)));

HashMap

//key reversed (big to small) treemap
var map = new TreeMap<Integer, Integer>(Collections.reverseOrder());

//leetcode 2190
class Solution {
    public int mostFrequent(int[] nums, int key) {
        var hashmap = new HashMap<Integer, Integer>();
        
        for (int i=1; i<nums.length; i++) {
            if (nums[i-1]==key) {
                hashmap.put(nums[i], 1 + hashmap.getOrDefault(nums[i], 0));
            }
        }
        
        int maxC = 0;
        int ans = 0;
        
        
        for(Integer k : hashmap.keySet()) {
            if (hashmap.get(k)>maxC) {
                maxC = hashmap.get(k);
                ans = k;
            }
        }
        return ans;
    }
}

//create ArrayList of arr
var list = new ArrayList<String[]>();

cast between char, string and integer

//int to string
var s = String.valueOf(x);

//solution for leetcode 2194
class Solution {
    public List<String> cellsInRange(String s) {
        
        var row = new int[2];
        
        //cast string "2" to integer
        row[0]  = Integer.parseInt(s.substring(1,2));
        
        row[1]  = Integer.parseInt(s.substring(4,5));
        
        //cast char 'A' to integer
        var col = new int[2];
        col[0] = (int)s.charAt(0);
        col[1] = (int)s.charAt(3);
       
        var ans = new ArrayList<String>();
        
        for (int c= col[0]; c<=col[1]; c++) {
            
            for (int r=row[0]; r<=row[1]; r++) {
            	//int to char; char to string
                var cell = Character.toString((char)c) + r;
                ans.add(cell);
            }
        }
        
        return ans;
   
    }
}

bit operation

bitwise and. & AND Sets each bit to 1 if both bits are 1

int a = 4&3;
System.out.println(a); //0 because 100 &011

Bit shift

    // 2 bit left shift operation
    int number = 2;
    int result = number << 2;
    System.out.println(result); // prints 8

    // 1 bit left shift operation
    int number2 = 2;
    int result2 = number2 << 1;
    System.out.println(result2); // prints 4

The fastest way to check if a number is a prime

private int isPrime(int n) {
    if (n <= 1) return 0;
    if (n == 2 || n == 3) return 1;
    if (n % 2 == 0 || n % 3 == 0) return 0;
    for (int i = 5; i * i <= n; i = i + 6) {
      if (n % i == 0 || n % (i + 2) == 0) return 0;
    }
    return 1;
  }

Find all primes less than n

  //find all primes LESS THAN n
  //if want to primes less or equals, set argument to 
  //be n+1 when call this function.
  public ArrayList<Integer> countPrimes(int n) {
    ArrayList<Integer> arr = new ArrayList<>();
    boolean[] notPrime = new boolean[n];

    for (int i = 2; i < n; i++) {
      if (notPrime[i] == false) {
        arr.add(i);

        for (int j = 2; i * j < n; j++) {
          notPrime[i * j] = true;
        }
      }
    }

    return arr;
  }

TreeSet floor and ceiling

It will find a value for the set. floor: greast value less or equals the given value. ceiling: smalles value greater or equals to the given value.

//solution for Leetcode 2817
class Solution {
    public int minAbsoluteDifference(List<Integer> nums, int x) {
        int ans = Integer.MAX_VALUE;
        TreeSet<Integer> set = new TreeSet<>();

        for (int i=x; i<nums.size(); i++) {
            set.add(nums.get(i-x));
            
            Integer val = set.floor(nums.get(i));
            if (val!=null) ans = Math.min(ans, Math.abs(val - nums.get(i)));

            val = set.ceiling(nums.get(i));
            if (val!=null) ans = Math.min(ans, Math.abs(val - nums.get(i)));
        }

        return ans;
        
    }
}

Run codes

//javac Solution.java | java Solution
class Solution {

  public boolean canMakeSquare(char[][] grid) {
    if (isGood(grid, 0, 0)) return true;
    if (isGood(grid, 1, 0)) return true;
    if (isGood(grid, 0, 1)) return true;
    if (isGood(grid, 1, 1)) return true;

    return false;
  }

  private boolean isGood(char[][] grid, int row, int col) {
    int b = 0;
    int w = 0;

    for (int i = row; i <= row + 1; i++) {
      for (int j = col; j <= col + 1; j++) {
        if (grid[i][j] == 'B') {
          b++;
        } else {
          w++;
        }
      }
    }

    return b >= 3 || w >= 3;
  }

  public static void main(String[] args) {
    Solution obj = new Solution();
    char[][] test = { { 'B', 'W', 'B' }, { 'B', 'W', 'W' }, { 'B', 'W', 'B' } };

    var ans = obj.canMakeSquare(test);
    System.out.println(ans);
  }
}

Java Queue

Java Queue