map 订阅
Map(Modified Atmosphere Packaging)是一种应用于气调保鲜技术的名词。该名词常使用在食品包装领域。可能可以在食品包装袋中看到。 展开全文
Map(Modified Atmosphere Packaging)是一种应用于气调保鲜技术的名词。该名词常使用在食品包装领域。可能可以在食品包装袋中看到。
信息
外文名
Modified Atmosphere Packaging
领    域
食品包装
中文名
Map
性    质
气调保鲜技术
Map气调保鲜技术
  气调保鲜技术是人为控制气调保鲜库中气体中氮气、氧气、二氧化碳、乙烯等成分比例、湿度、温度(冰冻临界点以上)及气压,通过抑制储藏物细胞的呼吸量来延缓其新陈代谢过程,使之处于近休眠状态,而不是细胞死亡状态,从而能够较长时间的保持被储藏物的质地、色泽、口感、营养等的基本不变,进而达到长期保鲜的效果。即使被保鲜储藏物脱离开气调保鲜环境后,其细胞生命活动仍将保持自然环境中的正常新陈代谢率,不会很快成熟腐败。
收起全文
精华内容
下载资源
问答
  • map
    千次阅读
    2021-05-18 10:35:41

    c++中map容器提供一个键值对容器,那么你知道map的用法有哪些吗,下面秋天网 Qiutian.ZqNF.Com小编就跟你们详细介绍下c语言中map的用法,希望对你们有用。

    c语言中map的用法:map基本用法  1. 头文件

    复制代码 代码如下:

    #include

    2. 定义

    复制代码 代码如下:

    map my_map; //注意这里的int和int可以是其他类型

    或者是

    复制代码 代码如下:

    typedef map my_map;

    my_map my_map;

    3. 插入数据

    (1) my_map[1] = 1;

    (2) my_map.insert(map::value_type(2,2));

    (3) my_map.insert(pair(3,3));

    (4) my_map.insert(make_pair(4,4));

    4. 查找数据和修改数据

    (1)

    复制代码 代码如下:

    int i = my_map[1];

    my_map[1] = i;

    (2)

    复制代码 代码如下:

    my_map::iterator my_itr;

    my_itr.find(2);

    int j = my_itr->second;

    my_itr->second = j;

    注意:

    a.键本身是不能被修改的,除非删除。

    b.不管键存不存在,比如my_map[1] = i;,都会执行赋值操作。

    5. 删除数据

    (1) my_map.erase(my_itr);

    (2) my_map.erase(3);

    6. 遍历数据

    复制代码 代码如下:

    for(my_itr=my_map.begin();my_itr!=my_map.end();++my_itr){}

    7. 其它方法

    my_map.size() :返回元素数目

    my_map.empty():判断是否为空

    my_map.clear() :清空所有元素

    c语言中map的用法:嵌套用法  1.示例如下:

    复制代码 代码如下:

    map >multimap; //对于这样的map嵌套定义,

    map temp; //定义一个map变量,对其定义后在插入multimap

    temp[9] = 9;

    temp[10] = 10;

    multimap[10] = temp;

    multimap[10][11]=11;

    multimap[5][30]=30;

    map >::iterator multitr; // 以下是如何遍历本multimap

    map::iterator intertr;

    for(multitr=multimap.begin();multitr!=multimap.end();multitr++)

    {

    for(intertr= multitr ->second.begin(); intertr != multitr ->second.end(); intertr ++)

    cout<< multitr ->first<first< second <

    }

    2.也可以这样:

    复制代码 代码如下:

    map* >multimap;

    map* temp = new map;

    multimap[10]=temp;

    这样动态new内存,就要记得delete,否则会有内存泄露,delete如下:

    复制代码 代码如下:

    map* temp1;

    for(multitr=multimap.begin();multitr!=multimap.end();multitr++)

    {

    temp1 = multitr ->second;

    delete temp1;

    temp1 = null;

    }

    c语言中map的用法  1 头文件

    #include

    2、map的功能

    自动建立key - value的对应。key 和 value可以是任意你需要的类型。

    根据key值快速查找记录,查找的复杂度基本是log(n),如果有1000个记录,最多查找10次,1,000,000个记录,最多查找20次。

    快速插入key - value 记录。

    快速删除记录

    根据key 修改value记录。

    遍历所有记录。

    3,

    map的构造函数

    map共提供了6个构造函数,这块涉及到内存分配器这些东西,略过不表,在下面我们将接触到一些map的构造方法,这里要说下的就是,我们通常用如下方法构造一个map:

    map mapstudent;

    定义

    map my_map;

    或者是typedef map my_map;

    my_map my_map;

    4, 插入数据

    (1) my_map["a"] = 1;

    改变map中的条目非常简单,因为map类已经对[]操作符进行了重载

    enummap[1] = "one";

    enummap[2] = "two";

    .....

    这样非常直观,但存在一个性能的问题。插入2时,先在enummap中查找主键为2的项,没发现,然后将一个新的对象插入enummap,键是2,值是一个空字符串,插入完成后,将字符串赋为"two"; 该方法会将每个值都赋为缺省值,然后再赋为显示的值,如果元素是类对象,则开销比较大。我们可以用以下方法来避免开销:

    enummap.insert(map :: value_type(2, "two"))

    (2) my_map.insert(map::value_type("b",2));

    (3) my_map.insert(pair("c",3));

    (4) my_map.insert(make_pair("d",4));

    note : 如果相同元素放入到map中就是操作失败,此处可应用于看看map中是否有此元素,插入判断,防止代码实现功能错误

    5.

    查找并获取map中的元素

    下标操作符给出了获得一个值的最简单方法:

    cstring tmp = enummap[2];

    但是,只有当map中有这个键的实例时才对,否则会自动插入一个实例,值为初始化值。

    我们可以使用find()和count()方法来发现一个键是否存在。

    查找map中是否包含某个关键字条目用find()方法,传入的参数是要查找的key,在这里需要提到的是begin()和end()两个成员,分别代表map对象中第一个条目和最后一个条目,这两个数据的类型是iterator.

    int nfindkey = 2; //要查找的key

    //定义一个条目变量(实际是指针)

    udt_map_int_cstring::iterator it= enummap.find(nfindkey);

    if(it == enummap.end()) {

    //没找到

    }

    else {

    //找到

    }

    6, 迭代数据

    for (my_itr=my_map.begin(); my_itr!=my_map.end(); ++my_itr) {}

    7,map的大小

    在往map里面插入了数据,我们怎么知道当前已经插入了多少数据呢,可以用size函数,用法如下:

    int nsize = mapstudent.size();

    8,,数据的清空与判空

    清空map中的数据可以用clear()函数,判定map中是否有数据可以用empty()函数,它返回true则说明是空map

    9,

    //如果要删除1,用迭代器删除

    map::iterator iter;

    iter = mapstudent.find(1);

    mapstudent.erase(iter);

    //如果要删除1,用关键字删除

    int n = mapstudent.erase(1);//如果删除了会返回1,否则返回0

    //用迭代器,成片的删除

    //一下代码把整个map清空

    mapstudent.earse(mapstudent.begin(), mapstudent.end());

    //成片删除要注意的是,也是stl的特性,删除区间是一个前闭后开的集

    更多相关内容
  • Unity Tilemap模块全攻略

    万人学习 2019-02-01 09:50:46
    这是Tilemap相关的系列教程,在Unity2017.2以及以上版本中提供了这样的新功能,他可以快速的设计2D关卡,减少关卡设计的重复操作,提高效率,很有魅力的一个模块,跟五斗米老师一起学习吧,你一定会为这个新功能欢呼...
  • 4个主要的map实现类介绍

    万次阅读 多人点赞 2019-07-31 18:36:57
    map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍): HashMap:我们最常用的Map,HashMap的值是没有顺序的,他是按照key的HashCode来...

    一、简单介绍

    map是键值对的集合接口,它的实现类主要包括:HashMap,TreeMap,Hashtable以及LinkedHashMap等。其中这四者的区别如下(简单介绍):

    HashMap:我们最常用的Map,HashMap的值是没有顺序的,他是按照key的HashCode来实现的,就是根据key的HashCode 值来存储数据,根据key可以直接获取它的Value,同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。

    TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序,也可以指定排序的比较器,当用Iterator 遍历TreeMap时,得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。

    Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步,即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢,只有hashtable是继承自Dictionary抽象类的,hashMap和treeMap都继承自AbstractMap抽象类,LinkedHashMap继承自hashMap。

    LinkedHashMap: 保存了记录的插入顺序,在用Iterator遍历LinkedHashMap时,先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空,非同步的。

    一些常识:

    1.Collection与Map集合是不是继承自Object?--不是,两个都是接口,Object是类,怎么可能会继承自Object,详细看java.util下的具体接口。

    二、Map排序

    TreeMap

    TreeMap默认是升序的,如果我们需要改变排序方式,则需要使用比较器:Comparator。

    Comparator可以对集合对象或者数组进行排序的比较器接口,实现该接口的public compare(T o1,To2)方法即可实现排序,该方法主要是根据第一个参数o1,小于、等于或者大于o2分别返回负整数、0或者正整数。如下:

     

    复制代码代码如下:


    public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>(
                    new Comparator<String>() {
                        public int compare(String obj1, String obj2) {
                            // 降序排序
                            return obj2.compareTo(obj1);
                        }
                    });
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");

            Set<String> keySet = map.keySet();
            Iterator<String> iter = keySet.iterator();
            while (iter.hasNext()) {
                String key = iter.next();
                System.out.println(key + ":" + map.get(key));
            }
        }
    }

     

    运行结果如下:

    d:ddddd 
    c:ccccc 
    b:bbbbb 
    a:aaaaa

    上面例子是对根据TreeMap的key值来进行排序的,但是有时我们需要根据TreeMap的value来进行排序。对value排序我们就需要借助于Collections的sort(List<T> list, Comparator<? super T> c)方法,该方法根据指定比较器产生的顺序对指定列表进行排序。但是有一个前提条件,那就是所有的元素都必须能够根据所提供的比较器来进行比较。如下:

     

    复制代码代码如下:


    public class TreeMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new TreeMap<String, String>();
            map.put("d", "ddddd");
            map.put("b", "bbbbb");
            map.put("a", "aaaaa");
            map.put("c", "ccccc");

            //这里将map.entrySet()转换成list
            List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
            //然后通过比较器来实现排序
            Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
                //升序排序
                public int compare(Entry<String, String> o1,
                        Entry<String, String> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }

            });

            for(Map.Entry<String,String> mapping:list){ 
                   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
        }
    }

     


    运行结果

    a:aaaaa 
    b:bbbbb 
    c:ccccc 
    d:ddddd

    HashMap

    我们都是HashMap的值是没有顺序的,他是按照key的HashCode来实现的。对于这个无序的HashMap我们要怎么来实现排序呢?参照TreeMap的value排序,我们一样的也可以实现HashMap的排序。

     

    复制代码代码如下:


    public class HashMapTest {
        public static void main(String[] args) {
            Map<String, String> map = new HashMap<String, String>();
            map.put("c", "ccccc");
            map.put("a", "aaaaa");
            map.put("b", "bbbbb");
            map.put("d", "ddddd");

            List<Map.Entry<String,String>> list = new ArrayList<Map.Entry<String,String>>(map.entrySet());
            Collections.sort(list,new Comparator<Map.Entry<String,String>>() {
                //升序排序
                public int compare(Entry<String, String> o1,
                        Entry<String, String> o2) {
                    return o1.getValue().compareTo(o2.getValue());
                }

            });

            for(Map.Entry<String,String> mapping:list){ 
                   System.out.println(mapping.getKey()+":"+mapping.getValue()); 
              } 
         }
    }

     

    运行结果

    a:aaaaa 
    b:bbbbb 
    c:ccccc 
    d:ddddd

    展开全文
  • Object转成map对象

    万次阅读 2021-04-07 16:54:26
    1、Object转换成map的方法 import java.lang.reflect.Field; import java.util.HashMap; import java.util.Map; /** * 将Object对象里面的属性和值转化成Map对象 * * @param obj * @return * @throws ...

    1、Object转换成map的方法

    import java.lang.reflect.Field;
    import java.util.HashMap;
    import java.util.Map;
    
    
    /**
         * 将Object对象里面的属性和值转化成Map对象
         *
         * @param obj
         * @return
         * @throws IllegalAccessException
         */
        public static Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
            Map<String, Object> map = new HashMap<String,Object>();
            Class<?> clazz = obj.getClass();
            for (Field field : clazz.getDeclaredFields()) {
                field.setAccessible(true);
                String fieldName = field.getName();
                Object value = field.get(obj);
                map.put(fieldName, value);
            }
            return map;
        }

    2、转换前的数据格式

    SearchHit{id='awQWpXgBwGXBeoctg1F5', score=2.1747518, sortValues=[], content=User(id=awQWpXgBwGXBeoctg1F5, name=吴京, msg=我是演员, job=演员, sex=男, age=12, createDate=Tue Apr 06 08:00:00 CST 2021), highlightFields={}}
    

    3、转换后的数据

    {score=2.1747518, innerHits={}, highlightFields={}, index=user, id=awQWpXgBwGXBeoctg1F5, nestedMetaData=null, sortValues=[], content=User(id=awQWpXgBwGXBeoctg1F5, name=吴京, msg=我是演员, job=演员, sex=男, age=12, createDate=Tue Apr 06 08:00:00 CST 2021)}
    

    4、取map中的值

    map.get("content")

    5、map转实体对象

    List searchHits = user.getSearchHits();
    
    List<User> users = new ArrayList<>();
            for (Object o : searchHits) {
                Map<String, Object> map = new HashMap<>();
                map = objectToMap(o);
                Map<String, Object> userMap = objectToMap(map.get("content"));
                User user1 = mapToBean(userMap);
                System.out.println("哈哈哈哈哈转换成功:"+user1.getMsg());
                users.add(user1);
            }

    6、map转实体类对象利用的方法

    参数类型按实际的实体类进行增加

    /**
         * map 转 实体类
         *
         * @param map
         * @return
         * @throws Exception
         */
        public User mapToBean(Map<String, Object> map)
                throws Exception {
            User permission = new User();
            if (map != null) {
                Field[] declaredFields = User.class.getDeclaredFields();
                if (declaredFields != null) {
    
                    for (Field declaredField : declaredFields) {
                        declaredField.setAccessible(true);
                        Set<String> mapKeys = map.keySet();
    
                        for (String mapKey : mapKeys) {
    
                            if (declaredField.getType().toString().contains("Integer"))//判断属性类型 进行转换,map中存放的是Object对象需要转换 实体类中有多少类型就加多少类型,实体类属性用包装类;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Integer.valueOf(map.get(mapKey).toString()));
                                    break;
                                }
                            if (declaredField.getType().toString().contains("String"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, map.get(mapKey));
    
                                    break;
                                }
                            if (declaredField.getType().toString().contains("Float"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Float.valueOf(map.get(mapKey).toString()));
    
                                    break;
                                }
    
                            if (declaredField.getType().toString().contains("Long"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Long.valueOf(map.get(mapKey).toString()));
                                    break;
                                }
    
                            if (declaredField.getType().toString().contains("Date"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    String s = map.get(mapKey).toString();
                                    Date parse = parse(s, "EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
                                    declaredField.set(permission, parse);
                                    break;
                                }
    
                        }
                    }
                }
    
            }
    
            return permission;

    7、里面用到的时间格式是格林威治,实体类存的是Date,具体方法如下:

    // 格林威治时间转Date
        private Date parse(String str, String pattern, Locale locale) {
            if (str == null || pattern == null) {
                return null;
            }
            try {
                return new SimpleDateFormat(pattern, locale).parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }

    8、完整代码在下面,因为我用的是springboot+es,所以,根据具体情况灵活变动

    package com.springboot.demo.es;
    
    import com.springboot.demo.entity.User;
    import com.springboot.demo.mapper.UserResipotry;
    import org.apache.tomcat.util.buf.StringUtils;
    import org.elasticsearch.index.query.BoolQueryBuilder;
    import org.elasticsearch.index.query.QueryBuilders;
    import org.junit.jupiter.api.Test;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
    import org.springframework.data.elasticsearch.core.SearchHits;
    import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
    import org.springframework.data.elasticsearch.core.query.GetQuery;
    import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
    
    import javax.xml.crypto.Data;
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.*;
    import java.lang.reflect.Field;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * @author dt
     * @date 2021年04月06日10:47
     */
    @SpringBootTest
    public class EsDemo01 {
    
    
        @Autowired
        private ElasticsearchRestTemplate elasticsearchRestTemplate;
    
       
        @Test
        void test4() throws Exception {
    
            //组合条件对象
            BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
            boolQuery.must(QueryBuilders.matchQuery("name", "吴京"));
    
            NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
            nativeSearchQueryBuilder.withQuery(boolQuery);
            SearchHits user = elasticsearchRestTemplate.search(nativeSearchQueryBuilder.build(), User.class, IndexCoordinates.of("user"));
            List searchHits = user.getSearchHits();
    
            List<User> users = new ArrayList<>();
            for (Object o : searchHits) {
                Map<String, Object> map = new HashMap<>();
                map = objectToMap(o);
                Map<String, Object> userMap = objectToMap(map.get("content"));
                User user1 = mapToBean(userMap);
                System.out.println("哈哈哈哈哈转换成功:"+user1.getMsg());
                users.add(user1);
            }
    
            System.out.println(users);
    
        }
    
    
        /**
         * 将Object对象里面的属性和值转化成Map对象
         *
         * @param obj
         * @return
         * @throws IllegalAccessException
         */
        public static Map<String, Object> objectToMap(Object obj) throws IllegalAccessException {
            Map<String, Object> map = new HashMap<String, Object>();
            Class<?> clazz = obj.getClass();
            for (Field field : clazz.getDeclaredFields()) {
                field.setAccessible(true);
                String fieldName = field.getName();
                Object value = field.get(obj);
                map.put(fieldName, value);
            }
            return map;
        }
    
    
        /**
         * map 转 实体类
         *
         * @param map
         * @return
         * @throws Exception
         */
        public User mapToBean(Map<String, Object> map)
                throws Exception {
            User permission = new User();
            if (map != null) {
                Field[] declaredFields = User.class.getDeclaredFields();
                if (declaredFields != null) {
    
                    for (Field declaredField : declaredFields) {
                        declaredField.setAccessible(true);
                        Set<String> mapKeys = map.keySet();
    
                        for (String mapKey : mapKeys) {
    
                            if (declaredField.getType().toString().contains("Integer"))//判断属性类型 进行转换,map中存放的是Object对象需要转换 实体类中有多少类型就加多少类型,实体类属性用包装类;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Integer.valueOf(map.get(mapKey).toString()));
                                    break;
                                }
                            if (declaredField.getType().toString().contains("String"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, map.get(mapKey));
    
                                    break;
                                }
                            if (declaredField.getType().toString().contains("Float"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Float.valueOf(map.get(mapKey).toString()));
    
                                    break;
                                }
    
                            if (declaredField.getType().toString().contains("Long"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    declaredField.set(permission, Long.valueOf(map.get(mapKey).toString()));
                                    break;
                                }
    
                            if (declaredField.getType().toString().contains("Date"))//判断属性类型 进行转换;
                                if (declaredField.getName().equals(mapKey)) {
                                    String s = map.get(mapKey).toString();
                                    Date parse = parse(s, "EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
                                    declaredField.set(permission, parse);
                                    break;
                                }
    
                        }
                    }
                }
    
            }
    
            return permission;
        }
    
    
        @Test
        public void getTime() throws ParseException {
            String str = "Tue Apr 06 08:00:00 CST 2021";
            Date date = parse(str, "EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
    
        }
    
        // 格林威治时间转Date
        private Date parse(String str, String pattern, Locale locale) {
            if (str == null || pattern == null) {
                return null;
            }
            try {
                return new SimpleDateFormat(pattern, locale).parse(str);
            } catch (ParseException e) {
                e.printStackTrace();
            }
            return null;
        }
    }
    

    9、那些转换方法都可以单独用

    参考文章链接:

    https://blog.csdn.net/qq_15204179/article/details/86677123

    https://www.cnblogs.com/zktww/p/14296407.html

    https://www.cnblogs.com/tobeymarshall/p/10217410.html

    展开全文
  • unordered_map使用详解

    万次阅读 多人点赞 2022-02-04 20:24:43
    STL:unordered_map使用笔记 参考网址: cpluscplus unordered_mapmap的区别(CSDN) 1.概述 unordered_map的模板定义如下: template < class Key, // unordered_map::key_type class T, // unordered_map:

    STL:unordered_map使用笔记

    参考网址:

    1.概述

    unordered_map的模板定义如下:

    template < class Key,                                    // unordered_map::key_type
               class T,                                      // unordered_map::mapped_type
               class Hash = hash<Key>,                       // unordered_map::hasher
               class Pred = equal_to<Key>,                   // unordered_map::key_equal
               class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
               > class unordered_map;
    

    unordered_map是一种关联容器,存储基于键值和映射组成的元素,即key-value。允许基于键快速查找元素。在unordered_map中,键值唯一标识元素,映射的值是一个与该对象关联的内容的对象。

    对于有序和无序性:

    • unordered_map的无序体现在内部存储结构为哈希表,以便通过键值快速访问元素。
    • 与之对应的有序的关联容器为map,map的有序体现在内部存储结构为红黑树,存储时元素自动按照从小到大的顺序排列。

    而内部存储结构也决定了unordered_map和map在某些特性上的不同:

    • 查找的效率
      • unordered_map查找效率更高,可以达到O(1),但是对于元素子集的范围迭代效率较低。
      • 对于map,按照中序遍历的遍历次序,能够方便迭代得出从小到大的元素

    无序映射实现了直接访问操作符(operator[]),该操作符允许使用其键值作为参数直接访问映射值。容器中的迭代器至少是前向迭代器forward iterators

    2.属性

    2.1 关联性

    关联容器中的元素由他们的键引用,而不是由他们在容器中的绝对位置引用。

    2.2 无序性

    无序容器使用散列表来组织它们的元素,散列表允许通过它们的键快速访问元素。

    2.3 Map映射

    每个元素将一个键key与一个映射值value相关联:键意味着标识其主要内容是映射值的元素。

    2.4 key的唯一性

    在容器中没有两个元素有相同的key

    2.5 Allocator-aware

    容器使用一个分配器对象来动态地处理它的存储需求。

    3.模板参数

    template < class Key,                                    // unordered_map::key_type
               class T,                                      // unordered_map::mapped_type
               class Hash = hash<Key>,                       // unordered_map::hasher
               class Pred = equal_to<Key>,                   // unordered_map::key_equal
               class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
               > class unordered_map;
    
    • key

      键值的类型。unordered_map中的每个元素都是由其键值唯一标识的。

    • T

      映射值的类型。unordered_map中的每个元素都用来存储一些数据作为其映射值。

    • Hash

      一种一元函数对象类型,它接受一个key类型的对象作为参数,并根据该对象返回size_t类型的唯一值。这可以是一个实现函数调用操作符的类,也可以是一个指向函数的指针(参见构造函数)。默认为hash<Key>

    • Pred

      接受两个键类型参数并返回bool类型的二进制谓词。表达式pred (a, b), pred是这种类型的一个对象,a和b是键值,返回true,如果是应考虑相当于b。这可以是一个类实现一个函数调用操作符或指向函数的指针(见构造函数为例)。这默认为equal_to<Key>,它返回与应用相等操作符(a==b)相同的结果。

    • Allloc

      用于定义存储分配模型的allocator对象的类型。默认情况下,使用allocator类模板,它定义了最简单的内存分配模型,并且与值无关。

    4.成员函数

    4.1 构造函数与初始化

    (1)模板类的默认构造函数,创建空的unordered_map

    unordered_map<int, string> umap;
    

    (2)使用初始化列表初始化

    unordered_map<int, string> umap = unordered_map<int, string>({{1,"a"},{2,"b"}});  // 显式调用C++的构造函数
    unordered_map<int, string> umap2({{3,"c"},{4,"d"}});	// 隐式调用构造函数,更简洁
    unordered_map<string, string> umap{
        {"淘宝","https://www.taobao.com/"},
        {"京东","https://www.jd.com/"},
        {"天猫商城","https://jx.tmall.com/"} };
    

    (3)拷贝构造函数初始化

    // 拷贝构造函数 
    unordered_map<int, string> umap4(umap3);
    

    (4)迭代器初始化

    // range
    unordered_map<int, string> umap5(umap1.begin(), umap1.end());
    

    (5)拷贝初始化

    typedef std::unordered_map<std::string,std::string> stringmap;
    first = {{"AAPL","Apple"},{"MSFT","Microsoft"}};  // init list
    second = {{"GOOG","Google"},{"ORCL","Oracle"}};   // init list
    third = merge(first,second);                      // move
    first = third;                                    // copy	
    

    4.2 capacity

    (1)是否为空

    cout << "first " << (first.empty() ? "is empty" : "is not empty") << endl;
    cout << "first " << (second.empty() ? "is empty" : "is not empty") << endl;
    

    (2)目前容量

    cout << "thrid.size is" << third.size() << endl;
    

    4.3 迭代

    /**  Iteration **/
    for (auto it = first.begin(); it != first.end(); it++){
        cout << " " << it->first << ":" << it->second;
    }
    cout<<endl;
    

    4.4 元素的访问

    (1)operator[]

    first["GOOG"] = "Google";		// new element inserted
    first["AAPL"] = "Apple";		// new element inserted
    first["MSFT"] = "Microsoft";	// new element inserted
    first["BOB"] = "Bob";
    string brand1 = first["GOOG"];	// read
    first["BOB"] = "";				// writen
    for (auto it = first.begin(); it != first.end(); it++){
        cout << " " << it->first << ":" << it->second;
    }
    cout<<endl;
    

    (2)at

    unrdered_map<string,int> mymap = {
        {"Mars", 3000},
        {"Saturn", 60000},
        {"Jupiter", 70000}};
    mymap.at("Mars") = 3396;
    mymap.at("Saturn") += 127;
    mymap.at("Jupiter") = mymap.at("Saturn") + 9638;
    	
    for (auto& x: mymap) {
        std::cout << x.first << ": " << x.second << std::endl;
    }
    

    4.5 元素的查找

    (1)find

    find函数的原型如下:

    iterator find ( const key_type& k );
    const_iterator find ( const key_type& k ) const;
    

    find函数可以用来获取元素的迭代器:

    std::unordered_map<std::string,double> mymap1 = {
    	    {"mom",5.4},
    	    {"dad",6.1},
    	    {"bro",5.9} };
    	
    string person = "dad";
    unordered_map<std::string,double>::const_iterator got = mymap1.find(person);
    
    if(got == mymap1.end()){
        cout << "not found" << endl;
    }else{
        cout << got->first << " is " << got->second << endl; 
    }
    

    注意迭代器的声明方式:

    unordered_map<string,double>::const_iterator
    

    (2)count

    成员函数count判断集合中有没有键值k,函数原型如下:

    size_type count ( const key_type& k ) const;
    

    其中size_type是一个整型变量,如果无序map中有key k,那么返回值为1,否则返回值为0。

    4.6 修改

    (1)元素的插入

    • operator[]

      使用操作符map_name [key_name] = value,实现对应key的value值的覆盖,若是key值是原来不存在的key,那么实现了新的元素的插入。

    • emplace()

      在unordered_map中插入一个新元素(如果其键是唯一的)。此新元素是使用 args 作为元素构造函数的参数来构造的。

      仅当容器中没有元素具有与要放置的元素等效的键(unordered_map中的键是唯一的)时才会进行插入。

      如果插入,这实际上会将容器大小增加一个。

      存在类似的成员函数 insert,它将现有对象复制或移动到容器中。

      // unordered_map::emplace
      #include <iostream>
      #include <string>
      #include <unordered_map>
      
      int main ()
      {
        std::unordered_map<std::string,std::string> mymap;
      
        mymap.emplace ("NCC-1701", "J.T. Kirk");
        mymap.emplace ("NCC-1701-D", "J.L. Picard");
        mymap.emplace ("NCC-74656", "K. Janeway");
      
        std::cout << "mymap contains:" << std::endl;
        for (auto& x: mymap)
          std::cout << x.first << ": " << x.second << std::endl;
      
        std::cout << std::endl;
        return 0;
      }
      
    • insert()

      insert的插入和emplace的插入类似,只有当键是唯一时,才能进行插入,同时size增加。

      insert的插入形式比emplace更加灵活:

      (1)	
      pair<iterator,bool> insert ( const value_type& val );
      (2)	
      template <class P>
          pair<iterator,bool> insert ( P&& val );
      (3)	
      iterator insert ( const_iterator hint, const value_type& val );
      (4)	
      template <class P>
          iterator insert ( const_iterator hint, P&& val );
      (5)	
      template <class InputIterator>
          void insert ( InputIterator first, InputIterator last );
      (6)	
      void insert ( initializer_list<value_type> il );
      
      /** 元素的插入 **/
      // insert
      unordered_map<string,double> myrecipe, mypantry = {{"milk",2.0},{"flour",1.5}};;					
      pair<string,double> myshopping ("baking powder",0.3);
      myrecipe.insert(myshopping);	// copy insertion
      myrecipe.insert(mypantry.begin(), mypantry.end());	// range inseration
      myrecipe.insert({{"sugar",0.8},{"salt",0.1},{"sugar",0.9}});		// initializer list inseration
      
      cout << "myrecipe contains:" << endl;
      for(auto& x:myrecipe){
          cout << x.first << ":" << x.second << " "; 
      }
      

      image-20220204200919401

    (2)元素的删除

    元素的删除使用erase()方法,删除的形式有多种:

    by position (1)iterator erase ( const_iterator position );
    by key (2)size_type erase ( const key_type& k );
    range (3)iterator erase ( const_iterator first, const_iterator last );
    //erase
    std::unordered_map<std::string,std::string> mymap3;
    
    // populating container:
    mymap3["U.S."] = "Washington";
    mymap3["U.K."] = "London";
    mymap3["France"] = "Paris";
    mymap3["Russia"] = "Moscow";
    mymap3["China"] = "Beijing";
    mymap3["Germany"] = "Berlin";
    mymap3["Japan"] = "Tokyo";
    
    cout << endl;
    cout << "------------------------------------------" << endl;
    // 根据位置,删除第一个:
    mymap3.erase(mymap3.begin());
    // 根据key
    mymap3.erase("France");
    // range
    mymap3.erase(mymap3.find("Germany"), mymap3.end());
    
    for (auto& x : mymap3) {
        cout << x.first << ":" << x.second << " ";
    }
    
    展开全文
  • 遍历map的四种方法

    万次阅读 2021-11-01 13:35:52
    Map.entrySet() 这个方法返回的是一个Set<Map.Entry<K,V>>,Map.Entry 是Map中的一个接口,他的用途是表示一个映射项(里面有Key和Value),而Set<Map.Entry<K,V>>表示一个映射项的Set。Map...
  • Object 转MapMap转Object方式总结

    千次阅读 2022-03-16 11:35:16
    } 通过反射实现Map转Bean //Map转Object public static Object mapToObject(Map map, Class beanClass) throws Exception { if (map == null) return null; Object obj = beanClass.newInstance(); Field[] fields ...
  • Golang map

    千次阅读 2020-08-04 10:56:46
    在 Go 语言中,一个 map 就是一个哈希表的引用,map 类型可以写为 map[K]V,其中 K 和 V 分别对应 key 和 value。map 中所有的 key 都有相同的类型,所有的 value 也有着相同的类型,但是 key 和 value 之间可以是...
  • sql-map-2.dtd和sql-map-config-2.dtd

    千次下载 热门讨论 2014-06-10 22:45:04
    ibatis标签提示工具 sql-map-2.dtd
  • java的Map集合 详解Map集合

    万次阅读 多人点赞 2022-04-08 08:47:41
    java 集合 Map, HashMap,LinkedHashMap,Hashtable, 详解Map集合
  • c++中map详解

    千次阅读 2022-04-29 20:35:13
    map简介 map是STL的一个关联容器,以键值对存储的数据,其类型可以自己定义,每个关键字在map中只能出现一次,关键字不能修改,值可以修改;map同set、multiset、multimap(与map的差别仅在于multimap允许一个键对应...
  • C++ map详解

    千次阅读 2022-04-14 09:47:12
    1、map 对象的定义 map<k, v> m; 创建一个名为m的空map对象,其键和值得类型分别为k和v map<k, v> m(m1); 创建m1的副本m,m与m1必须有相同的键类型和值类型 map<k, v> m(b, e); 创建map类型的对象m...
  • java-合并两个Map

    千次阅读 2021-05-15 16:49:09
    Java8中如何合并两个map? 如何处理Map含有重复元素的情况? 1. 初始化 我们定义两个map实例 private static Map<String, People> map1 = new HashMap<>(); private static Map<String, People>...
  • MapStruct - 一篇就能上手 MapStruct

    万次阅读 多人点赞 2021-02-22 17:45:25
    MapStruct是满足JSR269规范的一个Java注解处理器,用于为Java Bean生成类型安全且高性能的映射。它基于编译阶段生成get/set代码,此实现过程中没有反射,不会造成额外的性能损失。 您所要做的就是定义一个mapper...
  • map与unordered_map的用法

    千次阅读 2021-02-02 17:07:44
    map翻译为映射,也是常见的STL容器 在定义数组时(如int array[100]),其实是定义了一个从int型到int型的映射 比如array[0]=25、array[4]=36就分别是将0映射到25、将4映射到36 一个double型数组则是将int型映射到...
  • java8 Map添加的新方法,你知道吗?会用吗?
  • mapstruct原理解析

    万次阅读 2021-09-09 20:06:31
    目录 一、mapstruct简介 二、mapstruct与其他映射框架...有了mapstruct,只需要定义一个映射器接口,声明需要映射的方法,在编译过程中,mapstruct会自动生成该接口的实现类,实现将源对象映射到目标对象的效果。 ...
  • c++ map与unordered_map区别及使用

    万次阅读 多人点赞 2018-12-01 13:06:34
    需要引入的头文件不同 map: #include &lt; map &gt; unordered_map: #include &lt; unordered_map &...mapmap内部实现了一个红黑树(红黑树是非严格平衡二叉搜索树,而AVL是严格平衡二...
  • 一、 Dart 数据类型 Map 类型、 二、 Map 类型初始化并赋值、 1、 创建 Map 对象同时进行初始化操作、 2、 先创建 Map 对象再进行赋值、 三、 Map 集合遍历、 1、 使用 forEach 遍历 Map 集合、 2、 使用普通 for ...
  • 在我们最初使用map复制开发业务代码时,通常会踩到深浅复制(拷贝)这个坑里,比如我,在Map复制时 (如:Map<String, String> new_Map = old_Map) 出现过以下两类问题: 1.使用Map<String, String> ...
  • MapStruct Map 转换成对象

    千次阅读 2020-08-23 21:59:33
    想把这种 map 结果转为项目中对应的JavaBean如DTO 或者 VO,又不想写很多的 dto.setXxx(map.get("xxx")) 的代码。 结果 查阅了一下,MapStruct 目前(1.3.1.Final 及之前)的版本暂不支持直接将 map 转换成 ...
  • 第1章 ConfigMap概述 1.1 什么是ConfigMap? 1.2配置信息真正的保存地方 1.3配置信息保存格式 1.4 创建ConfigMap对象的4种方式 第2章 创建ConfigMap对象, 关联pod内部的配置文件的路径 2.1通过命令行参数--...
  • Java的Map中的map.keySet()方法

    万次阅读 多人点赞 2019-03-28 20:27:46
    今天再代码中看到了Map集合中的HashMap的map.keySet()方法,首先看一下这个方法的定义 /** * Returns a {@link Set} view of the keys contained in this map. * The set is backed by the map, s...
  • unordered_map详细介绍

    万次阅读 多人点赞 2019-07-21 15:50:21
    转载自关联容器:unordered_map详细介绍(附可运行代码) 介绍 1 特性 2 Hashtable和bucket 模版 1 迭代器 功能函数 1 构造函数 12示例代码 2 容量操作 21 size 22 empty 3 元素操作 31 find 32 ...
  • 遍历Map集合、修改Map集合中的value值

    千次阅读 2020-12-31 09:44:18
    Map集合是基于java核心类——java.util中的;Map集合用于储存元素对,Map储存的是一对键值(key和value),是通过key映射到它的valuevalues(): 是获取集合中的所有的值----没有键,没有对应关系。KeySet(): 将Map中...
  • C++中map用法详解

    千次阅读 2022-04-29 20:32:50
    Map是c++的一个标准容器,她提供了很好一对一的关系,在一些程序中建立一个map可以起到事半功倍的效果,总结了一些map基本简单实用的操作! 1. map最基本的构造函数; map<string , int >mapstring; map<...
  • java-将Map ,Object>转换为Map ,String>

    千次阅读 2021-03-06 01:46:47
    java-将Map 转换为Map 如何将Map转换为Map?这不起作用:Map map = new HashMap(); //Object is containing StringMap newMap =new HashMap(map);11个解决方案37 votes现在我们有了Java 8 / streams,我们可以在列表...
  • C++中的map

    万次阅读 多人点赞 2019-04-28 23:06:21
    map基本操作3.1 头文件3.2 创建map对象3.3 map元素访问3.3.1 使用下标 [ ] 访问3.3.2 使用 at() 方法访问3.4 map中元素的插入3.4.1 使用下标[]插入3.4.2 使用insert()插入元素3.4 erase() 删除元素3.5 count(k) ...
  • java 实体转map

    千次阅读 2022-03-21 00:04:46
    实体,map
  • JAVA中的Map简单使用

    千次阅读 2022-04-19 12:32:15
    Map的简述 Map中得每个元素属于键值对模式。 如果往map中添加元素时 需要添加key 和 value. 它也属于一个接口,该接口常见得实现类有: HashMap. Map中key有唯一性的特点,不能重复。 1.如何创建Map对象 public ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,024,001
精华内容 1,609,600
关键字:

map

友情链接: ficon.zip