精华内容
下载资源
问答
  • 常用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();
    	}
    
    }
    
    
    展开全文
  • 常用集合有哪些

    万次阅读 多人点赞 2018-09-07 15:56:11
    常用的三大类集合:Set、List、Map。 1 Set 1) Set 集合属于单列集合,不允许包含重复元素; 2) 判断元素是否重复的标准为对象的 equals 方法,存在时返回 false,不存在返回 true; 3) 元素的排序规则,由相应...

    常用的三大类集合:Set、List、Map。


    1 Set

    1) Set 集合属于单列集合,不允许包含重复元素;
    2) 判断元素是否重复的标准为对象的 equals 方法,存在时返回 false,不存在返回 true;
    3) 元素的排序规则,由相应的实现类决定,分为无序、元素大小排序、写入顺序排序;
    4) 初始化大小,扩容参考 HashMap。
    

    1.1 Set 接口、实现类:

    名称 类型 线程同步 描述
    Set 接口 继承了Collection接口
    SortedSet 接口 继承了Set接口
    HashSet 实现类 不同步 继承了AbstractSet类,实现了Set、Cloneable、Serializable接口
    TreeSet 实现类 不同步 继承了AbstractSet类,实现了NavigableSet(继承了SortedSet)、Cloneable、Serializable接口
    LinkedHashSet 实现类 不同步 继承了HashSet类,实现了Set、Cloneable、Serializable接口

    1.2 HashSet

    1) HashSet 实现了 Set 接口,继承了 AbstractSet 类,由哈希表支持,看源码可以发现是一个 HashMap 实例。
    2) HashSet 不保证集合内元素的迭代顺序,特别是不保证迭代顺序永久不变,该集合运行 null 元素存在。
    3) HashSet 中的元素,作为 HashMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    4) HashSet 默认初始化大小为 16,扩容加载因子为 0.75,扩容大小为原来的一倍。即一个初始化size为16的
       HashSet,元素添加到12个的时候会进行扩容,扩容后的大小为32。
    备注:具体添加、读取、删除等规则需要参考 HashMap 的具体实现。
    

    1.3 TreeSet

    1) TreeSet 实现了 NavigableSet 接口,继承了AbstractSet类,由哈希表支持,看源码可以发现是一个 TreeMap 实例。
    2) TreeSet 中的元素有序的,排序规则遵照元素本身的大小进行排序,元素不能重复。
    3) TreeSet 中的元素,作为 TreeMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    备注:具体添加、读取、删除等规则需要参考 TreeMap 的具体实现。
    

    1.4 LinkedHashSet

    1) LinkedHashSet 实现了 Set 接口,继承了HashSet类,由哈希表支持,看源码可以发现是一个 LinkedHashMap 实例。
    2) LinkedHashSet 中的元素有序的,排序规则遵照元素写入顺序进行排序,元素不能重复。
    3) LinkedHashSet 中的元素,作为 LinkedHashMap 键值对的 Key 存储,而 Value 由一个统一的值保存。 
    备注:具体添加、读取、删除等规则需要参考 LinkedHashMap、HashMap 的具体实现,LinkedHashMap继承了HashMap。
    

    1.5 线程安全

    由于 HashSet、TreeSet、LinkedHashSet的底层实现为HashMap、TreeMap、LinkedHashMap,所以Set集合是非线程安全的。
    如果要实现 Set 集合的线程安全,可以使用 ConcurrentHashMap 实现一个Set集合。
    

    2 List

    1) List 集合属于单列、有序的、允许元素重复、可以为 null 的集合;
    2) List 接口的实现类主要有三种:ArrayList、LinkedList、Vector。
    

    2.1 List 接口、实现类:

    名称 类型 线程同步 描述
    List 接口 继承了Collection接口
    ArrayList 实现类 不同步 继承了AbstractList类,实现了List、RandomAccess、Cloneable、Serializable接口
    LinkedList 实现类 不同步 继承了AbstractSequentialList类,实现了List、Deque、Cloneable、Serializable接口
    Vector 实现类 同步 继承了AbstractList类,实现了List、RandomAccess、Cloneable、Serializable接口

    2.2 ArrayList

    1) ArrayList 实现了 List 接口,继承了 AbstractList 类,由一个 Object[] 实例实现,即底层为数组结构;
    2) 默认初始化长度为 10,扩容规则为 0.5倍的原容量加1,即一次扩容后的长度为 16;
    3) 特点:查询速度快,添加、删除相对于LinkedList较慢、线程不同步(不安全)。
    

    2.2 LinkedList

    1) LinkedList 实现了 List 接口,继承了 AbstractSequentialList 类,由一个 Node 节点链表实现,即底层为链表结构;
    2) 由于LinkedList 数据结构为链表,无预扩容机制;
    3) 特点:添加、删除速度快,查询相对于ArrayList较慢、线程不同步(不安全)。
    

    2.3 Vector

    1) Vector实现了 List 接口,继承了 AbstractList 类,由一个 Object[] 实例实现,即底层为数组结构;
    2) 默认初始化长度为 10,扩容加载因子为 1,当元素长度大于原容量时进行扩容,默认为 10,一次扩容后容量为 20;
    3) 特点:线程安全,但是速度慢;在实现的方法上,用 synchronized 关键字进行了修饰,即在方法上实现了同步锁。
    备注:具体实现细节请查看源码。
    

    3 Map

    1) Map 集合属于双列Key-value键值对的集合,Key不允许重复,是否允许为 null 根据实现类而定,Value 随意;
    2) Map 接口的实现类主要有三种:HashMap、LinkedHashMap、TreeMap、Hashtable、ConcurrentHashMap。
    

    3.1 Map 接口、实现类:

    名称 类型 线程同步 描述
    Map 接口
    HashMap 实现类 不同步 继承了AbstractMap类,实现了Map、Cloneable、Serializable接口
    LinkedHashMap 实现类 不同步 继承了HashMap类,实现了Map接口
    TreeMap 实现类 不同步 继承了AbstractMap类,实现了NavigableMap(继承了SortedMap)、Cloneable、
    Serializable接口
    Hashtable 实现类 同步 继承了Dictionary类,实现了Map、Cloneable、Serializable接口
    ConcurrentHashMap 实现类 同步 继承了AbstractMap类,实现了ConcurrentMap(继承了Map)、Serializable接口

    3.2 HashMap

    1) HashMap实现了 Map接口,继承了 AbstractMap类,数据结构采用的位桶数组,底层采用链表或红黑树进行存储;
    2) 默认初始化长度为 16,扩容加载因子为 0.75,一旦大于 0.75*16之后,就会调用resize()进行扩容,扩容2倍,即32;
    3) JDK1.7中,数据结构采用:位桶数组+链表结构;
       JDK1.8中,数据结构采用:位桶数组+(链表/红黑树);
    4) 支持克隆,无序,线程不同步,非安全。
    

    3.3 LinkedHashMap

    1) LinkedHashMap 实现了 Map 接口,继承了 HashMap 类;
       引用实现;
    3) 迭代顺序由 accessOrder 属性的决定,默认为 false,以插入顺序访问;设置为 true 则按上次读取顺序访问(每次访问
       元素时会把元素移动到链表末尾方便下次访问,结构会时刻变化)。
    4) 默认初始化长度为 16,扩容加载因子为 0.75,一旦>0.75*16之后,就会调用resize()进行扩容,与HashMap一致;
    5) 支持克隆,有序,线程不同步,非安全。
    

    3.4 TreeMap

    1) TreeMap实现了 NavigableMap接口,继承了 AbstractMap 类;
    2) 数据结构基于红黑树实现;
    3) 该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法;
    4) 无初始化长度;
    5) 支持克隆,有序,线程不同步,非安全。
    

    3.5 Hashtable

    1) Hashtable实现了 Map 接口,继承了 Dictionary类;
    2) 数据结构:也是一个散列表,数据结构与HashMap相同,key、value都不可以为 null;
    3) 该映射根据其键的自然顺序进行排序,或者根据创建映射时提供的 Comparator 进行排序,具体取决于使用的构造方法;
    4) 默认初始化长度为 11,扩容加载因子为 0.75,一旦>0.75*11之后,就会进行扩容,扩容到2n+1,即23;
    5) 支持克隆,无序,线程同步,安全。在实现的方法上,用 synchronized 关键字进行了修饰,即在方法上实现了同步锁。
    6) 支持 Enumeration 遍历方式。
    

    3.6 ConcurrentHashMap

    1) ConcurrentHashMap实现了 ConcurrentMap接口,继承了 AbstractMap类;
    2) 默认初始化长度为 16,扩容加载因子为 0.75,一旦大于 0.75*16之后,就会调用resize()进行扩容,扩容2倍,即32;
    3) 数据结构:由Segment数组结构和HashEntry数组结构组成,一个ConcurrentHashMap中包含一个Segment数组,
       Segment的结构和HashMap类似,是一种数组和链表结构。
    4) 使用了锁分段技术,Segment是一种可重入锁ReentrantLock,每个Segment拥有一个锁,当对HashEntry数组的
       数据进行修改时,必须先获得对应的Segment锁
    5) 不支持克隆,无序,线程同步,安全。
    
    展开全文
  • java.util.Map——Map集合常用方法

    万次阅读 多人点赞 2018-05-07 12:53:20
    开发中最常用的就是List集合和Map集合Map集合是基于java核心类——java.util中的;Map集合用于储存元素对,Map储存的是一对键值(key和value),是通过key映射到它的value;下面介绍的是Map集合的一些经常用到的...

    Java技术交流群:817997079,欢迎“有志之士”的加入。

    阿里云服务器优惠链接:https://www.aliyun.com/minisite/goods?userCode=epd6ezxj

    开发中最常用的就是List集合和Map集合,Map集合是基于java核心类——java.util中的;Map集合用于储存元素对,Map储存的是一对键值(key和value),是通过key映射到它的value;下面介绍的是Map集合的一些经常用到的方法以及代码示例。

    1.map.size();
    方法作用:获取map集合类的大小(map集合包含键值对关系映射的数量)
    示例:

    public static void main(String[] args) {
            //new出map实例
           Map map = new HashMap();
            //向map实例中添加键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
            //返回值为int类型
            int size = map.size();
    	//输出size
    	System.out.println("map实例中的键值个数为:"+size);
    
    
         }
    

    2.map.values();
    方法作用:获取map集合类所有的值(value)

    示例:

    public static void main(String[] args) {
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//得到map实例中所有的value,返回值类型为Collection
    	Collection values = map.values();
    	//输出values
    	System.out.println("map实例中所有的值(value)为"+values);
        }

    3.map.keySet();
    方法作用:获取map集合所有的键(key)
    示例

    public static void main(String[] args) {
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//获取map实例中所有的键(key),返回值类型为Set
    	Set set = map.keySet();
    	//输出set
    	System.out.println("map实例中所有的key为:"+set);
        }

    4.map.get();//形参为key的名字
    方法作用:通过键(key)的名字获取和键相匹配的值(方法映射),如果key或者value为空,则返回null;
    示例:

    public static void main(String[] args) {
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//通过key获取value
    	Object o = map.get("1");
    	//输出o
    	System.out.println("得到的value为:"+o);
        }

    5.map.remove()//形参为key
    方法作用:根据key移除map中的与该key对应的value
    示例:

    public static void main(String[] args) {
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加了3个键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//移除key为1的键值
    	map.remove("1");
    	//输出map的大小
    	System.out.println("移除后的map大小为:"+map.size());//此处输出为2
        }

    6.map.clear();//形参为空,返回值为空
    方法作用:清空Map集合中所有的键值
    示例:

    public static void main(String[] args) {
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加了3个键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//清空map的键值
    	map.clear();
    	//输出map的大小
    	System.out.println("清空后的map大小为:"+map.size());//此处输出为0
        }

    7.Entry
    作用:Entry是Map集合中的一个内部接口,用于封装Map集合中的一组键值(key和value)
    jdk1.5新特性之前的写法为Map.entry<k,v>,jdk1.5的新特性静态导入的导包方式写法为Entry,两种写法达到的效果一致,并没有什么不同。
    前者为父类引用指向子类对象,后者是直接调用子类对象。
    示例:

    public static void main(String[] args) {
    	//获取Map内部接口Entry
    	Entry entry;
            //new出map实例
            Map map = new HashMap();
            //向map实例中添加键值
            map.put("1","飞机");
            map.put("2","坦克");
            map.put("3","大炮");
    	//获得map中键值对的集合
            Set set = map.entrySet();
            //得到集合的迭代器
            Iterator iterator = set.iterator();
            //遍历迭代器
            while (iterator.hasNext()){
                //遍历出的键值放进entry集合里
                entry=(Map.Entry) iterator.next();
                //得到entry的key
                String key = (String) entry.getKey();
                //得到entry的value
                String value = (String) entry.getValue();
    	    //输出key和value
                System.out.println("得到的key为"+key);
                System.out.println("得到的value为"+value);
            }
    	
         }

    8.map.putAll()//形参为map集合
    方法作用:把一个map集合合并到另一个map集合里
    示例:

    public static void main(String[] args) {
            //new出map1实例
            Map map1 = new HashMap();
            //向map1实例中添加了3个键值
            map1.put("1","飞机");
            map1.put("2","坦克");
            map1.put("3","大炮");
    	//输出map1的大小
    	System.out.println("map1的大小为:"+map1.size());//此处输出为3
    	//new出map2实例
            Map map2 = new HashMap();
            //向map2实例中添加了2个键值
            map2.put("4","苹果");
            map2.put("5","香蕉");
    	//输出map2的大小
    	System.out.println("map2的大小为:"+map2.size());//此处输出为2
    	//把map2合并到map1里
    	map1.putAll(map2);//合并时如果map2的key与map1的key有重复的,则map2的键值覆盖与map1重复的键值
    	System.out.println("合并后的map1大小为:"+map1.size());//此处输出为5
    	
        }

    9.JDK8新特性新增的lambda表达式遍历Map的方法——Map.forEach();

    public static void main(String[] args) {
    		Map<String,String> map = new HashMap<>();
    		map.put("1","飞机");
    		map.put("2","坦克");
    		map.put("3","大炮");
    		map.forEach((k,v)-> {
    		    System.out.println(k+":"+v);
    		});
    	}

    以上是我总结的一些Map基本的常用的方法,一般是用来封装参数的,希望可以对大家有些帮助,也算是自己的一个笔记。

                                                                                                                       ————————————纯属原创,不喜勿喷。

     

    展开全文
  • Map集合常用方法

    千次阅读 2018-05-14 21:35:35
    /* SortedSet和TreeSet需要写一个类实现conparable,或者写一个比较器 HashMap和Hashtable需要重写HashCoed和equals方法 Map是一对一对存储的,Collection是一个一个存储的 Map集合常用的方法 void clear() ...
    /*
    SortedSet和TreeSet需要写一个类实现conparable,或者写一个比较器
    HashMap和Hashtable需要重写HashCoed和equals方法

    Map是一对一对存储的,Collection是一个一个存储的

    Map集合中常用的方法
    void clear() 清空map 
      boolean containsKey(Object key)  判断Map中是否包含这样的Key
      boolean containsValue(Object value) 判断Map中是否包含这样的Value
    Set<Map.Entry<K,V>> entrySet() 
     
      V get(Object key)  //通过Key获取Value
      boolean isEmpty()  判断该集合是否为空
     
      Set<K> keySet() 获取Map中所有的Key 
      V put(K key, V value)  向集合中添加键值对
      V remove(Object key)   通过key将键值对删除
      Collection<V> values()   获取所有的value
     
      注意:存储在Map集合Key部分的元素需要同时重写hashCode+equals方法


    */
    import java.util.*;


    public class fuck13{

    public static void main(String[] args){

    //1.创建Map集合
    //HashMap的默认初始化值是16,默认加载因子是0.75
    Map persons =new HashMap();

    //2.存储键值对
    persons.put("10000","jack");
    persons.put("13000","luck");
    persons.put("10400","tom");
    persons.put("10020","lucy");
    persons.put("10200","kim");
    persons.put("10000","lisa");

    //3.判断键值对的个数
    //Map中的Key是无序不可重复的,和HashCode相同
    System.out.println(persons.size());//5

    //4.判断集合中是否包含这样的Key
    System.out.println(persons.containsKey("10000"));//true

    //5.判断集合中是否包含这样的Value
    //注意:Map中如果Key重复了,value采用的是覆盖
    System.out.println(persons.containsValue("lisa"));//true

    //6.通过Key获取Value
    Object v=persons.get("10200");
    System.out.println(v);

    //7.通过Key删除键值对
    persons.remove("10200");
    System.out.println(persons.size());//4

    //8.获取所有的value
    Collection values=persons.values();
    Iterator it=values.iterator();
    while(it.hasNext()){
    System.out.println(it.next());
    }

    //9获取所有的Key
    //以下程序演示如何遍历Map集合
    Set Keys=persons.keySet();
    Iterator it1=Keys.iterator();
    while(it1.hasNext()){
    Object no=it1.next();
    Object name=persons.get(no);
    System.out.println(no+"-->"+name);
    }

    //10.entrySet
    //将Map转换成Set集合
    Set set=persons.entrySet();
    Iterator it2=set.iterator();
    while(it2.hasNext()){
    System.out.println(it2.next());
    }

    }


    }



    展开全文
  • Map集合 map集合也被称呼为:双列集合 map集合与单列集合是不同的,在单列集合中,每个元素都是孤立存在的,在向集合存储元素时采用一个个元素的方式存储,而双列集合中的元素是成对出现的,每个元素都是由两部分组成,前面...
  • Map集合方法及常用实现类

    千次阅读 2017-05-23 10:39:23
    一、常用方法 1.添加: map.put(key,value) //在key位置上存储value值,key存在则覆盖原有值;...//将Map集合m放在map中 2.删除: map.clear(); //清空map中的数据 map.remvoe(key); //删除key及其位置上的元素,返
  • 文章目录Map的常见集合...HashMap是最常用Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值,具有很快的访问速度,遍历时,取得数据的顺序是完全随机的。因为键对象不可以重...
  • 遍历map集合常用的4种方式

    千次阅读 2019-03-09 23:48:12
    之前面试被问到遍历map集合有几种方式:现做常见的4种遍历方式: @Test public void testMap() { Map&lt;String, Integer&gt; map = new HashMap&lt;String, Integer&gt;(); map.put("01&...
  • JAVA中Map集合常用的方法

    千次阅读 2017-05-31 17:00:58
    我们通过查看Map接口描述,发现Map接口下的集合与Collection接口下的集合,它们存储数据的形式不同,如下图。 A:Collection中的集合,元素是孤立存在的(理解为单身),向集合中存储元素采用一个个元素的方式存储 ...
  • Map集合的value()方法
  • * public V put (K key,V value):把键与值添加到Map集合中 * public V remove (Object key):删除key对应的值 * public V get(Object key):根据指定的键,获取对应的值 * public V containKey(Object ...
  • 常用集合有哪些?比如List如何排序? Set、List、Map.png Java中常用集合类 对于集合,大家都不陌生了,常见的集合接口Set、List、Map等,其中Set和List继承自Collection。 Collection是一组对象的集合...
  • Map集合

    千次阅读 2019-05-15 15:38:42
    Map 集合的特点 能够存储唯一的列数据(唯一,不可重复)set 能够存储可以重复的数据(可重复)list 值的顺序取决于键的顺序 键和值都是可以存储 null 元素的 一个映射不能包含重复的键,每个键最多只能映射一个值 ...
  • 集合主要Collection和Map接口。 List特点:元素放入顺序,元素可重复 Map特点:元素按键值对存储,无放入顺序 Set特点:元素无放入顺序,元素不可重复(注意:元素虽然无放入顺序,但是元素在set中的位置是该...
  • Set集合和Map集合

    千次阅读 2019-12-07 10:05:35
    Set接口和Map接口 回顾 1 集合概念,用来存储一组数据的容器。和数组类似,数组是长度固定的,集合长度可以变化。数组能存储基本类型和引用类型,集合只能存储引用类型。 2 Collection接口,父接口, add() remove()...
  • java常用对象Map集合中关于取出元素的说明 之前在上一篇《java常用对象API中集合框架之Map的用法》文章中简单的例举了一些Map集合中的一些简单方法和一些常用的子类,那么本章将对例举的方法和子类进行一一的详细...
  • map集合排序

    千次阅读 2019-05-05 20:32:59
    今天做统计时需要对X轴的地区按照地区代码(areaCode)进行排序,由于在构建XMLData使用的map来进行数据统计的,所以在统计过程中就需要对map进行排序。...map是键值对的集合接口,它的实现类主要包...
  • Map集合的特点: 1. Map集合是一个双列集合,一个元素包含两个值(一个key,一个value) ; 2. Map集合中的元素,key和value的数据类型可以相同,也可以不同 ; 3. Map集合中的元素,key是不允许重复的,...
  • Map集合总结

    千次阅读 2013-03-12 23:38:06
    一:Map Map用于保存具有映射关系的数据,总是以键值对的方式存储数据。 Map继承树 ...Map集合的key和value都可以是任何引用类型的数据。Map集合的key不允许重复,value允许重复。key和value之间存在
  • Java Map集合

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

    万次阅读 多人点赞 2019-04-29 10:52:47
    java 有哪些常用容器(集合)? java 容器都有哪些? Collection | ├AbstractCollection 对Collection接口的最小化抽象实现 | │ | ├List 有序集合 | │-├AbstractList 有序集合的最小化抽象实现 | │...
  • 常用map集合遍历方式 一共分为四种这是用到的一些方法 方法 意思 Set keySet() 根据键找value值方式遍历集合 Set<Map.Entry<K,V>> entrySet() 获取键值对对象通过迭代器或增强for遍历取值 ...
  • springMVC中存储map集合原理

    千次阅读 2018-10-17 08:55:40
    在SpringMVC中,常用Map集合然后存入域中,然后发现在JSP中用EL取Map集合时取不到集合元素. 例如: 一般在JSP中用EL获取Map集合的写法为:${requestScope.map集合名.键名} 在SpringMVC在JSP中用EL获取Map集合的写法为 ...
  • Map集合——(1) 常用方法与MapSet

    千次阅读 2018-09-12 22:01:01
    package cn.itcast.p6.map.demo; import java.util.Collection; import java.util.HashMap; import java.util.Iterator...import java.util.Map; import java.util.Set; public class MapDemo { public static v...
  • Java Map集合面试题汇总

    千次阅读 2018-08-11 19:03:21
    1、 你都知道哪些常用Map集合? HashMap、HashTable、LinkedHashMap、ConcurrentHashMap。 2、Collection集合接口和Map接口什么关系? 没关系,Collection是List、Set父接口不是Map父接口。 3、HashMap是线程...
  • Map集合及其子类理解

    千次阅读 2018-08-05 19:41:23
    本文主要内容时Map集合和其子类HashMap与LinkedHashMap,包含格式以及一些特点和主要方法的使用,treeMap暂时没学到,没有对treeMap的介绍。 目录 Map集合 Map集合与Collection集合区别 Map常用子类 Map集合...
  • Java map集合深入学习

    万次阅读 多人点赞 2018-10-29 00:12:48
    常用集合类是 List 和 MapMap 提供了一个更通用的元素存储方法。Map 集合类用于存储元素对(称作“键”和“值”),其中每个键映射到一个值。 本文主要介绍java map的初始化、用法、map的四种常用的遍历...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 183,466
精华内容 73,386
关键字:

常用的map集合有哪些