java学习----Collection体系集合之Set

Collection体系集合之Set

1. Set子接口

1. 特点：无序、无下标、元素不可重复
2. 方法全部继承自Collection中的方法

下面代码为Set的简单使用

public static void main(String[] args) {

        //创建集合
        Set<Student> students = new HashSet<>();

        Student stu1 = new Student("zhangsan",11);
        Student stu2 = new Student("wangwu",12);
        Student stu3 = new Student("wanger",23);

        students.add(stu1);
        students.add(stu2);
        students.add(stu3);

        System.out.println(students.size());
        System.out.println(students.toString());

        //遍历
        for(Student s : students){
            System.out.println(s.toString());
        }

        //使用迭代器
        Iterator<Student> it = students.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }

        //判断是否为空
        System.out.println(students.isEmpty());
        //判断是否存在某元素
        System.out.println(students.contains(stu1));
        //清空
        students.clear();
        //删除
        students.remove();
        //判断是否存在
        students.contains(stu1);

    }

2. HashSet

2.1 总述

1. 基于hashCode、equals实现元素不重复
2. 当存入元素的哈希码相同时，会调用“==”或equals进行确认，结果为true，拒绝后者存入。
3. 存储结构为哈希表（数组+链表）

简单的使用方法，和上述代码一样，不再赘述。

2.2 存储过程

1. 根据hashcode的值进行计算，如果计算出的位置是没有元素的，直接添加。
2. 如果这个位置是有元素的，判断equals，如果equals返回值为false，则创建一个新的节点，加在这个元素的后面（就是链表）。如果equals返回值直接是true，则判断为相同元素。
   存储结构：
   

2.3 HashSet的使用

public static void main(String[] args) {
		HashSet<Student> students=new HashSet<Student>();
		//LinkedHashSet有顺序的，多添加一个链表保存顺序
		//LinkedHashSet<Student> students=new LinkedHashSet<Student>();
		Student s1=new Student("张三",18);
		Student s2=new Student("李四",19);
		Student s3=new Student("王五",22);
		//添加元素
		students.add(s1);
		students.add(s2);
		students.add(s3);
		students.add(new Student("王五",22));
		System.out.println("元素个数:"+students.size());
		System.out.println(students.toString());
		//删除
		students.remove(new Student("张三",18));
		System.out.println(students.toString());
		//遍历
		//增强for
		System.out.println("增强for");
		for (Student student : students) {
			System.out.println(student.toString());
		}
		System.out.println("迭代器");
		Iterator<Student> it = students.iterator();
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//判断
		System.out.println(students.contains(new Student("李四",19)));
	}

见上述代码所示。

3. LinkedHashSet

特点：链表实现的HashSet，按照链表进行存储，也就是说可以保留元素的插入顺序。
具体使用方法和HashSet一样。

4. TreeSet

4.1 特点

1. 基于排列顺序实现元素不重合。
2. 实现了sortedSet接口，对集合元素自动排序。
3. 元素对象的类型必须实现Comparable接口，指定排序的规则。
4. 通过ComparableTo方法确定是否为重复元素。

存储结构：自平衡红黑树，遍历方式是中序遍历。
优点：查找速度非常快。

4.2 简单的使用1

用的是整数型，输出的顺序是按照中序遍历进行输出。

       TreeSet<Integer> treeSet = new TreeSet<Integer>();
        treeSet.add(12);
        treeSet.add(10);
        treeSet.add(50);
        treeSet.add(80);

        //中序遍历
        System.out.println(treeSet.toString());
        
        //遍历方式两种
        for(Integer t : treeSet){
            System.out.println(t);
        }

        Iterator<Integer> tit = treeSet.iterator();
        while (tit.hasNext()){
            System.out.println(tit.next());
        }

4.3 简单的使用2----Comparable接口

main函数内的使用

 public static void main(String[] args) {
       
        Student stu1 = new Student("zhangsan",11);
        Student stu2 = new Student("wangwu",12);
        Student stu3 = new Student("wanger",23);
        Student stu4 = new Student("sun",20);
        
        TreeSet<Student> treeSet1 = new TreeSet<Student>();
        treeSet1.add(stu1);
        treeSet1.add(stu2);
        treeSet1.add(stu3);
        treeSet1.add(stu4);

        System.out.println(treeSet1.size());
        Iterator<Student> tit = treeSet1.iterator();
        while (tit.hasNext()){
            System.out.println(tit.next());
        }

        System.out.println(treeSet1.toString());

}

Student类

public class Student implements Comparable<Student>{
    String name;
    int age;

    public Student(){

    }
    public Student(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 String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }


    @Override
    public int compareTo(Student o) {
        //1.先比较姓名
        int b1 = this.getName().compareTo(o.getName());
        //比较年龄
        int b2 = this.getAge() - o.getAge();

        return b1==0 ? b2:b1;


    }
}

4.4 自定义比较器Comparator

注意：自定义比较器的优先级要高于元素排序规则

 public static void main(String[] args) {

        //自定义比较器，自定义比较器的优先级高于元素排序
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String o1,String o2) {
                int b1 = o1.length() - o2.length();
                int b2 = o1.compareTo(o2);
                return b1==0 ? b2:b1;
            }
        };

        TreeSet<String> treeSet = new TreeSet<String>(comparator);
        treeSet.add("hr");
        treeSet.add("dali");
        treeSet.add("xian");
        treeSet.add("qingdao");
        treeSet.add("weifang");
        System.out.println(treeSet.toString());


    }

运行结果如下