Cacher is the code snippet organizer for pro developers

// String
String s = "abc";
s.charAt(0);
s.length();
s.substring(0, 1);
s.substring(1);
s.equals("b");
s = s.trim();
s.indexOf("a");
s.indexOf("a", 1);
s.lastIndexOf("a");
s.indexOf("a", 1);
s.toCharArray();

// convert to string
Integer.valueOf(s); // returns an Integer object
Integer.parseInt(s); // returns an int primitive
String.valueOf(s); // integer to string

// string operation
s.replaceAll("\\W+", " ");
s.toLowerCase();
s.split("\\s+");

// create string from **
String key = String.valueOf(s);

// StringBuilder
StringBuilder sb = new StringBuilder();
sb.append("a");
sb.insert(0, "a");
sb.deleteCharAt(sb.length() - 1);
sb.reverse();
sb.toString();

// Array
int[] a = new int[10];
char[] b = { 'a', 'b' };
int[][] c = new int[10][10];
ArrayList<String> list = new ArrayList<String>() {
    {
        add("A");
        add("B");
        add("C");
    }
};

// length
int m = a.length;
int n = c[0].length;

// sort
Arrays.sort(a);
Arrays.sort(a, (p1, p2) -> p1.start - p2.start);
Arrays.sort(intervals, new Comparator<Interval>() {
    public int compare(Interval a, Interval b) {
        return a.start - b.start;
    }
});

// copy 
Arrays.copyOfRange(points, 0, K);

// List
// inilize
List<Integer> list = new ArrayList<Integer>();
ArrayList<Integer> list1 = new ArrayList<Integer>();
List<List<Integer>> list2 = new ArrayList<List<Integer>>();
ArrayList<Element> arrayList = Arrays.asList(1, 2, 3);
ArrayList<Element> arrayList = Arrays.asList(array);// Element为基本类型时不可用
ArrayList<Element> arrayList = new ArrayList<Element>(Arrays.asList(array));
List<Element> list = new ArrayList<Element>(array.length);

Element[] array = { new Element(1), new Element(2), new Element(3) }; // 数组转list

// basic
list.add(0);
list.add(1, 1); // add elements at the index 1
list.get(0);
list.size();
list.remove(list.size() - 1);

// 遍历
// 1
for (Element data : list) {
}
// 2
for (Iterator<Element> it = list.iterator(); it.hasNext();) {
    Element e = it.next();
}

// Collections
Collections.sort(list);
Collections.sort(list, Collections.reverseOrder());
Collections.addAll(list, array);
Collections.sort(list, new Comparator<Integer>() {
    @Override
    public int compare(Integer o1, Integer o2) {
        return o1 - o2; // 0->1
        // return o2-o1; 1->0
    }
});

// Stack
Stack<Integer> stack = new Stack<Integer>();
stack.push(0);
stack.pop();
stack.peek();
stack.isEmpty();
stack.size();

// Queue add ------> remove, peek
Queue<Integer> q = new LinkedList<Integer>();
q.add(0);
q.remove();
q.peek();
q.isEmpty();
q.size();

// HashMap
HashMap<Character, Integer> map = new HashMap<Character, Integer>();
map.put('c', 1);
map.get('c');
if (map.containsKey('c')) {
}
if (map.containsValue(1)) {
}
for (Character d : map.keySet()) {
}
for (Integer i : map.values()) {
}
map.isEmpty();
map.size();

for (Map.Entry<String, Integer> item : map.entrySet()) {
    System.out.print(item.getKey() + "\t");
    System.out.println(item.getValue());
}

// HashSet
HashSet<Integer> set = new HashSet<Integer>();

Set<Character> vowel = new HashSet<Character>(
        Arrays.asList(new Character[] { 'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U' }));

set.add(0);
set.remove(0);
if (set.contains(0)) {
}
set.isEmpty();
set.size();

// mini heap
PriorityQueue<Interval> heap = new PriorityQueue<Interval>((p1, p2) -> p1.start - p2.start);
PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
pq.add(0);
pq.remove();
pq.peek();
pq.isEmpty();
pq.size();
while (!pq.isEmpty()) {
}

PriorityQueue<Student> pq = new PriorityQueue<Student>(5, new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        if (s1.cgpa < s2.cgpa)
            return 1;
        else if (s1.cgpa > s2.cgpa)
            return -1;
        return 0;
    }
});
}

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.ArrayList;
import java.util.List;
import java.util.Comparator;