1.1TreeMap源码分析
使用TreeMap存储进行排序,要么自然排序,使用一些实现comparable接口的类的compareTo方法,要么自己定义比较机制,一种是user类去实现comparable接口,并实现compareTo方法,另一种是mycomparator写一个类去实现comparator接口实现compare方法,将mycomparator作为参数传入到treemap构造方法
3.1.1类名及其成员变量
// 比较器对象 private final Comparator<? super K> comparator;
// 根节点 private transient Entry<K,V> root;
// 集合大小 private transient int size = 0;
// 树结构被修改的次数 private transient int modCount = 0;
// 静态内部类用来表示节点类型 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; // } |
3.1.2类的构造方法
默认comparator为null public TreeMap() { // 1,无参构造方法 comparator = null; // 默认比较机制 }
2,自定义比较器的构造方法,实现comparator接口,并作为参数传入 public TreeMap(Comparator<? super K> comparator) { // this.comparator = comparator; }
3,构造已知Map对象为TreeMap,比较器仍然为空 public TreeMap(Map<? extends K, ? extends V> m) { // comparator = null; // 默认比较机制 putAll(m); } 4,构造已知的SortedMap对象为TreeMap public TreeMap(SortedMap<K, ? extends V> m) { // comparator = m.comparator(); // 使用已知对象的构造器 try { 此方法为排序集合中构造TreeMap,复杂度为线性 buildFromSorted(m.size(), m.entrySet().iterator(), null, null); } catch (java.io.IOException cannotHappen) { } catch (ClassNotFoundException cannotHappen) { } } 这里插入讲putAll方法 public void putAll(Map<? extends K, ? extends V> map) { int mapSize = map.size(); if (size==0 && mapSize!=0 && map instanceof SortedMap) { Comparator<?> c = ((SortedMap<?,?>)map).comparator(); if (c == comparator || (c != null && c.equals(comparator))) { ++modCount; try { buildFromSorted(mapSize, map.entrySet().iterator(), null, null); } catch (java.io.IOException cannotHappen) { } catch (ClassNotFoundException cannotHappen) { } return; } } super.putAll(map); } ①获得sortedmap的size ②如果size为0,map的size不为0,且map是sortedmap类型 ---2.1获得map的比较器, ------2.1.1如果比较器与当前的比较器一样,执行buildfromsorted,后面分析 ------2.1.2如果不一样,就调用父类putAll方法,内部调用了Treemap的put方法 ③如果②的条件不满足,就直接条用putall方法 ---------------------------------- 底层用TreeMap自身的put方法,后面介绍 public void putAll(Map<? extends K, ? extends V> m) { for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) put(e.getKey(), e.getValue()); } -------------------------------------- private void buildFromSorted(int size, Iterator<?> it, java.io.ObjectInputStream str, V defaultVal) throws java.io.IOException, ClassNotFoundException { this.size = size; root = buildFromSorted(0, 0, size-1, computeRedLevel(size), it, str, defaultVal); } ------------------------------------------------------------- 计算完全二叉树的层数 private static int computeRedLevel(int sz) { int level = 0; for (int m = sz - 1; m >= 0; m = m / 2 - 1) level++; return level; }
----------------------------------------------------------- 分为三部分; private final Entry<K,V> buildFromSorted(int level, int lo, int hi, int redLevel,Iterator<?> it,java.io.ObjectInputStream str V defaultVal) throws java.io.IOException, ClassNotFoundException {
if (hi < lo) return null;
int mid = (lo + hi) >>> 1;
Entry<K,V> left = null; 递归构造左节点 if (lo < mid) left = buildFromSorted(level+1, lo, mid - 1, redLevel, it, str, defaultVal);
构造middle节点; K key; V value; 为middle的key和value设定值 如果迭代器为空 ----key从流中获取,如果defaultval为空,value就是流中的对象,如果defaultval不为空,value就是defaultval; 如果迭代器不为空 ----如果defaultval为空,将迭代器的next转为mapentry,设置key和value ----如果defaultval不为空,key为迭代器的next转为key,value为defaultval if (it != null) { if (defaultVal==null) { Map.Entry<?,?> entry = (Map.Entry<?,?>)it.next(); key = (K)entry.getKey(); value = (V)entry.getValue(); } else { key = (K)it.next(); value = defaultVal; } } else { // use stream key = (K) str.readObject(); value = (defaultVal != null ? defaultVal : (V) str.readObject()); } 将key和value存到middle节点中 Entry<K,V> middle = new Entry<>(key, value, null); 只要把前面3层的结点都设置为黑色,第四层的节点设置为红色,则构造完的树,就是红黑树。level从0开始的,所以上述9个节点,计算出来的是3,实际上就是代表的第4层 if (level == redLevel) middle.color = RED; 如果左节点不为空,就将左节点作为middle的左孩子 if (left != null) { middle.left = left; left.parent = middle; } 构造右节点 if (mid < hi) { Entry<K,V> right = buildFromSorted(level+1, mid+1, hi, redLevel, it, str, defaultVal); middle.right = right; right.parent = middle; }
return middle; } 大体思路: ①如果hi < lo,return null,表示为空,如果hi>=lo表示当前子树构造完成 ②获取mid 的值,lo + hi的一半 ③定义left entry为null;如果lo < mid; 构造左子树(left = 递归,其中level+1, hi = mid - 1) ④处理当前根节点的key和value;如果迭代器不为空,取map的key,value要么等于map的value,要么等于defaultval;如果迭代器为空,从str流中取key,value要么等于流的对象,要么等于defaultval; ⑤创建middle当前根节点,设定key,value;如果level==redlevel,标红,表示叶子节点即最后一层; ⑥如果left不为空,设定middle的left等于left,left的parent等于middle ⑦如果mid < hi;构建右子树(right = 递归,level+ 1,lo =mid +1);结束后将right作为mid的右孩子,mid作为right的父亲; ⑧返回middle |
3.1.3查找方法
底层调用getEntry,返回value值 public V get(Object key) { Entry<K,V> p = getEntry(key); return (p==null ? null : p.value); } 如果比较器不为null,调用getEntryUsingComparator查找,如果key为null,抛出异常;如果比较器为null,调用key实现的comparable接口的compareTo方法与红黑树的节点进行比较;小于0往左,大于0往右; final Entry<K,V> getEntry(Object key) { // Offload comparator-based version for sake of performance if (comparator != null) return getEntryUsingComparator(key); if (key == null) throw new NullPointerException(); @SuppressWarnings("unchecked") Comparable<? super K> k = (Comparable<? super K>) key; Entry<K,V> p = root; while (p != null) { int cmp = k.compareTo(p.key); if (cmp < 0) p = p.left; else if (cmp > 0) p = p.right; else return p; } return null; } 用比较器进行比较,如果比较器不为空,调用compare方法将key和红黑树的节点比较,同样小于0往左;大于0往右 final Entry<K,V> getEntryUsingComparator(Object key) { @SuppressWarnings("unchecked") K k = (K) key; Comparator<? super K> cpr = comparator; if (cpr != null) { Entry<K,V> p = root; while (p != null) { int cmp = cpr.compare(k, p.key); if (cmp < 0) p = p.left; else if (cmp > 0) p = p.right; else return p; } } return null; } 获得红黑树的根节点,一直往左,就能得到最小的 final Entry<K,V> getFirstEntry() { Entry<K,V> p = root; if (p != null) while (p.left != null) p = p.left; return p; }
获得红黑树的根节点,一直往右,就能得到最大的 final Entry<K,V> getLastEntry() { Entry<K,V> p = root; if (p != null) while (p.right != null) p = p.right; return p; } |
3.1.4添加操作
比较方法:如果comparator为null,调用key的接口或者对象中带的compareto方法,否则就是用比较器的compare final int compare(Object k1, Object k2) { return comparator==null ? ((Comparable<? super K>)k1).compareTo((K)k2) : comparator.compare((K)k1, (K)k2); } public V put(K key, V value) { Entry<K,V> t = root; if (t == null) { 再次判断key不能为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 Comparator<? super K> cpr = comparator; if (cpr != null) { do { parent = t; 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") 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 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; } ①得到根节点,如果根节点为空,检查key不能为空,然后将key,value构造一个entry,赋值为根节点 ②定义父亲节点,即插入节点的父亲节点,也就是插入的位置 ③寻找带插入的位置,也就是找parent;如果比较器不为空,用比较器的compare方法,如果比较器为空,使用key实现的接口或者自带的compareTo方法,小于0往左找,大于0往右找;如果等于0,调用setValue,将value值替换,返回新的value;并将当前节点赋值给parent ④根据比较的结果大于0还是小于0,将待插入节点设置为parent的左孩子或右孩子 ⑤调整红黑树 |
3.1.5删除操作
获取key对应的entry,如果是null,返回null,否则获取旧值,调用deleteEntry,返回旧值 public V remove(Object key) { Entry<K,V> p = getEntry(key); if (p == null) return null;
V oldValue = p.value; deleteEntry(p); return oldValue; } 寻找t的后继节点;右子树不为空,就右子树最左,,否则向上找到第一个左父节点 目的在于找到最接近t的节点进行替换 static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) { if (t == null) return null; else if (t.right != null) { Entry<K,V> p = t.right; while (p.left != null) p = p.left; return p; } else { Entry<K,V> p = t.parent; Entry<K,V> ch = t; while (p != null && ch == p.right) { ch = p; p = p.parent; } return p; } }
private void deleteEntry(Entry<K,V> p) { modCount++; size--; if (p.left != null && p.right != null) { Entry<K,V> s = successor(p); p.key = s.key; p.value = s.value; p = s; } // p has 2 children
// Start fixup at replacement node, if it exists. Entry<K,V> replacement = (p.left != null ? p.left : p.right);
if (replacement != null) { // Link replacement to parent replacement.parent = p.parent; if (p.parent == null) root = replacement; else if (p == p.parent.left) p.parent.left = replacement; else p.parent.right = replacement;
// Null out links so they are OK to use by fixAfterDeletion. p.left = p.right = p.parent = null;
// Fix replacement if (p.color == BLACK) fixAfterDeletion(replacement); } else if (p.parent == null) { // return if we are the only node. root = null; } else { // No children. Use self as phantom replacement and unlink. if (p.color == BLACK) fixAfterDeletion(p);
if (p.parent != null) { if (p == p.parent.left) p.parent.left = null; else if (p == p.parent.right) p.parent.right = null; p.parent = null; } } } 大体思路: ①如果有两个孩子,找到后继节点s,将p的key,value用s替代;p指向s,接下来对通过p间接操作s,则s变为只有左孩子或右孩子之一,或者没有孩子 ②如果p只有一个孩子,将p的孩子赋值给replacement,如果rep不为空,就将rep的parent指向p的parent;如果p的parent为空,说明p为根节点,root指向rep;如果p是左孩子,就p的parent的left指向rep,否则right指向rep,然后将p的左右孩子和父亲设为null,如果p是黑色,要进行调整 如果rep为空,且p的parent也为空,那么说明只有一个p节点,则root =null ③如果rep为空,p的parent不为空,说明p没有孩子;如果p是黑色,调整红黑树,如果p是左孩子,p的parent的left为空,否则right为空;然后p的parent为null |
3.2TreeSet源码分析
TreeSet是基于TreeMap实现的一个保证元素有序的集合,其底层的存储盒TreeMap一样也是一棵红黑树,执行和TreeMap的增删改查操作
3.2.1内部属性
定义navigablemap接口类型m private transient NavigableMap<E,Object> m; object类型的present,作为key-value中的value值,将需要保存的值放入key中 private static final Object PRESENT = new Object(); |
3.2.2构造方法
多态,其实m是TreeMap的实现类 TreeSet(NavigableMap<E,Object> m) { this.m = m; } 无参构造器,传入一个TreeMap对象,key为E类型,value为Object类型 public TreeSet() { this(new TreeMap<E,Object>()); } 传入一个带比较器的TreeMap public TreeSet(Comparator<? super E> comparator) { this(new TreeMap<>(comparator)); } 将指定集合放入treeset中 public TreeSet(Collection<? extends E> c) { this(); addAll(c); } 将有序集合s方法TreeSet中 public TreeSet(SortedSet<E> s) { this(s.comparator()); addAll(s); } 所有的构造方法都是调用TreeSet(NavigableMap<E,Object> m)因此m一定会被初始化为TreeMap类型
将集合加入TreeSet中,如果m是TreeMap类型,且c是有序的,使用map的方法进行添加,value就是Present;,如果不是有序的,就使用c集合实现类的addall方法 public boolean addAll(Collection<? extends E> c) { // Use linear-time version if applicable if (m.size()==0 && c.size() > 0 && c instanceof SortedSet && m instanceof TreeMap) { SortedSet<? extends E> set = (SortedSet<? extends E>) c; TreeMap<E,Object> map = (TreeMap<E, Object>) m; Comparator<?> cc = set.comparator(); Comparator<? super E> mc = map.comparator(); if (cc==mc || (cc != null && cc.equals(mc))) { map.addAllForTreeSet(set, PRESENT); return true; } } return super.addAll(c); } 默认调用有序的建立treemap的方法; void addAllForTreeSet(SortedSet<? extends K> set, V defaultVal) { try { buildFromSorted(set.size(), set.iterator(), null, defaultVal); } catch (java.io.IOException cannotHappen) { } catch (ClassNotFoundException cannotHappen) { } } |