精华内容
下载资源
问答
  • 如果需要在遍历过程中增加元素,可以新建一个临时map存放新增元素,等遍历完毕,再把临时map放到原来的mapjava的map遍历有多种方法,从最早Iterator,到java5支持foreach,再到java8 Lambda,让我们一起...

    重要提示(同最后的总结):

    • 如果只是获取key,或者value,推荐使用keySet或者values方式
    • 如果同时需要key和value推荐使用entrySet
    • 如果需要在遍历过程中删除元素推荐使用Iterator
    • 如果需要在遍历过程中增加元素,可以新建一个临时map存放新增的元素,等遍历完毕,再把临时map放到原来的map中

    java中的map遍历有多种方法,从最早的Iterator,到java5支持的foreach,再到java8 Lambda,让我们一起来看下具体的用法以及各自的优缺点

    先初始化一个map

    public class TestMap {
      public static Map<Integer, Integer> map = new HashMap<Integer, Integer>();
    }
    

    keySet values

    如果只需要map的key或者value,用map的keySet或values方法无疑是最方便的

      // KeySet 获取key
      public void testKeySet() {
        for (Integer key : map.keySet()) {
          System.out.println(key);
        }
      }
      // values 获取value
      public void testValues() {
        for (Integer value : map.values()) {
          System.out.println(value);
        }
      }
    

    keySet get(key)

    如果需要同时获取key和value,可以先获取key,然后再通过map的get(key)获取value

    需要说明的是,该方法不是最优选择,一般不推荐使用

      // keySet get(key) 获取key and value
      public void testKeySetAndGetKey() {
        for (Integer key : map.keySet()) {
          System.out.println(key + ":" + map.get(key));
        }
      }
    

    entrySet

    通过对map entrySet的遍历,也可以同时拿到key和value,一般情况下,性能上要优于上一种,这一种也是最常用的遍历方法

      // entrySet 获取key and value
      public void testEntry() {
        for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
          System.out.println(entry.getKey() + ":" + entry.getValue());
        }
      }
    

    Iterator

    对于上面的几种foreach都可以用Iterator代替,其实foreach在java5中才被支持,foreach的写法看起来更简洁

    但Iterator也有其优势:在用foreach遍历map时,如果改变其大小,会报错,但如果只是删除元素,可以使用Iterator的remove方法删除元素

      // Iterator entrySet 获取key and value
      public void testIterator() {
        Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
        while (it.hasNext()) {
          Map.Entry<Integer, Integer> entry = it.next();
          System.out.println(entry.getKey() + ":" + entry.getValue());
          // it.remove(); 删除元素
        }
      }
    

    Lambda

    java8提供了Lambda表达式支持,语法看起来更简洁,可以同时拿到key和value,不过,经测试,性能低于entrySet,所以更推荐用entrySet的方式

      // Lambda 获取key and value
      public void testLambda() {
        map.forEach((key, value) -> {
          System.out.println(key + ":" + value);
        });
      }
    

    简单性能测试

    用10万条数据,做了一个简单性能测试,数据类型为Integer,map实现选取HashMap

      static {
        for (int i = 0; i < 100000; i++) {
          map.put(i, 1);
        }
      }
    

    测试结果如下:

    KeySet:           392
    Values:           320
    keySet get(key):  552
    entrySet:         465
    entrySet Iterator:508
    Lambda:           536
    

    需要说明的是,map存储的数据类型,map的大小,以及map的不同实现方式都会影响遍历的性能,所以该测试结果仅供参考

    总结

    如果只是获取key,或者value,推荐使用keySet或者values方式

    如果同时需要key和value推荐使用entrySet

    如果需要在遍历过程中删除元素推荐使用Iterator

    如果需要在遍历过程中增加元素,可以新建一个临时map存放新增的元素,等遍历完毕,再把临时map放到原来的map中

    展开全文
  • Java的Map

    2021-04-23 11:45:11
    Java的Map Map集合是双列集合 Map<K,V> 一个对象包含两个值 K不允许重复 Map集合特点: 1.一个元素包含两个值 K 和 V 2.Map集合中的元素,Key 和 Vaule 数据类型 可以相同也可以不同 3.Map集合中的元素...

    Java中的Map

    Map集合是双列集合 Map<K,V>
    一个对象包含两个值 K不允许重复

    Map集合的特点:

    1.一个元素包含两个值 K 和 V
    2.Map集合中的元素,Key 和 Vaule 的数据类型 可以相同也可以不同
    3.Map集合中的元素,Key 不允许重复

    Map集合常用实现类

    HashMap<K,V> (无序 多线程)
    查询特别快
    子类:LinkedHashMap<K,V> 增加一条链表 保证了存储有序

    Map集合常用方法

    1.put 向集合中添加 <K,V>

    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		System.out.print(m);
    		
    		
    	}
    }
    

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

    2.get 通过K获取Value

    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		System.out.println(m);
    		
    		String s = m.get("张三");
    		System.out.println(s);
    		
    	}
    }
    

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

    3.remove 通过K删除Value

    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		System.out.println(m);
    		
    		String s = m.remove("沛宇");  //返回一个被删除的值
    		System.out.println(s);   
    		System.out.println(m);
    		
    	}
    }
    

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

    4.containsKey 判断集合是否含有这个K

    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		System.out.println(m);
    		
    		boolean s = m.containsKey("沛宇");
    		System.out.println(s);
    		
    	}
    }
    

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

    5.keySet 返回此映射中包含的K

    //利用keySet遍历Map
    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		m.put("小丑","PY");
    		m.put("DG","CT");
    		m.put("秦政","DC");
    		System.out.println(m);
    		
    		Set<String> set = m.keySet();
    		Iterator<String> it = set.iterator();
    		while(it.hasNext()) {
    			String key = it.next();
    			String value = m.get(key); 
    			System.out.print(key + " = " + value + " ");
    		}
    	
    	}
    }
    

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

    6.entrySet 返回此映射中包含的映射关系

    public class Test {
    	public static void main(String [] args) {
    		
    		Map<String,String> m = new HashMap<>();
    		m.put("张三","NB");
    		m.put("沛宇","LJ");
    		m.put("小丑","PY");
    		m.put("DG","CT");
    		m.put("秦政","DC");
    		System.out.println(m);
    		
    		Set<Map.Entry<String, String>> set = m.entrySet();
    		Iterator<Map.Entry<String, String>> it = set.iterator();
    		
    		while(it.hasNext()) {
    			Map.Entry<String, String> entry = it.next();
    			System.out.print(entry+" ");
    		}
    	}
    }
    

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

    HashMap存储自定义类型健值

    作为key的元素,必须重写hashCode方法和equals方法 保证key唯一

    public class Person{
    	private String name;
    	private int age;
    	
    	public int getAge() {
    		return age;
    	}
    	public void setAge(int age) {
    		this.age = age;
    	}
    	
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	
    	public Person() {
    		
    	}
    	
    	public Person(String name,int age) {
    		this.name = name;
    		this.age = age;
    	}
    	
    	@Override
    	public String toString() {
    		// TODO Auto-generated method stub
    		return "{姓名:" + this.name + " 年龄:"+ this.age+"}";
    	}
    	
    	@Override
    	public int hashCode() {
    		// TODO Auto-generated method stub
    		return Objects.hash(name,age);
    	}
    	
    	@Override
    	public boolean equals(Object obj) {
    		// TODO Auto-generated method stub
    		if(this == obj) return true;
    		if(obj == null || getClass() != obj.getClass()) return false;
    		Person person = (Person) obj;
    		return age == person.age &&
    				Objects.equals(name,person.name);
    	} 
    	
    }
    
    
    
    
    public class Test {
    	public static void main(String [] args) {
    		
    		HashMap<Person,String> map = new HashMap();
    		map.put(new Person("张三",18),"北京");
    		map.put(new Person("李四",19),"上海");
    		map.put(new Person("王五",20),"广东");
    		map.put(new Person("张三",18),"河南");   
    		
    		//使用keySet遍历
    		Set<Person> set = map.keySet();
    		for(Person key : set) {
    			String value = map.get(key);
    			System.out.print(key+"->"+value+" ");
    		}
    		
    		 
    		
    	}
    }
    

    运行结果:

    LinkedHashMap<K,V>

    继承了HashMap集合 增加了一条链表 是有序集合
    底层原理是 哈希表加上链表

    public class Test {
    	public static void main(String [] args) {
    		
    		LinkedHashMap<String,String> lmap = new LinkedHashMap<String,String>();
    		lmap.put("1", "一号选手");
    		lmap.put("2", "二号选手");
    		lmap.put("1", "重复后的一号选手");
    		lmap.put("4", "四号选手");
    		lmap.put("3", "三号选手");
    		
    		System.out.print(lmap);
    	}
    }
    

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

    Hashtabkle<K,V>

    最早期的双链结构 不能有空值
    同步 单线程 速度慢 但线程安全
    与Vector集合一样 逐渐被取代
    Hashtable的子类Properties依然活跃在历史舞台
    Properties集合是一个唯一和IO流相结合的集合

    展开全文
  • import java.util.List; import java.util.Map;... List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素 static <E> List<E> of​(E... elements) ...
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    
    /*
        JDK9的新特性:
            List接口,Set接口,Map接口:里边增加了一个静态的方法of,可以给集合一次性添加多个元素
            static <E> List<E> of​(E... elements)
            使用前提:
                当集合中存储的元素的个数已经确定了,不在改变时使用
         注意:
            1.of方法只适用于List接口,Set接口,Map接口,不适用于接接口的实现类
            2.of方法的返回值是一个不能改变的集合,集合不能再使用add,put方法添加元素,会抛出异常
            3.Set接口和Map接口在调用of方法的时候,不能有重复的元素,否则会抛出异常
     */
    public class Demo01JDK9 {
        public static void main(String[] args) {
            List<String> list = List.of("a", "b", "a", "c", "d");
            System.out.println(list);//[a, b, a, c, d]
            //list.add("w");//UnsupportedOperationException:不支持操作异常
    
            //Set<String> set = Set.of("a", "b", "a", "c", "d");//IllegalArgumentException:非法参数异常,有重复的元素
            Set<String> set = Set.of("a", "b", "c", "d");
            System.out.println(set);
            //set.add("w");//UnsupportedOperationException:不支持操作异常
    
            //Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20,"张三",19);IllegalArgumentException:非法参数异常,有重复的元素
            Map<String, Integer> map = Map.of("张三", 18, "李四", 19, "王五", 20);
            System.out.println(map);//{王五=20, 李四=19, 张三=18}
            //map.put("赵四",30);//UnsupportedOperationException:不支持操作异常
        }
    }
    
    展开全文
  • Java基础Map

    2018-11-04 14:35:41
    对元素增加时,先对元素的key进行hash,得到一个哈希值,哈希值根据数组的长度算出数组的下标hashCode%length。当多个元素得到同一个数组下标时,为了解决冲突,HashMap在数组后面增加了链表,这样相同hashcode的值...

    Map的类关系图

    在这里插入图片描述

    HashMap

    实现原理
    HashMap内部是通过数组+链表的方法进行实现的。数组类型是Node(实现了Entry)。

    对元素增加时,先对元素的key进行hash,得到一个哈希值,哈希值根据数组的长度算出数组的下标hashCode%length。当多个元素得到同一个数组下标时,为了解决冲突,HashMap在数组后面增加了链表,这样相同hashcode的值就在同一个链表里。相同的key值,value会覆盖掉。

    当要查找元素时,先计算key的hashCode得到数组的下标,再对链表进行遍历匹配key值,从而得到value值。

    随着元素的增加,数组后面的链表是很长的,而对链表的查找效率是很低的,所以这时候就要进行扩容,在进行动态扩容时,HashMap内部数组默认大小是16,加载因子是0.75,即当75%的数组后面的链表有元素时进行2次幂扩容。
    下图是哈希表的结构

    在这里插入图片描述
    jdk1.8中,当发生哈希冲撞使得链表长度达到一定值,使用红黑树来替换链表。
    具体的细节可参考jdk1.8中的HashMap
    特点
    是基于Map接口的实现,存储键值对时,它可以接收null的键值,是线程不安全的。

    遍历方式

    1.得到Entry集合,for-each遍历,大容量时推荐用
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
    for (Map.Entry<Integer, Integer> entry : map.entrySet()) {  
      
        System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
      
    } 
    
    2.得到key集合,for-each遍历
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
    for (Integer key : map.keySet()) {  
      
        Integer value = map.get(key);  
      
        System.out.println("Key = " + key + ", Value = " + value);  
      
    }
    
    3.得到Entry集合的迭代器
    Map<Integer, Integer> map = new HashMap<Integer, Integer>();  
    Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();  
    while (entries.hasNext()) {  
      
        Map.Entry<Integer, Integer> entry = entries.next();  
      
        System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());  
      
    } 
    

    HashTable

    散列表默认初始值11,动态扩容是2n+1,HashTable的方法都加上了synchronized。与HashMap不同,不支持null键。
    实现原理
    与HashMap类似,内部也是数组+链表。
    特点
    线程安全,公共方法使用了synchronized ,但相对与HashMap效率降低了。

    展开全文
  • Javajava9of方法

    千次阅读 2020-06-15 18:58:52
    List接口,Set接口,Map接口:里面增加了一个静态的方法of,可以给集合一次性添加多个元素 static <E> List<E> of (E...elements) 使用前提: 当集合中存储的元素个数已经确定了,不再改变时使用。 ...
  • JAVA多线程-ConcurrentMap

    2020-07-22 11:50:25
    ConcurrentMap在继承了java.util.Map父接口基础上额外增加了一些原子方法。 ConcurrentMap实现 既然ConcurrentMap是个接口, 如果需要用它则需要实现这个接口。java.util.concurrent包含了ConcurrentMap的实现: ...
  • Java9 集合工厂方法

    千次阅读 2017-10-07 15:02:03
    使集合框架更便捷的工厂方法JEP269中提议,为集合框架增添一些工厂方法,来使创建不可变集合类与含有少量元素的Map变得更加便捷。下文就为什么它们应运而生来展开详细的阐述。集合框架增加工厂方法是必然的结果Java...
  • Java三种常见集合List、Set、Map 数组长度是固定,在需要一个不固定长度"数组"存储数据时,集合就出现了 集合特点 可存放不同类型对象(必须是对象) 数组只能存放同一类型数据,但是可以存放基本类型...
  • Java-day07-Map

    2019-08-02 09:05:52
    一:Map Map:接口 HashMap:底层是哈希表,线程不安全 TreeMap:底层是二叉树,线程不安全 Collection:直接存储的是值 Map:本身是接口,存储的是键值对,... Map接口的方法 HashMap 1.增加: 2.删除: ...
  • list java 源码 JdkCodeTree Java源代码阅读之Object,String,List,Map ...引(元素在List中位置,类似于数组下标)来访问List中的元素,这类似于Java的数组 ArrayList类   ArrayList实现了可变大小数组。它允许所
  • 此数组元素数大于实际存储数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比...
  • 主要分两部分: 1.先对输入单词进行处理: 使用map接口,单词为键,出现次数为值 用字符串内部方法替换掉单词中的特殊符号 ...和Map.entrySet()):把键值对看作一个整体,这个整体就是list中元素的具体...
  • java Collection与Map简介

    2011-11-29 11:09:18
    数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动 等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全 )所以性能上比ArrayList要 差,...
  • 此数组元素数大于实际存储数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动等内存操作,所以索引数据快插入数据慢,Vector由于使用了synchronized方法(线程安全)所以性能上比...
  • javaAPI(Map双列集合)

    2015-07-19 11:55:55
    Map集合成员方法增加功能V put(K key, V value)返回是被覆盖值当key在集合中不存在时,添加元素;当key在集合存在时候,替换元素 删除功能 void clear 清除所有键值对数据 V remove(Object key) 根据指定...
  • JEP269中提议,为集合框架增添一些工厂方法,来使创建不可变集合类与含有少量元素的Map变得更加便捷。下文就为什么它们应运而生来展开详细的阐述。 集合框架增加工厂方法是必然的结果 Java饱受其语法臃肿的...
  • 一、Map接口 Map集合的特点是:通过key值找到对应的value值,key值是唯一的,...上面Map接口提供的方法大致可以分为下面几种: 1、put/putAll/remove/clear 增加删除 get/values 获取值 2、containKey/c
  • Java容器类List、ArrayList、Vector及map、HashTable、HashMap区别与用法 ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据...
  • List Collection的子接口,增加了一些特有的方法,有序 可以重复 有索引 ArrayList 底层采用的数组结构实现,顺序存储,查询修改快 LinkedList 底层采用的是双向链表实现,链式存储,增加删除快 Set ...
  • 最近用到了,所以依然是转载ArrayList 和Vector是采用数组方式存储数据,此数组元素数大于实际存储数据以便增加和插入元素,都允许直接序号索引元素,但是插入数据要设计到数组元素移动 等内存操作,所以索引数据...
  • ArrayList与LinkedList ...LinkedList增加了可以使其作栈、队列或双端队列的方法。 Set不保存重复的元素(查找最重要) HashSet 优化了快速查找。使用散列,输出无顺序。 TreeSet 可以对元素自动排序(...
  • 首页来个简单的,javascript提供了数据结构的对象,Array,只有添加方法,却不可以针对元素下表来进行元素的删除。上代码吧。... //prototype为对象原型,注意这里为对象增加自定义方法的方法。 if(n...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 216
精华内容 86
关键字:

javamap增加元素的方法

java 订阅