java学习初探十三之集合—Set详解

1.哈希表/散列表
HashSet底层实际上是一个HashMap。HashMap底层是哈希表/散列表。
哈希表是数组和单向链表的集合。
哈希表本质是一个数组，只不过这个数组中的每个元素又是个单向链表。类似于现实世界中的字典。
final int hash这个是哈希值，是通过key调用hashCode方法得到的值，再通过“哈希算法”得到的值。在单向链表中，每个节点的哈希值是相同的。代表的是数组的下标。注，不同key的获得的hashCode可能相同，也可能不相同。

2.HashSet详解
（1）HashSet底层实际上是一个HashMap，HashMap底层采用了哈希表数据结构。
（2）哈希表又叫散列表，哈希表底层是一个数组，这个数组中每个元素是一个单向链表。每个单向链表都有一个独一无二的hash值，代表数组的下标。在某个单向链表中的每一个节点上的hash值是相等的。hash值实际上是key调用hashCode方法，再通过“hash function”转换成的值。
（3）如何向哈希表中添加元素：
先调用被存储key的hashCode方法，经过某个算法得到hash值，如果在这个哈希表中不存在这个hash值，则直接加入元素。如果该hash值已经存在，继续调用key之间的equals方法，如果equals方法返回false，则将该元素添加。如果equals返回true，则放弃添加该元素。
（4）HashSet其实是HashMap中的key部分。HashSet有什么特点，HashMap中的key应该具有相同的特点。
（5）HashMap和HashSet初始化容量都是16，默认加载因子是0.75。

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;
public class SetTest {
    public static void main(String[] args) {
        //创建Set集合
        Set s=new HashSet();
        //无序不可重复
        s.add(1);
        s.add(1);
        s.add(100);
        s.add("ok");
        s.add(85);
        s.add(88);
        //遍历
        Iterator it=s.iterator();
        while(it.hasNext()) {
            System.out.println(it.next());//1 100 85 88 ok
        }
    }
}

关于往Set集合中存储的元素，该元素的hashCode和equals方法：
HashMap中有一个put方法，put(key,value) key是无序不可重复的。
结论：存储在HashSet集合或HashMap集合key部分的元素，需要同时重写public int hashCode()()和public boolean equals(Object o)方法。
hashCode目的：让散列分布均匀。

import java.util.HashSet;
import java.util.Set;

public class SetTset02 {

    public static void main(String[] args) {
        //创建集合
        Set es=new HashSet();
        Employee e1=new Employee("1000", "JACK");
        Employee e2=new Employee("1000", "JACK");
        Employee e3=new Employee("2000", "JIM");
        Employee e4=new Employee("2001", "SUN");
        Employee e5=new Employee("3000", "ROSE");
        Employee e6=new Employee("3001", "COOK");

        //添加元素
        es.add(e1);
        es.add(e2);
        es.add(e3);
        es.add(e4);
        es.add(e5);
        es.add(e6);

        //重写hashCode和equals方法前        查看集合元素hash值和元素个数
        System.out.println(e1.hashCode());//366712642
        System.out.println(e2.hashCode());//1829164700
        System.out.println(es.size());//6

        //重写hashCode和equals方法后        查看集合元素hash值和元素个数
        System.out.println(e1.hashCode());//1507423
        System.out.println(e2.hashCode());//1507423
        System.out.println(es.size());//5       


    }

}

//根据现实的业务逻辑得知：该公司员工编号是：1000-9999
class Employee{
    //编号
    String no;
    //姓名
    String name;
    //Constructor
    Employee(String no,String name){
    this.no=no;
    this.name=name;
    }
    //重写hashCode方法
    public int hashCode() {
        //以员工编号分组
        return no.hashCode();
    }
    //重写equals方法
    //如果员工编号相同，并且名字相同，则是同一个人
    public boolean equals(Object o) {
        if(this==o) return true;
        if(o instanceof Employee) {
            Employee e=(Employee)o;
            if(e.no.equals(this.no)&&e.name.equals(this.name)) {
                return true;
            }
        }
        return false;
    }
}

3.SortedSet详解
（1）无序不可重复，但是存进去的元素可以按照元素大小顺序自动排序。
数据结构：二叉树

import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class SetTest03 {
    public static void main(String[] args) throws ParseException {
        //创建集合
        SortedSet ss=new TreeSet();
        //添加元素
        ss.add(10);//自动装箱
        ss.add(20);
        ss.add(15);
        ss.add(30);
        ss.add(25);
        ss.add(9);
        //遍历
        Iterator it=ss.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());//9 10 15 20 25 30
        }

        //String
        SortedSet strs=new TreeSet();
        strs.add("JACK");
        strs.add("SUN");
        strs.add("COOK");
        strs.add("LUCY");
        strs.add("KING");
        //遍历
        Iterator its=strs.iterator();
        while (its.hasNext()) {
            System.out.println(its.next());//COOK JACK KING LUCY SUN
        }

        //Date
        String t1="2008-08-08";
        String t2="2009-08-08";
        String t3="2008-09-08";
        String t4="2008-08-09";
        String t5="2012-08-08";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
        Date date1=sdf.parse(t1);
        Date date2=sdf.parse(t2);
        Date date3=sdf.parse(t3);
        Date date4=sdf.parse(t4);
        Date date5=sdf.parse(t5);
        SortedSet strse=new TreeSet();
        strse.add(date1);
        strse.add(date2);
        strse.add(date3);
        strse.add(date4);
        strse.add(date5);
        //遍历
        Iterator itst=strse.iterator();
        while (itst.hasNext()) {
            Object element=itst.next();
            if(element instanceof Date) {
                Date d=(Date)element;
                System.out.println(sdf.format(d));
                /*输出结果
                2008-08-08
                2008-08-09
                2008-09-08
                2009-08-08
                2012-08-08
                */
            }
        }

    }
}

（2）实现Comparable接口
SortedSet集合存储元素为什么可以自动排序？

因为被存储的元素实现了Comparable接口，
SUN编写的TreeSet集合在添加元素的时候，会调用compareTo方法，完成比较。

import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class SetTest04 {

    public static void main(String[] args) {
        SortedSet users=new TreeSet();
        User u1=new User(15);
        User u2=new User(16);
        User u3=new User(25);
        User u4=new User(13);
        User u5=new User(14);
        //添加元素
        users.add(u1);
        users.add(u2);
        users.add(u3);
        users.add(u4);
        users.add(u5);
        //实现java.lang.Comparable接口前      遍历
        Iterator it=users.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
            /*
             * java.lang.ClassCastException: 
             * User cannot be cast to java.lang.Comparable
             */

        }

        //实现java.lang.Comparable接口前      遍历
        Iterator it2=users.iterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
            /*
             * User[age=13]
               User[age=14]
               User[age=15]
               User[age=16]
               User[age=25]
             */

        }       


    }

}
class User implements Comparable{
    int age;
    User(int age){
        this.age=age;

    }
    public String toString() {
        return "User[age="+age+"]";
    }
    //实现java.lang.Comparable接口中的compareTo方法
    //该方法程序员负责实现，SUN提供的程序已经调用了该方法
    //需求：按照User的age年龄排序
    public int compareTo(Object o) {
        //编写一个比较规则
        int age1=this.age;
        int age2=((User)o).age;
        return age1-age2;
    }
}

（3）java.util.Comparator
SortedSet集合做到排序还有另外一个方法java.util.Comparator相比Comparable更为灵活，耦合度较低，推荐使用Copmparator比较器

import java.util.Comparator;
import java.util.Iterator;
import java.util.SortedSet;
import java.util.TreeSet;

public class SetTest05 {

    public static void main(String[] args) {

        //创建TreeSet集合的时候提供一个比较器
        SortedSet products=new TreeSet(new ProductComparator());

        //还可以用下面匿名内部类的方式实现比较器,不推荐使用，因为毕竟器不能得到重复利用

        /*
         SortedSet products=new TreeSet(new Comparator() {
                    public int compare(Object o1, Object o2) {
                        double price1=((Product)o1).price;
                        double price2=((Product)o2).price;
                        if(price1==price2) {
                            return 0;
                        }else if(price1>price2) {
                            return 1;
                        }else {
                            return -1;
                        }
                    }
        });
        */

        Product p1=new Product(3.4);
        Product p2=new Product(4.0);
        Product p3=new Product(2.0);
        Product p4=new Product(3.0);
        Product p5=new Product(5.0);

        //添加元素
        products.add(p1);
        products.add(p2);
        products.add(p3);
        products.add(p4);
        products.add(p5);
        //遍历
        Iterator it =products.iterator();
        while (it.hasNext()) {
            System.out.println(it.next());
        /*
         *  输出结果
         *  2.0
            3.0
            3.4
            4.0
            5.0

         */

        }
    }

}
class Product{
    double price;
    public Product(double price) {
        this.price=price;
    }
    public String toString() {
        return price+"";

    }
}
//单独写一个比较器
class ProductComparator implements Comparator{

    //重写：
    //需求：按照商品价格排序
    public int compare(Object o1, Object o2) {
        double price1=((Product)o1).price;
        double price2=((Product)o2).price;
        if(price1==price2) {
            return 0;
        }else if(price1>price2) {
            return 1;
        }else {
            return -1;
        }
    }
}