set集合学习笔记一

1.HashSet:存储无序,唯一的单一对象，底层采用HashMap的Key存值。

注意:HashSet的泛型数据类型中一定要重写hashCode()和equals()方法。
唯一性(去重性):通过hashCode()和equals()方法实现。
优点:去除重复的元素。
根据key调用hashCode()经过计算得到hash码，根据hash码和数组的长度计算出该key存储的位置index，如果index索引位置上没有值，将当前key-value键值对存在当前位置index上；如果位置index已经存在了键值对（节点），则用key调用equals()与index位置上原本的key进行比较，如果key相同，则当前key-value（新增的键值对）中的key不存value覆盖；如果key不相同，则将key-value键值对（新增的）接着存入到index的后面。

public static void main(String[] args) {
    //创建集合对象
    Set<Integer> hset1=new HashSet();
    //向集合中添加元素
    hset1.add(66);
    hset1.add(11);
    hset1.add(77);
    hset1.add(66);
    
    /*遍历集合*/
    //获得集合的迭代器对象
    Iterator<Integer> it1=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it1.hasNext()) {
        //获得迭代的元素
        Integer num=it1.next();
        System.out.println(num);
    }
    System.out.println("--------------------------------");
    
    //删除集合中元素
    hset1.remove(66);
    //获得集合的迭代器对象
    Iterator<Integer> it2=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it2.hasNext()) {
        //获得迭代的元素
        Integer num=it2.next();
        System.out.println(num);
    }
}

public static void main(String[] args) {
    //创建集合对象
    //Student泛型类型的HashSet能根据对象属性实现去重,重写hashCode(),equals()
    Set<Student> hset1=new HashSet();
    //向集合中添加元素
    hset1.add(new Student("张三", 66));
    hset1.add(new Student("李四", 86));
    hset1.add(new Student("王八", 76));
    hset1.add(new Student("张三", 66));
    
    /*遍历集合*/
    //获得集合的迭代器对象
    Iterator<Student> it1=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it1.hasNext()) {
        //获得迭代的元素
        Student s=it1.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("--------------------------------");
    
    //删除集合中元素
    hset1.remove(new Student("王八", 76));
    //获得集合的迭代器对象
    Iterator<Student> it2=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it2.hasNext()) {
        //获得迭代的元素
        Student s=it2.next();
        System.out.println(s.sanme+","+s.sage);
    }
}

2.LinkedHashSet:存储有序,唯一的单一对象.底层采用哈希表和链表实现了Set接口，具有可预测的迭代次序

public static void main(String[] args) {
    //创建集合对象
    Set<Integer> hset1=new LinkedHashSet();
    //向集合中添加元素
    hset1.add(66);
    hset1.add(11);
    hset1.add(77);
    hset1.add(66);
    
    /*遍历集合*/
    //获得集合的迭代器对象
    Iterator<Integer> it1=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it1.hasNext()) {
        //获得迭代的元素
        Integer num=it1.next();
        System.out.println(num);
    }
    System.out.println("--------------------------------");
    
    //删除集合中元素
    hset1.remove(66);
    //获得集合的迭代器对象
    Iterator<Integer> it2=hset1.iterator();
    //判断迭代器对象后面是否有元素可迭代
    while (it2.hasNext()) {
        //获得迭代的元素
        Integer num=it2.next();
        System.out.println(num);
    }
}

3.TreeSet:存储无序可排序,唯一的单一对象，底层采用TreeMap的key存值。

注意：TreeSet一定要用排序器,重写排序方法。
优点:可排序,去重重复元素。
可排序性:通过排序器的排序方法来实现,排序方法结果返回负数(-1),排在前面,返回正数排后面。
// 如果按字典顺序此 String 对象位于参数字符串之前，则比较结果为一个负整数。
唯一性:通过排序器的排序方法返回0,表示元素相同,Key不存,value覆盖来实现去重。
将key-value键值对中的key拿出调用排序器的排序方法，与根节点相比较，如果当前是一棵空树（即没有根节点），将当前的键值对作为根节点；继续将下一对key-value键值对中的key拿出来调用排序器的排序方法与根节点开始依次向下的节点相比较，直到找到该key-value键值对所应该存放的位置为止，比较结果返回负数（-1）排在当前节点的左子节点，返回正数（1）排在当前节点的右子节点，若是返回0则说明是相同的节点，key不存（还是原来的key）value覆盖（新key-value中value）。

public static void main(String[] args) {
    //创建集合对象
    TreeSet<Integer> tset1=new TreeSet<>();
    //向集合中添加元素
    tset1.add(66);
    tset1.add(44);
    tset1.add(88);
    tset1.add(33);
    tset1.add(99);
    tset1.add(66);
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Integer> it1=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it1.hasNext()) {
        //获得跌代的元素
        Integer count=it1.next();
        System.out.println(count);
    }
    System.out.println("-------------------------");
    
    //删除集合中元素
    tset1.remove(88);
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Integer> it2=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it2.hasNext()) {
        //获得跌代的元素
        Integer count=it2.next();
        System.out.println(count);
    }
    System.out.println("-------------------------");
}

４.排序器：

4.1:自然排序器(Comparable):

public class Student implements Comparable<Student>{
	public String sanme;
	public Integer sage;
	public Student() {
        // TODO Auto-generated constructor stub
	}
	
	public Student(String sanme, Integer sage) {
         super();
        this.sanme = sanme;
        this.sage = sage;
	}

	/**
	 * 重写排序方法
	 * @param o 每个要比较节点对象,从根节点对象
	 * 排序规则:按姓名升序排序,姓名相同按年龄由大到小排序
	 */
	@Override
	public int compareTo(Student o) {
        if (this.sanme.compareTo(o.sanme)>0) {
            return 1;
        }else if (this.sanme.compareTo(o.sanme)<0) {
            return -1;
        }else {//姓名相同,按年龄比较
            if (this.sage>o.sage) {
                return -1;
            }else if(this.sage<o.sage) {
                return 1;
            }else {
                return 0;
            }
        }
	}
}

public static void main(String[] args) {
    //创建集合对象
    TreeSet<Student> tset1=new TreeSet<>();
    //向集合中添加元素
    tset1.add(new Student("kk",66));
    tset1.add(new Student("dd",44));
    tset1.add(new Student("mm",88));
    tset1.add(new Student("aa",33));
    tset1.add(new Student("zz",99));
    tset1.add(new Student("kk",98));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student> it1=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it1.hasNext()) {
        //获得跌代的元素
        Student s=it1.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
    
    //删除集合中元素
    tset1.remove(new Student("mm",88));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student> it2=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it2.hasNext()) {
        //获得跌代的元素
        Student s=it2.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
}

4.2:自定义排序器(Comparator):

public class MyComparator implements Comparator<Student3>{

    /**
    * 重写自定义排序器的排序规则
    * @param o1 代表当前要添加的对象
    * @param o2代表要比较每一个节点对象
    * 排序规则:先按年龄由小到大排序,年龄相同按照姓名降序排序
    */
    @Override
    public int compare(Student3 o1, Student3 o2) {
        if (o1.sage.compareTo(o2.sage)!=0) {
            return o1.sage.compareTo(o2.sage);
        }else {//年龄相同,按姓名排序
            return -o1.sanme.compareTo(o2.sanme);
        }
    }
}

public static void main(String[] args) {
    //创建一个自定义排序器对象
    MyComparator mc=new MyComparator();
    //创建集合对象
    TreeSet<Student3> tset1=new TreeSet<>(mc);
    //向集合中添加元素
    tset1.add(new Student3("kk",66));
    tset1.add(new Student3("dd",44));
    tset1.add(new Student3("mm",88));
    tset1.add(new Student3("aa",99));
    tset1.add(new Student3("zz",99));
    tset1.add(new Student3("kk",98));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student3> it1=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it1.hasNext()) {
        //获得跌代的元素
        Student3 s=it1.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
    
    //删除集合中元素
    tset1.remove(new Student3("mm",88));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student3> it2=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it2.hasNext()) {
    //获得跌代的元素
    Student3 s=it2.next();
    System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
}

4.3:匿名内部类自定义排序器:

public static void main(String[] args) {
    //创建集合对象
    TreeSet<Student3> tset1=new TreeSet<>(new Comparator<Student3>() {
        /**
        * 重写自定义排序器的排序规则
        * @param o1 代表当前要添加的对象
        * @param o2代表要比较每一个节点对象
        * 排序规则:先按年龄由小到大排序,年龄相同按照姓名降序排序
        */
        @Override
        public int compare(Student3 o1, Student3 o2) {
            if (o1.sage.compareTo(o2.sage)!=0) {
                return o1.sage.compareTo(o2.sage);
            }else {//年龄相同,按姓名排序
                return -o1.sanme.compareTo(o2.sanme);
            }
        }
    });
    //向集合中添加元素
    tset1.add(new Student3("kk",66));
    tset1.add(new Student3("dd",44));
    tset1.add(new Student3("mm",88));
    tset1.add(new Student3("aa",99));
    tset1.add(new Student3("zz",99));
    tset1.add(new Student3("kk",98));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student3> it1=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it1.hasNext()) {
        //获得跌代的元素
        Student3 s=it1.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
    
    //删除集合中元素
    tset1.remove(new Student3("mm",88));
    
    /*遍历集合*/
    //获得跌代器对象
    Iterator<Student3> it2=tset1.iterator();
    //判断跌代器对象后面是否有元素可跌代
    while (it2.hasNext()) {
        //获得跌代的元素
        Student3 s=it2.next();
        System.out.println(s.sanme+","+s.sage);
    }
    System.out.println("-------------------------");
}