总结：括号级别最高，逗号级别最低，单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值。
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
Deque<Integer> stack = new ArrayDeque<>(); // stack Deque<String> queue = new ArrayDeque<>(); // queue PriorityQueue<Integer> queue = new PriorityQueue<>(); // priority queue // Set HashSet<String> unordered_set = new HashSet<>(); // 乱序，底层使用散列函数 LinkedHashSet<String> set = new LinkedHashSet<>(); // 以插入顺序排序 TreeSet<String> set = new TreeSet<>(); // 以字典序排序，底层使用红黑树 // Map HashMap<String, Object> unordered_map = new HashMap<>(); // 乱序 LinkedHashMap<Integer, Integer> map = new LinkedHashMap<>(); // 以插入顺序排序 TreeMap<Integer, Integer> map = new TreeMap<>(); // 以字典序排序 TreeMap<Integer, Integer> map = new TreeMap<Integer, Integer>(); // 手动加泛型，多一些约束少一些出错。在运行期没有任何区别, java的泛型只在编译期有效。
ArrayList:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
public static void main(String[] args) { ArrayList<String> sites = new ArrayList<String>(); sites.add("Google"); sites.add("Runoob"); sites.add("Taobao"); sites.add("Weibo"); System.out.println(sites.get(1)); // 访问第二个元素 sites.set(2, "Wiki"); // 第一个参数为索引位置，第二个为要修改的值 sites.remove(3); // 删除第四个元素 Collections.sort(sites); // 字母排序 System.out.println(sites.isEmpty()); // 空判断 System.out.println(sites); String[] arr = new String[sites.size()]; // 创建一个新的 String 类型的数组 sites.toArray(arr); // 将ArrayList对象转换成数组 }
LinkedList:
1
HashSet:
1 2 3 4 5 6 7 8 9 10 11
public static void main(String[] args) { HashSet<Integer> set = new HashSet<Integer>(); set.add(1); set.add(2); set.add(3); set.remove(2); System.out.println(set.contains(4)); for(int item: set){ System.out.println(item); } }
HashMap:
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
public static void main(String[] args) { Map<String, Integer> numbers = new HashMap<>(); numbers.put("One", 1); numbers.put("Two", 2); numbers.put("Three", 3); numbers.put("Four", 4); System.out.println(numbers.getOrDefault("Five", 0)); numbers.remove("Two"); numbers.replace("One",111); System.out.println(numbers.containsKey("Four")); System.out.println(numbers.containsValue(111)); // Method A(Recommended!) numbers.forEach((k,v) -> System.out.println("Item: " + k + " Count: " + v)); numbers.forEach((k,v) -> { System.out.println("Item: " + k + " Count: " + v); if("Four".equals(k)){ System.out.println("Hello Four"); } }); // Method B(Recommended!) for (Map.Entry<String, Integer> entry : numbers.entrySet()) { System.out.println("key:" + entry.getKey() + ".value:" + entry.getValue()); } // Method C(NOT Recommended!) for (String string : numbers.keySet()) { System.out.println("key:" + string + ".value:" + numbers.get(string)); } // Method D(Recommended When Deleting) Iterator<String> iterators = numbers.keySet().iterator(); while (iterators.hasNext()) { String key = iterators.next(); System.out.println("key:" + key + ".value:" + numbers.get(key)); } }
ArrayDeque：
在堆栈中，元素从栈顶插入，从栈顶弹出
在队列中，元素从队尾插入，从队首弹出
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
public static void main(String[] args) { ArrayDeque<String> animals= new ArrayDeque<>(); /* *****Stack***** */ animals.push("Pig"); System.out.println("返回栈顶元素： " + animals.peek()); System.out.println("返回栈顶元素并弹出： " + animals.pop()); /* *****Queue***** */ animals.offer("Horse"); System.out.println("返回队首元素： " + animals.peek()); System.out.println("返回队首元素并弹出： " + animals.poll()); /* *****Deque***** */ animals.push("Bird"); // 队首 animals.offer("Dog"); // 队尾 System.out.println("返回队首元素： " + animals.peek()); System.out.println("返回队首元素并弹出： " + animals.poll()); System.out.println("返回队尾元素： " + animals.peekLast()); System.out.println("返回队尾元素并弹出： " + animals.pollLast()); /* *****Common***** */ System.out.println("判断是否包含Dog： " + (animals.contains("Dog") ? "是" : "否")); System.out.println("转换成数组输出： " + Arrays.toString(animals.toArray())); }
赋值是创建常量，在编译期时就被确定了；new创建的对象不是常量，无法在编译期中确定。
1 2 3 4 5 6 7 8
String s0 = "aaa" + "bbb"; // 常量，同"aaabbb"，放入常量池中。创建了1个对象 String s1 = "aaa" + new String("bbb"); // 非常量，因为new出来的字符串无法在编译期中确定。创建了4个对象 String s2 = new String("aaabbb"); // 同上。由于常量池中已经存在"aaabbb"，因此只创建了1个对象 System.out.println(s1.intern() == s0); // true，intern()函数会在常量池里找是否相同的字符串，有则返回常量池的引用 System.out.println(s2.intern() == s0); // true，同上 System.out.println(s0 == s1); // false，虽然内容一样，但是new出来的地址肯定不一样 System.out.println(s1 == s2); // false，同上
SEE HERE
赋值是给变量绑定一个新对象，而不是改变对象。
举例：
1 2 3 4 5 6 7 8 9
public static void main(String[] args) { String x = new String("沉默王二"); change(x); System.out.println(x); // "沉默王二" } public static void change(String x) { x = "沉默王三"; }
直接改变对象内容。
举例：
1 2 3 4 5 6 7 8 9
public static void change(A a) { a.name = "bbb"; } public static void main(String[] args) { A a = new A(); a.name = "aaa"; change(a); System.out.println(a.name); // "bbb" }
一棵含有n个节点的红黑树的高度至多为2log(n+1).See Here.
同步容器主要包括2类：
Vector、Stack、HashTable
Collections类中提供的静态工厂方法创建的类
同步容器的所有操作并不都是线程安全的。HERE
所谓“线程安全”，并不包括多个操作之间的“原子性”支持。
100%的情况下不要用 StringBuffer
99% 的情况下不要用 Vector
那么那剩下的 1% 用 Vector 的情况在哪呢？
熟悉Swing的都知道： 现有的一些 model 的类里面用了 Vector，假如你去定制它们，有时不可避免要用到 Vector。
与StringBuffer相比，StringBuilder不是线程安全，所以单线程情况下效率更高。两者除线程安全方面之外无差别。
1 2
StringBuilder sb = new StringBuilder(); sb.append("a".repeat(100)); // repeat方法用于构造重复String
