Home Java知识点记录博客
Post
Cancel

Java知识点记录博客

运算符优先级

优先级运算符
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
This post is licensed under CC BY 4.0 by the author.

Ubuntu中关闭摄像头的自动曝光

Basics of Java