精华内容
下载资源
问答
  • 本文使用了两种方法进行spark 的top k词频查询,第S一种方法在很多博客中都介绍到了的,但是这种方法有一个问题,那就是在大数据的情况下效率不高,因为它是通过sparkAPI中的top方法来计算的,这个过程会引起一个...

    本文来自:http://blog.csdn.net/liangyihuai/article/details/54925737

    本文使用了两种方法进行spark 的top k词频查询,第一种方法在很多博客中都介绍到了的,但是这种方法有一个问题,那就是在大数据的情况下效率不高,因为它是通过sparkAPI中的top方法来计算的,这个过程会引起一个耗时的“洗牌“过程;第二种方法在其他博客中基本没有看到,使用的是堆的方式,具体为采用immutable.TreeMap这个自带排序功能的类,但是需要我们稍微修改一下,让它能够根据value的大小而不是key来排序。这个方法没有“洗牌“但有一个汇集数据的过程,但是这个动作所涉及到的数据量是比较小的(每个分区的k个数据),而且它只是汇聚数据,而不是耗时的shuffle,所以这个方法在效率优于第一种方法

    如何让immutable.TreeMap根据value值的大小自动排序呢?我们知道treemap默认是根据key值的大小自动排序的。为了实现这个功能,另外增加了一个辅助的数据结构:mutable.HashMap,该hashmap用于在覆写Ordering的compare方法的时候通过key值来查询出相应的value,通过比较value来构造compare方法的返回值(正数、负数或者0)。这里需要注意的是,这里的compare方法不能返回0,因为返回0的话treemap中具有相同value的数据不能同时存在,即使key是不用的,具体原因跟scala的treemap功能实现有关,希望读者能动手验证一下。

    具体的spark环境搭建和代码提交过程本文从略。有问题可以留言。

    import org.apache.hadoop.fs.Path
    import org.apache.spark.rdd.RDD
    import org.apache.spark.{SparkConf, SparkContext}
    import org.slf4j.LoggerFactory
    
    import scala.collection.immutable.TreeMap
    import scala.collection.mutable
    
    /**
      * 统计文本中词频最高的k个单词
      * 使用两种方法:第一种方法使用排序的方式,大数据的情况效率不高;第二种方法使用堆排序的方式,适合大数据的方式。
      * 下面的指令是本人提交代码用到的:
      /home/liangyh/installed/spark/bin/spark-submit \
      --master local \
      --class TopK \
      /home/liangyh/IdeaProjects/SparkTest/out/artifacts/SparkTest_jar/SparkTest.jar
      * Created by liangyh on 12/18/16.
      */
    object TopK {
    
      private val logger = LoggerFactory.getLogger(getClass.getName)
    
      val inputFileLocation:String = "hdfs://Master:9000/user/liangyh/input.txt";
      val outputFileLocation:String = "hdfs://Master:9000/user/liangyh/output";
    
      def main(args: Array[String]): Unit = {
        logger.info("---------------start---------")
        val sparkConf = new SparkConf().setAppName("TopK");
        sparkConf.setMaster("spark://Master:7077");
        val sc = new SparkContext(sparkConf)
    
    //    val hdfs = org.apache.hadoop.fs.FileSystem.get(
    //      new java.net.URI("hdfs://127.0.0.1:9000"), new org.apache.hadoop.conf.Configuration())
    //    val path = new Path(this.outputFileLocation)
    //    if(hdfs.exists(path)) hdfs.delete(path, true)
    
        logger.info("--------------read file----------------")
        val lines = sc.parallelize(List("aa a aa b bb b d b e f g h aa a a a d g "),2)
        doTopK1(lines)
        logger.info("---------done top k--------------")
        sc.stop
      }
    
      /**
        * 第一种top k方式
        * @param lines
        */
      def doTopK1(lines:RDD[String]):Unit = {
        //计算每一个单词的词频
        val wordCountRDD = lines.flatMap(_.split("\\s+")).map((_, 1)).reduceByKey(_+_)
        //排序
        val sorted = wordCountRDD.map{case(key,value) => (value,key)}.sortByKey(true,3)
        //得到词频最高的4个单词
        val topk = sorted.top(4)
        //print
        topk.foreach(println)
      }
    
      /**
        * 第二种topk方式
        * @param lines
        */
      def doTopK2(lines:RDD[String]):Unit = {
        //计算每个单词的词频
        val wordCountRDD:RDD[(String,Int)] = lines.flatMap(_.split("\\s+")).map((_, 1)).reduceByKey(_+_)
        //在每一个分区内进行top k查询
        val topK= wordCountRDD.mapPartitions(iter => {
          val partitionHeap = new Heap()
          while(iter.hasNext){
            partitionHeap.putToHeap(iter.next())
          }
          partitionHeap.getHeap().iterator
        })
    
        val driverHeap = new Heap()
        //将每个分区中统计出来的top k合并成一个新的集合,再统计新集合中的top k。
        topK.collect().foreach(driverHeap.putToHeap(_))
        driverHeap.getHeap().foreach(next => logger.info("------"+next._1+"->"+next._2+"-----"))
      }
    
    }
    
    /**
      * 一个能够根据treeMap的value大小降序排序的堆。
      * @param k 保留前面k个数
      */
    class Heap(k:Int = 4){
      /**
        * 辅助数据结构,加快查找速度
        */
      private val hashMap:mutable.Map[String,Int] = new mutable.HashMap[String, Int]()
    
      implicit val valueOrdering = new Ordering[String]{
        override def compare(x: String, y: String): Int = {
          val xValue:Int = if(hashMap.contains(x)) hashMap.get(x).get else 0
          val yValue:Int = if(hashMap.contains(y)) hashMap.get(y).get else 0
          if(xValue > yValue) -1 else 1
        }
      }
    
      /**
        *存储有序数据
        */
      private var treeMap = new TreeMap[String, Int]()
    
      /**
        * 把数据存入堆中
        * 自动截取,只保留前面k个数据
        * @param word
        */
      def putToHeap(word:(String,Int)):Unit = {
        hashMap += (word._1 -> word._2)
        treeMap = treeMap + (word._1 -> word._2)
    
        val dropItem = treeMap.drop(k)
        dropItem.foreach(treeMap -= _._1)
        treeMap = treeMap.take(this.k)
      }
    
      /**
        * 取出堆中的数据
        * @return
        */
      def getHeap():Array[(String,Int)] = {
        val result = new Array[(String, Int)](treeMap.size)
        var i = 0
        this.treeMap.foreach(item => {
          result(i) = (item._1, item._2)
          i += 1
        })
        result
      }
    }
    

    贴一下结果:

    17/02/08 12:32:55 INFO TopK$: ==collect ==> aa-3
    17/02/08 12:32:55 INFO TopK$: ==collect ==> b-3
    17/02/08 12:32:55 INFO TopK$: ==collect ==> d-2
    17/02/08 12:32:55 INFO TopK$: ==collect ==> h-1
    17/02/08 12:32:55 INFO TopK$: ==collect ==> a-4
    17/02/08 12:32:55 INFO TopK$: ==collect ==> g-2
    17/02/08 12:32:55 INFO TopK$: ==collect ==> e-1
    17/02/08 12:32:55 INFO TopK$: ------a->4-----
    17/02/08 12:32:55 INFO TopK$: ------aa->3-----
    17/02/08 12:32:55 INFO TopK$: ------b->3-----
    17/02/08 12:32:55 INFO TopK$: ------d->2-----
    
    展开全文
  • Map HashMap TreeMap

    2021-01-07 16:02:23
    import java.util.HashMap; import java.util.Map; /** * Map集合常用方法 * 添加 put(key,value) ... * 查询value是否存在 containsValue(value) * 集合是否为空 isEmpty() * 集合大小,长度,
    package com.llb.map;
    
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * Map集合常用方法
     *   添加    put(key,value)
     *   通过key删除    remove(key)
     *   查询key是否存在    containsKey(key)
     *   查询value是否存在    containsValue(value)
     *   集合是否为空    isEmpty()
     *   集合大小,长度,元素个数    size()
     *   清空集合    clear()
     *   获取到所有的 key 存到Set集合中    keySet();
     *   通过key获取到value    get(key)
     *
     */
    public class MyMap {
        public static void main(String[] args) {
            Map<String , String> map = new HashMap<>();
            //常用方法
            System.out.println("==========常用方法==============");
            //添加
            map.put("1001","tom");
            map.put("1002","jerry");
            map.put("1003","spiky");
            map.put("1004","hinata");
            map.put("1005","张三");
            map.put("1006","李四");
            System.out.println("被覆盖前的map : "+map);
            //如果要添加的key已经存在,会覆盖原来的值,会把原来的值当做返回值进行返回
            String naruto = map.put("1004", "naruto");
            System.out.println("被覆盖的value : "+naruto);//hinata
            System.out.println("被覆盖后的map : "+map);//map : {1004=naruto, 1003=spiky, 1002=jerry, 1001=tom}
            //根据key删除对应的value
            String remove = map.remove("1001");
            System.out.println("被删除的元素 : "+remove);//被删除的元素 : tom
            System.out.println("删除元素后的map : "+map);//删除元素后的map : {1004=naruto, 1003=spiky, 1002=jerry}
            //判断集合中是否包含指定的key
            boolean b = map.containsKey("1004");
            boolean b1 = map.containsKey("1010");
            System.out.println("是否包含key 1004 : "+b);//true
            System.out.println("是否包含key 1010 : "+b1);//false
            //判断集合中是否包含指定的value
            boolean b2 = map.containsValue("sasuke");//false
            boolean b3 = map.containsValue("jerry");//true
            System.out.println("是否包含value sasuke : "+b2);
            System.out.println("是否包含value jerry : "+b3);
            //判断集合是否为空
            boolean empty = map.isEmpty();
            System.out.println("集合是否为空 : "+empty);//不为空  false
            //返回集合的长度
            int size = map.size();
            System.out.println("集合大小 : "+size);//3
            //清空
            map.clear();
            System.out.println("清空后的集合 : "+map);//{}
            //判断集合是否为空
            boolean empty1 = map.isEmpty();
            System.out.println("集合是否为空 : "+empty1);//为空  true
            /**
             * 结果
             * ==========常用方法==============
             * 被覆盖前的map : {1006=李四, 1005=张三, 1004=hinata, 1003=spiky, 1002=jerry, 1001=tom}
             * 被覆盖的value : hinata
             * 被覆盖后的map : {1006=李四, 1005=张三, 1004=naruto, 1003=spiky, 1002=jerry, 1001=tom}
             * 被删除的元素 : tom
             * 删除元素后的map : {1006=李四, 1005=张三, 1004=naruto, 1003=spiky, 1002=jerry}
             * 是否包含key 1004 : true
             * 是否包含key 1010 : false
             * 是否包含value sasuke : false
             * 是否包含value jerry : true
             * 集合是否为空 : false
             * 集合大小 : 5
             * 清空后的集合 : {}
             * 集合是否为空 : true
             */
    
        }
    }
    
    //Map集合的遍历
    
    package com.llb.map;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    public class MyMap遍历 {
        public static void main(String[] args) {
            /**
             * 创建集合添加元素
             * 获取到所有的 key
             * 让每一个 key 找到自己对相应的 value
             * 打印 key 和 value
             */
            //创建集合,添加元素
            Map<String, String> map = new HashMap<>();
            map.put("001","100");
            map.put("002","200");
            map.put("003","300");
            map.put("004","400");
            map.put("005","500");
            map.put("006","600");
            map.put("007","700");
            //获取到所有的key
            Set<String> keys = map.keySet();
            //遍历set集合得到每一个key
            for (String key : keys) {
                String value = map.get(key);
                System.out.println("key\t"+key+"\tvalue\t"+value);
            }
        }
    }
    
    System.out.println("===============第二种遍历方式=================");
            /**
             * 第二种遍历方式
             * 获取到所有键值对 对象
             *
             */
            //获取到所有键值对 对象
            //Set集合中装的是键值对对象
            //Entry里装的是键和值
            Set<Map.Entry<String, String>> entries = map.entrySet();
            for (Map.Entry<String, String> entry : entries) {
                String key = entry.getKey();
                String value = entry.getValue();
                System.out.println("key\t"+key+"\tvalue\t"+value);
            }
    
    练习
    package com.llb.map;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Objects;
    import java.util.Set;
    
    public class MyHashMapExe {
        public static void main(String[] args) {
            HashMap<Student, String> map = new HashMap<>();
            Student stu1 = new Student("刘备", 20);
            Student stu2 = new Student("关羽", 21);
            Student stu3 = new Student("张飞", 22);
            map.put(stu1,"江苏");
            map.put(stu2,"安徽");
            map.put(stu3,"浙江");
            Set<Student> students = map.keySet();
            for (Student key : students) {
                String value = map.get(key);
                System.out.println("key\t"+key+"\tvalue\t"+value);
            }
            System.out.println("========================================");
            Set<Map.Entry<Student, String>> entries = map.entrySet();
            for (Map.Entry<Student, String> entry : entries) {
                Student key = entry.getKey();
                String value = entry.getValue();
                System.out.println("key\t"+key+"\tvalue\t"+value);
            }
            System.out.println("=======================================");
            map.forEach(
                    (Student key , String value) -> {
                        System.out.println("key\t"+key+"\tvalue\t"+value);
                    }
            );
        }
    }
    class Student{
        private String name;
        private Integer age;
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student student = (Student) o;
            return Objects.equals(name, student.name) &&
                    Objects.equals(age, student.age);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Student(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        public Student() {
        }
    }
    
    
    /TreeMap
    package com.llb.map;
    
    import java.util.Comparator;
    import java.util.Objects;
    import java.util.TreeMap;
    
    public class MyTreeMap {
        public static void main(String[] args) {
            TreeMap<Student00,String> tm = new TreeMap<>(new Comparator<Student00>() {
                @Override
                public int compare(Student00 o1, Student00 o2) {
                    int res = o2.getAge() - o1.getAge();
                    res = res == 0 ? o2.getName().compareTo(o1.getName()) : res ;
                    return res;
                }
            });
            Student00 s1 = new Student00("曹操", 100);
            Student00 s2 = new Student00("刘备", 100);
            Student00 s3 = new Student00("孙权", 50);
            tm.put(s1,"山东");
            tm.put(s2,"山西");
            tm.put(s3,"河北");
            tm.forEach((Student00 key , String value)->{
                System.out.println("key\t"+key+" \tvalue\t"+value);
            });
        }
    }
    class Student00 /*implements  Comparable<Student00>*/{
        private String name;
        private Integer age;
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Student00 student00 = (Student00) o;
            return Objects.equals(name, student00.name) &&
                    Objects.equals(age, student00.age);
        }
    
        @Override
        public int hashCode() {
            return Objects.hash(name, age);
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public Student00(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    
        public Student00() {
        }
    
        /*@Override
        public int compareTo(Student00 o) {
            int res = this.getAge()-o.getAge();
            res = res == 0? this.getName().compareTo(o.getName()) : res ;
            return res;
        }*/
    }
    
    
    
    展开全文
  • TreeMap源码分析

    2018-07-09 19:11:55
    从而来确保传入进去的元素都是按顺序保存的,我们查询出来的数据也是排序过得关于红黑树的基本操作可以参考我之前的一篇文章TreeMap红黑树基础相关内容介绍先来看添加元素操作public V put(K key, V value) { ...

    TreeMap的内部维护了一个红黑树,从而来确保传入进去的元素都是按顺序保存的,我们查询出来的数据也是排序过得

    关于红黑树的基本操作可以参考我之前的一篇文章TreeMap红黑树基础相关内容介绍

    先来看添加元素操作

    public V put(K key, V value) {
            Entry<K,V> t = root;
            if (t == null) { //如果root节点为null,
                compare(key, key); // type (and possibly null) check
    
                root = new Entry<>(key, value, null); //创建一个新的entry作为root节点
                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); //对比key的大小
                    if (cmp < 0)    // 如果小于0
                        t = t.left;  // 从左子树中查询
                    else if (cmp > 0)
                        t = t.right; //从右子树中查询
                    else
                        return t.setValue(value); //如果key相同,直接替换掉
                } while (t != null);
            }
            else { // 如果没有设置比较器,直接使用key值原生的比较方法,同样也是进行比较,找到相同的值,更新,找不到的话,可以定位到父节点
                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); //基于上面查找到的父节点,创建一个新的entry
            if (cmp < 0)
                parent.left = e;// 如果比父节点小,放在左节点
            else
                parent.right = e; // 入股偶比父节点大,放在父节点的右子节点
            fixAfterInsertion(e); // 调整红黑二叉树平衡
            size++; // size值加1
            modCount++;
            return null;
        }

    根据key进行查询某个元素

     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(); // key为null 抛出NPE异常
            @SuppressWarnings("unchecked")
                Comparable<? super K> k = (Comparable<? super K>) key; // 如果没有比较器
            Entry<K,V> p = root; 
            while (p != null) { //从root开始遍历,直到找到相同的元素
                int cmp = k.compareTo(p.key);
                if (cmp < 0)
                    p = p.left;
                else if (cmp > 0)
                    p = p.right;
                else
                    return p;
            }
            return null;
        }

    移除某个元素

     public V remove(Object key) {
            Entry<K,V> p = getEntry(key); //获取到key对应的元素
            if (p == null)
                return null;
    
            V oldValue = p.value; // 获取到元素对应的value
            deleteEntry(p); // 删除指定元素,并调整红黑树平衡
            return oldValue;
        }

    以上就是关于TreeMap的源码分析,如果之前对红黑树有过了解的话,看TreeMap会比较简单


    展开全文
  • HashMap简单总结:1、HashMap 是链式数组(存储链表的数组)实现查询速度可以,而且能快速的获取key对应的value;2、查询速度的影响因素有 容量和负载因子,容量大负载因子小查询速度快但浪费空间,反之则相反;3、...

    HashMap简单总结:

    1、HashMap 是链式数组(存储链表的数组)实现查询速度可以,而且能快速的获取key对应的value;

    2、查询速度的影响因素有 容量和负载因子,容量大负载因子小查询速度快但浪费空间,反之则相反;

    3、数组的index值是(key 关键字, hashcode为key的哈希值, len 数组的大小):hashcode%len的值来确定,如果容量大负载因子小则index相同(index相同也就是指向了同一个桶)的概率小,链表长度小则查询速度快,反之index相同的概率大链表比较长查询速度慢。

    4、对于HashMap以及其子类来说,他们是采用hash算法来决定集合中元素的存储位置,当初始化HashMap的时候系统会创建一个长度为capacity的Entry数组,这个数组里可以存储元素的位置称为桶(bucket),每一个桶都有其指定索引,系统可以根据索引快速访问该桶中存储的元素。

    5、无论何时HashMap 中的每个桶都只存储一个元素(Entry 对象)。由于Entry对象可以包含一个引用变量用于指向下一个Entry,因此可能出现HashMap 的桶(bucket)中只有一个Entry,但这个Entry指向另一个Entry 这样就形成了一个Entry 链。

    6、通过上面的源码发现HashMap在底层将key_value对当成一个整体进行处理(Entry 对象)这个整体就是一个Entry对象,当系统决定存储HashMap中的key_value对时,完全没有考虑Entry中的value,而仅仅是根据key的hash值来决定每个Entry的存储位置。

    介绍

    TreeMap的Key值是要求实现java.lang.Comparable,所以迭代的时候TreeMap默认是按照Key值升序排序的;TreeMap的实现是基于红黑树结构。适用于按自然顺序或自定义顺序遍历键(key)。

    HashMap的Key值实现散列hashCode(),分布是散列的、均匀的,不支持排序;数据结构主要是桶(数组),链表或红黑树。适用于在Map中插入、删除和定位元素。

    结论

    如果你需要得到一个有序的结果时就应该使用TreeMap(因为HashMap中元素的排列顺序是不固定的)。除此之外,由于HashMap有更好的性能,所以大多不需要排序的时候我们会使用HashMap。

    拓展

    1、HashMap 和 TreeMap 的实现

    HashMap:基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()],为了优化HashMap空间的使用,您可以调优初始容量和负载因子。

    HashMap(): 构建一个空的哈希映像

    HashMap(Map m): 构建一个哈希映像,并且添加映像m的所有映射

    HashMap(int initialCapacity): 构建一个拥有特定容量的空的哈希映像

    HashMap(int initialCapacity, float loadFactor): 构建一个拥有特定容量和加载因子的空的哈希映像

    TreeMap:基于红黑树实现。TreeMap没有调优选项,因为该树总处于平衡状态。

    TreeMap():构建一个空的映像树

    TreeMap(Map m): 构建一个映像树,并且添加映像m中所有元素

    TreeMap(Comparator c): 构建一个映像树,并且使用特定的比较器对关键字进行排序

    TreeMap(SortedMap s): 构建一个映像树,添加映像树s中所有映射,并且使用与有序映像s相同的比较器排序

    2、HashMap 和 TreeMap 都是非线程安全

    HashMap继承AbstractMap抽象类,TreeMap继承自SortedMap接口。

    AbstractMap抽象类:覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同,则这两个映射相等。映射的哈希码是映射元素哈希码的总和,其中每个元素是Map.Entry接口的一个实现。因此,不论映射内部顺序如何,两个相等映射会报告相同的哈希码。

    SortedMap接口:它用来保持键的有序顺序。SortedMap接口为映像的视图(子集),包括两个端点提供了访问方法。除了排序是作用于映射的键以外,处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口,否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一个实现。

    3、TreeMap中默认是按照升序进行排序的,如何让他降序

    通过自定义的比较器来实现

    定义一个比较器类,实现Comparator接口,重写compare方法,有两个参数,这两个参数通过调用compareTo进行比较,而compareTo默认规则是:

    如果参数字符串等于此字符串,则返回 0 值;

    如果此字符串小于字符串参数,则返回一个小于 0 的值;

    如果此字符串大于字符串参数,则返回一个大于 0 的值。

    自定义比较器时,在返回时多添加了个负号,就将比较的结果以相反的形式返回,代码如下:

    static class MyComparator implements Comparator{

    @Override

    public int compare(Object o1, Object o2) {

    // TODO Auto-generated method stub

    String param1 = (String)o1;

    String param2 = (String)o2;

    return -param1.compareTo(param2);

    }

    }

    之后,通过MyComparator类初始化一个比较器实例,将其作为参数传进TreeMap的构造方法中:

    MyComparator comparator = new MyComparator();

    Map map = new TreeMap(comparator);

    这样,我们就可以使用自定义的比较器实现降序了

    public class MapTest {

    public static void main(String[] args) {

    //初始化自定义比较器

    MyComparator comparator = new MyComparator();

    //初始化一个map集合

    Map map = new TreeMap(comparator);

    //存入数据

    map.put("a", "a");

    map.put("b", "b");

    map.put("f", "f");

    map.put("d", "d");

    map.put("c", "c");

    map.put("g", "g");

    //遍历输出

    Iterator iterator = map.keySet().iterator();

    while(iterator.hasNext()){

    String key = (String)iterator.next();

    System.out.println(map.get(key));

    }

    }

    static class MyComparator implements Comparator{

    @Override

    public int compare(Object o1, Object o2) {

    // TODO Auto-generated method stub

    String param1 = (String)o1;

    String param2 = (String)o2;

    return -param1.compareTo(param2);

    }

    }

    }

    总结

    以上所述是小编给大家介绍的在Java中如何决定使用 HashMap 还是 TreeMap,希望对大家有所帮助,如果大家有任何疑问请给我留言,小编会及时回复大家的。在此也非常感谢大家对脚本之家网站的支持!

    如果你觉得本文对你有帮助,欢迎转载,烦请注明出处,谢谢!

    展开全文
  • 目录 简介 字段 comparator,root,size,...查询方法 size,containsKey,containsValue,get,comparator,firstKey,lastKey 查询的辅助方法 8个getXXXEntry和getEntryXXX ,successor,predecessor put方法 简介 ...
  • HashMap是一个散列桶(数组和链表),它存储的内容是键值对(key-value)映射。 HashMap采用了数组和链表的数据结构,能在查询和修改方便继承了数组的线性查找和链表的寻址修改。 HashMap是非synchronized,所以...
  • Map用于保存具有映射关系的数据,Map里保存着两组数据:key和value,它们都可以使任何引用类型的数据,但key不能重复。...2、boolean containsKey(Object key):查询Map中是否包含指定key,如果包含则返回true。3、...
  • 使用中可以通过key查找到value数据,使用Map可以方便用户查询。 Map中定义的关键操作方法: 名称 作用 public V put(K key, V value) 向集合中追加数据 public V get(K key) 根据key返回对应的value...
  • Map用于保存具有映射关系的数据,Map里保存着两组数据:key和value,它们都可以使任何引用类型的数据,但key不能重复。...2、boolean containsKey(Object key):查询Map中是否包含指定key,如果包含则返回true
  • Map用于保存具有映射关系的数据,Map里保存着两组数据:key和value,它们都可以使任何引用类型的数据,但key不能重复。...2、boolean containsKey(Object key):查询Map中是否包含指定key,如果包含则返回true。 ...
  • import java.util.*;/**一:Collection接口的* Map接口: HashMap(主要实现类) : HashedMap / LinkedHashMap /TreeMap* Map接口:对, 重复的键会...* 修改查询操作: 1.put(key, value), 2.remove(key) 3.putAll(其他...
  • 哈希表的基本结构就是**“数组+链表”**,结合了数组和链表的优点,即查询,增删都快。 HashMap“数组+链表”的结构示意图 HashMap存储键值对过程的示意图 取value对象的过程与存入相同,当根据hash值到达Entry...
  • 查询

    2018-05-23 11:22:19
    查询表:1、Map接口2、HashMap3、Map的遍历4、有序的MapMap接口:1、Map接口定义的集合称为查找表,用于存储所谓的“Key-Value”映射对。Key可以看成是Value的索引,作为Key的对象在集合中不可以重复。2、根据内部...
  • 下面要给大家分享的是拼多多java工程师一面的面试题内容,有要去拼多多面试的小伙伴可以来看看这个一面面经哦。一面面试题:1、解释一下Java当中的HashMap、TreeMap...2、TreeMap查询写入的时间复杂度多少?3、...
  • public class BusinessUtil { public static String getBusniss(String lonAndLat) throws Exception{ // 计算sn跟参数对出现顺序有关,get请求请...key,value>,该方法根据key的插入顺序排序;post请使用TreeMap...
  • Java集合--Map

    2018-09-23 00:29:00
    可以根据key快速的查询value。key不可以重复,value可以重复。 常用实现类:HashMap,Hashtable,LinkedHashMap,TreeMap 常用方法 判断功能 boolean isEmpty():判断map是否为空 boolean containsKey(Obj...
  • 1、map以key-value形式存储数据。map的实现形式有hashmap,treemap,linkedhashmap等。 hashmap:map基于散列表实现,存储键值顺序和插入次序无关,优势在于查询速度快。 treemap:放入treemap中的值会根据key按照...
  • Map详解(附demo)

    2019-07-01 17:53:34
    1.HashTable key和value的值不允许为空。 2.HashMap key和value可为空 3.LinkedHashMap 按插入的顺序查询,v可为null。 4.TreeMap 按照key值从小到大排序,v可为空
  • Java中的Map集合详解

    万次阅读 2016-04-30 12:36:46
     java中的map集合使用key-value映射来保存数据,其中value值可以重复,但key必须是唯一,也可以为空,但最多只能有一个key为空,它的主要实现类有HashMap、LinkedHashMap、TreeMap。 二、HashMap、LinkedHashMap...
  • RE:JAVA学习-HashMap用法

    2017-08-23 21:08:56
    1.Map 查询表 1.1 用于存储”Key-Value” 映射对。Key可以看作Value的索引(其关系类似高中学过的函数x-y的映射) 1.2 常见实现类:HashMap TreeMap 1.3 Map中常用方法: V put(K key,V value) 向Map中存放...
  • Map查找表

    2019-04-17 19:25:14
    * Map总是会根据key来获取对应的value,所以可以将查询条件作为key,将查找内容作为value保存, * 以便后期获取 * 散列表是当局查询速度最快的数据结构 * java.util.HashMap 散列表 * java.util.TreeMap ...
  • // 查询订单信息 DbOrder order = dbOrderMapper.selectByPrimaryKey(orderId); // 处理加密参数 TreeMap, Object> treeMap = new TreeMap, Object>(); treeMap.put("nonce_str", CommonUtil.getUUID());...
  • Map java.util.HashMap散列表,查询速度最快 ... boolean containsValue(Object value)包含value java.util.TreeMap二叉树 /** * Map查找表 * Map体验的结构是一个多行两列的表格,其中左..
  • javaSE-(MAP)

    2018-03-17 15:05:00
    一、概述 java中的map集合使用键(key)值(value)来保存数据,其中值(value)可以重复,但键(key)必须是唯一,也可以为空,但最多只能有一个key为空,它的主要实现类有HashMap、LinkedHashMap、TreeMap。二、Map集合...
  • java Map

    2019-08-20 18:49:54
    Map继承自Map接口,实现对“key-value”形式的键值对的存储,通过key来查询calue。其中key要求唯一。 Map的有三个实现类:HashMap、TreeMap、HashTable Map的常用方法: put(key,value) 往map中添加key/value...

空空如也

空空如也

1 2 3 4
收藏数 66
精华内容 26
关键字:

treemap查询value