精华内容
下载资源
问答
  • 1.往treeMap添加元素的时候,如果元素本身具备了自然顺序的特性,那么就按照元素自然顺序特性进行排序储存。 2.往treeMap添加元素的时候,如果元素的键本身 不具备 自然顺序的特性,那么该键所属的类必须要实现...

    双列集合:数据是成对存在的,存在映射关系。

    TreeSet要注意的事项:
    1.往treeMap里添加元素的时候,如果元素本身具备了自然顺序的特性,那么就按照元素自然顺序特性进行排序储存。
    2.往treeMap里添加元素的时候,如果元素的键本身 不具备 自然顺序的特性,那么该键所属的类必须要实现Comparable接口,把键的
    比较规则定义在comparTo(T o)方法上。
    3.往treeMap添加元素的时候,如果元素的键本身没有具备自然顺序的特性,而键所属的类也没有实现comparable接口,那么必须在创建treeset对象
    的时候传入一个比较器。
    定义一个比较器: 自定义一个类实现comparator接口即可,把元素的键与元素的键之间的比交规则定义在compare内即可。
    class 类名 implements comparator{
    }

    展开全文
  • TreeMap元素插入

    2018-09-05 08:20:06
    2、添加元素代码实现: 1 public  V  put (K key, V value)   { 2   //找到合适的位置插入Entry元素 3  Entry,V> t = root; 4   if  (t ==  null ) { 5  compare(key, key);  // type ...

    微信公众号:I am CR7
    如有问题或建议,请在下方留言;
    最近更新:2018-09-05

    二分查找树(BST)

    1、定义:

        二分查找树又称二叉查找树、二叉排序树,英文缩写为BST,即Binary Search Tree。该数据结构的出现,是为了提高查找的效率。之所以成为二分查找树,是因为其采用二分查找的算法。

    2、特性:
    • 若左子树不为空,左子树上所有节点的值均小于根节点的值
    • 若右子树不为空,右子树上所有节点的值均大于根节点的值
    • 左右子树又分别是一棵二分查找树
    3、示例:

        下图是一个典型的二分查找树:

    图注:二分查找树

    查找节点10:
    1. 查看根节点5,因为10>5,往右子树走
    图注:查看根节点5

    1. 查看节点8,因为10>8,往右子树走
    图注:查看节点8

    1. 查看节点15,因为10<15,往左子树走
    图注:查看节点15
    1. 查看节点12,因为10<12,往左子树走
    图注:查看节点12
    1. 查看节点10,正是我们要找的节点
    图注:查看节点10
    4、思考:

        虽然二叉查找树提高了查询的效率,但是依旧存在着缺陷,请看下面例子:

    图注:依次插入6、5、4、3、2

        当依次插入6、5、4、3、2时,发现树成了线性形式,在此种情况下,查找效率大打折扣,因此就有了自平衡的二叉查找树,名为红黑树。

    红黑树(RBT)

    1、定义:

        红黑树,是一个自平衡的二叉排序树,英文简称为RBT,即Red Black Tree。每个节点上增加了颜色属性,要么为红,要么为黑。

    2、特性:
    • 每个节点要么为红色,要么为黑色
    • 根节点为黑色
    • 每个叶子节点(NIL)是黑色 [注意:这里叶子节点,是指为空(NIL或NULL)的叶子节点!]
    • 不允许连续两个红色节点
    • 从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑色节点
    3、示例:

        下图是一个典型的红黑树:

    图注:红黑树
    4、思考:

        针对于BST中提到的缺陷,依次插入6、5、4、3、2,红黑树是如何处理的呢?此处不做解答,请继续往下看。

    红黑树实践-TreeMap

    1、TreeMap.Entry:

        首先我们来看下TreeMap中存储键值对的类-TreeMap.Entry,该类定义了红黑树的数据结构。查看其成员变量,除了存储key、value外,还存储了左节点、右节点、父节点、颜色(默认为黑色)。

     1 static final class Entry<K,Vimplements Map.Entry<K,V{
    2    K key;
    3    V value;
    4    Entry<K,V> left;
    5    Entry<K,V> right;
    6    Entry<K,V> parent;
    7    boolean color = BLACK;
    8
    9    /**
    10     * Make a new cell with given key, value, and parent, and with
    11     * {@code null} child links, and BLACK color.
    12     */

    13    Entry(K key, V value, Entry<K,V> parent) {
    14        this.key = key;
    15        this.value = value;
    16        this.parent = parent;
    17    }
    18
    19    /**
    20     * Returns the key.
    21     *
    22     * @return the key
    23     */

    24    public K getKey() {
    25        return key;
    26    }
    27
    28    /**
    29     * Returns the value associated with the key.
    30     *
    31     * @return the value associated with the key
    32     */

    33    public V getValue() {
    34        return value;
    35    }
    36
    37    /**
    38     * Replaces the value currently associated with the key with the given
    39     * value.
    40     *
    41     * @return the value associated with the key before this method was
    42     *         called
    43     */

    44    public V setValue(V value) {
    45        V oldValue = this.value;
    46        this.value = value;
    47        return oldValue;
    48    }
    49
    50    public boolean equals(Object o) {
    51        if (!(o instanceof Map.Entry))
    52            return false;
    53        Map.Entry<?,?> e = (Map.Entry<?,?>)o;
    54
    55        return valEquals(key,e.getKey()) && valEquals(value,e.getValue());
    56    }
    57
    58    public int hashCode() {
    59        int keyHash = (key==null ? 0 : key.hashCode());
    60        int valueHash = (value==null ? 0 : value.hashCode());
    61        return keyHash ^ valueHash;
    62    }
    63
    64    public String toString() {
    65        return key + "=" + value;
    66    }
    67}
    复制代码
    2、添加元素代码实现:
     1public V put(K key, V value) {
    2    //找到合适的位置插入Entry元素
    3    Entry<K,V> t = root;
    4    if (t == null) {
    5        compare(key, key); // type (and possibly null) check
    6
    7        root = new Entry<>(key, value, null);
    8        size = 1;
    9        modCount++;
    10        return null;
    11    }
    12    int cmp;
    13    Entry<K,V> parent;
    14    // split comparator and comparable paths
    15    Comparator<? super K> cpr = comparator;
    16    if (cpr != null) {
    17        do {
    18            parent = t;
    19            cmp = cpr.compare(key, t.key);
    20            if (cmp < 0)
    21                t = t.left;
    22            else if (cmp > 0)
    23                t = t.right;
    24            else
    25                return t.setValue(value);
    26        } while (t != null);
    27    }
    28    else {
    29        if (key == null)
    30            throw new NullPointerException();
    31        @SuppressWarnings("unchecked")
    32            Comparable<? super K> k = (Comparable<? super K>) key;
    33        do {
    34            parent = t;
    35            cmp = k.compareTo(t.key);
    36            if (cmp < 0)
    37                t = t.left;
    38            else if (cmp > 0)
    39                t = t.right;
    40            else
    41                return t.setValue(value);
    42        } while (t != null);
    43    }
    44    Entry<K,V> e = new Entry<>(key, value, parent);
    45    if (cmp < 0)
    46        parent.left = e;
    47    else
    48        parent.right = e;
    49    //进行插入后的平衡调整
    50    fixAfterInsertion(e);
    51    size++;
    52    modCount++;
    53    return null;
    54}
    复制代码

        因为插入后可能带来红黑树的不平衡,所以需要进行平衡调整,方法无非两种:

    • 变色
    • 旋转(左旋或者右旋)
     1private void fixAfterInsertion(Entry<K,V> x) {
    2    //默认插入元素颜色为红色
    3    x.color = RED;
    4
    5    //只要x不为根且父亲节点为红色就继续调整
    6    while (x != null && x != root && x.parent.color == RED) {
    7        //父节点为爷爷节点的左节点
    8        if (parentOf(x) == leftOf(parentOf(parentOf(x)))) {
    9            //获取右叔节点
    10            Entry<K,V> y = rightOf(parentOf(parentOf(x)));
    11            //右叔节点为红色(此时父节点也为红色)
    12            if (colorOf(y) == RED) {
    13                //变色
    14                //父节点改为黑色
    15                setColor(parentOf(x), BLACK);
    16                //右叔节点改为黑色
    17                setColor(y, BLACK);
    18                //爷爷节点改成红色
    19                setColor(parentOf(parentOf(x)), RED);
    20                //爷爷节点所在的子树已平衡,所以让x指向爷爷节点,继续往上调整
    21                x = parentOf(parentOf(x));
    22            } else {
    23                //父亲节点在爷爷节点的左边,而x在父亲节点的右边,则需要调整到同一侧
    24                if (x == rightOf(parentOf(x))) {
    25                    //x指向父节点
    26                    x = parentOf(x);
    27                    //以x进行左旋
    28                    rotateLeft(x);
    29                }
    30                //变色
    31                //父节点改为黑色
    32                setColor(parentOf(x), BLACK);
    33                //右叔节点改为黑色-本身已经为黑色
    34                //爷爷节点改为红色
    35                setColor(parentOf(parentOf(x)), RED);
    36                //右叔为黑,变色后左边黑色多与右边,故以爷爷节点为中心右旋
    37                rotateRight(parentOf(parentOf(x)));
    38            }
    39        } else {//父节点为爷爷节点的右节点
    40            //获取左叔节点
    41            Entry<K,V> y = leftOf(parentOf(parentOf(x)));
    42            //左叔节点为红色(此时父节点也为红色)
    43            if (colorOf(y) == RED) {
    44                //变色
    45                //父节点改为黑色
    46                setColor(parentOf(x), BLACK);
    47                //左叔节点改为黑色
    48                setColor(y, BLACK);
    49                //爷爷节点改为红色
    50                setColor(parentOf(parentOf(x)), RED);
    51                //爷爷节点所在的子树已平衡,所以让x指向爷爷节点,继续往上调整
    52                x = parentOf(parentOf(x));
    53            } else {
    54                //父亲节点在爷爷节点的右边,而x在父亲节点的左边,则需要调整到同一侧
    55                if (x == leftOf(parentOf(x))) {
    56                    //x指向父节点
    57                    x = parentOf(x);
    58                    //以x进行右旋
    59                    rotateRight(x);
    60                }
    61                //变色
    62                //父节点改为黑色
    63                setColor(parentOf(x), BLACK);
    64                //左叔节点改为黑色-本身已经为黑色
    65                //爷爷节点改为红色
    66                setColor(parentOf(parentOf(x)), RED);
    67                //左叔为黑,变色后右边黑色多与左边,故以爷爷节点为中心左旋
    68                rotateLeft(parentOf(parentOf(x)));
    69            }
    70        }
    71    }
    72    //根节点设置为黑色
    73    root.color = BLACK;
    74}
    复制代码
    3、添加元素流程图:
    图注:插入元素调整流程
    4、添加元素精简流程图:
    图注:插入元素调整流程

        通过上述流程图可以看出,红黑树的调整是采用局部平衡的方式,从下往上依次处理,最终达到整棵树的平衡。

    5、实践:

        依次插入2、3、4、5、7、8、16、15、14、10、12,画出红黑树插入过程。

    图注:插入元素2

    图注:插入元素3

    图注:插入元素4

    图注:插入元素5

    图注:插入元素7

    图注:插入元素8

    图注:插入元素16

    图注:插入元素15

    图注:插入元素14

    图注:插入元素10

    图注:插入元素12

        上述例子,涵盖了元素插入中遇到的所有情况。相信通过学习优化后的流程图,对于红黑树的元素插入问题,大家的思路是足够清晰的。

    总结

        本文主要是通过二分查找树的缺陷,引出了红黑树的说明。通过分析TreeMap插入元素的源码,整理出红黑树调整的流程图,最后通过示例来加深对于红黑树的理解。
        此时,再回到BST中的缺陷问题,红黑树是如何进行解决的,想必大家都已经有了答案。
        文章的最后,感谢大家的支持,欢迎扫描下方二维码,进行关注。如有任何疑问,欢迎大家留言。

    展开全文
  • 添加元素时顺序如下,而遍历treeMap 时顺序是contact_way,crm_name,contacts_name,混乱了 TreeMap<String, String> treeMap = new TreeMap<String, String>(); treeMap.put("crm_n...

    java遍历TreeMap元素顺序不是添加的顺序问题

     

    解决方法:

    添加元素时顺序如下,而遍历treeMap 时顺序是contact_way,crm_name,contacts_name,混乱了

    TreeMap<String, String> treeMap = new TreeMap<String, String>();

     treeMap.put("crm_name", "客户名称");

     treeMap.put("contacts_name", "联系人");

     treeMap.put("contact_way", "联系方式");

     

    原因是TreeMap按照添加的key值排序的,所以不能使用TreeMap,使用:http://www.yayihouse.com/yayishuwu/chapter/1929

    展开全文
  • TreeMap元素删除

    千次阅读 2018-09-07 09:01:21
    微信公众号:I am CR7如有问题或建议,请...进一步分析TreeMap中插入元素的源码,最后借助示例来加深对于红黑树的理解。详细请看TreeMap元素插入 TreeMap之删除 1、删除指定key对应的元素: 1publicVremove(Obje...

    微信公众号:I am CR7
    如有问题或建议,请在下方留言;
    最近更新:2018-09-05

    TreeMap之插入

         通过上一篇文章,介绍了二分查找树的缺陷,引出了红黑树的介绍。进一步分析TreeMap中插入元素的源码,最后借助示例来加深对于红黑树的理解。详细请看TreeMap之元素插入

    TreeMap之删除

    1、删除指定key对应的元素:

     1public V remove(Object key) {
    2    //根据key获取键值对
    3    Entry<K,V> p = getEntry(key);
    4    if (p == null)
    5        return null;
    6    //删除该键值对,并返回value值
    7    V oldValue = p.value;
    8    deleteEntry(p);
    9    return oldValue;
    10}
    复制代码

    2、删除节点,并对树进行平衡调整:

    2.1、源码:
     1private void deleteEntry(Entry<K,V> p) {
    2    modCount++;
    3    size--;
    4
    5    //如果存在左右节点,则获取其后继节点,完成key、value的复制,p指向后继节点
    6    //此处思想就是将有左右节点的节点p的删除转化为其后继节点的删除
    7    if (p.left != null && p.right != null) {
    8        Entry<K,V> s = successor(p);
    9        p.key = s.key;
    10        p.value = s.value;
    11        p = s;
    12    } // p has 2 children
    13
    14    //获取删除节点的替代节点
    15    Entry<K,V> replacement = (p.left != null ? p.left : p.right);
    16
    17    //如果存在替代节点,则进行替代。接着先删除节点p,再进行删除的平衡调整
    18    if (replacement != null) {
    19        //用替代节点替代删除节点
    20        replacement.parent = p.parent;
    21        if (p.parent == null)
    22            root = replacement;
    23        else if (p == p.parent.left)
    24            p.parent.left  = replacement;
    25        else
    26            p.parent.right = replacement;
    27
    28        //删除节点p
    29        p.left = p.right = p.parent = null;
    30
    31        //如果删除节点为黑色,必然影响树的平衡,进行平衡调整
    32        if (p.color == BLACK)
    33            fixAfterDeletion(replacement);
    34    } else if (p.parent == null) { // return if we are the only node.
    35        root = null;
    36    } else {  //如果不存在替代节点,不需要替代。接着先进行删除的平衡调整,再删除节点p
    37        //如果删除节点为黑色,必然影响树的平衡,进行平衡调整
    38        if (p.color == BLACK)
    39            fixAfterDeletion(p);
    40
    41        //删除节点p
    42        if (p.parent != null) {
    43            if (p == p.parent.left)
    44                p.parent.left = null;
    45            else if (p == p.parent.right)
    46                p.parent.right = null;
    47            p.parent = null;
    48        }
    49    }
    50}
    51
    52//注意该方法执行的前提是t节点有左右节点,所以返回的是右子树里最左边的非空
    53static <K,V> TreeMap.Entry<K,V> successor(Entry<K,V> t) {
    54    if (t == null)
    55        return null;
    56    else if (t.right != null) {  //存在右子树
    57        Entry<K,V> p = t.right;
    58        while (p.left != null//一直往左走
    59            p = p.left;
    60        return p; //返回右子树里最左的非空节点
    61    } else {
    62        Entry<K,V> p = t.parent;
    63        Entry<K,V> ch = t;
    64        while (p != null && ch == p.right) {
    65            ch = p;
    66            p = p.parent;
    67        }
    68        return p;
    69    }
    70}
    复制代码


         通过上述逻辑我们知道,删除节点分为下面几种情况:

    • 有左右孩子节点
    • 只有一个孩子节点
    • 无孩子节点(叶子节点)【情况最为复杂,后面会详细讲解】
    2.2、代码整理成流程图:
    图注:删除元素流程图

    2.3、示例:
    1. 有左右孩子,且无替代节点:【先调整后删除的流程】
      图注:有左右孩子但无替代节点

         无替代节点,说明后继节点走到了叶子节点。需要调整说明后继节点为黑色,正如上图所示。此时就转化为对于叶子节点10的删除操作了,处理过程请往后看。

    1. 有左右孩子,且有替代节点:【先删除后调整的流程】
      图注:有左右孩子且有替代节点

         有替代节点,说明后继节点未走到叶子节点,那么后继节点肯定只有一个孩子节点,否则必可以走到叶子节点(此处可以画图体会体会)。一个节点只有一个孩子节点,那么只有一种可能,就是节点为黑,孩子为红,否则树不平衡,正如上图所示。此时,替代节点为红色,调整逻辑就很简单了,就是将该红色节点改成黑色节点即可。

    1. 只有一个孩子节点,必有替代节点:【先删除后调整的流程】
      图注:只有一个孩子->必有替代节点

         只有一个孩子节点,替代节点获取的规则就是要么左节点,要么右节点,所以必有替代节点。一个节点只有一个孩子节点,那么只有一种可能,就是节点为黑,孩子为红,否则树不平衡,正如上图所示。此时,替代节点为红色,调整逻辑就很简单了,就是将该红色节点改成黑色节点即可。

    2.4、总结:

         通过上述的分析,凡是先进行删除,后进行调整的情况,其调整逻辑都很简单,就是只需要将节点颜色从红色变成黑色即可。先进行调整,后进行删除的情况,才是逻辑最为复杂的,请继续往下看。

    3、对树进行删除后的调整:

      1private void fixAfterDeletion(Entry<K,V> x) {
    2    //只要x不为根节点且为黑色,就需要调整
    3    while (x != root && colorOf(x) == BLACK) {
    4        //X是否为父亲节点的左节点
    5        if (x == leftOf(parentOf(x))) {
    6            //获取X右兄弟节点sib
    7            Entry<K,V> sib = rightOf(parentOf(x));
    8            //X兄弟节点为红色转化为X兄弟节点为黑色的情况
    9            if (colorOf(sib) == RED) {
    10                //设置X兄弟节点为黑色
    11                setColor(sib, BLACK);
    12                //设置X父亲节点为红色
    13                setColor(parentOf(x), RED);
    14                //以X父亲节点为中心进行左旋
    15                rotateLeft(parentOf(x));
    16                //sib指向X的兄弟节点
    17                sib = rightOf(parentOf(x));
    18            }
    19
    20            //兄弟节点左右节点都为黑色
    21            if (colorOf(leftOf(sib))  == BLACK &&
    22                colorOf(rightOf(sib)) == BLACK) {
    23                //兄弟节点改成红色
    24                setColor(sib, RED);
    25                //X指向父节点
    26                x = parentOf(x);
    27            } else {
    28                //X远侄节点为黑色转化为X远侄节点为红色的情况
    29                if (colorOf(rightOf(sib)) == BLACK) {
    30                    //近侄节点改成黑色
    31                    setColor(leftOf(sib), BLACK);
    32                    //兄弟节点改成红色
    33                    setColor(sib, RED);
    34                    //以兄弟节点为中心进行右旋
    35                    rotateRight(sib);
    36                    //sib指向X右兄弟节点
    37                    sib = rightOf(parentOf(x));
    38                }
    39                //设置sib为X父节点颜色
    40                setColor(sib, colorOf(parentOf(x)));
    41                //设置X父节点为黑色
    42                setColor(parentOf(x), BLACK);
    43                //设置远侄节点为黑色
    44                setColor(rightOf(sib), BLACK);
    45                //以X父亲节点为中心进行左旋
    46                rotateLeft(parentOf(x));
    47                //X指向根,结束循环
    48                x = root;
    49            }
    50        } else { // symmetric
    51            //获取X左兄弟节点sib
    52            Entry<K,V> sib = leftOf(parentOf(x));
    53            //X兄弟节点为红色转化为X兄弟节点为黑色的情况
    54            if (colorOf(sib) == RED) {
    55                //设置X兄弟节点为黑色
    56                setColor(sib, BLACK);
    57                //设置X父亲节点为红色
    58                setColor(parentOf(x), RED);
    59                //以X父亲节点为中心进行右旋
    60                rotateRight(parentOf(x));
    61                //sib指向X的兄弟节点
    62                sib = leftOf(parentOf(x));
    63            }
    64
    65            //兄弟节点左右节点都为黑色
    66            if (colorOf(rightOf(sib)) == BLACK &&
    67                colorOf(leftOf(sib)) == BLACK) {
    68                //兄弟节点改成红色
    69                setColor(sib, RED);
    70                //X指向父节点
    71                x = parentOf(x);
    72            } else {
    73                //X远侄节点为黑色转化为X远侄节点为红色的情况
    74                if (colorOf(leftOf(sib)) == BLACK) {
    75                    //近侄节点改成黑色
    76                    setColor(rightOf(sib), BLACK);
    77                    //兄弟节点改成红色
    78                    setColor(sib, RED);
    79                    //以兄弟节点为中心进行左旋
    80                    rotateLeft(sib);
    81                    //sib指向X左兄弟节点
    82                    sib = leftOf(parentOf(x));
    83                }
    84                //设置sib为X父节点颜色
    85                setColor(sib, colorOf(parentOf(x)));
    86                //设置X父节点为黑色
    87                setColor(parentOf(x), BLACK);
    88                //设置远侄节点为黑色
    89                setColor(leftOf(sib), BLACK);
    90                //以X父亲节点为中心进行右旋
    91                rotateRight(parentOf(x));
    92                //X指向根,结束循环
    93                x = root;
    94            }
    95        }
    96    }
    97
    98    //设置X为黑色
    99    setColor(x, BLACK);
    100}
    复制代码
    3.1、代码整理为流程图:
    图注:删除操作的平衡流程图

    高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b3848ec1c7eee?w=1914&h=2314&f=jpeg&s=382012

    3.2、优化的流程图:
    图注:删除操作的平衡流程图-优化版

    高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b3848ec062ee1?w=1246&h=1341&f=jpeg&s=191723

    3.3、流程图解析说明:
    1. 兄弟节点为黑色,远侄节点为红色(删除节点X为叶子节点,且为黑色[如果为红直接删除即可])

      图注:兄弟为黑,远侄为红

    2. 兄弟节点为黑色,远侄节点为黑色(删除节点X为叶子节点,且为黑色[如果为红直接删除即可])

      图注:兄弟为黑,远侄为黑

           兄弟节点为黑色,并且删除节点X为黑色,且为叶子节点->远侄节点如果为黑色,必然是null节点,否则树不平衡。

    3. 兄弟节点为黑色,远侄近侄节点都为黑色(删除节点X为叶子节点,且为黑色[如果为红直接删除即可])

      图注:兄弟为黑,远近侄为黑

    4. 兄弟节点为红色(删除节点X为叶子节点,且为黑色[如果为红直接删除即可])

      图注:兄弟为红

           兄弟节点为红色,X为黑色,且是叶子->远侄节点和近侄节点必为null节点,否则树不平衡。

    3.4、示例:
    1. 兄弟节点为红色

      图注:兄弟为红

      高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b33e01bf074ab?w=7315&h=640&f=jpeg&s=558111

    2. 兄弟节点为黑色,远侄节点为红色

      图注:兄弟为黑,远侄为红

      高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b33e02c61c338?w=4471&h=640&f=jpeg&s=347442

    3. 兄弟节点为黑色,远侄节点为黑色

      图注:兄弟为黑,远侄为黑

      高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b3848ed9e566b?w=6613&h=640&f=jpeg&s=480598

    4. 兄弟节点为黑色,远侄近侄节点都为黑色

      图注:兄弟为黑,远近侄为黑

      高清图请看:https://user-gold-cdn.xitu.io/2018/9/7/165b33e03146c697?w=3902&h=640&f=jpeg&s=273947

    总结

         红黑树的删除相对于插入而言,复杂了不少。但是只要时刻记住五条性质,对于包含的每种场景动手去练习,我想理解它应该也不是难事。
         文章的最后,感谢大家的支持,欢迎扫描下方二维码,进行关注。如有任何疑问,欢迎大家留言。

    展开全文
  • TreeMap集合和ArrayList集合当中进行自定义对象的添加并对其排序public class Student implements Comparable&lt;Student&gt;{ public Student(String name,int age) { // TODO Auto-generated ...
  • Map集合的五种遍历方式及Treemap方法 废话不多说,直接上代码 //循环遍历map的方法 public class MapF { public static void main(String[] args) { Map<String, Integer> tempMap = new HashMap<String,...
  • import java.util.Comparator; import java.util.Iterator; import java.util.Map;...//向TreeMap添加key-value,要求key必须是由同一个类创建的对象 //因为要按照key进行排序:自然排序、定制排序 //自然排序 @Test
  • Map集合用于储存元素对,Map储存的是一对键值(key和value),是通过key映射到它的value。 说明:Map接口是一种双列集合,它的每个元素都包含一个键对象Key和值对象Value, 键和值对象之间存在一种对应关系,称为...
  • 1 TreeMap的两种遍历方式 思路1:键值对对象找键和值方式 entrySet()方法:获取键值对对象 ,把键和值封装起来看做一个对象 1)获取所有键值对对象的集合---entrySet()方法 2)遍历键值对对象的集合,获取到每一个...
  • 上周,我做了成都一个著名中学的考勤项目,其中里面有一个排行榜的功能,我就是用了TreeSet进行排序,最后发现排序前后莫名其妙的少了几个元素,当时我还没有发现,后来被测试小姐姐提成了BUG; 追溯 然后我就写了一...
  • TreeMap倒序以及遍历

    2015-12-17 20:10:41
    TreeMap倒序 TreeMap默认是按照Key给排序的,但是有的时候我们需要倒序,比如Key是日期,我们需要按照日期倒序显示(最近的时间在前面),类似下面这种情况 TreeMap倒序方法 treeMap.descen...
  • TreeMap中的Key可以自动排序 详解

    千次阅读 2018-05-14 22:34:24
    /* Set添加元素用的是add,Map添加元素用的是put 如果想自动排序:1.实现Comparable接口 2.单独便捷一个比较器*/import java.util.*;public class fuck15{ public static void main(String[] args){ //Map.Key...
  • Map里面存放的每一个元素都是key-value这样的键值对,而且都是通过put方法进行添加的,而且相同的key在Map中只会有一个与之关联的value存在。put方法在Map中的定义如下。  V put(K key, V value);  它用来存放...
  • scala treemap 如何在Scala TreeMap获得自定义排序? 好吧,这让我困惑了一段时间。 答案在于隐式和接收器类型转换器的世界。 scala.collection.immutable.TreeMap , scala.collection.immutable.TreeMap是...
  • 解析HashMap、HashSet、TreeMap、TreeSet判断元素是否存在的逻辑。
  • TreeMap put()和遍历

    2020-04-09 18:29:13
    这篇博客记录了学习TreeMap时关于put()方法和遍历TreeMap的解析,方便巩固学习,仅作参考。 TreeMap<String, String> treeMap = new TreeMap<>() ; String str1 = "12"; String str2 = "123"; ...
  • HashMap、HashSet、TreeMap、TreeSet判断元素相同   目录 1.1 HashMap 1.2 HashSet 1.3 TreeMap 1.4 TreeSet   1.1 HashMap  先来看一下HashMap里面是怎么存放元素的。Map里面存放的每一个元素都...
  • 使用集合来添加元素并对集合使用不同种元素进行遍历 分析 方式一:采用父接口中的迭代器 方式二:List 集合中的迭代器 方式三:采用for循环遍历 程序代码 package com.company.test; import java.util.ArrayList; ...
  • TreeMap的几种遍历方法

    千次阅读 2020-12-23 15:35:45
    这个方法用来遍历他的所有value,由于TreeMap底层使用红黑树实现的,红黑树是比较key的大小进行添加节点的。而底层用的遍历算法是中序遍历,所以此方法的返回结果是和key的遍历结果是一一对应的。即key是从小到大的...
  • 深入源码分析TreeSet和TreeMap

    千次阅读 2016-04-26 00:02:54
    分析TreeMap源码
  • TreeMap与TreeSet

    千次阅读 2017-03-28 11:31:28
    TreeMap与TreeSet
  • /* 返回元素个数 */ public int size() { return size; } /* 是否包含指定的key */ public boolean containsKey(Object key) { return getEntry(key) != null; } /* 是否包含指定的value值,从 getFirstEntry()获取...
  • 1、TreeMap集合   基于红黑树(Red-Black tree)的 NavigableMap 实现。该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法。  注意,此实现不是同步...
  • java TreeMap详解

    千次阅读 2019-05-23 11:24:31
    TreeMap 简介 TreeMap 是一个有序的key-value集合,它是通过红黑树实现的。 TreeMap继承于AbstractMap,所以它是一个Map,即一个key-value集合。 TreeMap 实现了NavigableMap接口,意味着它支持一系列的导航方法。...
  • Treemap,HashMap常用方法

    千次阅读 2018-08-01 08:42:53
    HashMap:数组方式存储key/value,线程非安全,允许null作为key和...TreeMap:基于红黑二叉树实现,线程非安全,不允许null,key不可以重复,value允许重复,存入TreeMap元素应当实现Comparable接口或者实现Com...
  • Java面试题大全(2020版)

    万次阅读 多人点赞 2019-11-26 11:59:06
    基于你的collection的大小,也许向HashMap中添加元素会更快,将map换为TreeMap进行有序key的遍历。 23. 说一下 HashMap 的实现原理? HashMap概述: HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选...
  • TreeMap集合特点、排序原理

    千次阅读 2017-04-19 20:40:25
    TreeMap特点(类似于TreeSet): ...无序,不允许重复(无序指元素顺序与添加顺序不一致) 2.TreeMap集合默认会对键进行排序,所以键必须实现自然排序和定制排序中的一种 3..底层使用的数据结构是二叉树
  • TreeMap实现原理及源码分析

    千次阅读 2017-08-01 09:12:34
    TreeMap是一个有序的key-value集合,基于红黑树(Red-Black tree)实现。该映射根据其键的自然顺序进行排序,或者根据创建时提供的Comparator进行排序、 对于TreeMap而言,每个Entry都被当成“红黑树”的一个节点对待...
  • TreeMap自定义排序进行遍历 1.第一种做法 /** * @Description:TreeMap遍历排序案例 * @author: cyz */ public class TreeMapTest { private static Set<String> keySet; public static void main...
  • Map 中的映射关系是一对一的,一个键 Key 对应唯一的值 value,键和值可以是任意的数据类型,而且键 Key 不允许重复,在访问 Map 集合中的元素时,只要指定了 Key,就能找到对应的 value。 方法声明 功能描...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,007
精华内容 15,602
关键字:

treemap添加元素