TreeSet类测试代码
package com.pero.set_;
import java.util.Comparator;
import java.util.TreeSet;
/**
* @author Pero
* @version 1.0
*/
public class TreeSet_ {
public static void main(String[] args) {
//当使用无参构造器创建TreeSet时，存取结果依然是无序的
TreeSet treeSet = new TreeSet();
treeSet.add("jake");
treeSet.add("tom");
treeSet.add("lj");
treeSet.add("p");
System.out.println(treeSet);
//如果添加元素按照字符串大小排序（通过ASCII码比较）
//使用TreeSet提供的构造器，可以传入比较器(匿名内部类，指定排序规则)
// TreeSet(Comparator<? super E>)
TreeSet treeSet1 = new TreeSet(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//通过调用String类中的compareTo()方法进行字符串大小比较
//从小到大排序
return ((String) o1).compareTo((String) o2);
}
});
treeSet1.add("a");
treeSet1.add("b");
treeSet1.add("c");
treeSet1.add("d");
treeSet1.add("e");
treeSet1.add("f");
treeSet1.add("g");
System.out.println(treeSet1);
}
}
TreeSet源码分析
1）执行构造器（在调用构造器前先进行类的加载，构造器将比较器comparator传给了TreeMap的this.comparator）
public Class<?> loadClass(String name) throws ClassNotFoundException {
return loadClass(name, false);
}public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
int var3 = var1.lastIndexOf(46);
if (var3 != -1) {
SecurityManager var4 = System.getSecurityManager();
if (var4 != null) {
var4.checkPackageAccess(var1.substring(0, var3));
}
}
if (this.ucp.knownToNotExist(var1)) {
Class var5 = this.findLoadedClass(var1);
if (var5 != null) {
if (var2) {
this.resolveClass(var5);
}
return var5;
} else {
throw new ClassNotFoundException(var1);
}
} else {
return super.loadClass(var1, var2);
}
}public TreeSet(Comparator<? super E> comparator) {
this(new TreeMap<>(comparator));
}public TreeMap(Comparator<? super K> comparator) {
this.comparator = comparator;
}TreeSet(NavigableMap<E,Object> m) {
this.m = m;
}private transient NavigableMap<E,Object> m;2)执行add()方法：调用TreeMap的put()方法
public boolean add(E e) {
return m.put(e, PRESENT)==null;
}3）执行put()方法：
public V put(K key, V value) {
Entry<K,V> t = root;
if (t == null) {
compare(key, key); // type (and possibly null) check
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
int cmp;
Entry<K,V> parent;
// split comparator and comparable paths
//cpr为在new TreeSet()时传入的匿名内部类new Comparator()
Comparator<? super K> cpr = comparator;
if (cpr != null) {
do {
parent = t;
//compare(key, t.key)调用((String) o1).compareTo((String) o2)（动态绑定）
//按照匿名内部类规定的排序要求对TreeSet传入的对象进行排序
cmp = cpr.compare(key, t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
return t.setValue(value);
} while (t != null);
}
else {
if (key == null)
throw new NullPointerException();
@SuppressWarnings("unchecked")
//将key对象转成Comparable类型，如果构造器没有传入Comparable接口的匿名内部类
//并且key对象的类型没有实现Comparable接口的话，在这里会报错
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else //此处，如果cmp==0，则返回0，当前这个待添加key就没有加入
return t.setValue(value);
} while (t != null);
}
Entry<K,V> e = new Entry<>(key, value, parent);
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}TreeMap的测试代码
package com.pero.map_;
import java.util.Comparator;
import java.util.TreeMap;
/**
* @author Pero
* @version 1.0
*/
public class TreeMap_ {
public static void main(String[] args) {
//无参构造器没有排序
//TreeMap treeMap = new TreeMap();
//提供了一个TreeMap(Comparator<? super K>)的构造器
TreeMap treeMap = new TreeMap(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
//要求按照传入的k(String)的大小（ASCⅡ码）进行排序（从小到大）
//return ((String) o1).compareTo((String) o2);
//按照字符串长度的大小进行排序(从短到长)
return ((String) o1).length() - ((String) o2).length();
}
});
treeMap.put("jack", "杰克");
treeMap.put("tom", "汤姆");
treeMap.put("smith", "史密斯");
treeMap.put("kristina", "克里斯提娜");
treeMap.put("pero","佩罗"); //无法添加，不是替换
System.out.println(treeMap);
}
}
TreeMap源码分析
1）执行构造器：（在调用构造器前先进行类的加载操作，然后把传入的实现了Comparator接口的匿名内部类传给了TreeMap的comparator；
public TreeMap(Comparator<? super K> comparator) {//形参是实现Comparator接口的类的对象
this.comparator = comparator; //传入比较器对象，比较器对象中明确了排序的比较内容
}private transient int size = 0; private transient int modCount = 0;
2）执行put()方法：
public V put(K key, V value) {
//定义辅助变量t,将root赋值给t
Entry<K,V> t = root; //root是在TreeMap类的内部定义的Entry<K,V>类型的节点
if (t == null) { //如果t为null，则说明当前添加的节点为第一个节点，与自身的key比较
compare(key, key); // type (and possibly null) check
//将存储信息k-v传入节点生成Entry<>对象赋值给root，生成第一个节点
root = new Entry<>(key, value, null);
size = 1;
modCount++;
return null;
}
//定义一个辅助变量cmp，接收compare()方法返回值，根据返回值判断元素比较结果然后排序
int cmp;
Entry<K,V> parent; //定义辅助变量parent
// split comparator and comparable paths
Comparator<? super K> cpr = comparator; //将比较器对象赋值给辅助变量cpr
//确定待添加元素的索引位置
if (cpr != null) { //如果比较器不为null则进行遍历比较
do { //循环遍历，比较已添加元素和待添加元素，给当前key寻找满足条件的位置
parent = t; //将root节点传递给parent，root是已添加节点
cmp = cpr.compare(key, t.key); //比较待添加节点和已添加节点的key值
//对已添加元素和待添加元素进行比较后，如果待添加元素应该放在已添加元素节点的左边
//则将左边节点赋值给t（t在其中起着指针节点的作用），如果左边节点不为null，
//则在进行比较，如果为null则说明该位置还没有添加节点，退出循环
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else
//比较过程中如果发现当前已有的key与待添加的key相同则调用setValue()方法
//对比较结果相同的key，待添加元素的value替换已添加元素的value
return t.setValue(value);
} while (t != null); //如果为null则说明该位置还没有添加节点，退出循环
}
/如果比较器为null
else {
if (key == null)//如果key为空抛出异常
throw new NullPointerException();
@SuppressWarnings("unchecked")
//默认比较
Comparable<? super K> k = (Comparable<? super K>) key;
do {
parent = t;
cmp = k.compareTo(t.key);
//对已添加元素和待添加元素进行比较后，如果待添加元素应该放在已添加元素节点的左边
//则将左边节点赋值给t（t在其中起着指针节点的作用），如果左边节点不为null，
//则在进行比较，如果为null则说明该位置还没有添加节点，退出循环
if (cmp < 0)
t = t.left;
else if (cmp > 0)
t = t.right;
else //同样，如果相等就替换value
return t.setValue(value);
} while (t != null);//如果目标节点为null则说明该位置还没有添加节点，退出循环
}
//
Entry<K,V> e = new Entry<>(key, value, parent); //待添加元素k-v生成节点
//根据比较结果将待添加元素放置在指引位置
if (cmp < 0)
parent.left = e;
else
parent.right = e;
fixAfterInsertion(e);
size++;
modCount++;
return null;
}//在TreeMap类的内部定义了一个节点类Entry<K,V>,该内部类实现了Map.Entry<K,V>接口
static final class Entry<K,V> implements Map.Entry<K,V> {
K key;
V value;
Entry<K,V> left;
Entry<K,V> right;
Entry<K,V> parent;
boolean color = BLACK;
/**
* Make a new cell with given key, value, and parent, and with
* {@code null} child links, and BLACK color.
*/
Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}//在TreeMap类的内部定义了一个Entry<K,V>类型的节点 root；
private transient Entry<K,V> root;Entry(K key, V value, Entry<K,V> parent) {
this.key = key;
this.value = value;
this.parent = parent;
}3）执行compare()方法：
final int compare(Object k1, Object k2) {
//先判断比较器对象是否为null，如果为null则进行默认判断然后排序，如果不为null调用
//比较器对象的compare()方法
return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2)
: comparator.compare((K)k1, (K)k2);
}4）执行setValue()方法：
//待添加元素的value替换已添加元素的value，他们key的比较结果是相同的compare(key,this.key)
public V setValue(V value) {
V oldValue = this.value;
this.value = value;
return oldValue;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
