友情支持
如果您觉得这个笔记对您有所帮助，看在D瓜哥码这么多字的辛苦上，请友情支持一下，D瓜哥感激不尽，😜
|
|
有些打赏的朋友希望可以加个好友，欢迎关注D 瓜哥的微信公众号，这样就可以通过公众号的回复直接给我发信息。
公众号的微信号是: jikerizhi。因为众所周知的原因，有时图片加载不出来。 如果图片加载不出来可以直接通过搜索微信号来查找我的公众号。 |
26. TreeMap
先看一个问题：
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
36
37
38
39
40
41
42
43
44
45
46
47
@Test
public void testQuestion() {
TreeMap<Pair, Pair> data = new TreeMap<>();
Pair pair = new Pair(1, System.currentTimeMillis());
data.put(pair, pair);
Pair value = data.get(new Pair(1));
// 请问，这里会输出 true ？还是 false ？
System.out.println(pair.equals(value));
}
class Pair implements Comparable<Pair> {
int key;
long time;
public Pair(int key) {
this.key = key;
}
public Pair(int key, long time) {
this.key = key;
this.time = time;
}
@Override
public int compareTo(Pair o) {
return Long.compare(this.time, o.time);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Pair pair = (Pair) o;
return key == pair.key;
}
@Override
public int hashCode() {
return Objects.hash(key);
}
}
TreeMap 底层是一个红黑树。
先定义一个测试实体类：
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
36
37
38
public static class Person {
long id;
int sortFactor;
public Person(long id) {
this(id, (int) id);
}
public Person(long id, int sortFactor) {
this.id = id;
this.sortFactor = sortFactor;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return id == person.id;
}
@Override
public int hashCode() {
return Objects.hash(id);
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", age=" + sortFactor +
'}';
}
}
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
@Test
public void testSort() {
Comparator<Person> comparator
= Comparator.comparingInt(a -> a.sortFactor);
TreeMap<Person, Person> map = new TreeMap<>(comparator);
for (int i = 0; i < 10; i++) {
if ((i & 1) == 1) {
Person person = new Person(i);
map.put(person, person);
} else {
Person param = new Person(i / 2);
Person person = map.get(param);
if (Objects.nonNull(person)) {
person.sortFactor = new Random().nextInt();
}
}
}
//
map.forEach((k, v) -> {
System.out.println(k);
});
System.out.println("-------------");
for (Person person : map.navigableKeySet()) {
System.out.println(person);
}
System.out.println("-------------");
for (Person person : map.descendingKeySet()) {
System.out.println(person);
}
}
修改排序字段，打印时，依然可以保持有序性。这个实现是怎么回事？
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Test
public void testDuplicateSortFactor() {
Comparator<Person> comparator
= Comparator.comparingInt(a -> a.sortFactor);
TreeMap<Person, Person> treeMap = new TreeMap<>(comparator);
Person p1 = new Person(1, 0);
Person p2 = new Person(2, 0);
assert !p1.equals(p2);
System.out.println(p1.equals(p2));
for (int i = 0; i < 10; i++) {
Person person = new Person(i, 0);
treeMap.put(person, person);
}
assert (treeMap.size() == 1);
treeMap.forEach((k, v) -> {
System.out.println("-----------------------");
System.out.printf("kid= %-4d kfactor= %-8d%n", k.id, k.sortFactor);
System.out.printf("vid= %-4d vfactor= %-8d%n", v.id, v.sortFactor);
});
}
由此看出，TreeMap 不能接受排序因子相同的值。如果存在，则后来者把前者的 Value 覆盖掉。
1
2
3
4
5
6
7
@Test
public void testPut() {
TreeMap<Integer, Integer> treeMap = new TreeMap<>();
for (int i = 0; i < 10; i++) {
treeMap.put(i, i * 100);
}
}