JAVA中Set集合的学习

Set集合概述和特点

不重复

Set集合特点：
	可以去除重复
	存取顺序不一致
	没有带索引的方法，所以不能使用普通for循环遍历，也不能通过索引类获取，删除Set集合里面的元素。

存储字符串并遍历练习

package com.shengda.Demo4Set;

/*Set集合的基本使用*/

import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;

public class Demo1MySet {
    public static void main(String[] args) {
        Set<String> set = new TreeSet<>();
        set.add("aaa");
        set.add("www");
        set.add("ddd");
        set.add("aaa");
        /*for (int i = 0; i < set.size(); i++) {
            // set集合是没有索引的，所以不能使用通过索引获取元素的方法
        }*/

        Iterator<String> it = set.iterator();
        while (it.hasNext()) {
            String s = it.next();
            System.out.println(s);
        }
        System.out.println("-------------------");
        for (String s : set) {
            System.out.println(s);
        }
    }
}

TreeSet集合概述和特点

TreeSet集合特点：
	不包含重复元素的集合
	没有带索引的方法
	可以将元素按照规则进行排序

TreeSet练习
存储Integer类型的整数，并遍历
如果存储的是Integer类型的整数时，会自动排序

package com.shengda.Demo4Set;

import java.util.TreeSet;

public class Demo2MyTreeSet {
    public static void main(String[] args) {
        TreeSet<Integer> ts = new TreeSet<>();
        ts.add(5);
        ts.add(2);
        ts.add(3);
        ts.add(1);
        ts.add(4);
        System.out.println(ts);  // [1, 2, 3, 4, 5]
    }
}

存储学生对象、并遍历
此处存储自定义对象的时候就要指定排序规则
如果不指定就会报错

自然排序Comparable的使用
	使用空参构造TreeSet集合
	自定义的Student类实现Comparable接口
	重写里面的compareTo方法

Student.java

package com.shengda.Demo4Set;

// 注意这里一定要实现Comparable接口 implements Comparable<Student> 这样才能重写里边的compareTo，也就是重写接口里的排序规则
public class Student implements Comparable<Student> {
    private String name;
    private 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) {
        // 按照对象的年龄进行的排序
        int result = this.age - o.age;
        return result;  // 如果返回值为负数，表示当前存入的元素的最小值，存左边
                        // 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
                        // 如果返回值为正数，表示当前存入的元素是较大值，存右边
    }
}

Demo3MyTreeSet.java

package com.shengda.Demo4Set;

// TreeSet集合存储Student类型

import java.util.TreeSet;

public class Demo3MyTreeSet {
    public static void main(String[] args) {
        TreeSet<Student> ts = new TreeSet<>();

        Student s1 = new Student("黑小虎", 22);
        Student s2 = new Student("沸羊羊", 18);
        Student s3 = new Student("双面龟", 20);

        ts.add(s1);
        ts.add(s2);
        ts.add(s3);

        System.out.println(ts);  // [Student{name='沸羊羊', age=18}, Student{name='双面龟', age=20}, Student{name='黑小虎', age=22}]

    }
}

Comparator排序的使用

Teacher.java

package com.shengda.Demo4Set;

public class Teacher {
    private String name;
    private int age;

    public Teacher() {
    }

    public Teacher(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 "Teacher{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

Demo5MyTreeSet.java

package com.shengda.Demo4Set;

import java.util.Comparator;
import java.util.TreeSet;

public class Demo5MyTreeSet {
    public static void main(String[] args) {
        TreeSet<Teacher> ts  = new TreeSet<>(new Comparator<Teacher>() {
            @Override
            public int compare(Teacher o1, Teacher o2) {
                // o1表示现在要存入的那个元素
                // o2表示已经存入到集合中的元素
                int result = o1.getAge() - o2.getAge();
                result = result == 0 ? o1.getName().compareTo(o2.getName()) : result;
                return result;
            } // 在这里重写排序规则
        });

        Teacher t1 = new Teacher("zhangsan", 34);
        Teacher t2 = new Teacher("lisi", 33);
        Teacher t3 = new Teacher("wangwu", 39);
        Teacher t4 = new Teacher("zhaoliu", 39);

        ts.add(t1);
        ts.add(t2);
        ts.add(t3);
        ts.add(t4);

        System.out.println(ts);
    }
}

两种比较方式小结

自然排序：自定义类实现Comparable接口，重写compareTo方法，根据返回值进行排序。
比较器排序：创建TreeSet对象的时候传递Comparator的实现类对象，重写compare方法，根据返回值进行排序。
在使用的时候，默认使用自然排序，当自然排序不满足现在的需求时，使用比较器排序。
两种方式中，关于返回值的规则：
	// 如果返回值为负数，表示当前存入的元素的最小值，存左边
    // 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
    // 如果返回值为正数，表示当前存入的元素是较大值，存右边