Map接口和实现类

Map集合接口规范概述

Map接口是存储键值对象的顶级集合接口。存储在Map集合中的键值对象必须确保每个键是不重复的;对于相同的键对象在添加到Map中时会产生覆盖源键值对象操作。

在通常情况下Map通过一个唯一的键查找其对应的值对象，键和值必需同时成对出现，一个键对应一个值对象。

在很多情况下可以使用Map对象替代实体对象，这样可以在应用程序实体类比较多的情况下减少类的定义。

键是存储的数据名称，值是存储的数据本身。

Map集合接口常用方法

Object put(Object key,Object value) //往集合中放值，第一个参数是键，第二个参数是值。可以使用任何类型的对象作为键和值，多数情况下键是字符串
Object get(Object key) //通过键查找值，并返回这个键对应的值
boolean containsKey(Object key) //对于某一个键，查找他是否包含这个键
boolean containsValue(Object value) //判断是否包含value这个对象
int size() //获取当前键值对的大小

Set<K> keySet() //返回当前Map中所有键的集合，封装在一个Set中
Collection<V> values() //返回一个Map所有值的集合，封装成一个Collection
boolean isEmpty() //Map是否为空
V remove(Object key) //移除key这个键值对象，键和值都移除，返回一个值对象的引用，也就是值对象的指针或句柄
void clear() //清空Map集合中的键值

HashMap集合实现类

HashMap是基于哈希表算法的Map接口的实现类。此实现类提供所有可选的映射操作，允许使用null值和null键。HashMap不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap不是线程安全的，如果在多线程中使用必需在程序中处理同步问题。

import java.util.Date;

/**
 * 汽车实体类
 */
public class Car {

    private String brand; //品牌
    private Date createDate; //生产日期
    private int horsepower; //马力
    private int speed; //时速

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public int getHorsepower() {
        return horsepower;
    }

    public void setHorsepower(int horsepower) {
        this.horsepower = horsepower;
    }

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }
}

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

public class TestMap {

    public static void main(String[] args) {

        Map carMap=new HashMap();  //使用HashMap实现类构建一个Map对象

        //使用put 方法向map中添加数据对象
        Car car=new Car();
        car.setBrand("奥迪");
        car.setCreateDate(new Date());
        car.setHorsepower(4);
        car.setSpeed(175);

        Car car2=new Car();
        car2.setBrand("大众");
        car2.setCreateDate(new Date());
        car2.setHorsepower(4);
        car2.setSpeed(205);

        Car car3=new Car();
        car3.setBrand("羚羊");
        car3.setCreateDate(new Date());
        car3.setHorsepower(3);
        car3.setSpeed(200);

        Car car4=new Car();
        car4.setBrand("宝马");
        car4.setCreateDate(new Date());
        car4.setHorsepower(5);
        car4.setSpeed(275);

        //使用put 方法向map中添加数据
        carMap.put("c0",car);
        carMap.put("c2",car2);
        carMap.put("c3",car3);
        carMap.put("c4",car4);

        //使用get方法按照给定的key查找所对应的值对象
        Object obj=carMap.get("c0");
        if(obj!=null){

            System.out.println(((Car) obj).getBrand()+"\t"+((Car) obj).getHorsepower());
        }else {

            System.out.println("未找到");
        }
    }
}
运行结果：奥迪 4

 　　　　//获取Map集合所有键值
        Set keySet=carMap.keySet();
        for (Object k:keySet) {

            System.out.println(((Car) carMap.get(k)).getBrand()+"\t"+((Car) carMap.get(k)).getSpeed());
        }

 　　　　//获取所有值对象
        Collection collection=carMap.values();

        for (Object c:collection) {

            System.out.println(((Car)c).getBrand()+"\t"+((Car)c).getSpeed());
        }

　　　　 /*移除键值对象*/        移除后会对应一个移除副本
        if (carMap.containsKey("c0")){
           Object removeobj=carMap.remove("c0");
            System.out.println(((Car)removeobj).getBrand()+"\t"+((Car)removeobj).getSpeed());
        }

 TreeMap集合实现类

基于红黑树（Red-Black tree）的NavigableMap实现。NavigableMap接口是SortedMap排序Map的子接口。

TreeMap基于树形结构的排序方式实现排序，TreeMap默认以键为依据采用自然顺序进行排序，或者根据创建映射时提供的Comparator进行排序，具体取决于使用的构造方法由于排序，通常此类比HashMap效率要低。

TreeMap不是线程安全的，在多线程中必需手动处理同步问题。

import com.Map.entity.Department;

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

class TestTreeMap {

    public static void main(String[] args) {

        TreeMap depTree=new TreeMap(new Comparator() {        //比较匿名内部类采用降序
            @Override
            public int compare(Object k1, Object k2) {

                Integer intK1=(Integer)k1;
                Integer intK2=(Integer)k2;
                if(intK1.intValue()>intK2.intValue())
                    return -1;
                else if(intK1.intValue()<intK2.intValue())
                    return 1;
                return 0;
            }
        });

        Department dep=new Department();
        dep.setCode("dep100");
        dep.setName("研发部");
        dep.setQuantity(20);

        Department dep2=new Department();
        dep2.setCode("dep200");
        dep2.setName("采编部");
        dep2.setQuantity(40);

        Department dep3=new Department();
        dep3.setCode("dep300");
        dep3.setName("广告部");
        dep3.setQuantity(120);

        Department dep4=new Department();
        dep4.setCode("dep400");
        dep4.setName("经理部");
        dep4.setQuantity(10);

        depTree.put(new Integer(100),dep);
        depTree.put(new Integer(50),dep2);
        depTree.put(new Integer(80),dep3);
        depTree.put(new Integer(10),dep4);

        Set deoKey=depTree.keySet();
        for (Object d:deoKey) {

            System.out.println(((Department)depTree.get(d)).getCode()+"\t"+((Department)depTree.get(d)).getName());
        }
    }
}

Hashtable集合实现类

Hashtable类实现一个哈希表，该哈希表将键映射到相应的值。任何非null对象都可以用作键和值。和HashMap不一样，Hashtable不予许存储空键和空值。

Hashtable与HashMap功能几乎相同的，最大区别在于HashMap是非线程同步的，而Hashtable是线程同步的，在多线程中通常使用同步的Hashtable。

由于Hashtable要考虑线程同步问题，因此Hashtable执行效率要比HashMap低。在非多线程中提倡使用HashMap存储键值对象，从而提高性能。

import java.util.*;

public class TestHashtable {

    public static void main(String[] args) {

        Scanner scanner=new Scanner(System.in);

        System.out.println("请输入三个学生信息");
        List stuList=new ArrayList();  //存储学生类信息
        for(int i=1;i<=3;i++){
            Map stuMap=new HashMap(); //使用Map替代学生实体数据类
            System.out.println("请输入第"+i+"学生信息");
            System.out.println("请输入学生姓名：");
            String name=scanner.next();
            stuMap.put("stuName",name);
            System.out.println("请输入学生性别：");
            String sex=scanner.next();
            stuMap.put("stuSex",sex);
            System.out.println("请输入学生年龄：");
            int age=scanner.nextInt();
            stuMap.put("stuAge",age);
            stuList.add(stuMap);  //将学生对象（Map实例）添加到List集合中
        }

        for(Object o:stuList){

            System.out.println(((HashMap)o).get("stuName")+"\t"+((HashMap)o).get("stuSex")+"\t"+((HashMap)o).get("stuAge"));
        }
    }
}

总结

　　Java中常用的3种集合接口

　 List是有序，Set是无序，Map是键值。使用哪个根据企业实际情况来定。