java基础36 双例集合Map下的HashMap和TreeMap集合

单例集合体系：

---------| collection  单例集合的根接口
--------------| List  如果实现了list接口的集合类，具备的特点：有序，可重复       注：集合中的有序不是指自然顺序，而是指添加进去的顺序与出来的顺序是一致的
------------------| ArrayList  ArrayList底层维护了一个object数组的实现的。(线程不安全)，特点：查询速度快，增删速度慢。（有序，可重复）
------------------| LinkedList  LinkedList底层是使用链表结构实现的，线程不安全，特点：查询速度慢，增删速度快。（有序，可重复）
------------------| Vector(了解即可)  底层也是维护一个Object数组的实现的，实现与ArrayList是一样的，但是Vector是线程安全的，操作效率低
--------------| Set  如果实现了set接口的集合类，具备的特点：无序，不可重复     注：集合中的无序不是指自然顺序，而是指添加元素进去的顺序与元素出来的顺序是不一致的
------------------| HashSet  底层是用于一个哈希表支持的，线程不安全，特点：存储速度块
------------------| TreeSet  底层是使用红黑树(二叉树)数据结构实现的，线程不同步(即线程不安全)，不能在多线程中共享，但可以使用synchroinzedMap()方法来实现同步。特点：会对元素进行排序存储（按自然顺序）

双例集合体系：

----------| Map  双例集合的根接口。如果是实现了Map接口的集合类，具备的特点：存储的数据都是以键值对形式存在的，键不可重复，值可以重复
--------------| HashMap  底层是基于哈希表实现的，HashMap允许键和值为null，线程不安全，特点：存储速度块
--------------| TreeMap  基于红黑数(二叉树)数据结构实现的，线程不同步(即线程不安全)，特点：会对元素经行排序存储
--------------| HashTable(了解即可)  线程安全

---

一、HashMap集合

1.1、HashMap集合的一些常用方法

和Map集合的常用方法差不多

1.2、HashMap的存储原理

往HasMap集合中添加元素时，首先会调用键的hashCode()方法得到元素的哈西马值，然后经过运算在哈希表找到相应存储位置
      情况1：如果算出的位置目前没有任何元素，那么该元素可以直接添加到哈希表中。
      情况2：如果算出元素的位置已经存在其他元素，那么就会调用equals方法与该元素位置已存在的元素做一次比较；如过equals方法返回值是true，那么该元素是重复元素，不允许存储；如果返回值是false，那么该元素不是重复元素，则允许存储。

和HashSet差不多（1.2或例1处）

1.3、HashMap和HashSet的区别

相同点：
    1.集合中元素都是无序，不可重复。且都要重写HashCode和equals方法进行判断比较。注：“无序”指添加元素进去(集合)的顺序与元素输出来的顺序是不一致的。指定的比较字段不可重复，但 非指定字段可重复
    2.都是线程不安全的

不同点：
    1.HashMap实现了Map接口；HashSet实现了Set接口。
    2.HashMap是以键值对的形式储存的；HashSet存储的是对象。
    3.HashMap比较快，因为使用的是唯一的键来获取对象；HashSet较HashMap来说，比较慢。
    4.HashMap是使用put()方法将元素放入map集合中；而HashSet是使用add()方法将元素放入set集合中。

1.4、实例

例1  （没有重写HashCode和equals方法的结果：“110，狗娃”这个重复元素，两个都添加进map集合中）

package com.dhb.collection;

import java.util.HashMap;

/**
 * @author DSHORE / 2018-5-30
 *
 */
class Personnal{
    int id;
    String name;

    public Personnal(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Personnal [id=" + id + ",name=" + name + "]";
    }

}
public class Demo22 {
    public static void main(String[] args) {
        HashMap<Personnal, String> map=new HashMap<Personnal, String>();
        map.put(new Personnal(,"狗娃"),"");
        map.put(new Personnal(,"狗剩"), "");
        map.put(new Personnal(,"狗蛋"),"");
        map.put(new Personnal(,"狗娃"),"");
        System.out.println("集合中的元素："+map);//返回值：{Personnal [id=330,name=狗蛋]=003, Personnal [id=220,name=狗剩]=002, Personnal [id=110,name=狗娃]=001, Personnal [id=110,name=狗娃]=007}
    }
}

例2   （重写HashCode和equals方法后的结果：“110，狗娃”这个重复元素，只有一个添加进map集合中）

 package com.dhb.collection;

 import java.util.HashMap;

 /**
  * @author DSHORE / 2018-5-30
  *
  */
 class Personnal{
     int id;
     String name;

     public Personnal(int id, String name) {
         super();
         this.id = id;
         this.name = name;
     }
     @Override
     public String toString() {
         return "Personnal [id=" + id + ",name=" + name + "]";
     }
     @Override
     public int hashCode() {//重写hashCode方法
         return this.id;
     }
     @Override
     public boolean equals(Object obj) {//重写equals方法
         Personnal p = (Personnal) obj;
         return this.id == p.id;  //指定的比较字段不可重复，但，非指定字段可重复
     }
 }
 public class Demo22 {
     public static void main(String[] args) {
         HashMap<Personnal, String> map=new HashMap<Personnal, String>(); //注：“无序”指添加元素进去(集合)的顺序与元素输出来的顺序是不一致的。
         map.put(new Personnal(,"狗娃"),""); //指定的比较字段不可重复，但，非指定字段可重复。   110是指定比较字段，狗娃不是
         map.put(new Personnal(,"狗剩"), "");
         map.put(new Personnal(,"狗蛋"),"");
         map.put(new Personnal(,"狗娃"),"");
         System.out.println("集合中的元素："+map);//返回值：{Personnal [id=220,name=狗剩]=002, Personnal [id=110,name=狗娃]=007, Personnal [id=330,name=狗蛋]=003}
     }
 }

重写HashCode和equals方法后，例2比例1少了一个id为110的重复值

二、TreeMap集合

2.1、TreeMap集合的一些常用方法

和Map集合的常用方法差不多

2.2、TreeMap需要注意的事项

1.往TrreMap添加元素时候，如果元素本身具备自然顺序时，那么就按照自然顺序排列存储。
    2.往TrreMap添加元素时候，如果元素本身不具备自然顺序，那么键所属的类必须要实现Comparable接口，把键比较的规则定义在CompareTo方法中。
    3.往TrreMap添加元素时候，如果元素本身不具备自然顺序，键所属的类也没有实现Comparable接口，那么必须在创建TreeMap是传入一个比较器。

和TreeSet差不多（2.2处）

2.3、自定义比较器

自定一个比较器只需要实现接口 Comparator<T>即可，把元素与元素之间的比较规则定义在compare方法内即可

自定义比较器的格式:
    class 类名  implements Comparator<T>{

    }

实例  （通过自定义比较器来排序存储）

 package com.dhb.collection;

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

 /**
  * @author DSHORE / 2018-5-30
  *
  */
 class Emp3{
     String name;
     int salary;
     public Emp3(String name,int salary) {
         this.name=name;
         this.salary=salary;
     }
     @Override
     public String toString() {
         return "Emp [name=" + name + ",salary=" + salary + "]";
     }
 }
 //自定义比较器    作用：用于根据指定字段进行比较 排序存储
 class MyComparator1 implements Comparator<Emp3>{

     public int compare(Emp3 o1, Emp3 o2) {
         return o1.salary-o2.salary;
     }
 }
 public class Demo23 {
     public static void main(String[] args) {
         MyComparator1 mc=new MyComparator1();//创建比较器MyComparator1对象
         TreeMap<Emp3, Integer> tm=new TreeMap<Emp3, Integer>(mc);
         tm.put(new Emp3("张三",),);
         tm.put(new Emp3("李四",), );
         tm.put(new Emp3("王五",),);
         tm.put(new Emp3("赵六",), );

         System.out.println(tm);//返回值：{Emp [name=李四,salary=1000]=2, Emp [name=张三,salary=2000]=1, Emp [name=赵六,salary=5000]=4, Emp [name=王五,salary=36000]=3}
     }
 }

2.4、TreeMap和TreeSet的区别

相同点：
    1.都是无序集合(添加进去和输出来的顺序不一样)，但是，存储方式都是一样的，都是按自然顺序排序存储的。
    2.都是非同步集合(线程不安全)，因此他们不能在多线程之间共享，不过可以使用方法Collections.synchroinzedMap()来实现同步。
    3.运行速度都要比Hash集合慢。

不同点：
    1.TreeMap实现了Map接口；TreeSet实现了Set接口。
    2.TreeMap是以键值对的形式储存的；TreeSet存储的是对象。
    3.TreeMap是使用put()方法将元素放入map集合中；而TreeSet是使用add()方法将元素放入set集合中。

2.5、实例

通过实现Comparable<T>接口来 排序存储

 package com.dhb.collection;

 import java.util.TreeMap;

 /**
  * @author DSHORE / 2018-5-30
  *
  */
 class Emp4 implements Comparable<Emp4>{ //实现Comparable<T>接口
     String name;//姓名
     int salary;//工资
     public Emp4(String name,int salary) {
         this.name=name;
         this.salary=salary;
     }
     @Override
     public String toString() {
         return "Emp [name=" + name + ",salary=" + salary + "]";
     }
     @Override
     public int compareTo(Emp4 e) {//实现Comparable接口后，重写compareTo方法
         return this.salary - e.salary;//用工资进行排序存储
     }
 }
 public class Demo24 {
     public static void main(String[] args) {
         TreeMap<Emp4, Integer> tm=new TreeMap<Emp4, Integer>();
         tm.put(new Emp4("张三",),);
         tm.put(new Emp4("李四",), );
         tm.put(new Emp4("王五",),);
         tm.put(new Emp4("赵六",), );

         System.out.println(tm);//返回值：{Emp [name=李四,salary=1000]=2, Emp [name=张三,salary=2000]=1, Emp [name=赵六,salary=5000]=4, Emp [name=王五,salary=36000]=3}
     }
 }

原创作者：DSHORE

作者主页：http://www.cnblogs.com/dshore123/

原文出自：https://www.cnblogs.com/dshore123/p/9110016.html

欢迎转载，转载务必说明出处。（如果本文对您有帮助，可以点击一下右下角的 推荐，或评论，谢谢！）