Map群集概述和特征

作者: 编程应用  发布:2019-09-26

Map群集的表征

  A:Map集结概述和个性(Set底层依赖的是Map)

1、Map集结中保存的都是键值对,键和值是逐个对应的

  • 将键映射到值的对象
  • 二个辉映无法包罗重复的键
  • 各样键最两只好照射到三个值

B:Map接口和Collection接口的不等

  • Map是双列的(是双列会集的根接口),Collection是单列的(是单列集结的根接口)
  • Map的键独一,Collection的子种类Set是不今不古的
  • Map集结的数据结构值针对键有效,跟值非亲非故;如:TreeMap:键是用二叉树算法,HashMap:键是hash算法, Collection集结的数据结构是针对成分有效

图解:

图片 1

 

2、一个辉映不能够包蕴重复的值

Map集合的作用概述

3、每种键最四只好照射到二个值上

   a:添美元素成效

Map接口和Collection接口的不等

  • V put(K key,V value):添新币素。
  • 若是键是率先次存款和储蓄,就一向存款和储蓄成分,重临null
  • 如果键不是第三回存在,就用值把在此在此之前的值替换掉,重临在此之前的值

Map是双列集结的根接口,Collection是单列集合的根接口

   b:删除成分成效

1、Map是双列的(是双列集结的根接口),Collection是单列的(是单列集合的根接口)

  • void clear():移除全数的键值对成分
  • V remove(Object key):遵照键删除键值对成分,并把值重临

2、Map的键是独一的,Collection的子接口Set是当世无双的

   c:决断功用

3、Map集结的数据结构值针对键有效,跟值毫无干系;如:TreeMap:键是用二叉树算法,HashMap:键是hash算法,Collection集结的数据结构是针对性成分有效

  • boolean containsKey(Object key):判定集结是不是包含内定的键
  • boolean containsValue(Object value):判定集结是还是不是含有内定的值
  • boolean isEmpty():推断集结是或不是为空

Map集结的遍历格局

    d:获取成分功效

package com.jd.text;import java.util.Collection;import java.util.HashMap;import java.util.Iterator;import java.util.Map;import java.util.Map.Entry;import java.util.Set;public class Demo06 {    public static void main(String[] args) {        // 创建map集合        Map map = new HashMap<>();        // 添加 将指定的值与此映射中的指定键关联        map.put("张三", 12);        map.put("李四", 13);        map.put("蔡文姬", 14);        map.put("王五", 15);        // 删除 如果存在一个键的映射关系,则将其从此映射中移除        map.remove("王五");        // map.clear();//删除全部 从此映射中移除所有映射关系        // 根据指定的key获取对应的value        Object obj1 = map.get("张三");        System.out.println;        // 是否包含指定的key,包含返回true,不包含返回false。        boolean b = map.containsKey("张三");        System.out.println;        // 是否包含指定的value,包含返回true,不包含返回false。        boolean c = map.containsValue(13);        System.out.println;                System.out.println("******************************");                // map集合的遍历,通过keyset        Set keySet = map.keySet();        Iterator iter = keySet.iterator();        while (iter.hasNext {            Object key = iter.next();            Object value = map.get;            System.out.println(key + ":" + value);        }        System.out.println("******************************");                // map集合的遍历,通过keyset()方法        Set keySet2 = map.keySet();        for (Object key : keySet2) {            Object value = map.get;            System.out.println(key + ":" + value);        }        System.out.println("******************************");                // map集合的遍历,通过entrySet()方法        Set entrySet = map.entrySet();        for (Object obj3 : entrySet) {            Entry e =  obj3;            Object key = e.getKey();            Object value = e.getValue();            System.out.println(key + ":" + value);        }        System.out.println("******************************");                // map集合的values方法,获取到的map集合的value的值组成的collection集合        Collection coll = map.values();        for (Object obj : coll) {            System.out.println;        }    }}
  • Set<Map.Entry<K,V>> entrySet():
  • V get(Object key):依照键获取值
  • Set<K> keySet():获取集结中全部键的聚众
  • Collection<V> values():获取集合中 * int size():重回群集中的键值对的个数全部值的集聚

    package online.msym.map; import java.util.Collection; import java.util.HashMap; import java.util.Map; public class Demo1_Map {

    public static void main(String[] args) {
        //demo1();//添加数据
        //demo2();//删除数据,判断是否包含键或者值
        demo3();//获取map中的所有的值
    }
    private static void demo3() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
    
        Collection<Integer> c = map.values();
        System.out.println(c);
        System.out.println(map.size());
    }
    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);
    
        //Integer value = map.remove("张三");                //根据键删除元素,返回键对应的值
        //System.out.println(value);
        System.out.println(map.containsKey("张三"));        //判断是否包含传入的键
        System.out.println(map.containsValue(100));        //判断是否包含传入的值
        System.out.println(map);
    }
    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        Integer i1 = map.put("张三", 23);//存入的过程先判断有没有"张三",没有就添加,有就覆盖,返回的是被覆盖的部分
        Integer i2= map.put("李四", 24);
        Integer i3 = map.put("王五", 25);
        Integer i4 = map.put("赵六", 26);
        Integer i5 = map.put("张三", 26);                    //相同的键不存储,值覆盖,把被覆盖的值返回
    
        System.out.println(map);
    
        System.out.println(i1);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(i4);
        System.out.println(i5);
    }
    

    }

运营结果:

Map集合的遍历之键找值

12truetrue******************************李四:13张三:12蔡文姬:14******************************李四:13张三:12蔡文姬:14******************************李四:13张三:12蔡文姬:14******************************131214

A:键找值思路:

  1. 赢得全部键的集纳
  2. 遍历键的聚合,获取到每三个键
  3. 依照键找值

图解:

图片 2

TreeMap集结保存自定义对象

package online.msym.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class Demo2_Iterator {
    /**
     * Map集合没有iterator方法,
     * 根据键获取值
     */
    public static void main(String[] args) {
        //demo1();//使用keySet方法,通过获取所有的键的集合,在遍历此集合,根据键再获取其对应的值
        demo2();
    }
    private static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);        
//        Integer i = map.get("张三");                    //根据键获取值
//        System.out.println(i);

        //获取所有的键
        Set<String> keySet = map.keySet();            //获取所有键的集合
        Iterator<String> it = keySet.iterator();    //获取迭代器
        while(it.hasNext()) {                        //判断集合中是否有元素
            String key = it.next();                    //获取每一个键
            Integer value = map.get(key);            //根据键获取值
            System.out.println(key + "=" + value);
        }        
    }
    //使用增强for循环
    private static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);        
        //使用增强for循环遍历
        for(String key : map.keySet()) {            //map.keySet()是所有键的集合
            System.out.println(key + "=" + map.get(key));
        }
    }
}

package com.jd.text;

Map群集的遍历之键值对指标找键和值

import java.util.Set;
import java.util.TreeMap;

A:键值对目的找键和值思路:

  1. 赢得具备键值对目的的聚合
  2. 遍历键值对目的的汇集,获取到每叁个键值对目的
  3. 依附键值对指标找键和值

    图片 3

/*
* TreeMap保存自定义对象,比较的Comparable和Comparator二种方法
* 1.由此完成Comparable接口,重写compareTo()方法。
*/
public class Demo07 {

package online.msym.map;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
public class Demo3_Iterator {
    /**
     * Map集合的第二种迭代,根据键值对对象,获取键和值
     *  A:键值对对象找键和值思路:
        获取所有键值对对象的集合
        遍历键值对对象的集合,获取到每一个键值对对象
        根据键值对对象找键和值
     */
    public static void main(String[] args) {
        //demo1();
        demo2();
    }
    public static void demo1() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);

        //Map.Entry说明Entry是Map的内部接口,将键和值封装成了Entry对象,并存储在Set集合中
        Set<Map.Entry<String, Integer>> entrySet = map.entrySet();
        //获取每一个对象
        Iterator<Map.Entry<String, Integer>> it = entrySet.iterator();
        while(it.hasNext()) {
            //获取每一个Entry对象
            Map.Entry<String, Integer> en = it.next();    //父类引用指向子类对象
            //Entry<String, Integer> en = it.next();    //直接获取的是子类对象
            String key = en.getKey();                    //根据键值对对象获取键
            Integer value = en.getValue();                //根据键值对对象获取值
            System.out.println(key + "=" + value);
        }    
    }
    //使用增强for循环进行迭代
    public static void demo2() {
        Map<String, Integer> map = new HashMap<>();
        map.put("张三", 23);
        map.put("李四", 24);
        map.put("王五", 25);
        map.put("赵六", 26);    
        //使用增强for循环进行迭代
        for(Map.Entry<String, Integer> en : map.entrySet()) {
            System.out.println(en.getKey() + "=" + en.getValue());
        }    
    }
}

public static void main(String[] args) {
TreeMap map=new TreeMap<>();
map.put(new User("张三01", 12),11);
map.put(new User("张三01", 10),11);
map.put(new User("张三02", 13),11);
map.put(new User("张三01", 12),11);
//通过重写hashCode()和equals(Object obj)方法防止重复的值存入
Set set = map.keySet();
for (Object key : set) {
Object value = map.get;
System.out.println(key + ":" + value);
}
}
}

【点击这里回到主页】

package com.jd.text;/* * 通过实现Comparable接口,重写compareTo()方法。 */public class User implements Comparable{    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 "User [name=" + name + ", age=" + age + "]";    }    public User(String name, int age) {        super();        this.name = name;        this.age = age;    }    public User() {        super();    }        @Override    public int hashCode() {        final int prime=31;        int result=1;        result=prime*result+age;        result=prime*result+((name==null)?0:name.hashCode;        return result;    }    @Override    public boolean equals(Object obj) {        if(this==obj)            return true;        if(obj==null)            return false;        if(getClass()!=obj.getClass            return false;        User user= obj;        if(age!=user.age)            return false;        if(name==null){            if(user.name!=null)                return false;        }else if(!name.equals(user.name))            return false;        return true;    }    @Override    public int compareTo {        if(o instanceof User){            User user= o;            int sum=name.compareTo(user.name);            if(sum==0)                return age-user.age;            return sum;        }        throw new ClassCastException("不是User类型");    }    }

运作结果:

User [name=张三01, age=10]:11User [name=张三01, age=12]:11User [name=张三02, age=13]:11

package com.jd.text;/* * TreeMap保存自定义对象,比较的Comparable和Comparator两种方式 * 2.自己构造比较器实现Comparator接口,重写compare(Object o1, Object o2)方法 */import java.util.Comparator;import java.util.Set;import java.util.TreeMap;public class Demo08 {    public static void main(String[] args) {        TreeMap map=new TreeMap(new MyCompare;        map.put(new User2("张三01", 12),11);        map.put(new User2("张三01", 10),11);        map.put(new User2("张三02", 13),11);        map.put(new User2("张三01", 12),11);        //通过重写hashCode()和equals(Object obj)方法防止重复的值存入        Set set = map.keySet();        for (Object key : set) {            Object value = map.get;            System.out.println(key + ":" + value);        }    }}class User2{    String name;    int age;        public User2(String name,int age){        this.name=name;        this.age=age;    }        @Override    public int hashCode(){        final int prime=31;        int result=1;        result=prime*result+age;        result=prime*result+((name==null)?0:name.hashCode;        return result;    }    @Override    public boolean equals(Object obj){        if(this==obj)            return true;        if(obj==null)            return false;        if(getClass()!=obj.getClass            return false;        User2 u= obj;        if(age!=u.age)            return false;        if(name==null){            if(u.name!=null)                return false;        }else if(!name.equals                return false;        return true;    }    @Override    public String toString() {        return "User2 [name=" + name + ", age=" + age + "]";    }}//比较器class MyCompare implements Comparator{    @Override    public int compare(Object o1, Object o2) {        if(o1 instanceof User2 && o2 instanceof User2){            User2 u1= o1;            User2 u2= o2;            int sum=u1.age-u2.age;            if(sum==0){                return u1.name.compareTo;            }            return sum;        }        throw new ClassCastException("不是User2 类型");    }    }

运转结果:

User2 [name=张三01, age=10]:11User2 [name=张三01, age=12]:11User2 [name=张三02, age=13]:11

本文由金沙澳门官网送注册58发布于编程应用,转载请注明出处:Map群集概述和特征

关键词:

上一篇:没有了
下一篇:没有了