java基础入门之TreeSet.docx
《java基础入门之TreeSet.docx》由会员分享，可在线阅读，更多相关《java基础入门之TreeSet.docx（22页珍藏版）》请在冰点文库上搜索。
java基础入门之TreeSet
1LinkedHashSet
packagecn.itcast_04;
importjava.util.LinkedHashSet;
/*
*LinkedHashSet:
底层数据结构由哈希表和链表组成。
*哈希表保证元素的唯一性。
*链表保证元素有素。
（存储和取出是一致）
*/
publicclassLinkedHashSetDemo{
publicstaticvoidmain（String[]args）{
//创建集合对象
LinkedHashSeths=newLinkedHashSet（）;
//创建并添加元素
hs.add（"hello"）;
hs.add（"world"）;
hs.add（"java"）;
hs.add（"world"）;
hs.add（"java"）;
//遍历
for（Strings:
hs）{
System.out.println（s）;
}
}
}
2TreeSetDemo.java
TreeSetDemo.java
packagecn.itcast_05;
importjava.util.TreeSet;
/*
*TreeSet：
能够对元素按照某种规则进行排序。
*排序有两种方式
*A:
自然排序
*B:
比较器排序
*
*TreeSet集合的特点：
排序和唯一
*
*通过观察TreeSet的add（）方法，我们知道最终要看TreeMap的put（）方法。
*/
publicclassTreeSetDemo{
publicstaticvoidmain（String[]args）{
//创建集合对象
//自然顺序进行排序
TreeSetts=newTreeSet（）;
//创建元素并添加
//20,18,23,22,17,24,19,18,24
ts.add（20）;
ts.add（18）;
ts.add（23）;
ts.add（22）;
ts.add（17）;
ts.add（24）;
ts.add（19）;
ts.add（18）;
ts.add（24）;
//遍历
for（Integeri:
ts）{
System.out.println（i）;
}
}
}
TreeSetDemo2.java
packagecn.itcast_05;
importjava.util.TreeSet;
/*
*TreeSet存储自定义对象并保证排序和唯一。
*
*A:
你没有告诉我们怎么排序
*自然排序，按照年龄从小到大排序
*B:
元素什么情况算唯一你也没告诉我
*成员变量值都相同即为同一个元素
*/
publicclassTreeSetDemo2{
publicstaticvoidmain（String[]args）{
//创建集合对象
TreeSetts=newTreeSet（）;
//创建元素
Students1=newStudent（"linqingxia",27）;
Students2=newStudent（"zhangguorong",29）;
Students3=newStudent（"wanglihong",23）;
Students4=newStudent（"linqingxia",27）;
Students5=newStudent（"liushishi",22）;
Students6=newStudent（"wuqilong",40）;
Students7=newStudent（"fengqingy",22）;
//添加元素
ts.add（s1）;
ts.add（s2）;
ts.add（s3）;
ts.add（s4）;
ts.add（s5）;
ts.add（s6）;
ts.add（s7）;
//遍历
for（Students:
ts）{
System.out.println（s.getName（）+"---"+s.getAge（））;
}
}
}
Student.java
packagecn.itcast_05;
/*
*如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
*/
publicclassStudentimplementsComparable{
privateStringname;
privateintage;
publicStudent（）{
super（）;
}
publicStudent（Stringname,intage）{
super（）;
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
@Override
publicintcompareTo（Students）{
//return0;
//return1;
//return-1;
//这里返回什么，其实应该根据我的排序规则来做
//按照年龄排序,主要条件
intnum=this.age-s.age;
//次要条件
//年龄相同的时候，还得去看姓名是否也相同
//如果年龄和姓名都相同，才是同一个元素
intnum2=num==0?
pareTo（s.name）:
num;
returnnum2;
}
}
4TreeSet的add方法
interfaceCollection{...}
interfaceSetextendsCollection{...}
interfaceNavigableMap{
}
classTreeMapimplementsNavigableMap{
publicVput（Kkey,Vvalue）{
Entryt=root;
if（t==null）{
compare（key,key）;//type（andpossiblynull）check
root=newEntry<>（key,value,null）;
size=1;
modCount++;
returnnull;
}
intcmp;
Entryparent;
//splitcomparatorandcomparablepaths
Comparator
superK>cpr=comparator;
if（cpr!
=null）{
do{
parent=t;
cmp=pare（key,t.key）;
if（cmp<0）
t=t.left;
elseif（cmp>0）
t=t.right;
else
returnt.setValue（value）;
}while（t!
=null）;
}
else{
if（key==null）
thrownewNullPointerException（）;
Comparable
superK>k=（Comparable
superK>）key;
do{
parent=t;
cmp=pareTo（t.key）;
if（cmp<0）
t=t.left;
elseif（cmp>0）
t=t.right;
else
returnt.setValue（value）;
}while（t!
=null）;
}
Entrye=newEntry<>（key,value,parent）;
if（cmp<0）
parent.left=e;
else
parent.right=e;
fixAfterInsertion（e）;
size++;
modCount++;
returnnull;
}
}
classTreeSetimplementsSet{
privatetransientNavigableMapm;
publicTreeSet（）{
this（newTreeMap（））;
}
publicbooleanadd（Ee）{
returnm.put（e,PRESENT）==null;
}
}
真正的比较是依赖于元素的compareTo（）方法，而这个方法是定义在Comparable里面的。
所以，你要想重写该方法，就必须是先Comparable接口。
这个接口表示的就是自然排序。
5按照姓名长度排序
TreeSetDemo.java
packagecn.itcast_06;
importjava.util.TreeSet;
/*
*需求：
请按照姓名的长度排序
*/
publicclassTreeSetDemo{
publicstaticvoidmain（String[]args）{
//创建集合对象
TreeSetts=newTreeSet（）;
//创建元素
Students1=newStudent（"linqingxia",27）;
Students2=newStudent（"zhangguorong",29）;
Students3=newStudent（"wanglihong",23）;
Students4=newStudent（"linqingxia",27）;
Students5=newStudent（"liushishi",22）;
Students6=newStudent（"wuqilong",40）;
Students7=newStudent（"fengqingy",22）;
Students8=newStudent（"linqingxia",29）;
//添加元素
ts.add（s1）;
ts.add（s2）;
ts.add（s3）;
ts.add（s4）;
ts.add（s5）;
ts.add（s6）;
ts.add（s7）;
ts.add（s8）;
//遍历
for（Students:
ts）{
System.out.println（s.getName（）+"---"+s.getAge（））;
}
}
}
Student.java
packagecn.itcast_06;
/*
*如果一个类的元素要想能够进行自然排序，就必须实现自然排序接口
*/
publicclassStudentimplementsComparable{
privateStringname;
privateintage;
publicStudent（）{
super（）;
}
publicStudent（Stringname,intage）{
super（）;
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
@Override
publicintcompareTo（Students）{
//主要条件姓名的长度
intnum=this.name.length（）-s.name.length（）;
//姓名的长度相同，不代表姓名的内容相同
intnum2=num==0?
pareTo（s.name）:
num;
//姓名的长度和内容相同，不代表年龄相同，所以还得继续判断年龄
intnum3=num2==0?
this.age-s.age:
num2;
returnnum3;
}
}
7按照姓名长度排列
TreeSetDemo.java
packagecn.itcast_07;
importjava.util.Comparator;
importjava.util.TreeSet;
/*
*需求：
请按照姓名的长度排序
*
*TreeSet集合保证元素排序和唯一性的原理
*唯一性：
是根据比较的返回是否是0来决定。
*排序：
*A:
自然排序（元素具备比较性）
*让元素所属的类实现自然排序接口Comparable
*B:
比较器排序（集合具备比较性）
*让集合的构造方法接收一个比较器接口的子类对象Comparator
*/
publicclassTreeSetDemo{
publicstaticvoidmain（String[]args）{
//创建集合对象
//TreeSetts=newTreeSet（）;//自然排序
//publicTreeSet（Comparatorcomparator）//比较器排序
//TreeSetts=newTreeSet（newMyComparator（））;
//如果一个方法的参数是接口，那么真正要的是接口的实现类的对象
//而匿名内部类就可以实现这个东西
TreeSetts=newTreeSet（newComparator（）{
@Override
publicintcompare（Students1,Students2）{
//姓名长度
intnum=s1.getName（）.length（）-s2.getName（）.length（）;
//姓名内容
intnum2=num==0?
s1.getName（）.compareTo（s2.getName（））
:
num;
//年龄
intnum3=num2==0?
s1.getAge（）-s2.getAge（）:
num2;
returnnum3;
}
}）;
//创建元素
Students1=newStudent（"linqingxia",27）;
Students2=newStudent（"zhangguorong",29）;
Students3=newStudent（"wanglihong",23）;
Students4=newStudent（"linqingxia",27）;
Students5=newStudent（"liushishi",22）;
Students6=newStudent（"wuqilong",40）;
Students7=newStudent（"fengqingy",22）;
Students8=newStudent（"linqingxia",29）;
//添加元素
ts.add（s1）;
ts.add（s2）;
ts.add（s3）;
ts.add（s4）;
ts.add（s5）;
ts.add（s6）;
ts.add（s7）;
ts.add（s8）;
//遍历
for（Students:
ts）{
System.out.println（s.getName（）+"---"+s.getAge（））;
}
}
}
Student.java
packagecn.itcast_07;
publicclassStudent{
privateStringname;
privateintage;
publicStudent（）{
super（）;
}
publicStudent（Stringname,intage）{
super（）;
this.name=name;
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicintgetAge（）{
returnage;
}
publicvoidsetAge（intage）{
this.age=age;
}
}
MyComparator.java
packagecn.itcast_07;
importjava.util.Comparator;
publicclassMyComparatorimplementsComparator{
@Override
publicintcompare（Students1,Students2）{
//intnum=this.name.length（）-s.name.length（）;
//this--s1
//s--s2
//姓名长度
intnum=s1.getName（）.length（）-s2.getName（）.length（）;
//姓名内容
intnum2=num==0?
s1.getName（）.compareTo（s2.getName（））:
num;
//年龄
intnum3=num2==0?
s1.getAge（）-s2.getAge（）:
num2;
returnnum3;
}
}
9总分高低排序
HashSetDemo.java
packagecn.itcast_08;
importjava.util.HashSet;
importjava.util.Random;
/*
*编写一个程序，获取10个1至20的随机数，要求随机数不能重复。
*
*分析：
*A:
创建随机数对象
*B:
创建一个HashSet集合
*C:
判断集合的长度是不是小于10
*是：
就创建一个随机数添加
*否：
不搭理它
*D:
遍历HashSet集合
*/
publicclassHashSetDemo{
publicstaticvoidmain（String[]args）{
//创建随机数对象
Randomr=newRandom（）;
//创建一个Set集合
HashSetts=newHashSet（）;
//判断集合的长度是不是小于10
while（ts.size（）<10）{
intnum=r.nextInt（20）+1;
ts.add（num）;
}
//遍历Set集合
for（Integeri:
ts）{
System.out.println（i）;
}
}
}
TreeSetDemo.Java
packagecn.itcast_08;
importjava.util.Comparator;
importjava.util.Scanner;
importjava.util.TreeSet;
/*
*键盘录入5个学生信息（姓名,语文成绩,数学成绩,英语成绩）,按照总分从高到低输出到控制台
*
*分析：
*A:
定义学生类
*B:
创建一个TreeSet集合
*C:
总分从高到底如何实现呢?
*D:
键盘录入5个学生信息
*E:
遍历TreeSet集合
*/
publicclassTreeSetDemo{
publicstaticvoidmain（String[]args）{
//创建一个TreeSet集合
TreeSetts=newTreeSet（newComparator（）{
@Override
publicintcompare（Students1,Students2）{
//总分从高到低
intnum=s2.getSum（）-s1.getSum（）;
//总分相同的不一定语文相同
intnum2=num==0?
s1.getChinese（）-s2.getChinese（）:
num;
升级会员 