精华内容
下载资源
问答
  • js自定义map集合

    2018-01-15 17:22:51
    由于原本把需要的数据存放到cookie中,但是cookie不能的key不能自动转译中文,出现乱码,后台服务器报错:Control character in cookie value or attribute.所以改为自定义map集合
  • JAVA中map集合遍历的五种方法,简单易学,java开发入门的基础知识!
  • JAVA--Map集合详解

    万次阅读 2019-06-25 14:38:20
    Map集合和Set集合很像,其实Set集合底层就是使用了Map集合。 什么时候使用Map集合: 当数据之间存在映射关系时,优先考虑Map集合Map集合常用共有方法 1.添加 V put(K key, V value):将指定的值与此映射中...

           特点:该集合存储键(key)值(value)对,一对一对往里存,而且要保证键(key)的唯一性。

           Map集合和Set集合很像,其实Set集合底层就是使用了Map集合。

    什么时候使用Map集合:

        数据之间存在映射关系时,优先考虑Map集合。

    Map集合常用共有方法

    1.添加

    V put(K key, V value):将指定的值与此映射中的指定键关联,添加键值对。

    void putAll(Map<? extends K,? extends V> m):从指定映射中将所有映射关系复制到此映射中,批量添加键值对。

    2.删除

    void clear():从此映射中移除所有映射关系,清空所有键值对。

    V remove(Object key):如果存在一个键的映射关系,则将其从此映射中移除,删除单个键值对。

    3.判断

    boolean containsKey(Object key):如果此映射包含指定键的映射关系(是否包含该键),则返回 true。

    boolean containsValue(Object value):如果此映射将一个或多个键映射到指定值(是否包含该值),则返回 true。

    boolean isEmpty():如果此映射未包含键-值映射关系,该map集合为空,则返回 true。

    4.获取

    V get(Object key):返回指定键所映射的值;如果此映射不包含该键的映射关系,则返回 null。

    int size():返回此映射中的键-值映射关系(键值对)数。

    Collection<V> values():返回此映射中包含的值的 Collection 视图(集合)。

    重点取出方式:

    Set<K> keySet():返回此映射中包含的键的 Set 视图(集合)。

    Set<Map.Entry<K,V>> entrySet():返回此映射中包含的映射关系的 Set 视图(集合)。

    练习

    class MapDemo{
    	public static void main(String[] args){
    		Map<String,String> map=new HashMap<String,String>();
    		
    		// 添加元素,如果出现相同的键,那么后添加的值会覆盖原有键对应值。
    		// put方法会返回被覆盖的值。
    		System.out.println("put:"+map.put("01","zhangsan1"));
    		System.out.println("put:"+map.put("01","wangwu"));
    		map.put("02","zhangsan2");
    		map.put("03","zhangsan3");
    		
    		System.out.println("containsKey:"+map.containsKey("022"));
    		System.out.println("remove:"+map.remove("02"));
    		
    		System.out.println("get:"+map.get("023"));
    		
    		map.put("04",null);	// 一般值不要存储null,没有意义
    		System.out.println("get:"+map.get("04"));
    		// 可以通过get方法的返回值来判断一个键是否存在。通过返回null来判断
    		
    		// 获取map集合中所有的值
    		Collection<String> coll=map.values();
    		
    		System.out.println(coll);
    		System.out.println(map);
    		
    	}
    }
    

    Hashtable

    底层是哈希表数据结构

    特点:不可以存入null键null值,该集合是线程同步的,JDK1.0出现,效率低。

    HashMap

    底层是哈希表数据结构

    特点:允许使用null值和null键,该集合是线程不同步的,JDK1.2出现,效率高。

    Map集合的两种取出方式

    Map集合的取出原理:将Map集合转成Set集合,再通过迭代器取出。

    1. Set<K> keySet():

    将Map集合中所有的键存入到Set集合。因为Set集合具备迭代器,所以可以通过迭代方法取出所有的键,再根据get()方法,获取每一个键对应的值。

          2.Set<Map.Entry<K,V>> entrySet():

    将Map集合中的映射关系存入到了Set集合中,而这个映射关系的数据类型就是:Map.Entry。

       Map.Entry:其实Entry也是一个接口,它是Map接口中的一个内部接口。 

    interface Map{
    	public static interface Entry{
    		public abstract Object getKey();
    		public abstract Object getValue();
    	}
    }
    
    class HashMap implements Map{
    	class Hahs implements Map.Entry{
    		public Object getKey(){};
    		public Object getValue(){};
    	}
    }
    

    案例 

    import java.util.*;
    class MapDemo2{
    	public static void main(String[] args){
    	Map<String,String> map=new HashMap<String,String>();
    	
    	map.put("02","zhangsan2");
    	map.put("03","zhangsan3");
    	map.put("01","zhangsan1");
    	map.put("04","zhangsan4");
    	
    	/*// 方法一:通过keySet()获取Map集合元素
    	// 先获取Map集合的所有键的Set集合,通过keySet()方法获取到
    	Set<String> keySet=map.keySet();
    	
    	// 有了键的Set集合,就可以获取其迭代器
    	Iterator<String> it=keySet.iterator();
    	while(it.hasNext()){
    		String key=it.next();
    		// 有了键可以通过Map集合的get()方法获取其对应的值
    		String value=map.get(key);
    		System.out.println("Key:"+key+",value:"+value);
    	}*/
    	
    	// 方法二:通过entrySet()获取Map集合元素
    	// 先获取Map集合中的映射关系的Set集合,通过entrySet()方法获取到
    	Set<Map.Entry<String,String>> entrySet=map.entrySet();
    	
    	// 有了键的Set集合,就可以获取其迭代器
    	Iterator<Map.Entry<String,String>> it=entrySet.iterator();
    	while(it.hasNext()){
    		Map.Entry<String,String> me=it.next();
    		// 有了映射关系可以通过映射关系的getKey()和getValue()方法获取其对应的键值
    		String key=me.getKey();
    		String value=me.getValue();
    		System.out.println("Key:"+key+",value:"+value);
    	}
    	
    	}
    }
    

    练习

    import java.util.*;
    /*
    目标:
    每一个学生都有对应的归属地。
    学生Student,地址String。
    学生属性:姓名,年龄。
    注意:姓名和年龄相同的视为同一个学生。
    保证学生的唯一性。
    
    思路:
    1.描述学生;
    2.定义Map容器。将学生(唯一性)作为键,地址作为值,存入;
    3.获取Map集合中的元素。
    */
    class MapTest{
    	public static void main(String[] args){
    	Map<Student,String> map=new HashMap<Student,String>();
    	
    	map.put(new Student("lisi1",21),"beijing");
    	map.put(new Student("lisi1",21),"tainjin");
    	map.put(new Student("lisi2",22),"shanghai");
    	map.put(new Student("lisi3",23),"nanjing");
    	map.put(new Student("lisi4",24),"jinan");
    	
    	// 第一种取出方式keySet
    	Set<Student> keySet=map.keySet();
    	
    	Iterator<Student> it=keySet.iterator();
    	while(it.hasNext()){
    		Student stu=it.next();
    		String addr=map.get(stu);	
    		sop(stu+"..."+addr);
    	}
    	
    	// 第二种取出方式entrySet
    	Set<Map.Entry<Student,String>> entrySet=map.entrySet();
    	
    	Iterator<Map.Entry<Student,String>> it2=entrySet.iterator();
    	while(it2.hasNext()){
    		Map.Entry<Student,String> me=it2.next();
    		Student stu=me.getKey();
    		String addr=me.getValue();
    		sop(stu+"......"+addr);
    	}
    	
    	}
    	
    	// 打印语句
    	public static void sop(Object obj){
    		System.out.println(obj);
    	}
    }
    
    // 学生类,保证学生的唯一性
    class Student implements Comparable<Student>{	
    	private String name;
    	private int age;
    	
    	public Student(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	
    	// 防止该对象往二叉树数据类型集合中存储报异常,应使该对象具备可比性
    	public int compareTo(Student s){
    		int num=new Integer(this.age).compareTo(new Integer(s.age));
    		
    		if(num==0)
    			return this.name.compareTo(s.name);
    		
    		return num;
    	}
    	
    	// 保证学生的唯一性
    	public int hashCode(){
    		return this.name.hashCode()+age*35;
    	}
    	
    	public boolean equals(Object obj){
    		
    		if(!(obj instanceof Student))
    			throw new ClassCastException("类型不匹配!");
    		
    		Student s=(Student)obj;
    		
    		return this.name.equals(s.name) && this.age==s.age;
    	}
    	
    	public String getName(){
    		return name;
    	}
    	
    	public int getAge(){
    		return age;
    	}
    	
    	public String toString(){
    		return name+":"+age;
    	}
    }
    

    TreeMap

    底层是二叉树(红黑树)数据结构

    特点:线程不同步,可以同时给Map集合中的键进行排序。

    案例

    import java.util.*;
    /*
    目标:
    每一个学生都有对应的归属地。
    学生Student,地址String。
    学生属性:姓名,年龄。
    注意:姓名和年龄相同的视为同一个学生。
    保证学生的唯一性。
    并且对学生对象大的年龄进行升序排序。
    
    思路:
    因为数据是以键值对形式存在的,
    所以要使用可以排序的Map集合:TreeMap。
    1.描述学生;
    2.定义Map容器。将学生(唯一性)作为键,地址作为值,存入;
    3.获取Map集合中的元素。
    */
    class MapTest2{
    	public static void main(String[] args){
    	TreeMap<Student,String> tm=new TreeMap<Student,String>(new StuNameComparator());	 
    	
    	tm.put(new Student("lisi1",21),"beijing");
    	tm.put(new Student("blisi3",23),"nanjing");
    	// tm.put(new Student("lisi1",21),"tainjin");
    	tm.put(new Student("alisi4",24),"jinan");
    	tm.put(new Student("lisi2",22),"shanghai");
    	
    	Set<Map.Entry<Student,String>> entrySet=tm.entrySet();
    	
    	Iterator<Map.Entry<Student,String>> it=entrySet.iterator();
    	while(it.hasNext()){
    		Map.Entry<Student,String> me=it.next();
    		Student stu=me.getKey();
    		String addr=me.getValue();
    		sop(stu+"......"+addr);
    	}
    	}
    	// 打印语句
    	public static void sop(Object obj){
    		System.out.println(obj);
    	}
    }
    
    // 按照学生姓名排序,当对象本身具有比较性,但还需另一种比较,
    // 可以定义比较器,在集合初始化时传入比较器,当有两种比较方式时默认按照比较器方法排序
    class StuNameComparator implements Comparator<Student>{
    	public int compare(Student s1,Student s2){
    		int num =s1.getName().compareTo(s2.getName());
    		
    		if(num==0)
    			return new Integer(s1.getAge()).compareTo(s2.getAge());
    		
    		return num;
    	}	
    }
    
    // 学生类,保证学生的唯一性
    class Student implements Comparable<Student>{	
    	private String name;
    	private int age;
    	
    	public Student(String name,int age){
    		this.name=name;
    		this.age=age;
    	}
    	
    	// 防止该对象往二叉树数据类型集合中存储报异常,应使该对象具备可比性
    	public int compareTo(Student s){
    		int num=new Integer(this.age).compareTo(new Integer(s.age));
    		
    		if(num==0)
    			return this.name.compareTo(s.name);
    		
    		return num;
    	}
    	
    	// 保证学生的唯一性
    	public int hashCode(){
    		return this.name.hashCode()+age*35;
    	}
    	
    	public boolean equals(Object obj){
    		
    		if(!(obj instanceof Student))
    			throw new ClassCastException("类型不匹配!");
    		
    		Student s=(Student)obj;
    		
    		return this.name.equals(s.name) && this.age==s.age;
    	}
    	
    	public String getName(){
    		return name;
    	}
    	
    	public int getAge(){
    		return age;
    	}
    	
    	public String toString(){
    		return name+":"+age;
    	}
    }

    练习

    核心思想原理图

    import java.util.*;
    /*
    目标:
    "sdfgzxcvasdfxcvdf"获取该字符串中的字母出现的次数。
    
    希望打印结果:
    a(1)c(2)……
    
    通过结果发现,每一个字母都有对应的次数。
    说明字母和次数之间存在映射关系。
    
    什么时候使用Map集合:
        当数据之间存在映射关系时,优先考虑Map集合。
    
    思路:
    1.将字符串转换成字符数组。因为要对每一个字母进行操作。
    2.定义一个Map集合。而且打印结果字母有顺序,所以使用TreeMap集合。
    3.遍历字符数组。
    	将每一个字母作为键去查Map集合元素。
    	如果返回null,将该字母和1存入到Map集合中。
    	如果返回不是null,说明该字母在Map集合已经存在并有对应次数(值)。
    	那么就获取该次数并进行自增,然后将该字母和自增后的次数存入到Map集合中。原理:覆盖已有键对应的值。
    4.将Map集合中的数据变成指定的字符串形式返回。
    */
    class MapTest3{
    	public static void main(String[] args){
    		
    		String s="sdfgzxcv,asdfxcv+df";
    		
    		String result=charCount(s);
    		
    		System.out.println(result);
    		
    	}
    	
    	public static String charCount(String str){
    		
    		char[] chs=str.toCharArray();
    		
    		TreeMap<Character,Integer> tm=new TreeMap<Character,Integer>();
    		
    		int count=0;
    		for(int x=0;x<chs.length;x++){
    			// 检查该字符是否为字母,如果不是跳出本次循环
    			if(!(chs[x]>='a' && chs[x]<='z' || chs[x]>='A' && chs[x]<='Z'))
    				continue;
    				
    			Integer value=tm.get(chs[x]);
    			
    			if(value!=null)
    				count = value;
    			count++;
    			tm.put(chs[x],count);
    			
    			count=0;
    			
    			/*// 繁复写法
    			if(value==null){
    				tm.put(chs[x],1);
    			}else{
    				value=value+1;
    				tm.put(chs[x],value);
    			}*/
    		}
    		
    		// System.out.println(tm);
    		
    		StringBuilder sb=new StringBuilder();
    		Set<Map.Entry<Character,Integer>> entrySet=tm.entrySet();
    		Iterator<Map.Entry<Character,Integer>> it=entrySet.iterator();
    		while(it.hasNext()){
    			Map.Entry<Character,Integer> me=it.next();
    			char key=me.getKey();
    			int value=me.getValue();
    			sb.append(key+"("+value+") ");
    		}
    		
    		return sb.toString();
    	}
    }
    

     

    展开全文
  • java中map集合的用法

    热门讨论 2013-01-07 22:57:06
    最常用的集合类是 List 和 Map。 List 的具体实现包括 ArrayList 和 Vector,它们是可变大小的列表,比较适合构建、存储和操作任何类型对象元素列表。 List 适用于按数值索引访问元素的情形。 Map 提供了一个更...
  • Map集合和List集合总结

    千次阅读 2019-05-27 17:32:15
    Map集合和List集合哪个效率更高 List接口 List集合是一个元素有序(存储有序)、可重复的集合,集合中的每个元素都有对应的索引,以便于查询和修改,List集合是允许存储null值的。 List集合可重复原因,请看源码: ...

    Map集合和List集合哪个效率更高

    List接口

    List集合是一个元素有序(存储有序)、可重复的集合,集合中的每个元素都有对应的索引,以便于查询和修改,List集合是允许存储null值的。

    List集合可重复原因,请看源码:

    public boolean add(E e) {
    	ensureCapacityInternal(size + 1);  // Increments modCount!!
    	elementData[size++] = e;
    	return true;
    }
    

    结论:无论添加重复还是不重复的元素,结果都是返回true.

    ArrayList集合

    ArrayList集合是List接口的实现类,有以下特点:

    1.有序,有索引
    2.元素可以重复
    3.可以存储null值
    4.随机访问速度快,修改快,增加/插入或者移除/删除的效率慢
    5.线程不安全

    注意:List集合的实现类想要实现去重复的话:
    思想:
      1、首先要创建一个新的集合。
      2、然后使用选择排序思想进行去除重复元素。

    Vector集合

      Vector集合也是List接口一个实现类,底层数据结构是数组,插入和移除性能较差,线程安全,效率低。

    总结:

    ArrayList集合和Vector集合
      ArrayList和Vector都是基于数组实现的list类,所以ArrayList和Vector封装了一个动态的,允许再分配的Object[]数组,不指定的话长度默认为10。ArrayList和Vector对象使用initialCapacity参数来设置该数组的长度,当向集合添加大量元素时,可以使用ensureCapac(int minCapacity)方法一次性的增加initialCapacity。

      ArrayList和Vector在用法上几乎完全相同,但Vector比较古老,方法名比较长,最好是不使用。ArrayList是线程不安全的,Vector是线程安全的,但这个完全可以手动将一个ArrayList变成线程安全的。

    ArrayList部分源码分析:

    1、首先我们先看一下ArrayList集合的构造器:
      无参构造器:创建一个默认长度为10的集合
      有参构造器:创建一个初始化长度的集合。

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    
    public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
    

    2、分析get方法
      我们调用get方法,获取数据时,底层会调用 rangeCheck(index)方法,然后对传入的索引进行判断,在 rangeCheck(int index)方法中如果传入的索引不存在,那么会抛出异常,如果传入的索引没有问题,那么会调用elementData(index)方法,返回传入该索引的值。

    public E get(int index) {
        rangeCheck(index);
    
        return elementData(index);
    }
    
    private void rangeCheck(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    
    E elementData(int index) {
        return (E) elementData[index];
    }
    

    3、add方法分析:
      我们使用add方法,向集合中添加一个元素时,首先,我们要调用ensureCapacityInternal()方法判断集合的长度是否够用,那么经过层层判断,如果集合长度不够,那么,将会对旧的集合使用集合的工具类的copyOf()方法进行拷贝创建新的集合,如果集合长度够用,那么返回true。

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    

    4、remove方法分析
      实现的逻辑和add方法大致一样,也是进行集合的拷贝。因此添加和移除的效率低。

        rangeCheck(index);
    
        modCount++;
        E oldValue = elementData(index);
    
        int numMoved = size - index - 1;
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        elementData[--size] = null; // clear to let GC do its work
    
        return oldValue;
    }
    

    LinkedList集合

    特点:
    1.底层数据结构是链表
    2.链表的特点有序,查询和修改效率低,增加和删除效率高
    3.可以存储null值
    4.线程不安全
    5.允许重复
    6.不可排序

    LinkedList与ArrayList集合比较
      LinkedList与ArrayList的实现机制完全不同,ArrayList内部以数组的形式来保存集合中的元素,因此随机访问集合元素时有较好的性能;而LinkedList内部以链表的形式来保存集合中的元素,因此随机访问性能较差,但是插入、删除元素时非常快。

    Map接口

      Map 未继承 Collection,而是独立的接口,Map 是一种把键对象和值对象进行映射的集合,它的每一个元素都包含了一对键对象和值对象,Map 中存储的数据是没有顺序的, 其 key 是不能重复的,它的值是可以有重复的。

    Map集合的特点:

    1.能够存储唯一的列的数据(唯一,不可重复)
    2.能够存储可以重复的数据(可重复)
    3.值的顺序取决于键的顺序
    4.键和值都是可以存储null元素的

    Map 接口常见的四个实现类:Hashtable,HashMap,TreeMap,LinkedHashMap;

    HashTable集合

    内部存储的键值对是无序的是按照哈希算法进行排序,与 HashMap 最大的区别就是线程安全。键或者值不能为 null,为 null 就会抛出空指针异常。

    特点:
    不允许null键和null值
    线程安全,效率低

    HashMap集合

    基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作,并允许使用 null 值和 null 键。(除了非同步和允许使用 null 之外,HashMap 类与 Hashtable 大致相同。)
    此类不保证映射的顺序,特别是它不保证该顺序恒久不变。
    HashMap如何运行的:
      HashMap在Map.Entry静态内部类实现中存储key-value对。HashMap使用哈希算法,在put和get方法中,它使用hashCode()和equals()方法。当我们通过传递key-value对调用put方法的时候,HashMap使用Key hashCode()和哈希算法来找出存储key-value对的索引。Entry存储在LinkedList中,所以如果存在entry,它使用equals()方法来检查传递的key是否已经存在,如果存在,它会覆盖value,如果不存在,它会创建一个新的entry然后保存。当我们通过传递key调用get方法时,它再次使用hashCode()来找到数组中的索引,然后使用equals()方法找出正确的Entry,然后返回它的值。

    特点:
    键无序,唯一,类似于Set集合
    值有序,可重复,类似于List
    底层数据结构是哈希表,保证键唯一
    允许键为null,值为null

    HashMap和Hashtable的区别

    HashMap是不安全的不同步的效率高的  允许null键和null值
    Hashtable是安全的同步的效率低的 不允许null键和null值
    底层都是哈希表结构
    

    LinkedHashMap集合

    Map 接口的哈希表和链接列表实现,具有可预知的迭代顺序,相当于一个栈,先 put 进去的最后出来,先进后出。

    特点:
    键有序,唯一,
    值有序,可重复,类似于List
    底层数据结构是哈希表和链表,哈希表保证键唯一,链表保证键有序

    TreeMap集合

    基于红黑树 (red-black tree) 数据结构实现,按 key 排序,默认的排序方式是升序。

    总结:

      如果List 和Map存储的元素都比较多。那么在取元素方面,List要慢很多。 但是这也不是绝对的,因为List底层基于数组,如果你明确的知道你要取的元素在哪个下标上,那么List也是相当的快。但是如果你不清楚,只能通过迭代内部全部元素然后进行条件判断查找,那么List就要慢的多,因为他要从头到尾一个个的元素去查,直到找到满足你的要求的那个元素,而Map则不需要迭代,因为Map有键,直接取键对应的值。 对于添加元素,List是在数组的结尾追加,当容量不够时,创建一个新的更长的数组然后将旧的全部拷贝过来。Map和他的方式差不多,也是容量不足的时候需要重新创建新的然后拷贝,但是当发生删除元素时,List简直就是灾难。假设你有10000个元素,你删除首个元素,在删除完毕以后 List中的所有元素都必须进行一次移动操作,向前位移。。。而Map则不需要。

      大概就是这样,如果你考虑一个长度比较可预测的保存元素的集合,并且很少有删除操作,大部分是进行全部迭代的操作,那么用List会比较合适。
      如果你的List还要经常增删,那么用LinkedList比较合适。
      如果你要快速查找,取值,用HashMap比较合适。
      如果同时要保证,元素放进去的顺序和取出来的顺序一致用LinkedHashMap。

    展开全文
  • Java基础 Map集合

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

    主要内容

    Map集合

    教学目标

    能够说出Map集合特点
    使用Map集合添加方法保存数据
    使用”键找值”的方式遍历Map集合
    使用”键值对”的方式遍历Map集合
    能够使用HashMap存储自定义键值对的数据
    能够使用HashMap编写斗地主洗牌发牌案例

    第一章 Map集合

    1.1概述

    现实生活中,我们常会看到这样的一种集合:IP地址与主机名,身份证号与个人,系统用户名与系统用户对象等,这种一一对应的关系,就叫做映射。Java提供了专门的集合类用来存放这种对象关系的对象,即java.util.Map 接口。

    我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图。
    在这里插入图片描述
    Collection 中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储。
    Map 中的集合,元素是成对存在的(理解为夫妻)。每个元素由键与值两部分组成,通过键可以找对所对应的 值。
    Collection 中的集合称为单列集合, Map 中的集合称为双列集合。
    需要注意的是, Map 中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。

    1.2Map常用子类

    通过查看Map接口描述,看到Map有多个子类,这里我们主要讲解常用的HashMap集合、LinkedHashMap集合。
    HashMap:存储数据采用的哈希表结构,元素的存取顺序不能保证一致。由于要保证键的唯一、不重复,需 要重写键的hashCode()方法、equals()方法。
    LinkedHashMap:HashMap下有个子类LinkedHashMap,存储数据采用的哈希表结构+链表结构。通过链表结构可以保证元素的存取顺序一致;通过哈希表结构可以保证的键的唯一、不重复,需要重写键的hashCode()方法、equals()方法。
    tips:Map接口中的集合都有两个泛型变量,在使用时,要为两个泛型变量赋予数据类型。两个泛型变量的数 据类型可以相同,也可以不同。

    1.3Map接口中的常用方法

    Map接口中定义了很多方法,常用的如下:
    public V put(K key, V value) : 把指定的键与指定的值添加到Map集合中。
    public V remove(Object key) : 把指定的键 所对应的键值对元素 在Map集合中删除,返回被删除元素的 值。public V get(Object key) 根据指定的键,在Map集合中获取对应的值。
    public Set keySet() : 获取Map集合中所有的键,存储到Set集合中。
    public Set<Map.Entry<K,V>> entrySet() : 获取到Map集合中所有的键值对对象的集合(Set集合)。
    Map接口的方法演示

    public class MapDemo {
    public static void main(String[] args) {
    //创建 map对象
    HashMap<String, String> map = new HashMap<String, String>();
    
    //添加元素到集合
    map.put("黄晓明", "杨颖");
    map.put("文章", "马伊琍");
    map.put("邓超", "孙俪");
    System.out.println(map);
    
    //String remove(String key)
     System.out.println(map.remove("邓超")); 
    System.out.println(map);
    
    // 想要查看 黄晓明的媳妇 是谁
    System.out.println(map.get("黄晓明")); 
    System.out.println(map.get("邓超"));
    }
    }
    

    tips:
    使用put方法时,若指定的键(key)在集合中没有,则没有这个键对应的值,返回null,并把指定的键值添加到 集合中;
    若指定的键(key)在集合中存在,则返回值为集合中键对应的值(该值为替换前的值),并把指定键所对应的 值,替换成指定的新值。

    1.4Map集合遍历键找值方式

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

    1. 获取Map中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键。方法提示: keyset()
    2. 遍历键的Set集合,得到每一个键。
    3. 根据键,获取键所对应的值。方法提示: get(K key)
      代码演示:
    public class MapDemo01 {
    public static void main(String[] args) {
    //创建Map集合对象
    HashMap<String, String> map = new HashMap<String,String>();
    //添加元素到集合
    map.put("胡歌", "霍建华");
    map.put("郭德纲", "于谦");
    map.put("薛之谦", "大张伟");
    
    //获取所有的键 获取键集
    Set<String> keys = map.keySet(); // 遍历键集 得到 每一个键
     for (String key : keys) {
      //key 就是键 //获取对应值 
      String value = map.get(key); 
      System.out.println(key+"的CP是:"+value); 
      } 
      } 
      }
    

    遍历图解:
    在这里插入图片描述

    1.5 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集合)。

    1.6 Map集合遍历键值对方式

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

    public class MapDemo02 {
    public static void main(String[] args) {
    // 创建Map集合对象
    HashMap<String, String> map = new HashMap<String,String>();
    // 添加元素到集合
    map.put("胡歌", "霍建华");
    map.put("郭德纲", "于谦");
    map.put("薛之谦", "大张伟");
    
    // 获 取 所 有 的 entry 对 象 entrySet Set<Entry<String,String>> entrySet = map.entrySet();
    
    // 遍历得到每一个entry对象
    for (Entry<String, String> entry : entrySet) {
    // 解 析
    String key = entry.getKey(); String value = entry.getValue();
    System.out.println(key+"的CP是:"+value);
    }
    }
    }
    

    遍历图解:

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

    1.7HashMap存储自定义类型键值

    练习:每位学生(姓名,年龄)都有自己的家庭住址。那么,既然有对应关系,则将学生对象和家庭住址存储到
    map集合中。学生作为键, 家庭住址作为值。
    注意,学生姓名相同并且年龄相同视为同一名学生。编写学生类:

    
    public class Student {
    private String name; private int age;
    
    public Student() {
    }
    
    public Student(String name, int age) { this.name = name;
    this.age = 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;
    }
    
    @Override
    public boolean equals(Object o) { if (this == o)
    return true;
    if (o == null || getClass() != o.getClass()) return false;
    Student student = (Student) o;
    return age == student.age && Objects.equals(name, student.name);
    }
    
    @Override
    public int hashCode() {
    return Objects.hash(name, age);
    }
    }
    
    

    编写测试类:

    
    public class HashMapTest {
    public static void main(String[] args) {
    //1,创建Hashmap集合对象。
    Map<Student,String>map = new HashMap<Student,String>();
    //2,添加元素。map.put(newStudent("lisi",28), "上海");
    map.put(newStudent("wangwu",22), "北京");
    map.put(newStudent("zhaoliu",24), "成都");
    map.put(newStudent("zhouqi",25), "广州"); 
    map.put(newStudent("wangwu",22), "南京"); 
    //3,取出元素。键找值方式 
    Set<Student>keySet = map.keySet(); 
    for(Student key: keySet){ 
    Stringvalue = map.get(key); 
    System.out.println(key.toString()+"....."+value);
     }
      } 
     }
    
    

    当给HashMap中存放自定义对象时,如果自定义对象作为key存在,这时要保证对象唯一,必须复写对象的 hashCode和equals方法(如果忘记,请回顾HashSet存放自定义对象)。
    如果要保证map中存放的key和取出的顺序一致,可以使用 java.util.LinkedHashMap 集合来存放。

    1.8 LinkedHashMap

    我们知道HashMap保证成对元素唯一,并且查询速度很快,可是成对元素存放进去是没有顺序的,那么我们要保 证有序,还要速度快怎么办呢?
    在HashMap下面有一个子类LinkedHashMap,它是链表和哈希表组合的一个数据存储结构。

    
    public class LinkedHashMapDemo {
    public static void main(String[] args) {
    LinkedHashMap<String, String> map = new LinkedHashMap<String, String>(); 
    map.put("邓超", "孙俪");
    map.put("李晨", "范冰冰");
    map.put("刘德华", "朱丽倩");
    Set<Entry<String, String>> entrySet = map.entrySet(); 
    for (Entry<String, String> entry : entrySet) {
    System.out.println(entry.getKey() + " " + entry.getValue());
    }
    }
    }
    

    结果:

    邓 超 孙 俪李晨 范冰冰
    刘德华 朱丽倩
    

    1.9Map集合练习

    需求:
    计算一个字符串中每个字符出现次数。分析:
    1.获取一个字符串对象
    2.创建一个Map集合,键代表字符,值代表次数。

    3.遍历字符串得到每个字符。
    4.判断Map中是否有该键。
    5.如果没有,第一次出现,存储次数为1;如果有,则说明已经出现过,获取到对应的值进行++,再次存储。
    6.打印最终结果
    代码:

    
    public class MapTest {
    public static void main(String[] args) {
    //友情提示
    System.out.println("请录入一个字符串:");
    String line = new Scanner(System.in).nextLine();
    // 定义 每个字符出现次数的方法
    findChar(line);
    }
    private static void findChar(String line) {
    //1:创建一个集合 存储 字符 以及其出现的次数
    HashMap<Character, Integer> map = new HashMap<Character, Integer>();
    //2:遍历字符串
    for (int i = 0; i < line.length(); i++) { char c = line.charAt(i);
    //判断 该字符 是否在键集中
    if (!map.containsKey(c)) {//说明这个字符没有出现过
    //那就是第一次
    map.put(c, 1);
    } else {
    //先获取之前的次数
    Integer count = map.get(c);
    //count++;
    //再次存入 更新
    map.put(c, ++count);
    }
    }
    System.out.println(map);
    }
    }
    

    第二章 补充知识点

    2.1JDK9对集合添加的优化

    通常,我们在代码中创建一个集合(例如,List 或 Set ),并直接用一些元素填充它。 实例化集合,几个 add方法调用,使得代码重复。

    public class Demo01 {
     public static void main(String[] args) { 
     List<String> list = new ArrayList<>();
     list.add("abc"); list.add("def"); list.add("ghi"); 
     System.out.println(list); } 
     }
    

    Java 9,添加了几种集合工厂方法,更方便创建少量元素的集合、map实例。新的List、Set、Map的静态工厂方法可以更方便地创建集合的不可变实例。
    例子:

    public class HelloJDK9 {
    public static void main(String[] args) {
     Set<String> str1=Set.of("a","b","c");
    //str1.add("c");这里编译的时候不会错,但是执行的时候会报错,因为是不可变的集合
    System.out.println(str1);  
    Map<String,Integer> str2=Map.of("a",1,"b",2); 
    System.out.println(str2);
    List<String> str3=List.of("a","b");
     System.out.println(str3);
    }
    }
    

    需要注意以下两点:
    1:of()方法只是Map,List,Set这三个接口的静态方法,其父类接口和子类实现并没有这类方法,比如HashSet,ArrayList等待;
    2:返回的集合是不可变的;

    2.2Debug追踪

    使用IDEA的断点调试功能,查看程序的运行过程
    1.在有效代码行,点击行号右边的空白区域,设置断点,程序执行到断点将停止,我们可以手动来运行程序
    在这里插入图片描述
    2.点击Debug运行模式

    在这里插入图片描述

    3.程序停止在断点上不再执行,而IDEA最下方打开了Debug调试窗口
    在这里插入图片描述
    在这里插入图片描述
    4.Debug调试窗口介绍
    在这里插入图片描述
    5.快捷键F8,代码向下执行一行,第九行执行完毕,执行到第10行(第10行还未执行)
    在这里插入图片描述
    6.切换到控制台面板,控制台显示 请录入一个字符串: 并且等待键盘录入
    在这里插入图片描述
    7.快捷键F8,程序继续向后执行,执行键盘录入操作,在控制台录入数据 ababcea

    在这里插入图片描述
    回车之后效果:
    在这里插入图片描述
    调试界面效果:
    在这里插入图片描述
    8.此时到达findChar方法,快捷键F7,进入方法findChar
    在这里插入图片描述
    9.快捷键F8 接续执行,创建了map对象,变量区域显示
    在这里插入图片描述
    10.快捷键F8 接续执行,进入到循环中,循环变量i为 0,F8再继续执行,就获取到变量c赋值为字符‘a’ 字节值97
    在这里插入图片描述
    11.快捷键F8 接续执行,进入到判断语句中,因为该字符 不在Map集合键集中,再按F8执行,进入该判断中
    在这里插入图片描述
    12.快捷键F8 接续执行,循环结束,进入下次循环,此时map中已经添加一对儿元素
    在这里插入图片描述
    13.快捷键F8 接续执行,进入下次循环,再继续上面的操作,我们就可以看到代码每次是如何执行的了
    在这里插入图片描述

    14.如果不想继续debug,那么可以使用快捷键F9,程序正常执行到结束,程序结果在控制台显示
    在这里插入图片描述

    第三章 模拟斗地主洗牌发牌

    3.1案例介绍

    按照斗地主的规则,完成洗牌发牌的动作。
    在这里插入图片描述
    具体规则:
    1.组装54张扑克牌将
    2.54张牌顺序打乱
    3.三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌。
    4.查看三人各自手中的牌(按照牌的大小排序)、底牌
    规则:手中扑克牌从大到小的摆放顺序:大王,小王,2,A,K,Q,J,10,9,8,7,6,5,4,3

    3.2案例需求分析

    1.准备牌:
    完成数字与纸牌的映射关系:
    使用双列Map(HashMap)集合,完成一个数字与字符串纸牌的对应关系(相当于一个字典)。
    2.洗牌:
    通过数字完成洗牌发牌
    3.发牌:
    将每个人以及底牌设计为ArrayList,将最后3张牌直接存放于底牌,剩余牌通过对3取模依次发牌。 存放的过程中要求数字大小与斗地主规则的大小对应。
    将代表不同纸牌的数字分配给不同的玩家与底牌。
    4.看牌:
    通过Map集合找到对应字符展示。
    通过查询纸牌与数字的对应关系,由数字转成纸牌字符串再进行展示。
    在这里插入图片描述

    3.3实现代码步骤

    public class Poker {
    public static void main(String[] args) {
    /*
    * 1组装54张扑克牌
    */
    // 1.1 创建Map集合存储
    HashMap<Integer, String> pokerMap = new HashMap<Integer, String>();
    // 1.2 创建 花色集合 与 数字集合
    ArrayList<String> colors = new ArrayList<String>(); 
    ArrayList<String> numbers = new ArrayList<String>();
    
    
    
    
    
    
    "3");
    
    // 1.3 存储 花色 与数字
    Collections.addAll(colors, "♦", "♣", "♥", "♠");
    Collections.addAll(numbers, "2", "A", "K", "Q", "J", "10", "9", "8", "7", "6", "5", "4",
    
    // 设置 存储编号变量
    int count = 1; pokerMap.put(count++, "大王"); pokerMap.put(count++, "小王");
    // 1.4 创建牌 存储到map集合中
    for (String number : numbers) { for (String color : colors) {
    String card = color + number; pokerMap.put(count++, card);
    
    }
    }
    /*
    * 2 将54张牌顺序打乱
    */
    // 取出编号 集合
    Set<Integer> numberSet = pokerMap.keySet();
    // 因为要将编号打乱顺序 所以 应该先进行转换到 list集合中ArrayList<Integer> numberList = new ArrayList<Integer>(); numberList.addAll(numberSet);
    
    // 打乱顺序
    
    Collections.shuffle(numberList);
    // 3 完成三个玩家交替摸牌,每人17张牌,最后三张留作底牌
    // 3.1 发牌的编号
    // 创建三个玩家编号集合 和一个 底牌编号集合
    ArrayList<Integer> noP1 = new ArrayList<Integer>(); ArrayList<Integer> noP2 = new ArrayList<Integer>(); ArrayList<Integer> noP3 = new ArrayList<Integer>(); ArrayList<Integer> dipaiNo = new ArrayList<Integer>();
    
    // 3.2发牌的编号
    for (int i = 0; i < numberList.size(); i++) {
    // 获取该编号
    Integer no = numberList.get(i);
    // 发 牌
    // 留出底牌
    if (i >= 51) { dipaiNo.add(no);
    } else {
    if (i % 3 == 0) {
    noP1.add(no);
    } else if (i % 3 == 1) { noP2.add(no);
    } else {
    noP3.add(no);
    }
    }
    }
    
    // 4 查看三人各自手中的牌(按照牌的大小排序)、底牌
    // 4.1 对手中编号进行排序
    Collections.sort(noP1); Collections.sort(noP2); Collections.sort(noP3); Collections.sort(dipaiNo);
    
    // 4.2 进行牌面的转换
    // 创建三个玩家牌面集合 以及底牌牌面集合
    ArrayList<String> player1 = new ArrayList<String>(); 
    ArrayList<String> player2 = new ArrayList<String>();
     ArrayList<String> player3 = new ArrayList<String>();
      ArrayList<String> dipai = new ArrayList<String>();
    
    // 4.3转换
    for (Integer i : noP1) {
    // 4.4 根据编号找到 牌面 pokerMap String card = pokerMap.get(i);
    // 添加到对应的 牌面集合中
    player1.add(card);
    }
    
    for (Integer i : noP2) {
    String card = pokerMap.get(i); player2.add(card);
    }
    for (Integer i : noP3) { 
    String card = pokerMap.get(i); player3.add(card); 
    }
    for (Integer i : dipaiNo) {
     String card = pokerMap.get(i); dipai.add(card);
      }
      //4.5 查看 
      System.out.println("令狐冲:"+player1); 
      System.out.println("石破天:"+player2); 
      System.out.println("鸠摩智:"+player3); 
      System.out.println("底牌:"+dipai);
       }
        }
    
    展开全文
  • 常用的Map集合

    千次阅读 2019-05-22 21:12:22
    Map集合Map集合常用方法增加删除判断获取Map集合中TreeSet的应用Map集合中HashSet的应用 Map集合常用方法 Map集合和Collection集合的区别 Map集合是有Key和Value的,Collection集合是只有Value。 Collection集合底层...

    Map集合常用方法

    Map集合和Collection集合的区别

    Map集合是有Key和Value的,Collection集合是只有Value。

    Collection集合底层也是有Key和Value,只是隐藏起来。

    1.增加 put (K key, V value)
    2.删除 clear() 删除这个集合的所有值 remove(Object key) 根据键删除这一类
    3.判断 containsKey(Object key) containsValue(Object value) isEmpty()
    4.获取 get(Object key) size() values() entrySet() keySet()

    增加

    Map的put方法

    • 1.添加集合元素的同时,它可以编辑原有的元素
    • 如果说集合中没有key对应的value,那么就往集合中添加元素
    • 如果说集合对应的key有value值,则代表替换原有的值
    • 2.返回替换前key对应的value值
      在这里插入图片描述

    删除

    clear() 删除这个集合的所有值

    在这里插入图片描述 remove(Object key) 根据键删除这一类

    在这里插入图片描述

    判断

    containsKey(Object key) 这里就举这一个例子
    在这里插入图片描述

    获取

    KeySet():
    将Map中所有的键存入到set集合中。因为set具备迭代器。所有可以迭代方式取出所有的键,再根据get方法。获取每一个键对应的值。 keySet():迭代后只能通过get()取key

    entrySet():

    Set<Map.Entry<K,V>> entrySet() //返回此映射中包含的映射关系的 Set 视图。 Map.Entry表示映射关系。entrySet():迭代后可以e.getKey(),e.getValue()取key和value。返回的是Entry接口 。

    在这里插入图片描述

    Map集合中TreeSet的应用

    底层是二叉树数据结构,线程不同步,可以用于给Map集合中的键进行排序

    package com.zking.Map;
    
    import java.util.Comparator;
    import java.util.HashMap;
    import java.util.Map;
    import java.util.Map.Entry;
    import java.util.Set;
    import java.util.TreeMap;
    
    /**
     * 1、将学生作为键,地址作为值进行存储,名字年龄相同则被认定为一个人,最后输出
     * 		A.建立一个student类,实例化作为key添加到map集合中
     * 		B.对学生进行判重
     * 2、最后按年龄进行排序
     * 3、需求改变、按姓名进行排序
     * @author huguiyun
     *
     */
    public class TreeMapDemo {
    	public static void main(String[] args) {
    //		Map<Student, String > map = new HashMap<>();//判重
    //		Map<Student, String > map = new TreeMap<>();//判重需要实现Comparable方法,排序
    		Map<Student, String > map = new TreeMap<>(new StuComp());//比较器排序
    
    		map.put(new Student("liuting", 18), "beijing");
    		map.put(new Student("wangwang", 43), "xingjiang");
    		map.put(new Student("goudan", 28), "dongjing");
    		map.put(new Student("xuyangyang", 38), "hulunbeier");
    		map.put(new Student("liuting", 18), "beijing");
    		map.put(new Student("liutingting", 18), "beijing");
    		
    		
    		System.out.println(map.size());
    		Set<Entry<Student, String>> entryset = map.entrySet();
    		for(Entry<Student, String> entry:entryset) {
    			System.out.println(entry.getKey()+"   ===   "+entry.getValue());
    		}
    	}
    }
    class Student implements Comparable<Student>{//让它具有比较性
    	private String name;
    	private int 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;
    	}
    	@Override
    	public String toString() {
    		return "Student [name=" + name + ", age=" + age + "]";
    	}
    	public Student(String name, int age) {
    		super();
    		this.name = name;
    		this.age = age;
    	}
    	public Student() {
    		super();
    	}
    	
    	//乘以39是为了增大他们的哈希,防止他们的哈希值相等
    	@Override
    	public int hashCode() {
    		return this.getName().hashCode()+this.getAge()*39;
    	}
    	@Override
    	public boolean equals(Object obj) {
    		Student stu = (Student)obj;
    		return this.getAge() ==stu.getAge()&&this.getName().equals(stu.getName()) ;
    	}
    	@Override
    	public int compareTo(Student o) {//一定要判断主要条件和次要条件
    		int num = this.getAge() - o.getAge();
    		if(num==0) {
    			this.getName().compareTo(o.getName());
    		}
    		return num;
    	}
    }
    
    
    class StuComp implements Comparator<Student>{//比较器排序
    
    	@Override
    	public int compare(Student o1, Student o2) {
    		int num = o1.getName().compareTo(o2.getName());
    		if(num==0) {
    			return o1.getAge() - o2.getAge();
    		}
    		return num;
    	}
    	
    }
    

    Map集合中HashSet的应用

    统计字符串中字符出现次数

    package com.zking.Map;
    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.TreeMap;
    
    /**
     * 
     * map集合中的泛型要使用包装类,或者是引用数据类型
     * 
     * 统计字符串中出现的次数
     *     sdkfgkdfadasdfasd
     *     a(2)c(5)
     *     
     * 思考
     *    统计,排序
     *    
     *    统计功能
     *    1.将字符串转为字符数组,将这个字符串中的字符当作map集合中的key,
     *    将出现的次数作为value值
     *    
     *    2.当字符第一次出现的时候,那么用它在集合中进行寻找,返回值必然是null,
     *    之后将该字符对应的值改为1
     *    
     *    3.如果说该字符不是第一次出现,该字符对应的值不为null,然后应该+1
     *     
     * @author huguiyun
     *
     */
    public class HashMapDemo {
    	public static void main(String[] args) {
    		String str = "ksdflaksdfasdrtwrtwerxvsdfghflaihijfaidfai";
    		str = cishu(str);
    		System.out.println(str);
    	}
    	public static String cishu(String str) {
    		char[] chararray = str.toCharArray();
    		Map<Character, Integer> map = new TreeMap<>();
    		for(char c : chararray) {
    			Integer value = map.get(c);
    			if(value==null) {
    				map.put(c, 1);
    			}
    			else {
    				map.put(c, ++value);
    			}
    		}
    //		StringBuffer跟string  string 会创建新的空间
    		StringBuffer sb = new StringBuffer();
    		for(Map.Entry<Character, Integer> entry:map.entrySet()) {
    			sb.append(entry.getKey()+"("+entry.getValue()+")");
    		}
    		return sb.toString();
    	}
    
    }
    
    
    展开全文
  • java之Map集合总结

    千次阅读 2020-06-22 20:35:41
    Collection中的集合称为单列集合Map中的集合称为双列集合。 需要注意的是,Map中的集合不能包含重复的键,值可以重复;每个键只能对应一个值。 1 Map常用子类 Map常用子类有: HashMap<K,V>:存储数据...
  • 一、 Dart 数据类型 Map 类型、 二、 Map 类型初始化并赋值、 1、 创建 Map 对象同时进行初始化操作、 2、 先创建 Map 对象再进行...3、 使用 map 方法进行遍历生成新的 Map 集合、 四、 完整代码示例、 五、 相关资源
  • [C++] map集合的使用

    千次阅读 2021-02-02 10:21:09
    【C++集合】STL中的map STL中的map以一种效率较高的形式(红黑树)实现了映射。(C++11又提供了一种更为先进的unordered_map,基于哈希表,拥有 O(1) 的时间复杂度,两种容器操作相同) map的创建 map<A, B> ...
  • Java集合map 集合使用

    万次阅读 2017-12-12 12:28:25
    Java集合中的四种遍历方式: ... import java.util.HashMap; import java.util.Iterator; import java.util.Map;... * Map集合的四种运用方法 * @author MrYang */ public class MapDemo { public static v
  • Map集合详细解析

    千次阅读 2019-09-23 20:38:10
    java 集合 API 中的Map是映射的意思 Map是一个接口,其目的是为了高性能解决查找问题 实现Map接口的类都封装了高性能查找算法,利用Map接口的实现类就可以提高软件的查 找性能,提供优秀的用户体验 Map的实现类 ...
  • Map集合实例练习一

    千次阅读 2018-11-11 17:09:27
    java基础是关键,当你掌握一定的知识量的时候,但感觉其实还是基础是关键,很多框架都是固定的,只要掌握框架的配置,再加基础,相信你也就可以入这行了。选择有很多,要么及早的地...Map集合的特点,如是否可重复,...
  • Java中的Map集合以及Map集合遍历实例

    千次阅读 2018-11-06 09:19:25
    Map集合 Map&amp;amp;amp;lt;K,V&amp;amp;amp;gt;k是键,v是值 1、 将键映射到值的对象,一个映射不能包含重复的键,每个键最多只能映射的一个值 2、 实现类  a) HashMap  b) TreeMap 3、 Map集合和...
  • Map集合中获取key-value值的方法

    千次阅读 2021-04-18 17:30:40
    集合是一种键值映射形式的集合。当调用put(K key,V value)方法把数据存到Map中后,如何把Map中的key值和value值取出来呢?都有哪几种取值的方法呢?下边就来一一介绍。 一、前置准备 以HashMap为例,先为map中存入几...
  • Java——集合(Map集合的两种迭代)

    千次阅读 2018-07-26 11:05:33
    一,Map集合的第一种迭代 Map集合的第一种迭代,通过get(key)方法,根据键去获取值 package com.wsq.map; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Set; ...
  • map集合排序

    千次阅读 2019-05-05 20:32:59
    今天做统计时需要对X轴的地区按照地区代码(areaCode)进行排序,由于在构建XMLData使用的map来进行数据统计的,所以在统计过程中就需要对map进行排序。...map是键值对的集合接口,它的实现类主要包...
  • Kotlin 基础——Map集合详解

    千次阅读 2020-04-13 21:33:03
    Kotlin基础——Map集合详解一、声明和创建Map集合二、使用Map的方法三、遍历Map四种方式四、可变的Map Kotlin的Map集合用于保存key-value对,其也被分为可变的和不可变的。 一、声明和创建Map集合 Kotlin提供了如下...
  • java中Map集合的四种遍历方式

    千次阅读 2020-06-20 13:40:25
    java中Map集合的四种遍历方式 Map接口和Collection接口的集合不同,Map集合是双列的,Collection是单列的.Map集合将键映射到值的对象. 双列的集合遍历起来也是比较麻烦些的,特别是嵌套的map集合,这里说下MAP集合的四种...
  • java中的Map集合

    万次阅读 多人点赞 2018-11-06 18:13:40
    什么是Map集合? Map用于保存具有映射关系的数据,Map集合里保存着两组值,一组用于保存Map的ley,另一组保存着Map的value。 图解 map集合的作用 和查字典类似,通过key找到对应的value,通过页数找到对应的...
  • java-Map集合

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

    万次阅读 多人点赞 2021-01-28 23:26:04
    注意 Set entrySet():返回所有key-value对构成的Set集合 Iterator<Map.Entry, String>> entries = map.entrySet().iterator(); while (entries.hasNext()) { Map.Entry, String> entry = entries.next(); System....
  • scala之Map集合

    千次阅读 2019-05-03 23:40:50
    1.创建Map 2.对集合操作 3.zip:将Array集合相同位置的值进行合并为一个 Tuple 1.创建Map (1)immutable.Map val ages = Map("Leo" -> 30, "Jen" -> 25, "Jack" -> 23) (2)mutable.Map // 创建...
  • Map集合遍历键找值方式 键找值方式:即通过元素中的键,获取键所对应的值 操作步骤与图解: 1.获取Map集合中所有的键,由于键是唯一的,所以返回一个Set集合存储所有的键 2.遍历键的Set集合,得到每一个键 3.根据键...
  • Java中Map集合的使用

    2019-04-25 10:13:16
    Map:存储双列数据的集合,通过键值对存储数据,存储 的数据是无序的,Key值不能重复,value值可以重复 1:声明一个Map Map<String,Object> map = new HashMap<String,Object>(); map.put(key,va...
  • vue遍历Map集合

    千次阅读 2020-11-30 13:27:29
    vue使用v-for遍历Map对象 vue循环遍历List,Map,Array
  • C#中的map集合

    千次阅读 2021-05-11 22:20:23
    相当于Java中的Map集合 C# 中的map集合遍历取值方法如下: Dictionary<string, string> map = new Dictionary<string, string>(); map.Add("1", "Chinese"); map.Add("2", "Math"); map.Add("3", ...
  • Java list集合转换Map集合

    千次阅读 2020-07-30 19:12:53
    Java list集合转换Map集合 在我们平常处理数据的时候,常常需要将list集合转换为Map集合,其中的key可以是list集合元素对象中的某个唯一属性,以此作为key,对象作为value,方便后续处理的时候,对于相同key的对象...
  • Map集合及其子类理解

    千次阅读 2018-08-05 19:41:23
    本文主要内容时Map集合和其子类HashMap与LinkedHashMap,包含格式以及一些特点和主要方法的使用,treeMap暂时没学到,没有对treeMap的介绍。 目录 Map集合 Map集合与Collection集合区别 Map常用子类 Map集合...
  • 1.调用这个方法BeanMapUtils.mapToBean(),实现map集合转实体类对象; 注意:这个方法转换时我这边老是报类型转换错误,引用这段代码没有报错的小伙伴可继续使用,此方法扩展性好,报错的小伙伴请看最下面的一个map转实体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 607,420
精华内容 242,968
热门标签
关键字:

map集合