Set

Set集合概述和特点

• 不可以存储重复的元素
• 没有索引,无法使用for循环遍历

存储字符串并遍历:

public class MySet {
    public static void main(String[] args) {
      	//创建集合对象
        Set<String> set = new TreeSet<>();
      	//添加元素
        set.add("Z");
        set.add("A");
        set.add("R");
        set.add("D");

//        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);
        }
    }
}

Set常用方法:

返回值	方法(形参)	说明
Boolean	Add(E e)	如果set中尚未存在指定的元素，则添加此元素。
Boolean	addAll(Collection c)	如果set中没有指定collection中的所有元素则，将其添加到set中。
Void	Clear()	移除此set中的所有元素
Boolean	Contains(Object o)	如果set包含指定的元素，则返回true。
Boolean	containsAll(Collection c)	如果此set包含指定collection的所有元素，则返回true
Boolean	Equals(Object o)	比较指定对象与set的相等性
Int	hashCode()	返回set的哈希码值。
Boolean	isEmpty()	如果set不包含元素，则返回true
Iterator	Iterator()	返回在此set中的元素上进行迭代的迭代器。
Boolean	Remove(Object o)	如果set中存在指定的元素，则将其移除。
Boolean	RemoveAll(Collection c)	移除set中那些包含在指定collection中的元素。
Boolean	RemoveAll(Collection c)	仅保留set中的那些包含在指定collection中的元素
Int	Size()	返回set中的元素数(其容量)。
Object[]	toArray()	返回一个包含set中所有元素的数组。
T[]	toArray(T[] a)	返回一个包含此set中所有元素的数组；返回数组的运行时类型时指定数组的类型

TreeSet集合

TreeSet集合概述和特点

• 不可以存储重复的元素
• 没有索引
• 可以将元素按照规则进行排序
  • TreeSet()：根据其元素的自然排序进行排序
  • TreeSet(Comparator comparator) ：根据指定的比较器进行排序

TreeSet集合基本使用

public class TreeSetDemo {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Integer> ts = new TreeSet<Integer>();

        //添加元素
        ts.add(10);
        ts.add(40);
        ts.add(30);
        ts.add(50);
        ts.add(20);

        ts.add(30);

        //遍历集合
        for(Integer i : ts) {
            System.out.println(i);
        }
    }
}

自然排序Comparable应用

- 案例需求
  - 存储学生对象并遍历，创建TreeSet集合使用无参构造方法
  - 要求：按照年龄从小到大排序，年龄相同时，按照姓名的字母顺序排序

- 实现步骤
  1. 使用空参构造创建TreeSet集合
     用TreeSet集合存储自定义对象，无参构造方法使用的是自然排序对元素进行排序的
  2. 自定义的Student类实现Comparable接口
     自然排序，就是让元素所属的类实现Comparable接口，重写compareTo(T o)方法
  3. 重写接口中的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;
        //次要判断条件: 年龄相同时，按照姓名的字母顺序排序
        result = result == 0 ? this.name.compareTo(o.getName()) : result;
        return result;
    }
}

//测试类

public class MyTreeSet2 {
    public static void main(String[] args) {
        //创建集合对象
        TreeSet<Student> ts = new TreeSet<>();
	    //创建学生对象
        Student s1 = new Student("zhangsan",28);
        Student s2 = new Student("lisi",27);
        Student s3 = new Student("wangwu",29);
        Student s4 = new Student("zhaoliu",28);
        Student s5 = new Student("qianqi",30);
		//把学生添加到集合
        ts.add(s1);
        ts.add(s2);
        ts.add(s3);
        ts.add(s4);
        ts.add(s5);
		//遍历集合
        for (Student student : ts) {
            System.out.println(student);
        }
    }
}

比较器排序Comparator的应用

//测试类   实现类用上面的学生类
public class MytreeSet5 {
    public static void main(String[] args) {


        //自然排序能做的,比较器都能做,自然排序做不了的,比较器也能做  ---基本上都用比较器
        TreeSet<String> treeSet = new TreeSet<>(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                int result = o1.length() - o2.length();
                result = result == 0 ? o1.compareTo(o2) : result;

                return result;
            }
        });
        treeSet.add("Z");
        treeSet.add("A");
        treeSet.add("R");
        treeSet.add("D");
        System.out.println(treeSet);
    }
}

两种比较方式总结

• 两种比较方式小结
  • 自然排序: 自定义类实现Comparable接口,重写compareTo方法,根据返回值进行排序
  • 比较器排序: 创建TreeSet对象的时候传递Comparator的实现类对象,重写compare方法,根据返回值进行排序
  • 在使用的时候,默认使用自然排序,当自然排序不满足现在的需求时,必须使用比较器排序

• 两种方式中关于返回值的规则
  • 如果返回值为负数，表示当前存入的元素是较小值，存左边
  • 如果返回值为0，表示当前存入的元素跟集合中元素重复了，不存
  • 如果返回值为正数，表示当前存入的元素是较大值，存右边