容器的深入研究（二）—Set与Map

一、Set类的作用

二、Set类延生的四种形式

三、非基础类型如何使用Set的四种形式

四、Queue的使用

五、PriorityQueue的使用

六、Map的六种形式

七、HashMap散列码的实现

八、如何制作优秀的散列码

回答：

1、Set的特点：①、存入Set的每个元素在Set中都是唯一的  ②、输出的时候不保证元素的次序

2、Set延生的四种类型：

①、HashSet：为快速查找而设计的，存入Set的元素必须实现hashCode()方法

②、TreeSet:输出的时候保证元素的优先顺序（不是按照输入时候的顺序，而是根据元素的大小）。存入Set的元素必须实现Comparable接口

③、LinkedHashSet:具有HashSet快速查找的特性。还能够按照输入Set的顺序输出数据， 存入Set的元素必须实现hashCode()方法

④、SortedSet:对TreeSet的扩展，扩展了一些方法。（获取头，尾元素的方法。截取容器中部分元素的方法等）

3、对各种类型的使用。

步骤①、制作原始类TestType，制作HashCodeType继承TestType重写hashCode()方法，制作ComparableType继承TestType和Comparable接口

public class TestType {

    protected int index;
    public TestType(int index){
        this.index = index;
    }
    
    public int getIndex(){
        return index;
    }
    
    @Override
    public String toString() {
        return "TestType [index=" + index + "]";
    }
}

public class HashCodeType extends TestType {

    public HashCodeType(int index) {
        super(index);
        // TODO Auto-generated constructor stub
    }

    @Override
    public int hashCode() {
        // TODO Auto-generated method stub
        return index;
    }
    
    @Override
    public boolean equals(Object obj) {
        // TODO Auto-generated method stub
        //判断是否是相同类比较。
        if (obj instanceof TestType && ((TestType) obj).getIndex() == index){
            return true;
        }
        else {
            return false;
        }
    }
}

public class ComparableType extends TestType implements Comparable<ComparableType>{

    public ComparableType(int index) {
        super(index);
        // TODO Auto-generated constructor stub
    }

    @Override
    public int compareTo(ComparableType o) {
        // TODO Auto-generated method stub
        if (index > o.getIndex()){
            return -1;
        }
        else if (index == o.getIndex()){
            return 0;
        }
        else {
            return 1;
        }
    }
    
}

②、进行测试

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        fill(new HashSet<TestType>(), TestType.class);
        fill(new LinkedHashSet<HashCodeType>(), HashCodeType.class);
        fill(new TreeSet<>(), ComparableType.class);
    }
    
    public static <E> void fill(Set<E> set,Class<E> type ){
        for(int i=0; i<10; ++i){
                        //通过反射创建类
            try {
                Constructor<E> constructor = type.getConstructor(int.class);
                set.add(constructor.newInstance(i));
            } catch (NoSuchMethodException | SecurityException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InstantiationException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (IllegalArgumentException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 
        }
        System.out.println(set.toString());
    }
}

/**
*输出：
*[TestType [index=4], TestType [index=7], TestType [index=8], TestType [index=0], TestType [index=6], TestType [index=1], TestType [index=2], TestType [index=3], TestType [index=5], TestType [index=9]]
[TestType [index=0], TestType [index=1], TestType [index=2], TestType [index=3], TestType [index=4], TestType [index=5], TestType [index=6], TestType [index=7], TestType [index=8], TestType [index=9]]
[TestType [index=9], TestType [index=8], TestType [index=7], TestType [index=6], TestType [index=5], TestType [index=4], TestType [index=3], TestType [index=2], TestType [index=1], TestType [index=0]]
*/

四、Queue的使用

    ①、顾名思义按照先进先出的顺序执行。   ②、除了ProrityQueue不是按照该顺序执行

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //不介绍队列的种类，但要知道LinkedList是一个队列
        Queue<Integer> data = new LinkedList<>();
        for(int i=0; i<10; ++i){
            //添加数据
            data.offer(i);
        }
        //返回顶部数据
        while(data.peek() != null){
            //移除顶部数据，并返回该条数据
            System.out.println(data.remove()+"  ");
        }
    }

}

PriorityQueue的使用详解

①、需要继承Comparable接口，确定优先级  ②、可分为多层优先级（等会示例可以看到）

public class ProrityItem implements Comparable<ProrityItem>{

    public char firstPrority;
    public int secondPrority;
    private String name;
    
    public ProrityItem(char firstPrority, int secondPrority, String name) {
        this.firstPrority = firstPrority;
        this.secondPrority = secondPrority;
        this.name = name;
    }

    @Override
    public String toString() {
        return "ProrityItem [firstPrority=" + firstPrority + ", secondPrority="
                + secondPrority + ", name=" + name + "]";
    }

    @Override
    public int compareTo(ProrityItem o) {
        // TODO Auto-generated method stub
        //第一级优先级
        if (firstPrority > o.firstPrority){
            return 1;
        }
        else if (firstPrority == o.firstPrority){
            //第二层优先级
            if (secondPrority > o.secondPrority){
                return 1;
            }
            else if (secondPrority == o.secondPrority) {
                return 0;
            }
            else {
                return -1;
            }
        }
        else {
            return -1;
        }
    }
}

public class Main {
    public static void main(String[] args){
        PriorityQueue<ProrityItem> queue = new PriorityQueue<>();
        queue.add(new ProrityItem('B', 1, "你好"));
        queue.add(new ProrityItem('A', 6, "HaHa"));
        queue.add(new ProrityItem('A', 2, "Yes"));
                //不要用toString方法，数据结果不符
        while(queue.peek()!= null){
            System.out.println(queue.remove()+"  ");
        }
    }
}

/*
*ProrityItem [firstPrority=A, secondPrority=2, name=Yes]  
*ProrityItem [firstPrority=A, secondPrority=6, name=HaHa]  
*ProrityItem [firstPrority=B, secondPrority=1, name=你好]  
*
*/    

五、Map

Map的种类：

HashMap、TreeMap、

LinkedHashMap：首次查询输出时候按照插入的顺序，   注意：当查找的时候，查询次数高的会被排在后面，查询次数少的会被排在前面。

举例：就是我存入了1 ，2 ，3   当一开始查询 时候输出是1 ，2 ，3 。但是当我查了 1之后，我再查询全部的时候，输出的就是  2, 3, 1

WeakHashMap：弱类型，容易被垃圾回收机制回收

ConcurrentHashMap：多线程情况下使用的map

SortMap:形式同SortSet都是TreeMap的延生

Map的散列原理（继承AbstractMap实现原生的HashMap）：

①、了解散列码的原理和快速查找的原理

首先散列集是由一段数组组成的，每个数组的控件称为桶。

通过数学公式将hashCode()方法中获取到的数据转换为数组的下标，找到对应的桶。

桶中存储的是一个容器对象（Collection），因为可能会有hashCode()转换成下标相同的情况。将hash值相同的对象放入容器中。

查找：

因为容器的查找，是从头开始一个个匹配的原则。

散列码能够先快速定位到相同的位置，再进行依次匹配。这样就能够减少其他不必要的查找，从而增加了效率。

②、制作HashMap

步骤①、继承AbstratMap类，确定桶的个数，桶中装载哪种容器。

public class MyHashMap<K,V> extends AbstractMap<K, V>{
    //桶的数量
    private static final int BARREL_COUNT = 937;
        //使用ArrayList作为容器
    private ArrayList<Entry<K, V>> [] barrels;
        //为返回Set做准备
    private Set<java.util.Map.Entry<K, V>> mSet;
    public MyHashMap(){
        barrels = new ArrayList [BARREL_COUNT];
        mSet = new HashSet<>();
    }
}    

步骤②、创建HashEntry类继承Entry接口。用来存储key和value

class MyEntry implements Entry<K, V>{
        private K key;
        private V value;
        
        public MyEntry(K key,V value){
            this.key = key;
            this.value = value;
        }
        
        @Override
        public K getKey() {
            // TODO Auto-generated method stub
            return key;
        }

        @Override
        public V getValue() {
            // TODO Auto-generated method stub
            return value;
        }

        @Override
        public V setValue(V value) {
            // TODO Auto-generated method stub
            V oldValue = this.value;
            this.value = value;
            return oldValue;
        }
        
    }

步骤③、重写put方法 1、当放入数据的时候，先获key的hashCode转换为桶的下标 2、根据下标寻找桶对应 的容器，如果容器没被创建则创建，并将数据转换为Entry装入容器中（也装入Set这个容器中）。   3、如果容器被创建了，之后获取容器，并将容器中的Entry拿出来和放入数据的key进行判断，是否已经存在。如果已经存在则替换，如果不存在则将entry装入容器中（也装入Set这个容器中）。

@Override
    public V put(K key, V value) {
        //注意：常用获取索引的方法就是根据数组的大小取余  ①
        int index = Math.abs(key.hashCode())%BARREL_COUNT;
        ArrayList<Entry<K, V>> list = barrels[index];
        MyEntry entry = new MyEntry(key, value);
        //判断容器是否存在
        if (list == null){
            barrels[index] = new ArrayList<>();
            barrels[index].add(entry);
            mSet.add(entry);
            return value;
        }
        else{
            //查找是否key已经存在
            boolean found = false;
            for(Entry<K, V> myEntry: list){
                if (myEntry.getKey().equals(key)){
                    V oldValue = myEntry.getValue();
                    myEntry.setValue(value);
                    found = true;
                    return oldValue;
                }
            }
            //不存在则装入List中
            if (!found){
                list.add(entry);
            }
            return value;
        }
    }

步骤④、重写get方法   1、获取key的hashCode转换为桶的下标  2、根据下标寻找容器，如果容器不存在返回false，如果容器存在，则拿出entry与key进行比较。如果成功则返回value，不成功返回null

public V get(Object key) {
        int index =Math.abs(key.hashCode())%BARREL_COUNT;
        ArrayList<Entry<K, V>> list = barrels[index];
        if (list == null){
            return null;
        }
        else {
            boolean found = false;
            for(Entry<K, V> myEntry: list){
                if (myEntry.getKey().equals(key)){
                    return myEntry.getValue();
                }
            }
            return null;
        }
    }

步骤⑤、创建Set 将 所有的entry装入Set中

    @Override
    public Set<java.util.Map.Entry<K, V>> entrySet() {
        // TODO Auto-generated method stub
        return mSet;
    } 

如何制作好的散列码：

判定方法：①、hashCode()应该产生分布均匀的散列码。

如何制作：①、根据对象内容生成散列码  ②、首先给int result 初始化一个非0值 例如：int result = 7; ③、对每个可修改的成员变量计算出本身的散列码   比如：人  有 姓名和性别   所以需要对姓名和性别分别制作散列码。

④、合并计算。

举例：

public class HashTest {
    
    public String str;
    public int data;
    public HashTest(String str,int data){
        this.str = str;
        this.data = data;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof HashTest){
            HashTest test = (HashTest)obj;
            if (test.str == str && test.data == data){
                return true;
            }
            else {
                return false;
            }
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        //第一步，给result赋值
        int result = 17;
        //第二步给可改变的成员变量对应的值
        int strHash = str.hashCode();
        int dataHash = data;
        //第三步：合并值
        result = 10*result + strHash;
        result = 10*result + dataHash;
        return result;
        
    }

}