Set集合的子类HashSet集合，TreeSet集合

set:元素不可以重复，是无序。

    Set接口中的方法和Collection的方法一致。
    |--HashSet:内部数据结构是哈希表，是不同步的。
            如何保证该集合的元素唯一性呢?
            是通过对象的hashCode和equals方法来完成对象唯一性的。
            如果对象的hashCode值不同，那么要再次判断对象的equals方法是否为true.
            如果为true,视为相同元素，不存。如果为false，那么视为不同元素，就进行存储。

            记住:如果元素要存储到HashSet集合中，必须覆盖hashCode方法和equals方法。
            一般情况下，如果定义的类会产生很多对象。比如人，学生，书。通常都需要覆盖equals,hashCode方法。
            建立对象判断是否相同的依据。

集合框架-HashSet集合

public class Collection16 {
    public static void main(String[] args) {
        HashSet hs=new HashSet();
        String str=null;
        hs.add("hehe");
        hs.add("xixi");
        hs.add("heihei");
        hs.add("haha");
    //  hs.add("haha");//不会进栈，HashSet不可以重复

        Iterator it=hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

集合框架-哈希表

    哈希表的好处:可以快速的算出值的位置，所以取的速度就很快。
    哈希表的弊端:不允许值的重复出现。因为哈希值是唯一的。

哈希表确定元素是否相同

         1，判断的是两个元素的哈希值是否相同。
            如果相同，在判断两个对象的内容是否相同。

          2.判断哈希值，其实判断的是对象hashCode方法，
         判断内容相同，用的是equals方法。

         注意:如果哈希值不同，是不需要判断equals

集合框架-HashSet存储自定义对象

    //Object中的equals比较的是地址
class Person{
    private String name;
    private int age;
    public Person(){
        super();
    }
    public Person(String name,int age){
        super();
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    } 
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;


    }

    public int hashCode() {
        System.out.println(this+"..........hasCode");
        return name.hashCode()+age*38;//*38可以减少HashCode的相同情况
    }
    public boolean equals(Object obj) {
        System.out.println(this+".......equals....."+obj);
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public String toString(){
        return name+":"+age;

    }

}
public class Collection19_1 {
        public static void main(String[] args) {
            HashSet hs=new HashSet();
            /*HashSet集合数据结构是哈希表,所以存储元素的时候
             * 使用的元素的HashCode方法来确定位置，如果位置相同，再通过元素的
             * equals来确定位置是否相同
             * */
            hs.add(new Person("lisi4",24));
            hs.add(new Person("lisi7",27));
    //      hs.add(new Person("lisi9",29));
    //      hs.add(new Person("lisi9",29));//都会打印显示，因为地址的不同，解决方法：覆盖HashCode和equals方法
            Iterator it=hs.iterator();
            while(it.hasNext()){
                Person p=(Person)it.next();
                System.out.println(p.getName()+"--"+p.getAge());
            }
        }
}

集合框架练习

    //定义功能除去arrayList中重复的元素
public class Collection20_1 {
    public static void main(String[] args){
        ArrayList a1=new ArrayList();
        ArrayList a2=new ArrayList();
        a1.add("abc1");
        a1.add("abc2");
        a1.add("abc2");
        a1.add("abc1");
        a1.add("abc");
        System.out.println(a1);
        a2=getSingleElement(a1);
        System.out.println(a2);

    }
    public static ArrayList getSingleElement(ArrayList a1){
        //1定义一个临时容器
        ArrayList temp=new ArrayList();

        //2迭代a1集合
        Iterator it=a1.iterator();
        while(it.hasNext()){
            Object obj=(Object)it.next();
            //3.判断迭代到的元素是否在临时容器存在
            if(!temp.contains(obj)){  //如果此 collection 包含指定的元素，则返回 true
                temp.add(obj);
            }

        }

        return temp;
    }
}

    class Person{
    private String name;
    private int age;
    public Person(){
        super();
    }
    public Person(String name,int age){
        super();
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    } 
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age; 
    }

   public int hashCode() {
        //System.out.println(this+"..........hasCode");
        return name.hashCode()+age*38;//*38可以减少HashCode的相同情况
    }
    public boolean equals(Object obj) {
        //System.out.println(this+".......equals....."+obj);
        Person p=(Person)obj;
        return this.name.equals(p.name)&&this.age==p.age;
    }
    public String toString(){
        return name+":"+age;

    } 

}
public class Collection20_2 {
        public static void main(String[] args) {
            ArrayList a1=new ArrayList();
            a1.add(new Person("lisi1",21));
            a1.add(new Person("lisi2",22));
            a1.add(new Person("lisi3",23));
            a1.add(new Person("lisi4",24));
            a1.add(new Person("lisi4",24));
            Collection20_1  coll=new Collection20_1();
            System.out.println(a1);
            a1=coll.getSingleElement(a1);
            System.out.println(a1);
        }


}

集合框架-LinkedHashSet集合

要使元素不重复，又要保证其有序，用LingkedHashSet()

    public class Collection21_1 {
    public static void main(String[] args) {
        //要使元素不重复，又要保证其有序，用LingkedHashSet()
        HashSet hs=new LinkedHashSet();
        hs.add("haha");
        hs.add("hehe");
        hs.add("heihei");
        hs.add("xixi");
        Iterator it=hs.iterator();
        while(it.hasNext()){
            System.out.println(it.next());
        }
    }
}

TreeSet集合

可以对Set集合中的元素进行排序。是不同步的。
判断元素唯一性的方式:就是根据比较方法的返回结果是否是0，是0就是相同元素，就不存。


TreeSet对元素进行排序的方式之一:
    让元素自身具备比较功能，就需要实现Comparable接口，覆盖compareTo方法。

    如果不要按照对象中具备的自然排序进行排序。如果对象中不具备自然顺序。怎么办?
    可以使用TreeSet集合第二种排序方式二:
    让集合自身具备比较功能,定义一个类实现Comparator接口，覆盖compare方法。
    将该类对象作为参数传递给TreeSet集合中的构造函数。

元素是以二叉树的形式存 放的。

    /*class Person implements Comparable{
    private String name;
    private int age;
    public Person(){}
    public Person(String name,int age){
            this.name=name;
            this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public int compareTo(Object o) {
        Person p=(Person)o;
    int temp=this.age-p.age;
    return temp==0?this.name.compareTo(p.name):temp;//这里的compareTo是String类中的方法。专门用于比较字符串

    //  int temp=this.name.compareTo(p.name);
    //  return temp==0?this.age-p.age:temp;

    }

    public String toString(){
        return name+":"+age;

    }

}*/
public class Collection22_1 {
        public static void main(String[] args) {
            TreeSet  ts=new TreeSet();//

            /*
             * 以Person对象年龄的从小到大的排序。
             * */
            ts.add(new Person("zhangsan",28));
            ts.add(new Person("wanggu",23));
            ts.add(new Person("lisi",21));
            ts.add(new Person("zhouqi",29));
            ts.add(new Person("zhaoliu",25));


            Iterator it=ts.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }

        private static void demo1() {
            TreeSet ts=new TreeSet();

            ts.add("abc");
            ts.add("zaa");
            ts.add("aa");
            ts.add("nba");
            ts.add("cba");

            Iterator it=ts.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }
}

集合框架-TreeSet集合-Comparator比较器

比较器优先于自然排序（compareTo()）
在Person不是我们写的时候，我们也不可能去修改Person类的代码，但是也是需要自定义的比较功能。所以，就出现了比较器。

/**
 * 创建了一个根据Person类的name属性进行排序的比较器
 * */
public class ComparatorByName implements Comparator {

    @Override
    public int compare(Object o1, Object o2) {
        Person p1=(Person)o1;
        Person p2=(Person)o2;
        int temp=p1.getName().compareTo(p2.getName());

        return temp==0?p1.getAge()-p2.getAge():temp;
    //  return 1;//让TreeSet集合，先进先出
        //return -1;//让TreeSet集合，先进后出
    }

}



public class Collection22_1 {
        public static void main(String[] args) {
            TreeSet  ts=new TreeSet(new ComparatorByName());//把比较器传递进来。

            /*
             * 按照比较器的方法来，来排序Person();
             * */
            ts.add(new Person("zhangsan",28));
            ts.add(new Person("wanggu",23));
            ts.add(new Person("lisi",21));
            ts.add(new Person("zhouqi",29));
            ts.add(new Person("zhaoliu",25));
            ts.add(new Person("zzzliu",444));
//          ts.add(new Person())
            Iterator it=ts.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }