运算符优先级
优先级 | 运算符 |
---|---|
1 | ( ) [ ] . |
2 | ! ~ ++ – |
3 | * / % |
4 | + - |
5 | « » «< »> |
6 | < <= > >= instanceof |
7 | == != |
8 | & |
9 | ^ |
10 | | |
11 | && |
12 | || |
13 | ? : |
14 | = += -= *= /= %= &= |= ^= ~= «= »= »>= |
15 | , |
总结:括号级别最高,逗号级别最低,单目 > 算术 > 位移 > 关系 > 逻辑 > 三目 > 赋值。
容器(集合类)
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的区别
赋值是创建常量,在编译期时就被确定了;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,同上
Java只有值传递,没有引用传递
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"
}
length为属性,length()为方法
- 数组属性:length
- 字符串方法:length()
- 集合方法:size()
红黑树的时间复杂度为: O(logn)
一棵含有n个节点的红黑树的高度至多为2log(n+1).See Here.
同步容器
同步容器主要包括2类:
Vector、Stack、HashTable
Collections类中提供的静态工厂方法创建的类
同步容器的所有操作并不都是线程安全的。HERE
所谓“线程安全”,并不包括多个操作之间的“原子性”支持。
100%的情况下不要用 StringBuffer
99% 的情况下不要用 Vector
那么那剩下的 1% 用 Vector 的情况在哪呢?
熟悉Swing的都知道: 现有的一些 model 的类里面用了 Vector,假如你去定制它们,有时不可避免要用到 Vector。
StringBuilder
与StringBuffer相比,StringBuilder不是线程安全,所以单线程情况下效率更高。两者除线程安全方面之外无差别。
1
2
StringBuilder sb = new StringBuilder();
sb.append("a".repeat(100)); // repeat方法用于构造重复String