精华内容
下载资源
问答
  • java创建map集合对象
    千次阅读
    2021-03-13 15:33:31

    在这个Java泛型示例中,您将看到如何创建泛型Map对象。创建通用Map意味着您可以定义键的类型和存储在中的对象的值的类型Map。通用Map的声明和实例化仅与其他类型的集合不同,例如ListandSet是我们定义了两种类型。键的一种类型,值的另一种类型。

    创建通用Map的语法如下:Map map = new Map();

    哪里K是映射键V的类型,是映射中存储的值的类型。如果要让映射保存对Stringobject的引用值并使用Integer键作为键,则将编写声明和实例化,如下面的代码片段所示。Map  map = new HashMap();

    为了使其更简单,您也可以使用菱形运算符。Map  map = new HashMap<>();

    当您想向映射添加一些元素时,可以使用相同的put()方法。但是您不必担心在映射中放置了错误类型的对象。因为Java编译器将对其进行检查,以查看您是否存储了正确的类型。泛型将捕获在运行时不应发生的错误,因为代码已在编译时进行了验证。Map  map = new HashMap<>();

    map.put(1, "A");

    map.put(2, "B");

    map.put(3, "C");

    //map.put("4", new Date()); // 编译时错误!

    String a = map.get(1);

    String b = map.get(2);

    String c = map.get(3);

    get()方法将从映射中返回与给定键对应的值。因为映射知道它存储字符串值,所以它将返回一个字符串。因此,您无需从映射的get()方法强制转换返回值。您可能想知道为什么我们可以放置像1、2、3这样的键Integer?如果您还记得自动装箱功能,那么您会理解的。在屏幕后面,Java会将原语转换int为Integer。

    现在,在我们知道如何添加元素并从映射上读回元素之后。让我们迭代映射的内容。映射将具有两个可以迭代的集合,即键和值。下面的代码段将为您演示。第一个代码段向您展示如何使用键集合迭代映射,而第二个代码段则迭代映射的值。

    迭代键集合。Iterator keyIterator = map.keySet().iterator();

    while (keyIterator.hasNext()) {

    Integer key = keyIterator.next();

    String value = map.get(key);

    System.out.println("key = " + key + "; value = " + value);

    }

    当使用键集合迭代映射时,您将获得映射的键集,并检查hasNext()以查看它是否有next键。之后,可以使用next()方法获取键。要获取值,可以调用get()方法并将键作为参数传递。

    迭代值集合。Iterator valueIterator = map.values().iterator();

    while(valueIterator.hasNext()) {

    System.out.println("value = " + valueIterator.next());

    }

    如果要迭代该值并忽略键,则可以从映射中获取值集合。验证它是否仍然包含更多值,您可以调用hasNext()方法。要获取值,只需从迭代器调用next()方法。

    请注意,当使用泛型映射时,不需要进行任何类型转换。将所有内容添加到map,并根据键的类型和map的值从map读取。除了使用迭代器之外,还可以使用for-each循环来迭代映射。下面是使用for-each循环编写的上述代码的版本。for (Integer key : map.keySet()) {

    String value = map.get(key);

    System.out.println("key = " + key + "; value = " + value);

    }

    for (String s : map.values()) {

    System.out.println("value = " + s);

    }

    您可以选择与您的编码样式匹配的任何一种方式。两种迭代映射对象的方法都会产生相同的结果。

    更多相关内容
  • javaMap集合 详解Map集合

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

    一、Map集合的特点

    Map集合的特点
    1.Map是一个双列集合,一个元素包含两个值(一个key,一个value)

    2.Map集合中的元素,key和value的数据类型可以相同,也可以不同

    3.Map中的元素,key不允许重复,value可以重复

    4.Map里的key和value是一一对应的。

    二、Map中的方法:

    1.public   V  put (K key,V value) 把指定的键和值添加到Map集合中,返回值是V

    如果要存储的键值对,key不重复返回值V是null

    如果要存储的键值对,key重复返回值V是被替换的value值 

    2. public  V remove(Object key)把指定键所对应的键值对元素,在Map集合中删除,返回被删除的元素的值。 返回值:V 。如果key存在,返回被删除的值,如果key不存在,返回null

     

    3.public V remove (Object key):根据指定的键 在Map集合中获取对应的值

    如果key存在,返回对应的value值,如果key不存在,返回null

     

      4.boolean containsKey( Object key)判判断集合中是否包含指定的键

    包含返回true,不包含返回false

    三、遍历Map集合的方式

    1.通过键找值的方法;

    使用了setKey方法,将Map集合中的key值,存储到Set集合,用迭代器或foreach循环遍历Set集合来获取Map集合的每一个key,并使用get(key)方法来获取value值

     

     2.使用Entry对象遍历

    Map.Entry<K,V>,在Map接口中有一个内部接口Entry(内部类)

    作用:当集合一创建,就会在Map集合中创建一个Entry对象,用来记录键与值(键值对对象,键值的映射关系)

     有了Entry对象就可以使用Map中的entrySet方法,把Map集合中的多个Entry对象存入一个Set集合来遍历Set集合,获取Set集合中每一个Entry对象,然后可以使用Entry中的两个方法getKey和getValue来分别获取键和值。

    代码步骤:

     

     

     

    四、Map的常用实现类

    (一)、HashMap

    【1】.特点:1.HashMap底是哈希表,查询速度非常快(jdk1.8之前是数组+单向链表,1.8之后是数组+单向链表/红黑树 ,链表长度超过8时,换成红黑树)

         2. HashMap是无序的集合,存储元素和取出元素的顺序有可能不一致

         3.集合是不同步的,也就是说是多线程的,速度快

    【2】.HashMap存储自定义类型键值

    HashMap存储自定义类型键值,Map集合保证key是唯一的:作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一

     (二)LinkedHashMap

    HashMap有子类LinkedHashMap:LinkedHashMap <K,V> extends HashMap <K,V>

    是Map接口的哈希表和链表的实现,具有可预知的迭代顺序(有序)

    底层原理:哈希表+链表(记录元素顺序)

    特点:1.LinkedHashMap底层是哈希表+链表(保证迭代的顺序)

    2.LinkedHashMap是一个有序的集合,存储元素和取出元素的顺序一致

    改进之处就是:元素存储有序了

    (三)Hashtable

    Hashtable<K,V> implements Map<K,V>

    Hashtable:底层也是哈希表,是同步的,是一个单线程结合,是线程安全的集合,速度慢

    HashMap:底层也是哈希表,但是线程不安全的集合,是多线程集合,速度快

    HashMap(还有之前学的所有集合):都可以存储null键,null值

    Hashtable:不能存储null键,null值

    展开全文
  • Java当中,若希望在创建数组的同时给数组赋值很简单,可以想下面这样: int[] num = {1,2,3}; String strs = {"a", "b", "c"} 但是创建一个List、Set、Map的同时该如何进行赋值操作呢? 2、解决方法: 1...

    1、需求描述:

            在Java当中,若希望在创建数组的同时给数组赋值很简单,可以想下面这样:

            int[] num = {1,2,3};
            String strs = { "a", "b", "c"}
            但是创建一个List、Set、Map的同时该如何进行赋值操作呢?
    2、解决方法:
            1、方法一:调用函数方法
                    ArrayList<String> list = new ArrayList<>(Arrays.asList("aa", "bb", "cc"));
                      Arrays.asList(T... a) 方法的参数是一个可变长参数,也就是说他能够传入一个数组,也能够传入多个参数,而它的作用就是将传入的数组或多个数据封装成List集合返回,而上面的代码就是接收返回的List集合,并将其作为参数传入ArrayList的构造方法,创建一个新的ArrayList对象。
                    扩展:为什么不能直接将asList方法的返回值赋给list参数,而要将它传入构造器创建新的对象呢?
    // 代码1
    List<String> list1 = Arrays.asList("aa", "bb", "cc");
    list1.add("dd");// UnsupportedOperationException 操作list1时会抛异常
    // 代码2
    String[] str = {"a","b","c"};
    List<String> list = Arrays.asList(str);
    str[0] = "e"; //修改数组的0号数值时, list中的0号位置也一同改变

                     首先代码1,使用asList方法返回的创建的List对象,不允许进行修改操作,否则将会抛出一个UnsupportedOperationException;再来看代码2,我们将一个数组作为asList的参数,得到一个List对象,但是此时我们改变这个数组中元素的值,list对象的值也会发生改变,因为这个List对象底层引用的就是这个数组,并且和代码1一样,这个list也不能修改。

                     但是,若我们将返回的List对象作为参数传入ArrayList的构造器中,这个问题就不会发生,因为ArrayList的构造器将会把传入的list中所有的元素复制一份,因此不会影响到原数组,且可以随意改变。

            2、方法二:匿名内部类

    List<String> list = new ArrayList<String>(){ {add("a"); add("b"); add("c");} };

            这个方法它可以用在任意一种集合类型上(Map,Set......)

                这下应该比之前容易理解了。这段代码就是创建了一个匿名内部类对象,且这个类继承自ArrayList,在这个匿名内部类中添加了一个非静态代码块,并在代码块中调用了三次add方法,为这个List对象赋值。

              我们知道,若我们想创建一个对象,可以直接new 构造方法,但是我们若想写一个匿名内部类,这个匿名内部类继承自某个类,只需在构造方法后面加上一对大括号。同时,非静态代码块会在构造方法执行前被执行,所以我们将赋值语句放在了代码块中,于是就有了上面这段代码。若还是看不明白,没关系,看下面这段代码十有八九就明白了,我们将上面的代码换另一种方式写出来:

    public class Test {

            public static void main(String[] args) {

                    List<String> list = new MyList();

            }

    }

    // 创建一个类继承自ArrayList

    class MyList extends ArrayList{

    // 在类的非静态代码块中编写赋值语句

            {

            add("a");

            add("b");

            add("c");

            }

    }

      以上代码就是最开始那句代码的完整版,创建一个MyList类(名字随意),继承自ArrayList,并编写一个非静态代码块调用三次add方法,这个代码块将会在构造方法执行前被执行,因此创建一个MyList对象后,它肯定已经有三条数据了。若到此时还没有听懂,可能就需要去了解一下匿名内部类,以及代码块的执行机制了。

    这种为集合赋值的好处就是,它可以用在任意一种集合类型上(Map,Set......),如下代码:

    // 使用此方法为map赋值

    HashMap<String, Integer> map = new HashMap<String, Integer>() {

            {

            put("a", 1); put("b", 2); put("c", 3);

            }

    };

      当然,这种方法也有一些弊端,就拿ArrayList来说,那就是这种方法得到的对象,它的类型并不是ArrayList,我们调用对象.getClass().getName()方法获取对象的类名,得到的是代码所在类的类名+$1(这里和匿名内部类的机制有关,就不详细叙述了)。所以在代码中,如果对对象的类型有着严格的要求,就需要谨慎考虑是否应该使用这种方式。

    参考链接:Java创建List、Map等集合对象的同时进行赋值操作 - 特务依昂 - 博客园

    展开全文
  • javaMap集合总结

    千次阅读 2020-06-22 20:35:41
    Collection中的集合称为单列集合Map中的集合称为双列集合。 需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。 1 Map常用子类 Map常用子类有: HashMap<K,V>:存储数据...
    • Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
    • Map中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的值。
    • Collection中的集合称为单列集合,Map中的集合称为双列集合。
    • 需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。

    1 Map常用子类

    Map常用子类有:

    • HashMap<K,V>:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    • LinkedHashMap<K,V>:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。

    2 Map接口中的常用方法

    Map接口中定义了很多方法,常用的如下:

    • public V put(K key, V value): 把指定的键与指定的值添加到Map集合中。
    • public V remove(Object key): 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的值。
    • public V get(Object key) 根据指定的键,在Map集合中获取对应的值。
    • boolean containsKey(Object key) 判断集合中是否包含指定的键。
    • public Set<K> keySet(): 获取Map集合中所有的键,存储到Set集合中。
    • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

    代码运行如下:

    import java.util.HashMap;
    import java.util.Map;
    
    public class Demo01Map {
        public static void main(String[] args) {
            show01();
            show02();
            show03();
            show04();
        }
    
        private static void show04() {
            Map<String,Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
            Integer v1 = map.get("杨颖");
    
            boolean b1 = map.containsKey("赵丽颖");
            System.out.println("========show04=========");
            System.out.println("b1:" + b1);
    
            boolean b2 = map.containsKey("赵武");
            System.out.println("b2:"+b2);
        }
    
        private static void show03() {
            Map<String,Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
            Integer v1 = map.get("杨颖");
            System.out.println("=======show03==========");
            System.out.println("v1:"+v1);
    
            Integer v2 = map.get("迪丽热巴");
            System.out.println("v2: "+v2);
        }
    
        private static void show02() {
            //创建map集合对象
            Map<String, Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
            System.out.println("=======show02==========");
            System.out.println(map);
    
            Integer v1 = map.remove("林志玲");
            System.out.println("v1:"+v1);
            System.out.println(map);
    
            Integer v2 = map.remove("林志颖");
            System.out.println("v2:"+v2);
            System.out.println("================");
        }
    
        private static void show01() {
            Map<String, String> map = new HashMap<>();
            System.out.println("======show01===========");
            String v1 = map.put("李晨","范冰冰1");
            System.out.println("v1:"+v1);
            System.out.println(map);
    
            String v2 = map.put("李晨","范冰冰2");
            System.out.println("v2:"+v2);
            System.out.println(map);
    
            map.put("冷峰","龙小云");
            map.put("杨过","小龙女");
            map.put("尹志平","小龙女");
            System.out.println(map);
        }
    }
    

    运行结果如图:
    在这里插入图片描述

    3 Map集合遍历键找值方式

    键找值方式:即通过元素中的键,获取键所对应的值

    分析步骤:

    1. 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示:keyset()
    2. 遍历键的Set集合,得到每一个键。
    3. 根据键,获取键所对应的值。方法提示:get(K key)

    遍历图解:
    在这里插示范法
    代码运行如下:

    package Demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
        Map集合的第一种遍历方式:通过键找值的方式
        Map集合中的方法:
             Set<K> keySet() 返回此映射中包含的键的 Set 视图。
        实现步骤:
            1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
            2.遍历set集合,获取Map集合中的每一个key
            3.通过Map集合中的方法get(key),通过key找到value
     */
    public class Demo02KeySet {
        public static void main(String[] args) {
            //创建Map集合对象
            Map<String, Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
    
            //1.使用Map集合中的方法keySet(),把Map集合所有的key取出来,存储到一个Set集合中
            Set<String> set = map.keySet();
    
            //2.遍历set集合,获取Map集合中的每一个key
            //使用迭代器遍历Set集合
            Iterator<String> it = set.iterator();
            while (it.hasNext()){
                String key = it.next();
                Integer value = map.get(key);
                //3.通过Map集合中的方法get(key),通过key找到value
                System.out.println(key +"-->"+value);
            }
            System.out.println("=================");
            //使用增强for遍历Set集合
            for (String key :
                    set) {
                Integer value = map.get(key);
                System.out.println(key+"--->"+value);
            }
            System.out.println("===================");
            for (String key :
                    map.keySet()) { //3.通过Map集合中的方法get(key),通过key找到value
                Integer value = map.get(key);
                System.out.println(key+"-->"+value);
    
            }
        }
    }
    
    

    运行结果如图:
    在这里插入图片描述

    3.1 Entry键值对对象

    Map中存放的是两种对象,一种称为key(键),一种称为value(值),它们在在Map中是一一对应关系,这一对对象又称做Map中的一个Entry(项)Entry将键值对的对应关系封装成了对象。即键值对对象,这样我们在遍历Map集合时,就可以从每一个键值对(Entry)对象中获取对应的键与对应的值。

    既然Entry表示了一对键和值,那么也同样提供了获取对应键和对应值得方法:

    • public K getKey():获取Entry对象中的键。
    • public V getValue():获取Entry对象中的值。

    在Map集合中也提供了获取所有Entry对象的方法:

    • public Set<Map.Entry<K,V>> entrySet(): 获取到Map集合中所有的键值对对象的集合(Set集合)。

    4 Map集合遍历键值对方式

    键值对方式:即通过集合中每个键值对(Entry)对象,获取键值对(Entry)对象中的键与值。

    操作步骤与图解:

    1. 获取Map集合中,所有的键值对(Entry)对象,以Set集合形式返回。方法提示:entrySet()
    2. 遍历包含键值对(Entry)对象的Set集合,得到每一个键值对(Entry)对象。
    3. 通过键值对(Entry)对象,获取Entry对象中的键与值。 方法提示:getkey() getValue()

    在这里插入图片描述
    注意:Map集合不能直接使用迭代器或者foreach进行遍历。但是转成Set之后就可以使用了。

    代码运行如下:

    package Demo01;
    
    import java.util.HashMap;
    import java.util.Iterator;
    import java.util.Map;
    import java.util.Set;
    
    /*
        Map集合遍历的第二种方式:使用Entry对象遍历
    
        Map集合中的方法:
            Set<Map.Entry<K,V>> entrySet() 返回此映射中包含的映射关系的 Set 视图。
    
        实现步骤:
            1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
            2.遍历Set集合,获取每一个Entry对象
            3.使用Entry对象中的方法getKey()和getValue()获取键与值
     */
    public class Demo03EntrySet {
        public static void main(String[] args) {
            //创建Map集合对象
            Map<String, Integer> map = new HashMap<>();
            map.put("赵丽颖",168);
            map.put("杨颖",165);
            map.put("林志玲",178);
    
            //1.使用Map集合中的方法entrySet(),把Map集合中多个Entry对象取出来,存储到一个Set集合中
            Set<Map.Entry<String,Integer>> set = map.entrySet();
    
            //2.遍历Set集合,获取每一个Entry对象
            //使用迭代器遍历Set集合
            Iterator<Map.Entry<String , Integer>> it = set.iterator();
            while(it.hasNext()){
                Map.Entry<String , Integer> entry = it.next();
                //3.使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+"--->"+value);
            }
            System.out.println("========================");
            for (Map.Entry<String, Integer> entry:set
            ){//3.使用Entry对象中的方法getKey()和getValue()获取键与值
                String key = entry.getKey();
                Integer value = entry.getValue();
                System.out.println(key+"-->"+value);
            }
        }
    }
    
    

    运行结果如图:
    在这里插入图片描述

    5 HashMap存储自定义类型键值

    • 当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的hashCode和equals方法(如果忘记,请回顾HashSet存放自定义对象)。

    • 如果要保证map中存放的key和取出的顺序一致,可以使用java.util.LinkedHashMap集合来存放。

    代码运行如下:

    package Demo02;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Set;
    
    /*
        HashMap存储自定义类型键值
        Map集合保证key是唯一的:
            作为key的元素,必须重写hashCode方法和equals方法,以保证key唯一
     */
    public class Demo01HashMapSavePerson {
        public static void main(String[] args) {
           show01();
           show02();
    
        }
        /*
               HashMap存储自定义类型键值
               key:String类型
                   String类重写hashCode方法和equals方法,可以保证key唯一
               value:Person类型
                   value可以重复(同名同年龄的人视为同一个)
            */
        private static void show01() {
            //创建HashMap集合
            HashMap<String,Person> map = new HashMap<>();
            //往集合中添加元素
            map.put("北京",new Person("张三",18));
            map.put("上海",new Person("李四",19));
            map.put("广州",new Person("王五",20));
            map.put("北京",new Person("赵六",18));
            //往集合中添加元素
            Set<String> set = map.keySet();
            for (String key :
                    set) {
                Person value = map.get(key);
                System.out.println(key+"-->"+value);
            }
            System.out.println("==================");
        }
    
        /*
            HashMap存储自定义类型键值
            key:Person类型
                Person类就必须重写hashCode方法和equals方法,以保证key唯一
            value:String类型
                可以重复
         */
        private static void show02(){
            //创建HashMap集合
            HashMap<Person, String> map = new HashMap<>();
            //往集合中添加元素
            map.put(new Person("女王",18),"英国");
            map.put(new Person("秦始皇",18),"秦国");
            map.put(new Person("普京",38),"俄罗斯");
            map.put(new Person("女王",18),"毛里求斯");
            //使用entrySet和增强for遍历Map集合
            Set<Map.Entry<Person,String >> set = map.entrySet();
            for (Map.Entry<Person, String> entry:set
                    ){
                Person key = entry.getKey();
                String value = entry.getValue();
                System.out.println(key+"===>"+value);
            }
        }
    }
    import java.util.Objects;
    
    public class Person {
        private String name;
        private  int age;
    
        public Person() {
    
        }
    
        public Person(String name, int age) {
    
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Person person = (Person) o;
            return age == person.age &&
                    Objects.equals(name, person.name);
        }
    
        @Override
        public int hashCode() {
    
            return Objects.hash(name, age);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    

    运行结果如图:
    在这里插入图片描述

    5.1 LinkedHashMap

    在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构,可以保证有序。

    代码运行如下:

    package Demo03;
    
    import java.util.HashMap;
    import java.util.LinkedHashMap;
    import java.util.Map;
    import java.util.Set;
    
    /*
        java.util.LinkedHashMap<K,V> entends HashMap<K,V>
        Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序。
        底层原理:
            哈希表+链表(记录元素的顺序)
     */
    public class Demo02LinkedHashMap {
        public static void main(String[] args) {
            HashMap<String, String> map = new HashMap<>();
            map.put("a","a");
            map.put("c","c");
            map.put("b","b");
            map.put("a","b");
            System.out.println(map);
            System.out.println("===================");
            LinkedHashMap<String, String> linked = new LinkedHashMap<>();
            linked.put("a","a");
            linked.put("c","c");
            linked.put("b","b");
            linked.put("a","b");
            System.out.println(linked);
            System.out.println("===================");
            LinkedHashMap<String, String> map1 = new LinkedHashMap<String, String>();
            map1.put("邓超", "孙俪");
            map1.put("李晨", "范冰冰");
            map1.put("刘德华", "朱丽倩");
            Set<Map.Entry<String, String>> entrySet = map1.entrySet();
            for (Map.Entry<String, String> entry : entrySet) {
                System.out.println(entry.getKey() + "  " + entry.getValue());
            }
    
        }
    }
    
    

    运行结果如图:
    在这里插入图片描述

    展开全文
  • Java中将Map集合对象、字符串转换为JSON对象1、Map集合转JSON对象2、普通对象转JSON对象3、字符串转JSON对象 1、Map集合转JSON对象 创建一个Map集合; 新建json对象,并将Map引入json中。 @Test public void ...
  • Java基础 Map集合

    千次阅读 2019-07-05 22:04:41
    Map集合 教学目标 能够说出Map集合特点 使用Map集合添加方法保存数据 使用”键找值”的方式遍历Map集合 使用”键值对”的方式遍历Map集合 能够使用HashMap存储自定义键值对的数据 能够使用HashMap编写斗地主洗牌发牌...
  • JavaMap集合的遍历

    千次阅读 2022-01-26 14:03:40
    方法一 1、获取所有键的集合:keySet() 2、遍历键的集合,获取每个键:增强for... //创建Map集合对象 Map<String, String> map = new HashMap<String, String>(); //添加元素 map.put("00003", "张三")
  • 如何用Map对象创建Set对象

    千次阅读 2021-02-26 17:09:06
    Java中的Map和Set有不少相似之处。本文将分享一个把Map类转化成Set类的小技巧。或许你已经知道,HashSet其实是一个披着Set方法外衣的HashMap;同样,TreeSet其实也是一个披着Set方法外衣的TreeMap。Map并不支持直接...
  • Java如何创建空的集合对象

    千次阅读 2021-03-22 17:50:32
    java.util.Collections实用工具类具有创建空的三个不同的静态常量List,Set和Map。Collections.EMPTY_LISTCollections.EMPTY_SETCollections.EMPTY_MAP当您要创建类型安全的空集合时,还有一些方法。Collections....
  • String strs = {"a", "b", "c"}但是,如果我们创建List集合,或者Map集合时,也想快速地为它赋初始值,应当如何做呢?解决方式方式1:调用函数请看如下代码:ArrayList list = new ArrayList<>(Arrays.as...
  • JavaMap集合的五种迭代方式

    千次阅读 2021-11-24 10:42:58
    JavaMap集合的五种迭代方式 1.首先我们准备一个Student类,用Student的对象作为键,用他们所在的地址作为值 package com.lagou.task04.homework; /** * @author 云梦归遥 * @date 2021/11/24 9:44 * @...
  • 首先新建一个实体类Person@Datapublic class Person {/** 编码 */private String code;/** 名字 */private String name;public Person(String code, String name) {this....}}实例化三个对象放入list集合中public s...
  • Java集合 —— Map集合

    千次阅读 2021-10-16 14:56:07
    Collection接口包含List接口与Set接口 ...Map集合Map接口和Collection接口的不同:Map集合的特点:Map集合的功能:这里使用的具体实现类是HashMap类,其特点是map集合的遍历方式一、根据键找值,借助S
  • Java-通过工厂、Map容器创建对象

    千次阅读 多人点赞 2021-03-28 10:28:30
    本文通过两种方式去创建对象,1.工厂+反射+配置文件:单例模式,... 第二种对一做了一个优化,当类加载时,对象就已经构造好,之后每次使用从map中获取就行。其实Spring IOC做的就是这件事情,只是它封装的更好而已。
  • java8 List,Map对象集合常用操作

    千次阅读 2018-11-06 15:25:08
    //新建map Map&amp;amp;amp;amp;lt;String, Integer&amp;amp;amp;amp;gt; items = new HashMap&amp;amp;amp;amp;lt;&amp;amp;amp;amp;gt;(); items.put(&amp;amp;amp;quot;A&amp;amp;amp...
  • java中的map集合如何创建,实现类是什么,map集合对象的基础操作有哪些
  • java集合类的创建方式

    千次阅读 2020-12-17 14:31:06
    java集合类的创建方式 常常因为不会创建集合类的语法而浪费时间。...常见的集合类有List集合、Set集合、Map集合。   下面举一个实例,看看如何创建并添加修改集合元素。 1 import java.util.Iterator; 2 impor
  • java集合对象

    2012-04-24 19:52:33
    java集合对象 介绍集合对象  Set:集----存储数据无序,所以不能存储相同的数据,set在存储数据方面有优势  List:列表-----存储数据有序,所以可以存储相同的数据,list在向集合对象中的指定位置添加数据和得到...
  • Java Map集合

    千次阅读 2019-02-07 10:00:39
    Map集合用于保存映射关系的数据,Map集合中保存了两组值,一组是 key, 一组是 value。 Map的key不能重复。 key和value之间存在单向一对一的关系, 通过key,能找到唯一的,确定的value。 HashMap和Hashtable是Map...
  • Java集合类(List、map、list集合)

    千次阅读 2021-02-26 18:49:11
    1.1集合类的概述Java.util包中提供了一些集合类,这些集合类...常用的集合有List集合、Set集合和Map集合,其中List和Set继承了Collection接口,各接口还提供了不同的实现类。上述集合类的继承关系如图14.1所示:1.1C...
  • 首先新建一个实体类Person@Datapublic class Person {/** 编码 */private String code;/** 名字 */private String name;public Person(String code, String name) {this....}}实例化三个对象放入list集合中public s...
  • JAVA三大集合map、list、set)

    千次阅读 2021-11-07 22:14:16
    Map接口和Collection接口是所有集合框架的父接口: Collection接口的子接口包括:Set接口和List接口 Map接口的实现类主要有:HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等 Set接口的实现类主要...
  • jQuery创建类似Javamap集合

    千次阅读 2017-07-18 15:50:21
    var map = {}; // Map map = new HashMap();map[key] = value; // map.put(key, value);var value = map[key]; // Object value = map.get(key);var has = key in map; // boolean has = map.containsKey(key);delet
  • Java中将Map集合默认值替换空值

    千次阅读 2021-03-08 05:50:42
    要将Java Map中的空值替换为默认值,代码如下示例importjava.util.*;importjava.util.stream.*;publicclassDemo{publicstaticMapnull_vals(Mapmy_map,Tdef_val){my_map=my_map.entrySet().stream().map(entry->{...
  • java-Map集合

    千次阅读 2020-01-26 16:41:16
    是一种键-值对(key-value)集合Map 集合中的每一个元素都包含一个键对象和一个值对象。其中,键对象不允许重复,而值对象可以重复,并且值对象还可以是 Map 类型的,就像数组中的元素还可以是数组一样。 Map ...
  • java Map集合深入解析

    千次阅读 2018-04-23 09:44:50
    java集合类梳理 要理解Java技术强大特性就有必要掌握集合框架
  • Map集合转为实体对象

    千次阅读 2021-03-11 01:39:37
    Map集合转为实体对象 源码:https://gitee.com/Jakewabc/small-study-case/blob/master/nm-demo/mongodb-demo/src/main/java/com/mongodb/utils/ObjectIdJsonSerializer.java 使用MongoDB朋友都明白,如果我们使用连...
  • Java集合中List,Set以及Map集合体系详解(史上最全)

    万次阅读 多人点赞 2018-06-12 14:09:24
    List Set Map都是接口,前两个继承至Collection接口,Map为独立接口 Set下有HashSet,LinkedHashSet,TreeSet List下有ArrayList,Vector,LinkedList Map下有Hashtable,LinkedHashMap,HashMap,TreeMap 还有...
  • 1、 创建 Map 对象同时进行初始化操作、 2、 先创建 Map 对象再进行赋值、 三、 Map 集合遍历、 1、 使用 forEach 遍历 Map 集合、 2、 使用普通 for 循环遍历 Map 集合、 3、 使用 map 方法进行遍历生成新的 Map ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 257,334
精华内容 102,933
关键字:

java创建map集合对象