鏈表
什么是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
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
//輸出數組列表中的元素以字符串形式
system.out.println((teacher)al.get(i));
}
System.out.println("對不起.系統出錯了!有個教師信息錯了，需要改正。");
al.set(5,t);
System.out.println("經過我們的審核后，教師信息如下:");
for(int i=0;i
System.out.Println((teacher)al.get(i));
}
//刪除數組列表中的元素
al.remove(2);
al.remove(4);
System.out.println(”有兩個教師辭職了，所以剩下教師信息為:");
for(int i=O;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大小相關的運算。類似數組的運算允許向量中增加、刪除和插入元素。
2157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
