Map接口常用的子类

Map接口常用的子类:

HashMap: 无序存放的，是新的操作类，key值不允许重复

Hashtable: 无序存放的，是旧的操作类，key值不允许重复

TreeMap: 可以排序的Map集合，按集合中的key排序，key不允许重复

IdentityHashMap: key可以重复的Map集合

HashMap:

package com.map;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashMapDemo01 {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("ZY", "www.baidu.com");
        map.put("YQ", "www.google.com");
        map.put("LS", "www.360.com");
        /*String str = map.get("YQ");
        System.out.println(str);*/
        System.out.println(map.get("YQ"));

        if(map.containsKey("YQ")){
            System.out.println("搜索的key存在！");
        }else{
            System.out.println("搜索的key不存在！");
        }

        if(map.containsValue("www.google.com")){
            System.out.println("搜索的Value存在！");
        }else{
            System.out.println("搜索的Value不存在！");
        }

        Set<String> keys = map.keySet();
        Iterator<String> iter1 = keys.iterator();
        System.out.printf("输出所有的key:");
        while(iter1.hasNext()){
            System.out.printf(iter1.next()+"、");
        }

        Collection<String> values = map.values();
        Iterator<String> iter2 = values.iterator();
        System.out.print("\n输出所有的values:");
        while(iter2.hasNext()){
            System.out.printf(iter2.next()+"、");
        }
    }

}

从运行结果可以看出存放数据的时候没有进行排序

www.google.com
搜索的key存在！
搜索的Value存在！
输出所有的key:ZY、LS、YQ、
输出所有的values:www.baidu.com、www.360.com、www.google.com、

Hashtable:

package com.map;

import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class HashTableDemo01 {
    public static void main(String[] args) {
        Map<String,String> map = new Hashtable<String,String>();
        map.put("ZY", "www.baidu.com");
        map.put("YQ", "www.google.com");
        map.put("LS", "www.360.com");
        System.out.println(map.get("YQ"));

        if(map.containsKey("YQ")){
            System.out.println("搜索的key存在!");
        }else{
            System.out.println("搜索的key不存在!");
        }

        if(map.containsValue("www.google.com")){
            System.out.println("搜索的value存在!");
        }else{
            System.out.println("搜索的value不存在!");
        }

        Set<String> keys = map.keySet();
        Iterator<String> iter = keys.iterator();
        System.out.printf("输出所有的keys:");
        while(iter.hasNext()){
            System.out.printf(iter.next()+"、");
        }

        Collection<String> values = map.values();
        Iterator<String> iter2 = values.iterator();
        System.out.printf("\n输出所有的values:");
        while(iter2.hasNext()){
            System.out.printf(iter2.next()+"、");
        }
    }

}

从运行结果可以看出存放数据的时候没有进行排序

www.google.com
搜索的key存在!
搜索的value存在!
输出所有的keys:LS、ZY、YQ、
输出所有的values:www.360.com、www.baidu.com、www.google.com、

HashMap与Hashtable的区别：

序号 比较点 ArrayList Vector
1 推出时间 JDk1.2之后推出，属于新的操作类 JDK1.时推出的，属于旧的操作类
2 性能 采用异步处理方式，性能更高 采用同步处理方式，性能更低
3 线程安全 属于非线程安全的操作类 属于线程安全的操作类
4 输出 key或value允许保存null key或value不允许保存null

TreeMap:最终保存在Map中的数据是经过排序的数据，按其key排序

package com.map;

import java.util.TreeMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class TreeMap {
    public static void main(String[] args) {
        Map<String,String> map = new TreeMap<String,String>();
        map.put("ZY", "www.baidu.com");
        map.put("YQ", "www.google.com");
        map.put("LS", "www.360.com");
        Set<String> keys = map.keySet();
        Iterator<String> iter = keys.iterator();

        while(iter.hasNext()){
            String str = iter.next();
            System.out.println(str+"-->"+map.get(str));
        }
    }

}

Iterator输出Map:

package com.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class IteratorMapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();        //声明Map对象，并实例化Map对象
        map.put("ZY", "www.baidu.com");                               //添加内容
        map.put("YQ", "www.google.com");
        map.put("LS", "www.360.com");
        Set<Map.Entry<String, String>> allSet = map.entrySet();       //声明一个Set集合指定泛型，将Map接口实例变为Set接口实例
        Iterator<Map.Entry<String, String>> iter = allSet.iterator(); //声明Iterator对象，并实例化Iterator
        while(iter.hasNext()){ 

            Map.Entry<String, String> mp = iter.next();                //找到Map.Entry实例
            System.out.println(mp.getKey()+"-->"+mp.getValue());       //输出key、value、

        }
    }

}
ZY-->www.baidu.com
LS-->www.360.com
YQ-->www.google.com

Foreach输出Map:将集合中的每个元素通过Map.Entry类型的对象进行所接收，然后进行key与value的分离

package com.map;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

public class ForeachMapDemo {
    public static void main(String[] args) {
        Map<String,String> map = new HashMap<String,String>();
        map.put("ZY", "www.baidu.com");
        map.put("YQ", "www.google.com");
        map.put("LS", "www.360.com");
        for(Entry<String, String> mp:map.entrySet()){
            System.out.println(mp.getKey()+"-->"+mp.getValue());
        }
    }

}
ZY-->www.baidu.com
LS-->www.360.com
YQ-->www.google.com

String-->Person的映射:

package com.map;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String toString(){
        return "name:"+this.name+","+"age:"+this.age;
    }

}

public class String_PersonDemo {
    public static void main(String[] args) {
        Map<String,Person> map = new HashMap<String,Person>();
        map.put("YQ", new Person("QQ",20));
        map.put("ZY", new Person("PP",30));
        map.put("LS", new Person("HH",25));
        System.out.println(map.get("YQ"));

        Set<String> keys = map.keySet();
        Iterator<String> iter1 = keys.iterator();
        System.out.println("输出所有的person:");
        while(iter1.hasNext()){
            String str = iter1.next();
            System.out.println(map.get(str)+"、");
        }
    }

}
name:QQ,age:20
输出所有的person:
name:PP,age:30、
name:HH,age:25、
name:QQ,age:20、

Person-->String的映射:

package com.map;

import java.util.HashMap;
import java.util.Map;

class Person2{
    private String name;
    private int age;

    public Person2(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String toString(){
        return "name:"+this.name+","+"age"+this.age;
    }

}

public class Person_StringDemo {
    public static void main(String[] args) {
        Map<Person2,String> map =new HashMap<Person2,String>();
        Person2 per = new Person2("YQ",20);
        map.put(per,"YQ");
        System.out.println(map.get(per));
    }

}
YQ
package com.map;

import java.util.HashMap;
import java.util.Map;

class Person3{
    private String name;
    private int age;

    public Person3(String name,int age){
        this.name=name;
        this.age=age;
    }

    public boolean equals(Object obj){          //覆写equals()方法
        if(this==obj){                          //判断地址是否相同
            return true;                        //返回true表示同一对象
        }
        if(!(obj instanceof Person3)){          //传递进来的不是本类的对象
            return false;                       //返回false表示不是同一类对象
        }

        Person3 p = (Person3) obj;              //向下转型
        if(this.name.equals(p.name) && this.age==p.age){//属性依次比较，相等返回true
            return true;
        }else{
            return false;                       //属性内容不相等返回false
        }
    }

    public int hashCode(){                      //覆写hashCode()方法
        return this.name.hashCode()*this.age;   //计算公式
    }

    public String toString(){                   //覆写toString()方法
        return "name:"+this.name+","+"age"+this.age;//返回信息
    }

}

public class Person_StringDemo02 {
    public static void main(String[] args) {
        Map<Person3,String> map =new HashMap<Person3,String>();
        Person3 per = new Person3("YQ",20);
        map.put(per,"YQ");
        System.out.println(map.get(per));
    }

}
YQ

IdentityHashMap:key值可以重复

package com.maps;
//key值可以重复的Map集合IdentityHashMap
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

class Person{
    private String name;
    private int age;

    public Person(String name,int age){
        this.name=name;
        this.age=age;
    }

    public boolean equals(Object obj){
        if(this==obj){
            return true;
        }
        if(!(obj instanceof Person)){
            return false;
        }

        Person p = (Person) obj;
        if(this.name.equals(p.name)&&this.age==p.age){
            return true;
        }else{
            return false;
        }
    }

    public int hashCode(){
        return this.name.hashCode()*this.age;
    }

    public String toString(){
        return "name:"+this.name+","+"age"+this.age;
    }

}

public class IdentityHashMapdemo01 {
    public static void main(String[] args) {
        Map<Person,String> map =new IdentityHashMap<Person,String>();//只要地址不相同,Key1!=key2,就表示不是相同的key
        /*Map<Person,String> map =new HashMap<Person,String>();    HashMap(),key1=key2则会被覆盖*/
        map.put(new Person("YQ",20),"1");
        map.put(new Person("YQ",20),"2");
        map.put(new Person("QQ",22),"3");
        map.put(new Person("PP",20),"4");

        Set<Map.Entry<Person, String>> allSet = map.entrySet();
        Iterator<Map.Entry<Person, String>> iter = allSet.iterator();
        while(iter.hasNext()){
            Map.Entry<Person, String> p = iter.next();
            System.out.println(p.getKey()+","+p.getValue());
        }

    }

}
name:QQ,age22,3
name:YQ,age20,2
name:PP,age20,4
name:YQ,age20,1

认真看过此篇的小伙伴，如果对你有收获，请点击旁边的小手推荐一下，如果有误，欢迎指正，谢谢！

版权声明：此篇为本人原创，转载请标明出处https://www.cnblogs.com/YQian/p/10880654.html

我的博客园地址：https://www.cnblogs.com/YQian/

原文地址：https://www.cnblogs.com/YQian/p/10880654.html

时间： 2024-10-22 07:37:00

Map接口常用的子类的相关文章

Map接口及其子类

Map接口操作的是一对对象,即二元偶对象,Map接口中的每个元素都使用"key--value"的形式存储在集合中. SortedMap接口是排序接口,只要是实现了此接口的子类,都属于排序的子类.TreeMap就是此接口的一个子类 Map接口常用的子类: HashMap:无序存放,新的操作类,key不允许重复 Hahtable:无序存放,旧的操作类,key不允许重复 TreeMap:可以排序的Map集合,按集合的key排序,key不允许重复 WeakHashMap:弱引用的Map集合,清

Java学习（Map接口）

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

Java基础中map接口和实现类

1.Map接口常用的实现类有HashMap和TreeMap. 2.HashMap类实现的Map集合对于添加和删除映射关系效率更高.HashMap是基于哈希表的Map接口的实现,HashMap通过哈希码对其内部的映射关系进行快速查询,由HashMap类实现的Map集合对于添加或删除映射关系效率较高. 3.TreeMap中的映射关系存在一定的顺序,如果希望Map集合中的对象存在一定的顺序,该使用TreeMap类实现Map集合. HashMap类 ①此类不保证映射的顺序,特别是不保证该顺序恒久不变 ②

Java中Map接口和其常用子类

一.Map接口常用方法 public V put(K key,V value):向集合中保存数据: public V get(Object key):根据key查找对应的value数据: public Set<K> keySet():取出全部的key,返回一个set集合: public Set<Map.Entry<K,V>> entrySet():将Map集合转化为set集合: 二.常用子类 1.public class HashMap<K,V> exten

Java中集合框架，Collection接口、Set接口、List接口、Map接口，已经常用的它们的实现类，简单的JDK源码分析底层实现

(一)集合框架: Java语言的设计者对常用的数据结构和算法做了一些规范(接口)和实现(实现接口的类).所有抽象出来的数据结构和操作(算法)统称为集合框架. 程序员在具体应用的时候,不必考虑数据结构和算法实现细节,只需要用这些类创建一些对象,然后直接应用就可以了,这样就大大提高了编程效率. (二)集合框架包含的内容: (三)集合框架的接口(规范)   Collection接口:存储一组不唯一,无序的对象 List接口:存储一组不唯一,有序的对象 Set接口:存储一组唯一,无序的对象 Map接口:

JAVA集合详解(Collection和Map接口)

在Java的util包中有两个所有集合的父接口Collection和Map,它们的父子关系:            java.util        +Collection 这个接口extends自 --java.lang.Iterable接口           +List 接口               -ArrayList 类              -LinkedList 类              -Vector 类     此类是实现同步的 +Queue 接口         

JAVA中Collection接口和Map接口的主要实现类

Collection接口 Collection是最基本的集合接口,一个Collection代表一组Object,即Collection的元素(Elements).一些Collection允许相同的元素而另一些不行.一些能排序而另一些不行.Java SDK不提供直接继承自Collection的类,Java SDK提供的类都是继承自Collection的“子接口”如List和Set. 所有实现Collection接口的类都必须提供两个标准的构造函数:无参数的构造函数用于创建一个空的Collectio

Map接口

Map接口和Collection有一定区别 1.保存形式: key->value的方式保存 例:张三 15953111111 2.常用子类 HashMap:无序存放,key不允许重复 HashTable:无序存放,key不允许重复 在以Map存放数据的时候,key都是唯一的 3.常用方法 put(Object key,Object value) 存入元素 boolean containsKey(Object key) 判断key是否存在 boolean containsValue(Object

MapDemo1+2 Map接口的常用方法及遍历 及HashMap原理

MapDemo1 Map接口的常用方法 /** * java.util * Map接口<K,V> 类型参数: K - 此映射所维护的键的类型 V - 映射值的类型 定义: Map是一个接口,又称作查找表 java提供了一组可以以键值对(key-value)的形式存储数据的数据结构, 这种数据结构成为Map.我们可以看成是一个多行两列的表格,一列是存放key,一列存放value. 而每一行就相当于一组 key-value对,表示一组数据. 注意: 1.Map对存入元素有一个要求,就是key不能重