java系统学习（十四） --------常用数据结构

链表

什么是java中的链表

如果把数组作为一种数据结构，可能更容易理解。数组这种结构有一个很大的缺点，数组中的所有元素都按序排列，如果要删除其中一个元素，后面的所有元素都需要依次

向前移动一个位置。如果这个数组中的元素很多，那么依次移动的次数就会明显增多，从而耗费大量的系统资源。

为了解决这个问题，引入了链表。

在Java语言中，链表中的元素存储在一条链的节点上，而不是像数组那样按序存储在一系列连续的空间中。



从图可以看出，如果在数组中删除一个元素，那么后面所有的元素都必须向前移动一位。如果元素比较多，那么移动的次数就会增加。从图中链表图中可以看出，删除一个元素时，只需将被删除元素的前一个元素的指针，指向被删除元素的后一个元素，使得被删除的元素脱离链表

就相当干删除了元素。链表不需要像数组那样移动元素，这样就节约了系统资源。

双向链表的结构如图



双链表每个元素都拥有两个指针属性，一个是previous指针，一个是next指针。每个元素的next指针都会指向下一个元素本身，而下一个个元素的previous指针都会指向上一个元素本身。这样，

要删除元素就比较简单了，只需要让被删元素前面元素的previous指针.指向被删元素后面的元素本身，再将被删除元素后面元素的next指针，指向被删除元素的前面元素本身即可。

对链表的添加实例

当向链表添加元素素时，需要分析多种情况。

口插入到空表:如果链表是一个空表，只需使head指向被插入的节点即可。

口插入到头指针后面:若链表中的节点没有顺序,可将新节点插入到head之后，再让插入节点的next指针指向原head指针指向的节点即可。

口插入到链表最后:若链表中的节点没有顺序，也可将新节点插人到链表的最后。需将最后一个节点的next指针指向新节点，再将新节点的next指针设置为null即可。

口插入到链表的中间:这是比较复杂的一种情况.对干有序的链表，会用到这种情况。需要遍历链表，井对每个节点的关键字进行比较，找到合适的位置，再将新节点插人

对链表的删除实例。这种方式，需要修改插入位置前节点的next指针，使其指向新插入的节点，然后再将新插入节点的next指针设置为指向下一个节点。

Public class filel{
public void add(){
LinkedList List=new LinkedList();//创建一个链表类对象List
//添加元素到对象List里
List .add("王鹏");
List.add("王浩");
Lis七.add("王杰");
Lis七.add("张杰");
List.add("李杰");
List.add("孙文杰");
List.add("赵杰");
Iterator it=List.iterator();//创建一个迭代器对象it
system.out.println("现在添加了如下的同学的姓名");
//通过:迭代器对象it来遍历List对象中的元素
while(it.hasNext()){
System.out.Println(it.next());
}
system.out.println("删除某些同学的姓名后，还剩下哪些同学呢?");
it.remove();//移除元素
//创建另一个迭代器对象itl来重新遍历list对象中的元素
Iterator itl=List.iterator();
for(inti=0;i<List.size();i++){
System.out.Println(itl.next());
}
}
public static void main(string[} args){//主方法
filel  f=new filel();//创建对象f
f.add();//调用方法add()
}
}

结果:
王鹏

王浩

王杰

张杰

李杰

孙文杰

赵杰

删除某些同学的姓名后还剩下哪些同学呢。

王鹏

王浩

王杰

张杰

李杰

孙文杰

因为第一个迭代器在遍历后，已经到了链表的末尾.所以必须再建立一个新的迭代器，重新让指针停留在链表第一个元素的前面。

对链表删除的实例

class student{  //创建一个学生类
//创建成员变量
String name;
int age;
String sexy;
String code;
String school;
String grade;
string major;
String address;
//创建两个student类型属性
studentx;
studenty;
student(String name){
this.name=name;
}
//带参构造函数
Public void set(int age，String sexy，string code，String scbool,
string grade，string major，string address){
this .age=age;
this .sexy=sexy;
this .school=school;
this .grade=grade;
this.major=major;
this.code=code;
this.address=address;
}
//创建各种属性的访问器
Public strinq getname(){
retUrn name;
}
Public string getcode(){
return name;
}
Public String getsexy(){
return sexy;
}
Public int getage(){
return age;
}
Public String getschool(){
return school;
}
public string getmajor(){
return major;
}
public Strinq getgrade(){
return grade;
}
Public String getaddress(){
return address'
}
//重写toString()方法是让对象以字符串的形式输出的方法
Public String toString(){
string information="学生姓名:"+name+" "+"学号:"+code+" "+"性别:"
+sexy+" "+"年龄:"+age+" "+"所在学校:"+school+" "
+"所学专业:"+major+" "+"所在年级:"+grade+" "+"家庭地址:"
+address;
return information;
}
}

Public class file2{  //创建测试类file2
Publie static void main(string[] args){ //主方法
//创建10个学生对象
student stl=new student("王鹏");
student st2=new student("王浩");
student st3=new student("孙鹏");
student st4=new student("孙文君");
student st5=new student("谭妮");
student st6=new student("赵志强");
student st7=new student("王凯");
student st8=new student("苏瑞");
student st9=new student("张伟");
student st10=new student("张杰");
//设置学生信息
st1.set(20,"男"，"10000","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st2.set(22,"男"，"10001","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st3.set(21,"男"，"10002","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st4.set(19,"女"，"10003","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st5.set(18,"女"，"10004","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st6.set(24,"男"，"10005","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st7.set(22,"男"，"10006","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st8.set(29,"女"，"10007","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st9.set(25,"女"，"10008","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
st10.set(28,"男"，"10009","重庆大学","大学三年级","计算机专业","重庆市沙坪坝区");
try{
LinkedList listl=new LinkedList(); //创建对象listl
//添加10个学生对象到对象listl中
listl.add(stl);
listl.add(st2);
listl.add(st3);
listl.add(st4);
listl.add(st5);
listl.add(st6);
listl.add(st7);
listl.add(st8);
listl.add(st9);
listl.add(st10);
//it是迭代器对象通过它来指向链表中的元素
Iterator it=listl.iterator();
System.out.println("以下就是所有的同学的信息:");
while(it.hasNext()){//通过循环输出相应信息
system.out.println(it.next());
}
System.out.println("其中有几个同学已经转学了!");
System.out.print1n("那么就从数据库中删除他:");
//移除相应信息
listl.relnove();
listl.remove();
listl.remove();
listl.reynove();
listl.remove();
Iterator it1=List1.iterator();//获取迭代器对象itl
while(itl.hasNext()){
System.out.Println(itl.next());
}
}catch(Exception e){
}
}
}

数组列表类

什么是数组列表类

数组的容量一旦被初始化就不可以再更改。这对于正在运行的程序来说，是一种缺陷。在程序设计过程中，经常会遇到一些不确定的因素，导致无法确定一个数组的容量。为了解决这个问题，java引进了数组列表。

数组列表类就是数组的一个扩展类，它继承了数组的特点，并且具有自己的特性。

数组列表就是一个可以动态变化容量的数组，其根据正在运行的程序的变化，随时改变数组的容量，以满足程序的需要。

ArrayList类是Java API所提供的类，定义在Java.util包里，所以每次编写程序的时候都必

须引入这个包。数组列表中存放的是Object类型，因此在数组列表中存放的对象类型，以其原型的父类代替。如果要提取其中的元素，都要进行类型转换，将元素还原为它本身的类型。

由于ArrayList是个可以自动伸缩的数组，所以可以无限制地向数组中添加新元素。另外，因为添加的是object类的子类类型，所以系统会自动地完成子类向父类的转换。

如果能预计一个数组列表中需要存储多少元素，那么可以在填充之前，调用"ensureCapacity()"方法，使得系统分配一个包含固定容量的内部数组。

实例熟悉数组列表

数组列表(ArrayList)的构造函数和常用方法如下。

口ArrayList():这是一个默认构造函数，系统默认的初始化容量是10。

口ArrayList(Collection):构建一个数组列表的对象，这个数组列表中包含集合的所有元素。

口ArrayList(int initcapcity):构建一个指定初始化容量的数组列表对象。

口void add(int index，object element):在指定位置插入指定的元素。

口boolean add(object):在数组列表的末尾追加一个新元素。

口boolean contains(object element):测试指定的数组列表中是否包含有指定的元素element，如果包含该元素则返回true，反之返回false。

口int size():返回数组列表中包含元素的数量。

口void set(int index，object obj):设置数组列表指定位置元素的值，它会覆盖原来的内容。要强调的就是index必须在0到size()-1之间。

口object get(int index):得到指定位置存储的元素值。

口object remove(int index):删除指定位置的元素。

class teacher{//创建教师对象类
//创建成员变量
private string schoolname;//关于教师所在学校名称属性
private string classname;//关于教师所教班级名称属性
private string teachername;//关于教师姓名属性
private string teachercode://关于教师工号属性
private string teachersexy;//关于教师性别属性
private string teacherbirthday;//关于教师出生年月属性
private string familyaddress://关于教师家庭地址属性
//带参构造函数
public teacher(String teachernamee，String teachercode，String teachersexy，
string teacherbirthday)(
this.teachername=teachername;
this.teachercode=teachercode;
this.teachersexy=teachersexy;
this.teacherbirthday=teacherbirthday;
}
//关于各个属性的访问器
public String getname(){
return teachername;
}
public String getcode(){
return teachercode;
}
public String getsexy(){
return teachersexy;
}
public String getbirthday(){
return teacherbirthday;
}
public void setschoolname(String schoolname){
this.schoolname=schoolname;
}
public void setclassname(String classname){
this.classname=classname;
}
public void setfamilyaddress(String familyaddress){
this.familyaddress=familyaddress;
}
public String getschoalname(){
return schoolname
}
public String getclassname(){
return classname;
}
public String getfamilyaddress(){
return familyaddress;
}
//重写toString()方法以使得对象能够以字符串形式输出的方法
public String toString(){
String infor="学校名称："+schoolname+" "+"班级名称："+classname+" "+"教师姓名："+steachername+" "+"教师工号："+teachercode+" "+"性别："+teachersexy+" "+"出生年月："+teacherbirthday+" "+"家庭地址："+familyaddress;
return infor；
}
}

public class  testl{
public static void main(String[] args){
ArrayList al=new ArrayList();
//创建7个教师对象
teacher t=new teacher("孟凡良","34512","男","1954-09-23");
teacher tl=new teacher("赵浩","1234001","男","1981-01-02");
teacher t2=new teacher("黎平","1234002","男","1982-08-09");
teacher t3=new teacher("王鹏","1234003","男","1982-11-22");
teacher t4=new teacher("宋波","1234004","女","1982-11-02");
teacher t5=new teacher("童伟","1234005","男","1980-01-12");
teacher t6=new teacher("孙君","1234006","女","1981-09-22");
//设置教师对象信息
tl.setschoolname("重庆大学");
tl.setclassname("计算机三班"’)，
tl.setfamilyaddress("重庆沙坪坝");
t2.setschoolname("重庆大学"”);
t2.setclassname("计算机三班");
t2.setfamilyaddress("重庆沙坪坝");
t3.setschoolname("重庆大学");
t3.setclassname("计算机三班");
t3.setfamilyaddress("重庆沙坪坝");
t4.setschoolname("重庆大学");
t4.setclassname("计算机三班");
t4.setfamilyaddress("重庆沙坪坝");
t5.setschoolname("重庆大学");
t5.setclassname("计算机三班");
t5.setfamilyaddress("重庆沙坪坝");
t6.setschoolname("重庆大学");
t6.setclassnarne("计算机三班");
t6.setfamilyaddress("重庆沙坪坝");
t.setschoolname("成都科技大学");
t.setc1assname("机械系三班");
t.setfamilyaddress("成都市区");
//把每个对象添加到数组列表中去
al.add(tl);
al.add(t2);
al.add(t3);
al.add(t4);
al.add(ts);
al.add(t6);
System.out.println("这个小组有"+al.size()+"个教师。");
//输出数组列表中的元素个数
for(int i=O;i<al .sizee();i++){
//输出数组列表中的元素以字符串形式
system.out.println((teacher)al.get(i));
}
System.out.println("对不起.系统出错了!有个教师信息错了，需要改正。"）;
al.set(5,t);
System.out.println("经过我们的审核后，教师信息如下:");
for(int i=0;i<al.size();i++){
System.out.Println((teacher)al.get(i));
}
//删除数组列表中的元素
al.remove(2);
al.remove(4);
System.out.println(”有两个教师辞职了，所以剩下教师信息为:");
for(int i=O;i<al.size();i++){
//输出剩下的数组别表中的元素
System.out.Println((teacher)al.get(i));
}
}
}

散列表

什么是散列表

在链表和数组列表中，要想查找某个特定的元素，就必须从头开始遍历。如果一个链表或者一个数组列表拥有的元素数量很大，那么就需要耗费大量的系统资源，去遍历整个数据结构。如何克服这个弊病?此时，就引进了另一个数据结构:散列表。

散列表通过“键一值对应”的形式存储元素。与链表和数组列表不同，它是一个无序的数据结构。

实例熟悉散列表

散列表(Hash table)的构造函数如下:

口Hashtable():构建一个空的散列表，初始容量为1l，负载因子为0.75。

口Hashtable(int initalCapacity,float loadFactor):指定初始化容量和负载因子，构造一个散列表。

口Hashtable(Map t):根据映像所包含的元素，构建一个散列表。

散列表(Hash table)的主要方法如下。

口object put( object key,object vaule):put方法是向一个散列表中添加元素。在散列表中根据所添加元素的键值来定位元素，这个键值是唯一的。针对这个方法，要记住这个键

值一定是对象型数据。

口boolean containskey(object key)和boolean containvalue(object valt:e):这两个方法是测试散列表中是否包含指定的键值和值。

口Object remove(object key):根据指定的键值从散列表中删除对应键的元素。

口collection values():返回散列表中所包含元素的集合，是元素的集合，而不是key的集合。

class teacher{//创建教师对象类
//创建成员变量
private string schoolname;//关于教师所在学校名称属性
private string classname;//关于教师所教班级名称属性
private string teachername;//关于教师姓名属性
private string teachercode://关于教师工号属性
private string teachersexy;//关于教师性别属性
private string teacherbirthday;//关于教师出生年月属性
private string familyaddress://关于教师家庭地址属性
//带参构造函数
public teacher(String teachernamee，String teachercode，String teachersexy，
string teacherbirthday)(
this.teachername=teachername;
this.teachercode=teachercode;
this.teachersexy=teachersexy;
this.teacherbirthday=teacherbirthday;
}
//关于各个属性的访问器
public String getname(){
return teachername;
}
public String getcode(){
return teachercode;
}
public String getsexy(){
return teachersexy;
}
public String getbirthday(){
return teacherbirthday;
}
public void setschoolname(String schoolname){
this.schoolname=schoolname;
}
public void setclassname(String classname){
this.classname=classname;
}
public void setfamilyaddress(String familyaddress){
this.familyaddress=familyaddress;
}
public String getschoalname(){
return schoolname
}
public String getclassname(){
return classname;
}
public String getfamilyaddress(){
return familyaddress;
}
//重写toString()方法以使得对象能够以字符串形式输出的方法
public String toString(){
String infor="学校名称："+schoolname+" "+"班级名称："+classname+" "+"教师姓名："+steachername+" "+"教师工号："+teachercode+" "+"性别："+teachersexy+" "+"出生年月："+teacherbirthday+" "+"家庭地址："+familyaddress;
return infor；
}
}

public class  test2{
public static void main(String[] args){
Hashtable ht=new Hashtable();
//创建7个教师对象
teacher t=new teacher("孟凡良","34512","男","1954-09-23");
teacher tl=new teacher("赵浩","1234001","男","1981-01-02");
teacher t2=new teacher("黎平","1234002","男","1982-08-09");
teacher t3=new teacher("王鹏","1234003","男","1982-11-22");
teacher t4=new teacher("宋波","1234004","女","1982-11-02");
teacher t5=new teacher("童伟","1234005","男","1980-01-12");
teacher t6=new teacher("孙君","1234006","女","1981-09-22");
tl.setschoolname("重庆大学");
tl.setclassname("计算机三班"’)，
tl.setfamilyaddress("重庆沙坪坝");
t2.setschoolname("重庆大学"”);
t2.setclassname("计算机三班");
t2.setfamilyaddress("重庆沙坪坝");
t3.setschoolname("重庆大学");
t3.setclassname("计算机三班");
t3.setfamilyaddress("重庆沙坪坝");
t4.setschoolname("重庆大学");
t4.setclassname("计算机三班");
t4.setfamilyaddress("重庆沙坪坝");
t5.setschoolname("重庆大学");
t5.setclassname("计算机三班");
t5.setfamilyaddress("重庆沙坪坝");
t6.setschoolname("重庆大学");
t6.setclassnarne("计算机三班");
t6.setfamilyaddress("重庆沙坪坝");
t.setschoolname("成都科技大学");
t.setc1assname("机械系三班");
t.setfamilyaddress("成都市区");
//在散列表中添加元素
ht.put("zh",t1);
ht.put("lp",t2);
ht.put("wp",t3);
ht.put("sb",t4);
ht.put("zw",t5);
ht.put("sj",t6);
System.out.println("这个小组有"+ht.size()+"个教师。");
System.out.println(ht.values());
System.out.println("我需要查找一个教师的信息。");
//输出散列表中的元素内容
if (ht.containsKey("wh")){
System.out.println("找到了此教师的信息.如下:");
System.out.println((teacher)ht.get("ww"));
}else{
System.out.println("没有找到此教师的信息!");
}
ht.remove("lp");//删除散列表中的元素
ht .remove("sj");
System.out.println("由于有些教师离开了学校,经过我们的审核后教师信息如下:");
System.out，println(ht.values());//输出散列表中剩下的元素内容
}
}

散列集

什么是散列集

散列表和散列集这两种数据结构，功能基本相同，不过它们实现的接口不一样。散列表实现的是Map(映像)接口，而散列集实现了Set接口。另外，散列表是线性同步，而散列集是非线性同步。

散列集( HashSet )既然实现了Set接口 ,也就实现了Collection接口，所以它是一个集合。仍然是add方法添加元素，接下来介绍散列集的构造函数和常用方法函数。

散列集( HashSet)的构造函数如下:

口HashSet():创建一个空的散列集对象。

口HashSet(collection c):创建一个包含有collection集合中所有元素的散列集对象。

口HashSet(int initialCapacity）:创建一个初始容量为initialCapacity的散列集对象。

口HashSet(int initialCapacity,float loadFactor):指定初始化容量和负载因子，构造一个散列表。它的初始容量是16，负载因子为0.75

散列集(HashSet)的常用方法如下:

口Boolean add(o):添加一个元素到散列集中。如果这个元素在散列集不存在，就直接添加它，否则就返回false

口Boolean remove(o):删除一个元素，如果这个元素存在，就删除它，否则就返回false

口Boolean isempty():判断集合是否为空。

当然散列集的方法不止这些，此处只是列出其中常用的。在后面的程序中，还会遇到一些到时候再介绍。

实例熟悉散列集

class teacher{//创建教师对象类
//创建成员变量
private string schoolname;//关于教师所在学校名称属性
private string classname;//关于教师所教班级名称属性
private string teachername;//关于教师姓名属性
private string teachercode://关于教师工号属性
private string teachersexy;//关于教师性别属性
private string teacherbirthday;//关于教师出生年月属性
private string familyaddress://关于教师家庭地址属性
//带参构造函数
public teacher(String teachernamee，String teachercode，String teachersexy，
string teacherbirthday)(
this.teachername=teachername;
this.teachercode=teachercode;
this.teachersexy=teachersexy;
this.teacherbirthday=teacherbirthday;
}
//关于各个属性的访问器
public String getname(){
return teachername;
}
public String getcode(){
return teachercode;
}
public String getsexy(){
return teachersexy;
}
public String getbirthday(){
return teacherbirthday;
}
public void setschoolname(String schoolname){
this.schoolname=schoolname;
}
public void setclassname(String classname){
this.classname=classname;
}
public void setfamilyaddress(String familyaddress){
this.familyaddress=familyaddress;
}
public String getschoalname(){
return schoolname
}
public String getclassname(){
return classname;
}
public String getfamilyaddress(){
return familyaddress;
}
//重写toString()方法以使得对象能够以字符串形式输出的方法
public String toString(){
String infor="学校名称："+schoolname+" "+"班级名称："+classname+" "+"教师姓名："+steachername+" "+"教师工号："+teachercode+" "+"性别："+teachersexy+" "+"出生年月："+teacherbirthday+" "+"家庭地址："+familyaddress;
return infor；
}
}

public class  test3{
public static void main(String[] args){
HashSet hs=new HashSet();
//创建7个教师对象
teacher t=new teacher("孟凡良","34512","男","1954-09-23");
teacher tl=new teacher("赵浩","1234001","男","1981-01-02");
teacher t2=new teacher("黎平","1234002","男","1982-08-09");
teacher t3=new teacher("王鹏","1234003","男","1982-11-22");
teacher t4=new teacher("宋波","1234004","女","1982-11-02");
teacher t5=new teacher("童伟","1234005","男","1980-01-12");
teacher t6=new teacher("孙君","1234006","女","1981-09-22");
tl.setschoolname("重庆大学");
tl.setclassname("计算机三班"’)，
tl.setfamilyaddress("重庆沙坪坝");
t2.setschoolname("重庆大学"”);
t2.setclassname("计算机三班");
t2.setfamilyaddress("重庆沙坪坝");
t3.setschoolname("重庆大学");
t3.setclassname("计算机三班");
t3.setfamilyaddress("重庆沙坪坝");
t4.setschoolname("重庆大学");
t4.setclassname("计算机三班");
t4.setfamilyaddress("重庆沙坪坝");
t5.setschoolname("重庆大学");
t5.setclassname("计算机三班");
t5.setfamilyaddress("重庆沙坪坝");
t6.setschoolname("重庆大学");
t6.setclassnarne("计算机三班");
t6.setfamilyaddress("重庆沙坪坝");
t.setschoolname("成都科技大学");
t.setc1assname("机械系三班");
t.setfamilyaddress("成都市区");
hs.add(t1);
hs.add(t2);
hs.add(t3);
hs.add(t4);
hs.add(t5);
hs.add(t6);
System.out.println("这个小组有"+hs.size()+"个教师。");
//输出散列集的元素个数
Iterator it=hs.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
hs.remove(t3);
hs.remove(t4);
System.out.println("由于有些教师离开了学校，经过我们的审核后，教师信息如下:");
Iterator it1=hs.iterator();//新建一个迭代器对象
while(it1.hasNext()){
System.out.println(itl.next());
}
System.out.println("这些教师今天都离职了，所有教师信息都可以删除了!");
hs.remove(tl);//删除散列集中的元素
hs.remove(t2);
hs.remove(t5);
hs.remove(t6);
if (hs.isEmpty()){//当hs中的元素为空时
System.out.println("这里把教师信息都删除了");
}else{
System.out.println("系统报错了!!!");
}
}
｝

树集

什么是树集

树集有点像散列集，但与散列集不同，树集是一种有序的数据结构。可以使用各种次序往树集中添加元素。当遍历时，元素出现次序是有序的。不过这种次序由系统自动完成。

那么系统是如何对其进行自动排序的呢?系统每添加一个元素时，将按照字典顺序比较相应的字符串，按相应顺序来完成排序。

树集的构造函数和常用的方法函数。树集(TreeSet )的构造函数如下:

口TreeSet():创建一个空的树集对象。

口TreeSet(collection c)：创建一个树集对象，并且用指定的比较器给它的元素排序。

口TreeSet(sortedSet element);创建一个树集，并把有序集element的所有元素插入树中,它使用与有序集element相同的元素比较器。

树集(TreeSet)的常用方法函数如下:

口Boolean add(object o):添加一个对象元素到树集中去。

口Boolean remove(object o):从树集中删除一个对象元素。

实例熟悉树集

class teacher implements Comparable{//设计实现Comparable接口的teacher

//创建成员变量
private string schoolname;//关于教师所在学校名称属性
private string classname;//关于教师所教班级名称属性
private string teachername;//关于教师姓名属性
private string teachercode://关于教师工号属性
private string teachersexy;//关于教师性别属性
private string teacherbirthday;//关于教师出生年月属性
private string familyaddress://关于教师家庭地址属性
//带参构造函数
public teacher(String teachernamee，String teachercode，String teachersexy，
string teacherbirthday)(
this.teachername=teachername;
this.teachercode=teachercode;
this.teachersexy=teachersexy;
this.teacherbirthday=teacherbirthday;
}
public int compareTo(Object o){ //实现方法compareTo
teacher t=(teacher) o;//转换成teacher对象
return(t.teachercode - teachercode);

}

//关于各个属性的访问器
public String getname(){
return teachername;
}
public String getcode(){
return teachercode;
}
public String getsexy(){
return teachersexy;
}
public String getbirthday(){
return teacherbirthday;
}
public void setschoolname(String schoolname){
this.schoolname=schoolname;
}
public void setclassname(String classname){
this.classname=classname;
}
public void setfamilyaddress(String familyaddress){
this.familyaddress=familyaddress;
}
public String getschoalname(){
return schoolname
}
public String getclassname(){
return classname;
}
public String getfamilyaddress(){
return familyaddress;
}
//重写toString()方法以使得对象能够以字符串形式输出的方法
public String toString(){
String infor="学校名称："+schoolname+" "+"班级名称："+classname+" "+"教师姓名："+steachername+" "+"教师工号："+teachercode+" "+"性别："+teachersexy+" "+"出生年月："+teacherbirthday+" "+"家庭地址："+familyaddress;
return infor；
}
}

public class  test6{
public static void main(String[] args){
ThreeSet ts=new ThreeSet();
//创建7个教师对象
teacher t=new teacher("孟凡良","34512","男","1954-09-23");
teacher tl=new teacher("赵浩","1234001","男","1981-01-02");
teacher t2=new teacher("黎平","1234002","男","1982-08-09");
teacher t3=new teacher("王鹏","1234003","男","1982-11-22");
teacher t4=new teacher("宋波","1234004","女","1982-11-02");
teacher t5=new teacher("童伟","1234005","男","1980-01-12");
teacher t6=new teacher("孙君","1234006","女","1981-09-22");
tl.setschoolname("重庆大学");
tl.setclassname("计算机三班"’)，
tl.setfamilyaddress("重庆沙坪坝");
t2.setschoolname("重庆大学"”);
t2.setclassname("计算机三班");
t2.setfamilyaddress("重庆沙坪坝");
t3.setschoolname("重庆大学");
t3.setclassname("计算机三班");
t3.setfamilyaddress("重庆沙坪坝");
t4.setschoolname("重庆大学");
t4.setclassname("计算机三班");
t4.setfamilyaddress("重庆沙坪坝");
t5.setschoolname("重庆大学");
t5.setclassname("计算机三班");
t5.setfamilyaddress("重庆沙坪坝");
t6.setschoolname("重庆大学");
t6.setclassnarne("计算机三班");
t6.setfamilyaddress("重庆沙坪坝");
t.setschoolname("成都科技大学");
t.setc1assname("机械系三班");
t.setfamilyaddress("成都市区");
ts.add(t1);
ts.add(t2);
ts.add(t3);
ts.add(t4);
ts.add(t5);
ts.add(t6);
System.out.println("这个小组有"+ts.size()+"个教师。");
//输出树集的元素个数
Iterator it=ts.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
hs.remove(t3);
hs.remove(t4);
System.out.println("由于有些教师离开了学校，经过我们的审核后，教师信息如下:");
Iterator it1=ts.iterator();//新建一个迭代器对象
while(it1.hasNext()){
System.out.println(itl.next());
}
System.out.println("这些教师今天都离职了，所有教师信息都可以删除了!");
ts.remove(tl);//删除散列集中的元素
ts.remove(t2);
ts.remove(t5);
ts.remove(t6);
if (ts.isEmpty()){//当hs中的元素为空时
System.out.println("这里把教师信息都删除了");
}else{
System.out.println("系统报错了!!!");
}
}
｝

映像

什么是映像

集合是一种可以快速查找已存在元素的数据结构。但如果数据库中拥有大量的数据，一般不用集合，因为它会耗费系统大量的资源和时间，去遍历整个数据结构。

前面讲过散列表，其实散列表就是一种映像。下面通过一个实例让读者对映像的概念有更深的认识。

映像是一种采用“键值一值”的对应方式存储数据的数据结构形式。在映像中，除了散列表，还有树映像和散列映像。由于映像不能使用迭代器，所以映像拥有get方法函数。无论是树映像，还是散列映像或散列表，它们的使用方法都差不多。

实例熟悉映像

下面通过实例了解树映像。

class teacher{

//创建成员变量
private string schoolname;//关于教师所在学校名称属性
private string classname;//关于教师所教班级名称属性
private string teachername;//关于教师姓名属性
private string teachercode://关于教师工号属性
private string teachersexy;//关于教师性别属性
private string teacherbirthday;//关于教师出生年月属性
private string familyaddress://关于教师家庭地址属性
//带参构造函数
public teacher(String teachernamee，String teachercode，String teachersexy，
string teacherbirthday)(
this.teachername=teachername;
this.teachercode=teachercode;
this.teachersexy=teachersexy;
this.teacherbirthday=teacherbirthday;
}

//关于各个属性的访问器
public String getname(){
return teachername;
}
public String getcode(){
return teachercode;
}
public String getsexy(){
return teachersexy;
}
public String getbirthday(){
return teacherbirthday;
}
public void setschoolname(String schoolname){
this.schoolname=schoolname;
}
public void setclassname(String classname){
this.classname=classname;
}
public void setfamilyaddress(String familyaddress){
this.familyaddress=familyaddress;
}
public String getschoalname(){
return schoolname
}
public String getclassname(){
return classname;
}
public String getfamilyaddress(){
return familyaddress;
}
//重写toString()方法以使得对象能够以字符串形式输出的方法
public String toString(){
String infor="学校名称："+schoolname+" "+"班级名称："+classname+" "+"教师姓名："+steachername+" "+"教师工号："+teachercode+" "+"性别："+teachersexy+" "+"出生年月："+teacherbirthday+" "+"家庭地址："+familyaddress;
return infor；
}
}

public class  test7{
public static void main(String[] args){
ThreeMap tm=new ThreeMap ();
//创建6个教师对象
teacher tl=new teacher("赵浩","1234001","男","1981-01-02");
teacher t2=new teacher("黎平","1234002","男","1982-08-09");
teacher t3=new teacher("王鹏","1234003","男","1982-11-22");
teacher t4=new teacher("宋波","1234004","女","1982-11-02");
teacher t5=new teacher("童伟","1234005","男","1980-01-12");
teacher t6=new teacher("孙君","1234006","女","1981-09-22");
tl.setschoolname("重庆大学");
tl.setclassname("计算机三班"’)，
tl.setfamilyaddress("重庆沙坪坝");
t2.setschoolname("重庆大学"”);
t2.setclassname("计算机三班");
t2.setfamilyaddress("重庆沙坪坝");
t3.setschoolname("重庆大学");
t3.setclassname("计算机三班");
t3.setfamilyaddress("重庆沙坪坝");
t4.setschoolname("重庆大学");
t4.setclassname("计算机三班");
t4.setfamilyaddress("重庆沙坪坝");
t5.setschoolname("重庆大学");
t5.setclassname("计算机三班");
t5.setfamilyaddress("重庆沙坪坝");
t6.setschoolname("重庆大学");
t6.setclassnarne("计算机三班");
t6.setfamilyaddress("重庆沙坪坝");
//通过设置器赋值给对象
tm.put("ab", t1);//添加对象到树映像
tm.put("1p"，t2);
tm.put("wp"，t3);
tm.put("sb"，t4);
tm.put("zw"，t5);
tm.put("sj"，t6);
System.out.println("这个小组有"+tm.siae()+"个教师。");
System.out.println(tm.values());
tm.remove("lp");//删除树映像中的元素
tm.remove("sb");
System.out.println("帮我查找一下有没有孙君这个教师");
if(tm.containsKey("sj")){
System.out.println("这个教师是存在的，他的信息如下:");
System.out.println((teacher)tm.get("sj"));
} else{
System.out.println("这里没有这个教师。");
}
System.out.println("由于有些教师离开了学校，经过我们的审核后，教师信息如下:");
System.out.println(tm.values());
System.out.println("这些教师今天都离开了,所有教师信息都可以删除了!");
tm.remove("zh");
tm.remove("sj");
tm.remove("zw");
tm.remove("wp");
if(tm.isEmpty()){
System.out.println("这里把教师信息都删除了");
}else{
System.out.println("系统报错了!");
}
}

常见问题

哪些是线程安全的数据结构

下面是线程安全的同步的类。

口Vector:比ArrayList多了个同步化机制(线程安全)。

口Statck:堆栈类，先进后出。

口Hashtable:比HashMap多了个线程安全。

口Enumeration:枚举，相当于迭代器。

除了这些之外，其他的都是非线程安全的类和接口。线程安全类的方法是同步的，每次只能一个访问，是重量级对象，效率较低。对干1卜线程安个的类和接口，在多线程中需要程序员

自己处理线程安全问题。

Vector是什么样的数据结构

答:没有讲述它的原因，是因为目前使用它的频率不高。一般用数组列表代替它，因为它们的使用方法几乎一样，唯独不同的就在线程安全方面。数组列表是非线程安全类，在实现线程编程时，要自己处理安全问题，而Vector则是线程安全类，会自动处理安全问题。

Vector类提供实现可增长数组的功能，随着更多元素加人其中，数组变得更大。在删除一些元素之后，数组变小。Vector有3个构造函数:

public Vector(int initialCapacity，int capacityIncrement)

public Vector(int initialCapacity)

public Vector()

Vector运行时创建一个初始的存储容量initialCapacity.存储容量是以capacityIncrement变量定义的增量增长。初始的存储容量和capacityIncrement可以在Vector的构造函数中定义，第2个构造函数只创建初始存储容量。第3个构造函数既不指定初始的存储容量，也不指定capacityIncrement。 Vector类提供的访问方法，支持类似数组的运算，也支持与Vector大小相关的运算。类似数组的运算允许向量中增加、删除和插入元素。