java学习笔记-TreeSet集合
概述：不可以重复，存取顺序不一致，没有带索引的方法，不可以使用普通的for循环进行遍历，也不能通过索引来获取删除set集合中的元素
package com.ustc.test5;
import java.util.Iterator;
import java.util.Set;
import java.util.TreeSet;
public class myset {
public static void main(String[] args) {
Set<String> set = new TreeSet<>();//set 是一个接口不可以直接使用
set.add("a");
set.add("b");
set.add("c");
set.add("d");
set.add("e");
set.add("e");
Iterator<String> it = set.iterator(); //迭代器
while(it.hasNext())
{
System.out.println(it.next());
}
}
}
TreeSet基本使用：不包含重复元素，没有带索引方法，将内部元素进行排序
- 指定排序规则1
如果compareTo的返回值是负数：表示当前存入的元素是较小值 存入左边，正数，存入右边，0 说明存入的元素和集合中的元素重复了，舍去
需求分析：如果年龄一样，按照姓名首字母进行排序
如果姓名和年龄一样，才认为是同一个学生对象 不存入
package com.ustc.test5;
import sun.reflect.generics.tree.Tree;
import java.util.TreeSet;
public class treeset {
public static void main(String[] args) {
TreeSet<Student> ts = new TreeSet<>();
Student s1 = new Student("xxx",21);
Student s2 = new Student("xxf",22);
Student s3 = new Student("xvf",23);
ts.add(s1);
ts.add(s2);
ts.add(s3);
System.out.println(ts);
}
}
package com.ustc.test5;
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; //按照对象年龄进行排序
//这个compareTo 和上面的compareTo不一样， 按照字典顺序比较字符串
result = result == 0 ? this.name.compareTo(o.getName()):result;//按照姓名进行排序
return result;
}
}
- 指定排序规则2：
比较器排序：TreeSet的带参构造方法使用的是比较器排序对元素进行排序
让集合构造方法接受Comparator实现类对象，重写compare(To1,To2)方法
重写方法时，一定要注意排序规则必须按照要求的主要条件和次要条件来写
package com.ustc.test5;
import sun.reflect.generics.tree.Tree;
import java.util.Comparator;
import java.util.TreeSet;
public class test11 {
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 = result == 0 ? o1.getName().compareTo(o2.getName()):result;//次要条件
return result;
}
});
Teacher t1 = new Teacher("zhangsan",23);
Teacher t2 = new Teacher("lisi",22);
Teacher t3 = new Teacher("wangwu",24);
ts.add(t1);
ts.add(t2);
ts.add(t3);
System.out.println(ts);
}
}
package com.ustc.test5;
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 +
'}';
}
}
两种方式比较：
自然排序：自定义实现接口Compareable 重写compareTo方法 根据返回值进行排序
比较器排序：创建treeSet对象的时候传递Comparator实现类对象，重写compare方法 根据返回值进行排序
需求：按照字符串的长度进行排序 如果长度一样长按照首字母进行排序
package com.ustc.test5;
import sun.reflect.generics.tree.Tree;
import java.util.Comparator;
import java.util.TreeSet;
public class test22 {
public static void main(String[] args) {
// TreeSet<String> ts = 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;
// }
// });
//上述方法使用匿名内部类进行重写方法
//下面的方法使用lambda进行重写
TreeSet<String> ts = new TreeSet<>(
(String o1,String o2)->{
int result = o1.length() - o2.length();
result = result == 0 ? o1.compareTo(o2):result;
return result;}
);
ts.add("c");
ts.add("ab");
ts.add("df");
ts.add("qwer");
System.out.println(ts);
}
}