Map集合接口

---恢复内容开始---

　　Collection集合的特点是每次进行单个对象的保存，那么如果现在要进行一对对象的保存（偶对象）就只能使用Map集合来完成，所以Map集合中会一次性保存两个，两个对线的关系：Key=value的结构，那么这种结构最大的特点是可以通过Key找到对应value内容。观察Map接口定义：

public interface Map<K,V>

　　在Map接口里面有如下几个方法：

　　　　向集合中追加数据：V put(K key,V value)

　　　　根据key取得对应的value如果没有key返回null：V get(Object key)

　　　　取得所有key的信息，key不能重复：Set<K> keySet()

　　　　取得所有的value 不关注内容是否重复：Collection<V> values()、

　　　　将我们的Map集合变为Set集合：Set<Map.Entry<K,V>> entrySet()

　　Map本身是一个接口，要使用Map必须通过子类来进行实例化对象，而子类有：HashMap，Hashtable，TreeMap，ConcurrentHashMap四个常用子类

HashMap子类（90%）

　　HashMap是在使用Map集合里面最为常用的一个子类了，下面先通过HashMap进行一个Map的使用操作

范例：Map的基本处理

 

package cn.Tony.demo;

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

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1, "Hello");
        map.put(1, "World");//key重复了
        map.put(2, "Tony");
        System.out.println(map);
        System.out.println(map.get(1));
        System.out.println(map.get(99));
        
    }
} 

 

范例：取得Map中的所有key的信息

package cn.Tony.demo;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1, "Hello");
        map.put(1, "World");//key重复了
        map.put(2, "Tony");
        Set<Integer> set=map.keySet();//取得所有key
        Iterator<Integer> iter=set.iterator();
        while(iter.hasNext()) {
            Integer key=iter.next();
            System.out.println(key+"="+map.get(key));
        }
    }
} 

　　此种操作没有任何实际意义，只是为了功能使用的说明，因为这样的输出处理复杂度太高。

面试题：请解释HashMap的原理

　　在数据量小的时候HashMap是按照链表的模式存储的。将数据量变大之后为了进行快速的查找，那么会将这个链表变为一个红黑树(均衡二叉树)，用hash码作为数据的定位来保存的。

Hashtable子类(1%)

　　JDK1.0提供有三大主要类：Vector，Enumeration，Hashtable。Hashtable是最早实现这种二元偶对象数据结构，后期设计的时候也让其Vector一样多实现了Map接口而已

范例：观察Hashtable

package cn.Tony.demo;
import java.util.Hashtable;
import java.util.Map;
public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Integer,String> map=new Hashtable<Integer,String>();
        map.put(1, "Hello");
        map.put(1, "World");//key重复了
        map.put(2, "Tony");
        System.out.println(map);
    }
} 

面试题：请解决HashMap与Hashtable的区别？

ConcurrentHashMap子类()

　　ConcurrentHashMap的特点=Hashtable的线程安全性+HashMap的高性能，在使用ConcurrentHashMap处理的时候既可以多个线程更新数据的同步，又可以保证高效的查询速度。

　　首先观察ConcurrentHashMap的子类定义:

public class ConcurrentHashMap<K,V> extends AbstractMap<K,V> implements ConcurrentMap<K,V>, Serializable

范例：使用ConcurrentHashMap

 

package cn.Tony.demo;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Integer,String> map=new ConcurrentHashMap<Integer,String>();
        map.put(1, "Hello");
        map.put(1, "World");//key重复了
        map.put(2, "Tony");
        System.out.println(map);
    }
}  

 

　　于是现在就需要分析一下ConcurrentHashMap的工作原理 

　　如果说现在采用一定的算法，将保持的大量数据平均分在不同的桶（数据区域 ），这样在进行数据查找的时候就可以避免掉这种全部的数据扫描。

范例：数据分桶

package cn.Tony.demo;
import java.util.Random;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        for(int x=0;x<10;x++) {
            new Thread(() -> {
                Random rand=new Random();
                int temp=rand.nextInt(9999);
                    int result=temp%3;
                    switch(result) {
                    case 0:
                        System.out.println("第【0】桶"+temp);
                        break;
                    case 1:
                        System.out.println("第【1】桶"+temp);
                        break;
                    case 2:
                        System.out.println("第【2】桶"+temp);
                        break;
                    }
            }).start();
        }
        
    }
}  

　　采用了分桶之后没一个数据中必须有一个明确的分桶的标记，很明显使用hashCode()。

使用Iterator输出Map集合(核心)

　　　在实际开发中，如果你存储数据是为了输出，那么优先考虑的一定是Collection 使用Map的主要操作就是设置内容，而后通过get()进行查找的。使用Map迭代输出的需求会有，但是不多，不过你们必须会，如果要想观察输出首先必须明确一点，Map接口没有Iterator()方法，通过一个简答的图形来观察Collection和Map保存数据的模型。

　　在Map接口里面有一个重要的方法，将Map集合转为Set集合：public Set<Map.Entry<K,V>>entrySet();

范例：通过Iterator输出Map集合

package cn.Tony.demo;

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

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Integer,String> map=new HashMap<Integer,String>();
        map.put(1, "Hello");
        map.put(2, "World");
        //1.将Map集合变为Set集合
        Set<Entry<Integer,String>> set=map.entrySet();
        //2.实例化Iterator接口
        Iterator<Entry<Integer,String>> iter=set.iterator();
        while(iter.hasNext()) {//3.迭代输出，取出每一个Map Entry对象
            Map.Entry<Integer, String> me=iter.next();//取出Map.Entry
            System.out.println(me.getKey()+"="+me.getValue());
        }
    }
}  

　　以上的形式相比较Collection(List Set)而言出现的几率不高,但是依然需要我们熟悉

Map中的key实现说明

　　在使用Map集合的时候之前使用的都是系统类作为了KEY（Integer），那么实际上用户也可以采用自定义的类作为Key（） 这个时候一定要记得覆写Object类中的hashCode与equals方法

　

package cn.Tony.demo;

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

class Person{
    private String name;
    public Person(String name) {
        this.name=name;
    }
    @Override
    public String toString() {
        return "姓名："+this.name;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        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;
        Person other = (Person) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }
}

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Map<Person,String> map=new HashMap<Person,String>();
        map.put(new Person("张三"), new String("zs"));
        System.out.println(map.get(new Person("张三")));
     }
}  

　　因为从实际的开发来讲，对于Map集合中的key的类型不是使用String就是Integer，浙西系统类都帮助用户覆写好hashCode equals方法了

TreeMap子类（）

　　TreeMap表示可以排序的Map子类，它是按照key的内容来进行排序的

范例：观察使用 

public class TestDemo{
    public static void main(String[] args) throws Exception {
//        Map<Person,String> map=new HashMap<Person,String>();
//        map.put(new Person("张三"), new String("zs"));
//        System.out.println(map.get(new Person("张三")));
        Map<Integer,String> map=new TreeMap<Integer,String>();
        map.put(2, "C");
        map.put(0, "X");
        map.put(1, "B");
        System.out.println(map);
    }
}  

　　这个时候的排序处理依然按照的是Comparable接口完成的。

总结：

1.Collection保存数据是为了输出，Map保存输出目的是为了根据Key查找 找不到的Key返回null

2.Map使用Iterator输出(Map.Entry的作用)

3.一些类的设计原理，这些是在你面试到的，开发就使用HashMap

Properties是Hashtable的子类，并且这个类定义：

public class Properties extendsHashtable<Object,Object>

　　所有的属性的信息实际上都是以字符串的形式出现的，在进行属性操作的时候往往会直接使用Properties子类完成：

　　　　设置属性：public Object setProperty(String key,String value)

　　　　取得属性：public String getProperty(String key) 如果没有指定的key返回的就是null

　　　　重载属性：public String getProperty(String key,String defaultValue)

范例：观察属性操作

 

package cn.Tony.demo;

import java.util.Properties;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Properties pp=new Properties();
        pp.setProperty("bj","Beijing");
        pp.setProperty("tj","TianJin");
        System.out.println(pp.getProperty("bj"));
        System.out.println(pp.getProperty("nj"));
    }
}   

 

　　在Properties类里面提供一个IO操作的方法：public void store(OutputStream out,String comments)throws IOException

　　读取属性：public void load(InputStream inStream)throws IOException

范例：将属性输出到文件

package cn.Tony.demo;

import java.io.File;
import java.io.FileOutputStream;
import java.util.Properties;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Properties pp=new Properties();
        pp.setProperty("bj","Beijing");
        pp.setProperty("tj","TianJin");
        pp.store(new FileOutputStream(new File("D:"+File.separator+"IO"+File.separator+"Hello.Properties")), "Tony Info");
    }
}   

范例：通过属性文件读取内容

 

package cn.Tony.demo;

import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;

public class TestDemo{
    public static void main(String[] args) throws Exception {
        Properties pp=new Properties();
        pp.load(new FileInputStream(new File("D:"+File.separator+"IO"+File.separator+"Hello.Properties")));
        System.out.println(pp.getProperty("bj"));
    }
}   

 

　　对于Properties而言，这种输入和输出不常见，主要使用他保存信息

总结

　　Properties只能操作String 它可以进行远程属性内容的加载。

 

---恢复内容结束---