Java To Remember

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
"Hello".toCharArray()             // ['H', 'e', 'l', 'l', 'o']
Collections.sort(List lst)        // sorts a List in place
Arrays.sort(T[] array)            // sort an array
Collections.reverse(List lst)     // reverses a LIST

Arrays.toString(char[] a)         // convert to string
"Hello".charAt(int x)             // get a char at the specific index
"Hello".length()                  // string length
[1,2,3,4,5].length                // array size

Character.isLetter('a')           // true
Character.isDigit(5)              // true
Character.isLetterOrDigit('a')    // true
Character.isWhitespace(' ')       // true

Character.toLowerCase('A')        // 'a'
Character.isUpperCase('a')        // false

"abcdef".substring(1, 2)          // "b"
"abcdef".substring(1, 5)          // "bcde"
"abcdef".substring(3)             // "def"
"   abcde   ".trim()              // "abcde"

1
2
3
4
5
6
7
8
9
class Node {
  int val;
  Node next;
  
  Node(int x) {
    val = x;      //value
    next = null;  //next element
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Stack{
  Node top; 
  
  /**
   *  Default constructor
   */
  public Stack(){}    
  

  /**
   *  Method that returns top node
   *  without removing it
   */
  public Node peek(){
    if(top != null){
      return top;
    }
    return null;
  }
  
  /**
   *  Method used to remove and
   *  return top node
   */
  public Node pop(){
    if(top == null){
      return null;
    } else {
      Node temp = new Node(top.val);
      top = top.next;
      return temp;  
    }
  }
  
  /** 
   *  Method to add Node
   *  to the top of the Stack
   */
  public void push(Node n){
    if(n != null){
      n.next = top;
      top = n;
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Queue {
  Node first, last;
  
  /**
   *  Push an element to the back
   *  of the queue
   */
  public void enqueue(Node n){
    if(first == null){
      first = n;
      last = first;
    } else {
      last.next = n;
      last = n;
    }
  }
 
  /**
   *  Remove element at the front
   */
  public Node dequeue(){
    if(first == null){
      return null;
    } else {
      Node temp = new Node(first.val);
      first = first.next;
      return temp;
    } 
  }
}

1
2
3
4
5
6
class TreeNode {
  int value;
  TreeNode parent;
  TreeNode left;
  TreeNode right;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class GraphNode{ 
  int val;
  GraphNode next;
  GraphNode[] neighbors;
  boolean visited;
 
  /**
   *  Constructor with value
   */
  GraphNode(int x) {
    val = x;
  }
  
  /**
   *  Constructor with value
   *  and with neightbors
   */
  GraphNode(int x, GraphNode[] n){
    val = x;
    neighbors = n;
  }
 
  /**
   *  toString method
   */
  public String toString(){
    return "value: "+ this.val; 
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static Node bfs(Node root, int value) {
  // Queue is abstract, use an implementation of queue
  Queue<Node> q = new Queue<Node>();
  Node returnValue;
  q.enqueue(root);
  
  while (!q.isEmpty()) {
    Node temp = q.dequeue();
    if (temp.value == value) {
      returnValue = temp;
      break;
    }
    for (Node adj : temp.adjecent) {
      q.enqueue(adj);
    }
  }
  return returnValue;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static Node dfs(Node root, int value) {
  Stack<Node> s = new Stack<Node>();
  Node returnValue;
  s.push(root);
  
  while (!q.isEmpty()) {
    Node temp = s.pop();
    if (temp.value == value) {
      returnValue = temp;
      break;
    }
    for (Node adj : temp.adjecent) {
      s.push(adj);
    }
  }
  return returnValue;
}

1
2
3
4
5
6
public static int fib(int n){
  if(n <= 1)
    return n;         //base case
  else
    return fib(n-1) + fib(n-2); //recursive case
}

1
2
3
4
5
6
7
8
9
10
11
12
13
public static int fibHelper(int start, int end, int prev, int current){
  if(start == end)
    return current;
  else
    return fibHelper(++start, end, current, current + prev);
}

public static int fib(int n){
  if(n <= 1)
    return n;
  else 
    return fibHelper(1,n,0,1);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public static int fib(int n) {
  if (n <= 1){
    return n;
  }
  int current = 1;
  int prev = 0;
  int temp = 0;
 
  for (int i = 2; i <= n; i++) {
    temp = current + prev;  //compute fib at pos n
    prev = current;     //old current is now prev
    current = temp;     //current is temp
  }
  return current;
}

1
2
3
4
5
6
7
8
9
10
11
12
public static int[] Steps = new int[100];
 
public static int f3(int n) {
  if (n <= 2)
    Steps[n]= n;
 
  if (Steps[n] > 0)
      return A[n];
  else
      Steps[n] = f3(n-1) + f3(n-2); //store results so only calculate once!
  return Steps[n];
}

1
2
3
4
5
6
7
8
9
10
public static double caculateProbability(int n){
  double x = 1; 
 
  for (int i=0; i<n; i++) {
    x *=  (365.0-i)/365.0;
  }
 
  double pro = Math.round((1-x) * 100);
  return pro/100;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public static void perm(int[] list, int pos){
  if (pos == list.length) {
    System.out.println( Arrays.toString(list) );
  } else {
    for(int i=pos; i < list.length; ++i){
      swap(list, i, pos);
      perm(list, pos + 1);
      swap(list, i, pos);
    }
  }
}

public static final <T> void swap (T[] a, int i, int j) {
  T t = a[i];
  a[i] = a[j];
  a[j] = t;
}

1
2
3
4
5
6
7
//java8 writing to file
try (BufferedWriter writer = Files.newBufferedWriter(Paths.get(filePath), 
        StandardCharsets.UTF_8)) {
    writer.write("line");
} catch(IOException ioe){
  ioe.printStackTrace();
}

1
2
3
4
5
6
//java8 read all the lines in a file
try (BufferedReader br = Files.newBufferedReader(Paths.get(filePath))) {
    list = br.lines().collect(Collectors.toList());
} catch (IOException e) {
    e.printStackTrace();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//Server
ServerSocket listener = new ServerSocket(9090);
try {
    while (true) {
        Socket socket = listener.accept();
        try {
            ObjectOutputStream out =
                new ObjectOutputStream(socket.getOutputStream());
            out.writeObject("Hi there");
        } finally {
            socket.close();
        }
    }
}
finally {
    listener.close();
}


//Client the data is sent through serialization
//to send objects, they must be serializable
Socket s = new Socket(serverAddress, 9090);
try{
  ObjectInputStream input = new ObjectInputStream(s.getInputStream());
  String answer = (String)input.readObject();
} catch(ClassCastException cce){
  cce.printStackTrace();
} finally {
  s.close();
}

//On mac, you can open a terminal and write "nc localhost 9090" to connect to server socket

1
2
3
4
5
6
7
//Long way, that can be reused
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaab");
boolean b = m.matches();

//shorthand
boolean b = Pattern.matches("a*b", "aaaaab");

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Padding left
System.out.printf("%10s %10s\n", "hello", "world");

// Padding right
System.out.printf("%-10s %-10s\n", "hello", "world");

// As is
System.out.printf("%s %s\n", "hello", "world");

// Max 2 characters
System.out.printf("%.2s %.2s\n", "hello", "world");

/*
     hello      world
hello      world     
hello world
he wo    
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Padding left
System.out.printf("%10d %10d\n", 12345, 54321);

// Padding right
System.out.printf("%-10d %-10d\n", 12345, 54321);

// As is
System.out.printf("%d %d\n", 12345, 54321);

// fill rest of 10 digits with 0s
System.out.printf("%010d %010d\n", 12345, 54321);

/*
     12345      54321
12345      54321     
12345 54321
0000012345 0000054321
*/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Padding left
System.out.printf("%14f %14f\n", 123.456789, 987.654321);

// Padding right
System.out.printf("%-14f %-14f\n", 123.456789, 987.654321);

// As is
System.out.printf("%f %f\n", 123.456789, 987.654321);

// 3 digit Precision + left padding 
System.out.printf("%14.3f %14.3f\n", 123.456789, 987.654321);

/*
    123.456789     987.654321
123.456789     987.654321    
123.456789 987.654321
       123.457        987.654
*/

1
2
3
4
5
6
7
8
9
10
11
Map<String, Integer> map = new HashMap<>();
map.put("a", 1); // { a:1 }
map.put("b", 2); // { a:1, b:2 }
map.put("c", 3); // { a:1, b:2, c:3 }

map.get("a");    // 1
map.containsKey("d"); // false
map.values();    // [1, 2, 3]
map.keySet();    // ["a", "b", "c"]
map.remove("a"); // { b:2, c:3 }
map.clear();     // {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
Set<Integer> set = new HashSet<>();
set.add(1);       // { 1 }
set.add(2);       // { 1, 2 }
set.add(3);       // { 1, 2, 3 }

set.contains(5);  // false
set.contains(2);  // true
set.remove(2);    // { 1, 3 }

for(int val: set) {
  System.out.println(val);
}
// 1
// 3

List<Integer> list = new ArrayList<>(set); // [1,3]

set.clear();      // {}

1
2
3
4
5
6
7
8
9
10
11
12
13
Deque<Integer> deque = new ArrayDeque<>();
deque.add(5);         // [5]
deque.addFirst(2);    // [2,5]
deque.addLast(3);     // [2,5,3]

deque.getFirst();     // 2
deque.getLast();      // 3

deque.removeFirst();  // 2 [5,3]
deque.removeLast();   // 3 [5]

int[] array = new int[deque.size()]; // [0]
deque.toArray(array);