Java

InputFile in = new InputFile("Cleanup.java"); //need to close
in.nextLine()

// Method 1
Stream<String> linesStream = Files.lines(Paths.get("Cleanup.java"));

// Method 2
in = new FileInputStream(new File("MessyExceptions.java")); //need to close
int contents = in.read();

// Method 3
List<String> lines = Files.readAllLines(Paths.get("MainException.java"));

Integer[] arr = {1,2,3,4,5};
Stream.of(arr);
Arrays.stream(arr);

public void filterEmployeesThenGroup() {
    List<Employee> employees = getAllEmployees().stream()
            .filter(employee -> "abc".equals(employee.getSubCompany()))
            .collect(Collectors.toList());
    Map<String, List<Employee>> resultMap = new HashMap<>();
    for (Employee employee : employees) {
        List<Employee> groupList = resultMap
                .computeIfAbsent(employee.getDepartment(), k -> new ArrayList<>());
        groupList.add(employee);
    }
    System.out.println(resultMap);
}

public void filterEmployeesThenGroupByStream() {
    Map<String, List<Employee>> resultMap = getAllEmployees().stream()
            .filter(employee -> "abc".equals(employee.getSubCompany()))
            .collect(Collectors.groupingBy(Employee::getDepartment));
    System.out.println(resultMap);
}

public void testForJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    StringBuilder builder = new StringBuilder();
    for (String id : ids) {
        builder.append(id).append(',');
    }
    builder.deleteCharAt(builder.length() - 1);
    System.out.println(builder.toString());
}

public void testCollectJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    String joinResult = ids.stream().collect(Collectors.joining(","));
    System.out.println(joinResult);
}

public void testSimpleStopOptions() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    System.out.println(ids.stream().filter(s -> s.length() > 2).count());
    System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
    ids.stream().filter(s -> s.length() > 2)
            .findFirst()
            .ifPresent(s -> System.out.println("findFirst:" + s));
}

public void testCollectStopOptions() {
    List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
    // collect to list
    List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toList());
    System.out.println("collectList:" + collectList);
    // collect to Set
    Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toSet());
    System.out.println("collectSet:" + collectSet);
    // collect to HashMap，keyto id，value to Dept
    Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20)
            .collect(Collectors.toMap(Dept::getId, dept -> dept));
    System.out.println("collectMap:" + collectMap);
}

public void testNumberCalculate() {
    List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
    Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
    System.out.println("Average：" + average);
    IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
    System.out.println("statistics analysis ： " + summary);
}

Predicate<String> len6 = pwd -> pwd.length() > 6;
Predicate<String> len10 = pwd -> pwd.length() < 10;

password = "1234567";
opt = Optional.ofNullable(password);
boolean result = opt.filter(len6.and(len10)).isPresent();
System.out.println(result);

interface InterfaceA {

    default void printSomething() {
        System.out.println("I am inside A interface");
    }
}

public interface InterfaceB {

    default void printSomething() {
        System.out.println("I am inside B interface");
    }
}

public class Main implements InterfaceA, InterfaceB {

    @Override
    public void printSomething() {

        //Option 1 -> Provide our own implementation.
        System.out.println("I am inside Main class");

        //Option 2 -> Use existing implementation from interfaceA or interfaceB or both.
        InterfaceA.super.printSomething();
        InterfaceB.super.printSomething();
    }

    public static void main(String args[]){
         Main main = new Main();
         main.printSomething();
    }
}

List                 | Add  | Remove | Get  | Contains | Next | Data Structure
---------------------|------|--------|------|----------|------|---------------
ArrayList            | O(1) |  O(n)  | O(1) |   O(n)   | O(1) | Array
LinkedList           | O(1) |  O(1)  | O(n) |   O(n)   | O(1) | Linked List
CopyOnWriteArrayList | O(n) |  O(n)  | O(1) |   O(n)   | O(1) | Array



Set                   |    Add   |  Remove  | Contains |   Next   | Size | Data Structure
----------------------|----------|----------|----------|----------|------|-------------------------
HashSet               | O(1)     | O(1)     | O(1)     | O(h/n)   | O(1) | Hash Table
LinkedHashSet         | O(1)     | O(1)     | O(1)     | O(1)     | O(1) | Hash Table + Linked List
EnumSet               | O(1)     | O(1)     | O(1)     | O(1)     | O(1) | Bit Vector
TreeSet               | O(log n) | O(log n) | O(log n) | O(log n) | O(1) | Red-black tree
CopyOnWriteArraySet   | O(n)     | O(n)     | O(n)     | O(1)     | O(1) | Array
ConcurrentSkipListSet | O(log n) | O(log n) | O(log n) | O(1)     | O(n) | Skip List



Queue                   |  Offer   | Peak |   Poll   | Remove | Size | Data Structure
------------------------|----------|------|----------|--------|------|---------------
PriorityQueue           | O(log n) | O(1) | O(log n) |  O(n)  | O(1) | Priority Heap
LinkedList              | O(1)     | O(1) | O(1)     |  O(1)  | O(1) | Array
ArrayDequeue            | O(1)     | O(1) | O(1)     |  O(n)  | O(1) | Linked List
ConcurrentLinkedQueue   | O(1)     | O(1) | O(1)     |  O(n)  | O(n) | Linked List
ArrayBlockingQueue      | O(1)     | O(1) | O(1)     |  O(n)  | O(1) | Array
PriorirityBlockingQueue | O(log n) | O(1) | O(log n) |  O(n)  | O(1) | Priority Heap
SynchronousQueue        | O(1)     | O(1) | O(1)     |  O(n)  | O(1) | None!
DelayQueue              | O(log n) | O(1) | O(log n) |  O(n)  | O(1) | Priority Heap
LinkedBlockingQueue     | O(1)     | O(1) | O(1)     |  O(n)  | O(1) | Linked List



Map                   |   Get    | ContainsKey |   Next   | Data Structure
----------------------|----------|-------------|----------|-------------------------
HashMap               | O(1)     |   O(1)      | O(h / n) | Hash Table
LinkedHashMap         | O(1)     |   O(1)      | O(1)     | Hash Table + Linked List
IdentityHashMap       | O(1)     |   O(1)      | O(h / n) | Array
WeakHashMap           | O(1)     |   O(1)      | O(h / n) | Hash Table
EnumMap               | O(1)     |   O(1)      | O(1)     | Array
TreeMap               | O(log n) |   O(log n)  | O(log n) | Red-black tree
ConcurrentHashMap     | O(1)     |   O(1)      | O(h / n) | Hash Tables
ConcurrentSkipListMap | O(log n) |   O(log n)  | O(1)     | Skip List

Collections.sort(list); // inplace
Collections.sort(list, Collections.reverseOrder()); // reverse order

list.stream().sorted().collect(Collectors.toList()); // return new
list.stream().sorted(Comparator.reverseOrder()).collect(Collectors.toList());

List list = new ArrayList(); //size of zero
list.add(12);
list.add(int index, E element);
list.addAll(anotherList);
list.addAll(3, anotherList);
list.get(1);

List sec_list = (ArrayList) list.clone();

list.remove(Integer.valueOf(30)); // This will remove 30 from the list

list.replaceAll((element) -> element.toUpperCase());

list.set(index, val);

list.indexOf(10)

import java.util.Comparator;

public class BrandComparator implements Comparator<Vehicle> {

	@Override
	public int compare(Vehicle o1, Vehicle o2) {
		return o1.brand.compareTo(o2.brand);
	}
}

private static class Node<E> {
     E item;
     Node<E> next;
     Node<E> prev;

     Node(Node<E> prev, E element, Node<E> next) {
         this.item = element;
         this.next = next;
         this.prev = prev;
     }
 }

List list = new CopyOnWriteArrayList();

// This TreeSet will store the elements in reverse order.
TreeSet<Integer> reverseSet = new TreeSet<>(Comparator.reverseOrder());

TreeSet<Integer> set = new TreeSet<>();

class Employee {
	int empId;
	String empName;

	public Employee(int empId, String empName) {
		super();
		this.empId = empId;
		this.empName = empName;
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + empId;
		result = prime * result + ((empName == null) ? 0 : empName.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		Employee emp = (Employee) obj;
		return this.empId == emp.empId;
	}
}

// LinkedHashMap with specified order
LinkedHashMap<Key, Value> numbers2 = new LinkedHashMap<>(capacity, loadFactor, accessOrder);

ThreadLocalRandom.current().nextInt();

Runtime runtime = Runtime.getRuntime();
Process process = runtime.exec("notepad.exe");

List<String> command = new ArrayList<>();
command.add("ls");
command.add("-la");

ProcessBuilder builder = new ProcessBuilder(command);
Process process = builder.start();

class MyThread extends Thread {
    @Override
    public void run() {
        // code to be executed in this thread
    }
}

MyThread thread = new MyThread();
thread.start();

class MyRunnable implements Runnable {
    public void run() {
        // code to be executed in this thread
				Thread.currentThread(); // Get current executing thread
    }
}

MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start();

ExecutorService executorService = Executors.newFixedThreadPool(100);
executorService.execute(() -> System.out.println("aaaa"));
executorService.shutdown();

import java.util.Timer;
import java.util.TimerTask;

public class Main {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("Hello, I am a well-behaved task");
            }
        }, 3000);
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) {
        ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();
        executor.schedule(() -> System.out.println("Hello, I am a well-behaved task"), 3, TimeUnit.SECONDS);
        executor.shutdown();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ExecutionException;

public class Main {

    public static void main(String[] args) {
        final int n = 10;
        Callable<Integer> sumTask = new Callable<Integer>() {
            public Integer call() throws Exception {
                int sum = 0;
                for (int i = 1; i <= n; i++)
                    sum += i;
                return sum;
            }
        };

        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future<Integer> result = executor.submit(sumTask);

        try {
            System.out.println("The sum is: " + result.get());
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            executor.shutdown();
        }
    }
}

class MyThread extends Thread {
    private Object lock;

    public MyThread(Object lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        synchronized (lock) {
            // critical section
        }
    }
}

class Student implements Runnable {
        static private int atomicInteger = 100;
        static private final Lock lock = new ReentrantLock();
        @Override
        public void run() {
            lock.lock();
            try{
                if (atomicInteger > 0) {
                    System.out.println(Thread.currentThread().getId() + "eat one " + atomicInteger--);
                }
            }finally {
                lock.unlock();
            }
        }
    }

class FooBar {
    private int n;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();
    private boolean isFirst = true;

    public FooBar(int n) {
        this.n = n;
    }

    public void foo(Runnable printFoo) throws InterruptedException {
        
        for (int i = 0; i < n; i++) {
            lock.lock();
            while(!isFirst){
                condition.await();
            }
	        	printFoo.run();
            isFirst = false;
             condition.signal();
            lock.unlock();
        }
    }

    public void bar(Runnable printBar) throws InterruptedException {
        
        for (int i = 0; i < n; i++) {
            lock.lock();
            while(isFirst){
                condition.await();
            }
	        	printBar.run();
            isFirst = true;
            condition.signal();
            lock.unlock();
        }
    }
}

class WaitingThread extends Thread {
    private final Object sharedLock;

    public WaitingThread(Object sharedLock) {
        this.sharedLock = sharedLock;
    }

    @Override
    public void run() {
        synchronized (sharedLock) {
            try {
                System.out.println(Thread.currentThread().getName() + " is waiting.");
                // wait for another thread to notify
                sharedLock.wait();
                // continue execution
                System.out.println(Thread.currentThread().getName() + " has been notified and is resuming execution.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // create shared lock object
        Object sharedLock = new Object();

        // create threads
        WaitingThread t1 = new WaitingThread(sharedLock);
        WaitingThread t2 = new WaitingThread(sharedLock);

        // set thread names
        t1.setName("Thread 1");
        t2.setName("Thread 2");

        // start threads
        t1.start();
        t2.start();

        // wait for threads to be in waiting state
        Thread.sleep(1000);

        // notify waiting threads
        notifyAllWaitingThreads(sharedLock);
    }

    private static void notifyAllWaitingThreads(Object sharedLock) {
        synchronized (sharedLock) {
            System.out.println("Notifying all waiting threads.");
            sharedLock.notifyAll();
        }
    }
}

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class CountDownLatchDemo {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(5);
        ExecutorService executorService = new ThreadPoolExecutor(6, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());

        for (int i = 0; i < 6; i++) {
            final int num = i + 1;
            Runnable runnable = () -> {
                try {
                    Thread.sleep(num * 1000);
                    System.out.println("The athlete " + num + " has arrived at the finish line.");
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } finally {
                    latch.countDown();
                }
            };
            executorService.submit(runnable);
        }

        try {
            System.out.println("Referee commands: On your marks, get set, go!");
            latch.await();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("Main thread ended.");

        executorService.shutdown();
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class SemaphoreDemo {
    private static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) {
        ExecutorService executorService = new ThreadPoolExecutor(6, 10, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(10), Executors.defaultThreadFactory(), new ThreadPoolExecutor.DiscardPolicy());
        for (int i = 0; i < 10; i++) {
            executorService.execute(new Shopping(semaphore, "Classmate " + i));
        }
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }

    public static class Shopping implements Runnable {

        private Semaphore semaphore;

        private String name;

        public Shopping(Semaphore semaphore, String name) {
            this.semaphore = semaphore;
            this.name = name;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println(name + " is shopping...");
                Thread.sleep(3000);

                System.out.println(name + " left the mall");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        }
    }
}

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
import java.util.HashMap;
import java.util.Map;

public class SharedResource {
    private final Map<String, String> data = new HashMap<>();
    private final ReadWriteLock lock = new ReentrantReadWriteLock();

    public String readData(String key) {
        lock.readLock().lock();
        try {
            return data.get(key);
        } finally {
            lock.readLock().unlock();
        }
    }

    public void writeData(String key, String value) {
        lock.writeLock().lock();
        try {
            data.put(key, value);
        } finally {
            lock.writeLock().unlock();
        }
    }

    public static void main(String[] args) {
        SharedResource sharedResource = new SharedResource();

        // Writing data
        sharedResource.writeData("key1", "value1");
        sharedResource.writeData("key2", "value2");

        // Reading data
        System.out.println("key1: " + sharedResource.readData("key1"));
        System.out.println("key2: " + sharedResource.readData("key2"));
    }
}

/*
+-------------------+----------------+----------------+----------+
|   Current Lock    | Requested Lock | Compatibility  | Allowed? |
+-------------------+----------------+----------------+----------+
| Read Lock (T1)    | Read Lock (T2)  | Compatible     | Yes      |
+-------------------+----------------+----------------+----------+
| Read Lock (T1)    | Write Lock (T2)| Incompatible   | No       |
+-------------------+----------------+----------------+----------+
| Write Lock (T1)   | Read Lock (T2)  | Compatible   | Yes       |
+-------------------+----------------+----------------+----------+
| Write Lock (T1)   | Write Lock (T2)| Incompatible   | No       |
+-------------------+----------------+----------------+----------+
*/

+----------------+-----------------+------------------+------------+------------+---------------+
| Data Structure |   Operation     | Return Type      | Insertion  | Deletion   | Retrieval     |
+----------------+-----------------+------------------+------------+------------+---------------+
| Queue          | add             | boolean          | Throws     |            |               |
|                |                 |                  | exception  |            |               |
|                | offer           | boolean          | Returns    |            |               |
|                |                 |                  | boolean    |            |               |
|                | remove          | E                |            | Throws     |               |
|                |                 |                  |            | exception  |               |
|                | poll            | E                |            | Returns    |               |
|                |                 |                  |            | null       |               |
|                | element         | E                |            |            | Throws        |
|                |                 |                  |            |            | exception     |
|                | peek            | E                |            |            | Returns       |
|                |                 |                  |            |            | null          |
+----------------+-----------------+------------------+------------+------------+---------------+
| Deque          | addFirst        | boolean          | Throws     |            |               |
|                | addLast         | boolean          | Throws     |            |               |
|                | offerFirst      | boolean          | Returns    |            |               |
|                | offerLast       | boolean          | Returns    |            |               |
|                | removeFirst     | E                |            | Throws     |               |
|                | removeLast      | E                |            | Throws     |               |
|                | pollFirst       | E                |            | Returns    |               |
|                | pollLast        | E                |            | Returns    |               |
|                | getFirst        | E                |            |            | Throws        |
|                | getLast         | E                |            |            | Throws        |
|                | peekFirst       | E                |            |            | Returns       |
|                | peekLast        | E                |            |            | Returns       |
+----------------+-----------------+------------------+------------+------------+---------------+
| BlockingQueue  | put             | void             | Blocks     |            |               |
|                |                 |                  | until      |            |               |
|                |                 |                  | space      |            |               |
|                | take            | E                |            | Blocks     |               |
|                |                 |                  |            | until      |               |
|                |                 |                  |            | element    |               |
+----------------+-----------------+------------------+------------+------------+---------------+
| BlockingDeque  | putFirst        | void             | Blocks     |            |               |
|                | putLast         | void             | Blocks     |            |               |
|                |                 |                  | until      |            |               |
|                |                 |                  | space      |            |               |
|                | takeFirst       | E                |            | Blocks     |               |
|                | takeLast        | E                |            | Blocks     |               |
|                |                 |                  |            | until      |               |
|                |                 |                  |            | element    |               |
+----------------+-----------------+------------------+------------+------------+---------------+

Class<?> listClass = Class.forName("java.util.ArrayList");

Method[] methods = listClass.getMethods();
for(Method method : methods) {
    System.out.println(method.getName());
}

Class<?> listClass = Class.forName("java.util.ArrayList");

ArrayList<String> list = (ArrayList<String>) listClass.getConstructor().newInstance();
list.add("a");
list.add("b");

Class<?> listClass = Class.forName("java.util.ArrayList");

ArrayList<String> list = (ArrayList<String>) listClass.getConstructor().newInstance();

Method addMethod = listClass.getMethod("add", Object.class);
addMethod.invoke(list, "a");
addMethod.invoke(list, "b");

Class<?> listClass = Class.forName("java.util.ArrayList");

ArrayList<String> list = (ArrayList<String>) listClass.getConstructor().newInstance();

Field sizeField = listClass.getDeclaredField("size");
sizeField.setAccessible(true); //Not work after java 1.8

System.out.println(sizeField.getInt(list));