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.排序器:
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("-------------------------");
}