第一篇：JAVA數據結構存儲剖析
JAVA數據結構存儲剖析
實用舉例：
1:堆棧(stack)
方法的參數值
public void sun(int a , int b)
//調用方法是在棧內存中為參數分配存儲空間，方法結束自動釋放。
局部變量
public static void main(String[] args){int a = 5;}
//在方法中的局部變量，存儲在棧內存中，方法結束時候，釋放內存
引用變量
Person p = new Person(“zhaoyue”, 22);
//調用構造方法的時候，“形參”先在堆棧中開辟內存，存放“實參”，再把“實參”的//一份拷貝傳入對象之中。此時，“實參”的拷貝存放在堆(heap)中，構造方法結束，//堆棧中的內存釋放。
堆棧的存儲要領：壓棧，出棧，自動清除！
2：堆(heap)
成員變量
public class Person{ String name;int age;}
// New 的時候存儲在堆中。
new得到的對象
Person p = new Person(“zhaoyue”, 22);
// New 的時候存儲在堆中。
3：數據區(Data segment)
3.1：靜態存儲(static storage)
靜態變量
public static int a = 5;
//JVM運行時首先為其開辟空間，位置不變,程序運行結束時空間釋放。并且在運行時只加載一次。
靜態方法
public static void run(){print(“hello”);}
//JVM運行時首先為其開辟空間，位置不變,程序運行結束時空間釋放。并且在運行時只加載一次。
3.2地址池（address pool）
非new的字符串
String s = “hello world”;
3.3常量存儲（constant storage）
常量
public final int a = 5;
4：Code segment(代碼區)
4.1：Code segment
存放代碼
4.2：方法區（method area）
成員方法
Public void run(){System.out.println(“I’m run!”);}
//類裝載的時候存儲在方法區,初始時被隱藏，實例化對象時被激活。
具體解釋：
在java中有6中存取機制:
1： 寄存器(register)
2： 堆棧(stack)
3： 堆(heap)
4： 靜態存儲(static storage)
5： 常量存儲(constant storage)
6： 非RAM存儲寄存器(register)：這是最快的存儲區，因為它位于不同于其他存儲區的地方——處理器內部。但是寄存器的數量極其有限，所以寄存器由編譯器根據需求進行分配。你不能直接控制，也不能在程序中感覺到寄存器存在的任何跡象。堆棧(stack)：位于通用RAM中，但通過它的“堆棧指針”可以從處理器哪里獲得支持。堆棧指針若向下移動，則分配新的內存；若向上移動，則釋放那些內存。這是一種快速有效的分配存儲方法，僅次于寄存器。創建程序時候，JAVA編譯器必須知道存儲在堆棧內所有數據的確切大小和生命周期，因為它必須生成相應的代碼，以便上下移動堆棧指針。這一約束限制了程序的靈活性，所以雖然某些JAVA數據存儲在堆棧中——特別是對象引用，但是JAVA對象不存儲其中。堆(heap)：一種通用性的內存池（也存在于RAM中），用于存放所有的JAVA對象。堆不同于堆棧的好處是：編譯器不需要知道要從堆里分配多少存儲區域，也不必知道存儲的數據在堆里存活多長時間。因此，在堆里分配存儲有很大的靈活性。當你需要創建一個對象的時候，只需要new寫一行簡單的代碼，當執行這行代碼時，會自動在堆里進行存儲分配。當然，為這種靈活性必須要付出相應的代碼。用堆進行存儲分配比用堆棧進行存儲存儲需要更多的時
間。
4: 靜態存儲(static storage)：這里的“靜態”是指“在固定的位置”。靜態存儲里存放程序運行時一直存在的數據。你可用關鍵字static來標識一個對象的特定元素是靜態的，但JAVA對象本身從來不會存放在靜態存儲空間里。
5: 常量存儲(constant storage)：常量值通常直接存放在程序代碼內部，這樣做是安全的，因為它們永遠不會被改變。有時，在嵌入式系統中，常量本身會和其他部分分割離開，所以在這種情況下，可以選擇將其放在ROM中
6: 非RAM存儲：如果數據完全存活于程序之外，那么它可以不受程序的任何控制，在程序沒有運行時也可以存在。
速度：
就速度來說，有如下關系：
寄存器 > 堆棧 > 堆 > 其他
關系：
然后我主要要說下堆與堆棧的關系：
堆：堆是heap，是所謂的動態內存，其中的內存在不需要時可以回收，以分配給新的內存請求，其內存中的數據是無序的，即先分配的和隨后分配的內存并沒有什么必然的位置關系，釋放時也可以沒有先后順序。一般由使用者自由分配，在C語言中malloc分配的就是堆，需要手動釋放。
堆棧:就是stack。實際上是只有一個出入口的隊列，即后進先出(frist in , last out)，先分配的內存必定后釋放。一般由，由系統自動分配，存放函數的參數值，局部變量等，自動清除。
還有，堆是全局的，堆棧是每個函數進入的時候分一小塊，函數返回的時候就釋放了，靜態和全局變量，new得到的變量，都放在堆中，局部變量放在堆棧中，所以函數返回，局部變量就全沒了。
JAVA中的基本類型，其實需要特殊對待。因為，在JAVA中，通過new創建的對象存儲在“堆”中，所以用new 創建一個小的、簡單的變量，如基本類型等，往往不是很有效。因此，在JAVA中，對于這些類型，采用了與C、C++相同的方法。也就是說，不用new 來創建，而是創建一個并非是“引用”的“自動”變量。這個變量擁有它的“值”，并置于堆棧中，因此更高效。
再說一說類的實例方法！
類的實例方法在內存中是只有一份,不過肯定不會是第一個對象中,如果是第一個對象的話,那么當第一個對象被銷毀的時候,那么后面的對象就永遠無法調用了。
類的實例方法存在一個專門的區叫方法區（method area）,事實上類剛裝載的時候就被裝載好了,不過它們在“睡眠”,只是這些方法必須當有對象產生的時候才會“蘇醒”.(比如,一個輸出類的成員變量的方法,如果連對象都沒有,何來的輸出成員變量).所以,方法在裝載的時候就有了,但是不可用,因為它沒有指象任何一個對象。
而靜態的又不一樣了,靜態的東西存在靜態存儲(static storage)區,他們和類是一個等級的，就是說只要類被裝載,它們就可以直接用.(用類名來調用).他們不依賴與任何對象,所以也不能輸出任何對象的成員屬性.(除非成員屬性也是靜態的).每個對象在new的時候都會在堆區中開辟內存,用來保存對象的屬性和方法.(實際上方法保存的只是方法區的引用,如果保存的是方法本身,那么試想一下,有多少個對象就得有多少個方法,那么又和第一點中“實例方法在內存中只有一份拷貝”相矛盾了。另外我補充一點，在父類的引用指向子類對象的時候，父類可以調用子類從父類繼承的屬性和方法，子類覆寫父類的屬性和方法，在動態綁定（也就是多態）時，子類對象有一個方法區得引用，動態new的時候這個引用指向子類的方法，從而實現了父類可以調用子類覆寫父類的方法。這也是動態綁定得名的原因。)
如果您認真看完這篇文章，估計java中內存方面肯定會有所幫助，這篇文章是我總結歸納出來的，并非完全自己寫的。有什么不對的地方，歡迎批評指正。
第二篇：java部分數據結構總結
package datastructtest;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Scanner;
import javax.swing.JFrame;
public class Testbase {
public static void main(String[] args)throws IOException{
//100之內被3或7整除的數的個數
//int m=0,n=0;
//for(int i=0;i<100;i++){
//if(i%3==0){
//m++;
//}
//if(i%7==0){
//n++;
//}
//}
//System.out.println(“m=”+m+“ ；”);
//System.out.println(“n=”+n+“ ；”);
//1~100之間的整數累加和，并顯示每個整數和當前累加和的對應關系 //int sum=0;
//for(int i=1;i<=100;i++){
//
//System.out.print(“i=”+i+“,sum=”+sum);
//sum+=i;
//System.out.println(“;i+sum=”+sum);
//}
//計算30的階乘
//int m=jiecheng(30);
//System.out.println(m);
//直接插入排序
//int[] test={64,5,7,89,6,24};
//int n=test.length;
//insertSort(test);
//for(int i=0;i //System.out.print(test[i]+“,”); //} //希爾排序 //int[] test={65,34,25,87,12,38,56,46,14,77,92,33};//int n=test.length; //int d[]={6,3,1};//每次循環用到的增量值 //int numOfD=d.length;//共進行幾次循環 //shellSort(test,d,numOfD); //for(int i=0;i //System.out.print(test[i]+“,”); // } //直接選擇排序 //int[] test={65,34,25,87,12,38,56,46,14,77,92,33}; //int n=test.length; // //selectSort(test); //for(int i=0;i //System.out.print(test[i]+“,”); // } ////字符串逆轉 //char[]a={'a','f','g','h','j'}; //char[]b=reverse1(a); //for(int i=0;i //System.out.print(b[i]+“,”); //} //Scanner類的應用和split的使用 //System.out.println(“請輸入帶逗號的字符：”); //Scanner sc=new Scanner(System.in); // //while(sc.hasNext()){ //StringBuffer str=new StringBuffer(); //str=str.append(sc.next()); ////System.out.println(str); //String st=str.toString(); //String[] a=st.split(“,”); //System.out.println(“字符串被逗號分割之后：”); //for(int i=0;i //System.out.println(a[i]); //} //} //寫文件和讀文件復制文件aa到bb //FileReader filein=new FileReader(new File(“d://aa.txt”));//此句會產生異常 //FileWriter fileout=new FileWriter(new File(“d://bb.txt”));//int c; //while((c=filein.read())!=-1){ //fileout.write(c); //} //filein.close(); //fileout.close(); // } private static int jiecheng(int n){ if(n==1) return 1; else return n*jiecheng(n-1); } //棧 private LinkedList list=new LinkedList(); public void push(Object v){ list.addFirst(v); } public Object top(){ return list.getFirst(); } public Object pop(){ return list.removeFirst(); } //直接插入排序 public static void insertSort(int[] a){ int i,j,temp; int n=a.length; for(i=0;i temp=a[i+1]; j=i; while(j>-1&&temp<=a[j]){ a[j+1]=a[j]; j--; } a[j+1]=temp; } //for(i=0;i //temp=a[i+1]; //// j=i; //while(i>-1&&temp<=a[i]){ //a[i+1]=a[i]; //i--; //} //a[i+1]=temp; //} } //希爾排序 public static void shellSort(int[]a,int[]d,int numOfD){ int i,j,k,m,span; int temp; int n=a.length; for(m=0;m span=d[m];//取本次的增量值 for(k=0;k for(i=k;i temp=a[i+span]; j=i; while(j>-1&&temp<=a[j]){ a[j+span]=a[j]; j=j-span; } a[j+span]=temp; } } } } //直接選擇排序 public static void selectSort(int[]a){ int i,j,small; int temp; int n=a.length; for(i=0;i small=i;//設第i個數據元素最小 for(j=i+1;j if(a[j] if(small!=i){ temp=a[small]; for(j=small;j>i;j--)//把該區段尚未排序元素依次后移 a[j]=a[j-1]; a[i]=temp;//插入找出的最小元素 } } } public static char[] reverse1(char[]a){ int n=a.length; char[]b=new char[n]; for(int i=0;i b[n-i-1]=a[i]; } return b; } } Java數據結構試題及解析 下列數據結構中，能用二分法進行查找的是__A____。 A、順序存儲的有序線性表 B、線性鏈表 C、二叉鏈表 D、有序線性鏈表 解析：二分法查找只適用于順序存儲的有序表。在此所說的有序表是指線性表中的元素按值非遞減排列(即從小到大，但允許相鄰元素值相等)。 在軟件設計中，不屬于過程設計工具的是__D____。 A、PDL(過程設計語言)B、PAD圖 C、N-S圖 D、DFD圖 解析：軟件設計工具包括：程序流程圖、N-S、PAD、HIPO，判定表，PDL(偽碼)。而DFD(數據流圖)屬于結構化分析工具。在switch(expression)語句中，expression的數據類型不能是__A____。 A、double B、char C、byte D、short 解析：表達式expression只能返回這個幾種類型的值：int、byte、short和char。多分支語句把表達式返回的值依次與每個case子句中的值相比較，如果遇到匹配的值，則執行該case子句后的語句序列。下列敘述中，錯誤的是__D____。 A、父類不能替代子類 B、子類能夠替代父類 C、子類繼承父類 D、父類包含子類 通過繼承實現代碼復用： Java中所有的類都是通過直接或間接地繼承java.lang.Object類得到的。繼承而得到的類稱為子類，被繼承的類稱為父類。子類不能繼承父類中訪問權限為private的成員變量和方法，子類可以重寫父類的方法，及命名與父類同名的成員變量。 子類通過隱藏父類的成員變量和重寫父類的方法，把父類的狀態和行為改變為自身的狀態和行為。注意：子類中重寫的方法和父類中被重寫的方法要具有相同的名字，相同的參數表和相同的返回類型，只是函數體不同。 由于子類繼承了父類所有的屬性(私有的除外)，所以子類對象可以作為父類對象使用。程序中凡是使用父類對象的地方，都可以用子類對象來代替。一個對象可以通過引用子類的實例來調用子類的方法。 java運行時系統根據調用該方法的實例，來決定調用哪個方法。對子類的一個實例，如果子類重寫了父類的方法，則運行時系統調用子類的方法;如果子類繼承了父類的方法(未重寫)，則運行時系統調用父類的方法。自定義表格類中的model部分應實現的接口是___A___。 A、AbstractTableModel B、JTable C、TableModel D、TableModelable 下列代碼中，將引起編譯錯誤的行是__B____。 1)public class Exercise{ 2)public static void main(String args[]){ 3)float f=0.0; 4)f+=1.0; 5)} 6)} A、第2行 B、第3行 C、第4行 D、第6行 解析：float定義變量賦值時，需要在數值后面加f以標識它為浮點型，讓系統知道該給它精確到多少位。下列關于Java多線程并發控制機制的敘述中，錯誤的是___B___。 A、Java中對共享數據操作的并發控制是采用加鎖技術 B、線程之間的交互，提倡采用suspend()/resume()方法 C、共享數據的訪問權限都必須定義為private D、Java中沒有提供檢測與避免死鎖的專門機制，但應用程序員可以采用某些策略防止死鎖的發生 解析： 1)Java中對共享數據操作的并發控制是采用傳統的封鎖技術。一個程序中單獨的、并發的線程對同一個對象進行訪問的代碼段，稱為臨界區。在Java語言中，臨界區可以是一個語句塊或是一個方法，并且用“synchronized”關鍵字標識。Java平臺將每個由synchronized(Object)語句指定的對象設置一個鎖，稱為對象鎖。 2)共享數據的所有訪問都必須作為臨界區，使用“synchronized”進行加鎖控制。用“synchronized”保護的數據也必須是私有的，使線程不能直接訪問這些數據，必須通過對象的方法。 3)Java中沒有檢測與避免死鎖的專門機制，因此完全由程序進行控制，防止死鎖的發生。 4)有時，某個線程進入“synchronized”塊后，共享數據的狀態并不一定滿足線程的需要，它要等待其他線程將共享數據改變為它需要的狀態后才能繼續執行，但由于此時它占有了該對象的鎖，其他線程無法對共享數據進行操作，為此Java引入wait()和notify()，這兩個方法使java.lang.object類的方法，使實現線程通信的兩個方法。 下列操作中，不屬于Applet安全限制的是___D___。 A、加載本 B、讀寫本地文件系統 C、運行本地可執行程序 D、與同一個頁面中的Applet通信 在進行模塊測試時，要為每個被測試的模塊另外設計兩類模塊：驅動模塊和承接模塊(樁模塊)。其中，驅動模塊相當于被測試模塊的主程序，它接收測試數據，并傳給被測試模塊，輸出實際測試結果。承接模塊通常用于代替被測試模塊調用的其他模塊，其作用僅做少量的數據操作，是一個模擬子程序，不必將子模塊的所有功能帶入。 Java語言具有可移植性、高性能、健壯性、安全性和獨立于體系結構的__跨平臺____特點。 解析：Java語言是一種跨平臺，適合于分布式計算環境的面向對象的編程語言。具體來說，它具有如下特性：簡單性、面向對象、分布式、解釋型、可靠、安全、平臺無關、可移植、高性能、多線程、動態性等。在運行時，由Java解釋器自動導入，而不用import語句引入的包是__java.lang____。 解析：因為包java.lang所包含的類和接口對所有實際的Java程序都是必要的，所以，它被自動導入所有的程序且它是Java最廣泛使用的包。下列程序的功能是創建了一個顯示5個“Hello!”的線程并啟動運行，請將程序補充完整。 public class ThreadTest extends Thread{ public static void main(String args[]){ ThreadTest t=new __ThreadTest()____; t.start();} public void run(){int i=0; while(true){System.out.println(“Hello!”); if(i++==4)break; } } 解析：ThreadTest繼承java.lang.Thread類，重寫了run()方法，實現了Java中的線程。ThreadTest t定義了空的線程對象，下面t.start()啟動了這個線程，因此ThreadTest t=new ______;就應該是實例化該線程對象，所以空格中應填ThreadTest()。 Swing的頂層容器有：JApplet、JWindow、JDialog和__JFrame____。 頂層容器：JFrame、JApplet、JDialog和JWindow共4個。 中間容器：JPanel、JScrollPane、JSplitPane、JToolBar。 特殊容器：JInternalFrame、JLayeredPane、JRootPane。 基本控件：JButton、JComboBox、JList、JMenu、JSlider、JTextField。 不可編輯信息的構件：JLabel、JProgressBar、ToolTip、可編輯信息的構件：JColorChooser、JFileChooser、JFileChooser、JTable、JTextArea 所有的這些構件的分類都是按功能來劃分的。14 下列敘述中正確的是___D___。 A、一個邏輯數據結構只能有一種存儲結構 B、數據的邏輯結構屬于線性結構，存儲結構屬于非線性結構 C、一個邏輯數據結構可以有多種存儲結構，且各種存儲結構不影響數據處理的效率 D、一個邏輯數據結構可以有多種存儲結構，且各種存儲結構影響數據處理的效率 解析：一般來說，一種數據的邏輯結構根據需要可以表示成多種存儲結構，常用的存儲結構有順序、鏈接、索引等存儲結構。而采用不同的存儲結構，其數據處理的效率是不同的。 Java的圖形用戶界面的最基本的組成部分就是構件(Component)，構件是一個可以以圖形化的方式顯示在屏幕上并能與用戶交互的對象，但構件不能獨立地顯示出來，必須將構件放在一定的容器中才可以顯示出來。解析：容器Container是一個類，因為容器本身也是一個構件，具有構件的所有性質，因此繼承之Component類。 下列敘述中，錯誤的是__A____。 A、File類能夠存儲文件 B、File類能夠讀寫文件C、File類能夠建立文件D、File類能夠獲取文件目錄信息 解析：文件類File是java.io包中的一個重要的非流類，它以一種與系統無關的方式表示一個文件對象的屬性。而目錄在Java中作為一種特殊文件，即文件名的列表，通過類File所提供的方法，可得到文件或目錄的描述信息(包括名字、路徑、長度、可讀、可寫等)，也可以生成新文件、目錄、修改文件和目錄，查詢文件屬性，重命名文件或者刪除文件。 下列敘述中，正確的是___C___。 A、Reader是一個讀取字符文件的接口 B、Reader是一個讀取數據文件的抽象類 C、Reader是一個讀取字符文件的抽象類 D、Reader是一個讀取字節文件的一般類 解析：Java中的流分為兩種，一種是字節流，另一種是字符流，分別由四個抽象類來表示(每種流包括輸入和輸出兩種，所以一共四個)：InputStream，OutputStream，Reader，Writer。Java中其他多種多樣變化的流均是由它們派生出來的。 在這其中InputStream和OutputStream在早期的Java版本中就已經存在了，它們是基于字節流的，而基于字符流的Reader和Writer是后來加入作為補充的。在這四個抽象類中，InputStream和Reader定義了完全相同的接口： int read() int read(char cbuf[]) int read(char cbuf[], int offset, int length) 而OutputStream和Writer也是如此： int write(int c) int write(char cbuf[]) int write(char cbuf[], int offset, int length)用于輸入壓縮文件格式的ZipInputStream類所屬包是___D___。 A、java.util B、java.io C、java.nio D、java.util.zip 解析：ZipInputStream該對象用于從ZIP壓縮文件中創建輸入流對象。 對象定義結構：java.util.zip.ZipInputStream 靜態成員變量：CENATT、CENATX、CENCRC……，這些靜態成員變量用于定義在壓縮過程中采用的壓縮算法。 構造方法：ZipInputStream(InputStream in)應用輸入流對象創建從ZIP文件中讀取數據的輸入流對象。 成員方法： int available()判斷當前入口指定的壓縮原始文件中是否還有未讀數據。 void close()關閉ZIP輸入流對象。 void closeEntry()關閉被讀取的ZIP入口，并移動到下一壓縮原始文件入口。 protectedZipEntry createZipEntry(String name)利用指定的名稱創建ZipEntry對象實例。 ZipEntry getNextEntry()將輸入流對象移動到下一入口對象。 int read(byte[] b, int off, int len)從當前ZipEntry中讀取字節數組。 long skip(long n)將輸入流指定的讀取數據位置移動n個字節。 在Swing中用輕量級的構件替代了AWT中的重量級的構件，而且Swing的替代構件中都包含有一些其他的特性。與AWT構件不同，Swing構件不能直接添加到頂層容器中，它必須添加到一個與Swing頂層容器相關聯的內容面板(contentPane)上。 查找隨機文件的記錄時，應使用的方法是___C___。 A、readInt()B、readBytes(int n)C、seek(long l)D、readDouble() 文件操作中經常需要的是隨機訪問，Java中的RandomAccessFile類提供隨機訪問文件的功能，其中的seek方法實現了查找隨機文件記錄的功能，格式如下： void seek(long pos);//用于移動文件指針到指定的位置 20 下列關于棧的描述中錯誤的是___B___。 A、棧是先進后出的線性表 B、棧只能順序存儲 C、棧具有記憶作用 D、對棧的插入與刪除操作中，不需要改變棧底指針 21 對于長度為n的線性表，在最壞情況下，下列各排序法所對應的比較次數中正確的是___D___。 A、冒泡排序為n/2 B、冒泡排序為n C、快速排序為n D、快速排序為n(n-1)22 對長度為n的線性表進行順序查找，在最壞情況下所需要的比較次數為__C____。 A、B、n/2 C、n D、n+1 23 在進行順序查找過程中，如果線性表中的第一個元素就是被查找元素，則只需做一次比較就查找成功，查找效率最高;但如果被查找的元素是線性表中的最后一個元素，或者被查找的元素根本就不在線性表中，則為了查找這個元素需要與線性表中所有的元素進行比較，這是順序查找的最壞情況。所以對長度為n的線性表進行順序查找，在最壞情況下需要比較n次。模塊獨立性是指每個模塊只完成系統要求的獨立的子功能，并且與其他模塊的聯系最少且接口簡單。耦合性與內聚性是模塊獨立性的兩個定性標準，耦合與內聚是相互關聯的。在程序結構中，各模塊的內聚性越強，則耦合性越弱。一般較優秀的軟件設計，應盡量做到高內聚，低耦合，即減弱模塊之間的耦合性和提高模塊內的內聚性，有利于提高模塊的獨立性。 計算機軟件是計算機系統中與硬件相互依存的另一部分，是包括程序、數據及相關文檔的完整集合。軟件具有以下特點：①軟件是一種邏輯實體，而不是物理實體，具有抽象性;②軟件的生產過程與硬件不同，它沒有明顯的制作過程;③軟件在運行、使用期間不存在磨損、老化問題;④軟件的開發、運行對計算機系統具有依賴性，受計算機系統的限制，這導致軟件移植的問題;⑤軟件復雜性高，成本昂貴;⑥軟件開發涉及諸多的社會因素。 數據獨立性是數據庫技術的重要特點之一。所謂數據獨立性是指__D____。 A、數據與程序獨立存放 B、不同的數據被存放在不同的文件中 C、不同的數據只能被對應的應用程序所使用 D、以上三種說法都不對 在讀字符文件Employee.dat時，使用該文件作為參數的類是___D___。 A、BufferedReader B、DataInputStream C、DataOutputStream D、FileInputStream 下列不是InputStream子類的是__C____。 A、文件輸入流FileInputStream B、對象輸入流ObjectInputStream C、字符輸入流CharInputStream D、壓縮文件輸入流ZipInputStream 28 Java中沒有CharInputStream流。 下列方法中可以用來創建一個新線程的是___C___。 A、實現java.lang.Runnable接口并重寫start()方法 B、實現java.lang.Runnable接口并重寫run()方法 C、繼承java.lang.Thread類并重寫run()方法 D、繼承java.lang.Thread類并重寫start()方法 下列關于線程優先級的說法中，正確的是__C____。 A、線程的優先級是不能改變的 B、線程的優先級是在創建線程時設置的 C、在創建線程后的任何時候都可以設置 D、B和C 下列代碼中，將引起一個編譯錯誤的行是__D____。 1)public class Test{ 2)int m,n; 3)public Test(){} 4)public Test(int a){m=a;} 5)public static void main(String args[]){ 6)Test t1,t2; 7)int j,k; 8)j=0;k=0; 9)t1=new Test(); 10)t2=new Test(j,k); 11)} 12)} A、第3行 B、第5行 C、第6行 D、第10行 閱讀下列代碼后 public class Person{ int arr[]=new int[10]; public static void main(String args[]){ System.out.println(arr[1]); } } 正確的說法是__A____。 A、編譯時將產生錯誤 B、編譯時正確，運行時將產生錯誤 C、輸出為零 D、輸出為空 32請閱讀下列程序代碼，然后將程序的執行結果補充完整。 程序代碼： class throwsException { static void Proc(int sel)throws ArithmeticException,ArrayIndexOutOfBoundsException { System.out.println(“In Situation”+sel); if(sel==0){ System.out.println(“no Exception caught”); return; } else if(sel==1){ int iArray[]=new int[4]; iArray[1]=3; } } public static void main(String[] args) { try{ Proc(0); Proc(1); }catch(ArrayIndexOutOfBoundsException e){ System.out.println(“Catch”+e); }finally{ System.out.println(“in Proc finally”); } } } 執行結果： In Situation0 no Exception caught __In Situation1____ in Proc finally 解析：調用Proc(1)時，執行語句System.out.println(“In Situation”+sel);控制臺輸出In Situation1。然后在if語句中執行sel==1分支，該分支中無任何輸出語句。 當使用Thread t=new Thread(r)創建一個線程時，表達式：r instanceof Thread的值是___false___。 表達式：r instanceof Thread的語義即“r是否為Thread的實例(instance)”。再看Thread的構造方法(Thread有許多構造方法，以下是最典型的構造方法，其它構造方法都是從下面的構造方法中“減掉”一些參數形成的)： Thread(ThreadGroup group, Runnable target, String name) 可見，Thread構造方法中沒有類型為Thread的參數，故r不可能是Thread的實例 實驗報告二 線性表的順序存儲 班級： 2010XXX 姓名： HoogLe 學號： 2010XXXX 專業： XXXX 2858505197@qq.com 一、實驗目的： （1）掌握順序表的基本操作的實現方法。 （2）應用順序表的基本算法實現集合A=AUB算法。 （3）應用順序表的基本算法實現兩有序順序表的歸并算法。 二、實驗內容： 1、線性表順序存儲結構的基本操作算法實現（要求采用類模板實現） [實現提示]（同時可參見教材p5822-p60頁算法、ppt）函數、類名稱等可自定義，部分變量請加上學號后3位。庫函數載和常量定義：（代碼）#include （1）順序表存儲結構的定義(類的聲明)：（代碼） template SeqList(datatype a[ ], int n);//有參構造函數 ~SeqList(){};//析構函數為空 int Length();//求線性表的長度 datatype Get(int i);//按位查找，取線性表的第i個元素 int Locate(datatype item);//查找元素item void Insert(int i, datatype item);//在第i個位置插入元素item datatype Delete(int i);//刪除線性表的第i個元素 void display();//遍歷線性表，按序號依次輸出各元素 private: datatype data[MaxSize];//存放數據元素的數組 int length;//線性表的長度 }; （2）初始化順序表算法實現（不帶參數的構造函數）/* *輸 入：無 *前置條件：順序表不存在 *功 能：構建一個順序表 *輸 出：無 *后置條件：表長為0 */ 實現代碼： template （3）順序表的建立算法（帶參數的構造函數） /* *輸 入：順序表信息的數組形式a[],順序表長度n *前置條件：順序表不存在 *功 能：將數組a[]中元素建為長度為n的順序表 *輸 出：無 *后置條件：構建一個順序表 */ 實現代碼： template cout<<“數組元素個數不合法”< data[i]=a[i];length=n;}（4）在順序表的第i個位置前插入元素e算法 /* *輸 入：插入元素e,插入位置i *前置條件：順序表存在，i要合法 *功 能：將元素e插入到順序表中位置i處 *輸 出：無 *后置條件：順序表插入新元素，表長加1 */ 實現代碼： template cout<<“溢出”< cout<<“i不合法！”< data[j]=data[j-1];data[i-1]=item;length++;}（5）刪除線性表中第i個元素算法 /* *輸 入：要刪除元素位置i *前置條件：順序表存在,i要合法 *功 能：刪除順序表中位置為i的元素 *輸 出：無 *后置條件： 順序表冊除了一個元素，表長減1 */ 實現代碼： template cout<<“表為空,無法刪除元素!”< cout<<“i不合法!”< for(j=i;j data[j-1]=data[j];//注意數組下標從0記 length--;return item;}（6）遍歷線性表元素算法 /* *輸 入：無 *前置條件：順序表存在 *功 能：順序表遍歷 *輸 出：輸出所有元素 *后置條件：無 */ 實現代碼： template cout<<“表為空，無法輸出!”< cout< （7）獲得線性表長度算法 /* *輸 入：無 *前置條件：順序表存在 *功 能：輸出順序表長度 *輸 出：順序表長度 *后置條件：無 */ 實現代碼： template （8）在順序線性表中查找e值，返回該元素的位序算法 /* *輸 入：查詢元素值e *前置條件：順序表存在 *功 能：按值查找值的元素并輸出位置 *輸 出：查詢元素的位置 *后置條件：無 */ 實現代碼： template //下標為i的元素等于item，返回其序號i+1 return 0;//查找失敗 } （9）獲得順序線性表第i個元素的值 /* *輸 入：查詢元素位置i *前置條件：順序表存在，i要合法 *功 能：按位查找位置為i的元素并輸出值 *輸 出：查詢元素的值 *后置條件：無 */ 實現代碼： template cout<<“i不合法!”< （10）判表空算法 /* *輸 入：無 *前置條件：無 *功 能：判表是否為空 *輸 出：為空返回1，不為空返回0 *后置條件：無 */ 實現代碼： template return 1;} else { return 0;} } (11)求直接前驅結點算法 /* *輸 入：要查找的元素e，待存放前驅結點值e1 *前置條件：無 *功 能：查找該元素的所在位置，獲得其前驅所在位置。*輸 出：返回其前驅結點的位序。*后置條件：e1值為前驅結點的值 */ 實現代碼： template return k;else { cout<<“無前驅結點！”< return 0;} }(12)求直接后繼結點算法 /* *輸 入：要查找的元素e，待存放后繼結點值e1 *前置條件：無 *功 能：查找該元素的所在位置，獲得其后繼所在位置。*輸 出：返回其后繼結點的位序。*后置條件：e1值為后繼結點的值 */ 實現代碼： template cout<<“無后繼結點!”< return k;} } 上機實現以上基本操作，寫出main()程序： void main(){ SeqList if(Seq.Empty()){ cout<<“線性表為空!”< } Seq.Insert(1,1);Seq.Insert(2,2);Seq.Insert(3,3);Seq.Insert(4,4);Seq.Insert(5,5);//插入元素操作 cout<<“輸出插入的五個元素:”< cout< cout<<“2是第”< cout<<“第五個元素是:”< cout<<“線性表的長度為:”< Seq.Delete(3);//刪除元素 cout<<“刪除第三個元素后的線性表為:”< cout< cout<<“元素2前驅結點的數值為：”< cout<<“元素4后繼結點的位置為：”< cout<<“元素4后繼結點的數值為：”< 要求對每個算法都加以測試，判斷是否正確；并測試不同類型數據的操作。粘貼測試數據及運行結果： 2、用以上基本操作算法，實現A=AUB算法。（利用函數模板實現）/* *輸 入：集合A,集合B *前置條件：無 *功 能：實現A=AUB *輸 出：無 *后置條件：A中添加了B中的元素。*/ 實現代碼： template return *this;else { int k=item.Length(); int num=this->Length(); for(int i=1;i<=k;i++) { for(int j=0;j if(data[j]==item.Get(i)) { break; } else if(num-1==j&&data[num-1]!=item.Get(i)) { this->Insert(++num,item.Get(i)); } } return *this;} } void main(){ SeqList B.Insert(1,2);B.Insert(2,6);B.Insert(3,1);B.Insert(4,8);B.Insert(5,9);//插入集合B中元素 A.Add(B);A.display();cout< 3、對以上順序表類中的基本操作算法適當加以補充，實現向一個有序的（非遞減）的順序表中插入數據元素e算法。/* *輸 入：插入元素e *前置條件：順序表已有序 *功 能：將元素e插入到順序表中適當的位置，使順序表依然有序 *輸 出： 無 *后置條件：有序順序表插入了新元素，且表長加1。*/ 實現代碼： template if((data[i] { for(int k=num;k>i;k--) data[k]=data[k-1]; data[i+1]=item; length++; break; } if(data[i]>item) { for(int k=num;k>i;k--) data[k]=data[k-1]; data[i]=item; length++; break; } } } void main(){ SeqList cout<<“原順序表為:”< cout< cout<<“插入新元素后的順序表為:”< 4、算法實現：La,Lb為非遞減的有序線性表，將其歸并為Lc，該線性表仍有序（未考慮相同時刪除一重復值）（利用函數類板實現）MergeList： /* *輸 入：有序線性表La,有序線性表Lb *前置條件：順序表已有序 *功 能：將兩線性表歸并，不去掉相同元素 *輸 出： 返回一個新的有序線性表Lc *后置條件：無 */ 實現代碼： template Seq1.orderInsert(Seq2.Get(i));} return Seq1;} void main(){ SeqList cout<<“合并后的Lc為:”< cout< 粘貼測試數據及運行結果： 三、心得體會：（含上機中所遇問題的解決辦法，所使用到的編程技巧、創新點及編程的心得） import java.io.*;import java.util.*;public class LittleProgram { static boolean isDelete = true; static boolean isFind = true; public static void main(String [] args)//主方法,程序從這里開始運行 throws IOException,NumberNotFoundException { int choice=-1; do{ LittleProgram lp = new LittleProgram(); System.out.println(); System.out.println(“t #”); System.out.println(); System.out.println(“tt通訊錄管理系統”); System.out.println(“t 請用號碼插入,查找,修改,刪除數據”); System.out.println(); System.out.println(“t #n”); System.out.print(“1.增加號碼:n”+ “2.查找號碼:n”+ “3.刪除號碼:n”+ “4.清除所有號碼:n”+ “5.把號碼全部打印到屏幕n”+ “6.把通訊錄按號碼排序n”+ “7.修改號碼n”+ “8.統計通碼訊錄的總人數n”+ “9.關于作者n”+ “0.退出程序.n” + “輸入:”); BufferedReader in = //從終 new BufferedReader（//端接 new InputStreamReader(System.in));//收數 String inputLine = in.readLine(); //字選 choice= Integer.valueOf(inputLine).intValue();//項; switch(choice) { case 1: {//1.增加號碼 String str = lp.inputData(); lp.addData(str); System.out.println(“增加號碼成功.”); timeOut(1); }break; case 2: {//2.查找號碼 long find = 0; System.out.print(“請輸入你要查找的號碼:”); BufferedReader inn = new BufferedReader（new InputStreamReader(System.in)); String inputLi = inn.readLine(); find = Integer.valueOf(inputLi).longValue(); lp.findData(find); timeOut(2); }break; case 3: {//3.刪除號碼 long deleteNumber = 0; System.out.print(“請輸入你想刪除號碼:”); BufferedReader bf = new BufferedReader（new InputStreamReader(System.in)); String inputL = bf.readLine(); deleteNumber = Integer.valueOf(inputL).longValue(); lp.deleteData(deleteNumber); if(isDelete) System.out.println(“刪除號碼成功!”); timeOut(1); }break; case 4: { lp.clearData();//4.清除所有號碼 timeOut(1); }break; case 5: { print();//5.把號碼全部打印到屏幕 timeOut(2); }break; case 6: { lp.numSort();//6.把號碼按號碼排序 System.out.println(“按照號碼從小到大排序成功!n”+ “排序后:n”); print(); timeOut(2); }break; case 7: { lp.rewrite();//7.修改號碼 timeOut(2); }break; case 8: { int count = lp.count(); System.out.println(“共有”+count+“個號碼記錄.”); timeOut(2); }break; case 9: { System.out.print(“tt李雪萍n”+ “tt安徽理工大學理學院n”+ “ttQQ:1154646392n”); timeOut(4); }break; }}while(choice!= 0); System.out.println(“Bye!^-^”); System.exit(0); } public String inputData()//從終端接收數據的方法,返回字符串 throws IOException,NumberFormatException { System.out.print(“請依次輸入 :號碼 姓名 地址 生日n” + “每項數據請用空格隔開:”); String all = “"; try{ BufferedReader in = //從終 new BufferedReader（//端接 new InputStreamReader(System.in)); //收數 String inputLine = in.readLine(); //據 StringTokenizer str = new StringTokenizer(inputLine,” “);//接收的數據用空格隔開,這個類用來提取每個字符串 long num = Integer.valueOf(str.nextToken()).longValue();//號碼 String name =(String)str.nextToken(); //姓名 String add =(String)str.nextToken(); // 地址 String birth =(String)str.nextToken();//出生年月 all = String.valueOf(num)+” , “+ name +” , “+ add +” , “+ String.valueOf(birth);//把所有的數據用” , “隔開然后在連起來放進字符串all }catch(IOException e){} catch(NumberFormatException e){} return all;//返回字符串all } public void addData(String str)//增加號碼的方法 throws IOException { String s1 =”“,s2=”“ ,s3= ”“; File file = new File(”c:data.txt“); if(file.exists())//如果文件data.txt存在 { try{ BufferedReader in = new BufferedReader（new FileReader(file)); while((s1=in.readLine())!=null) s2+=s1+”n“;//把文件中的每行數據全部放進一個字符串s2 s2+=str+”n“; //再把s2于形參str相連放進s2 BufferedReader in2 = //把字符 new BufferedReader（//串s2也 new StringReader(s2)); //就是原 PrintWriter out = //文件+ new PrintWriter（//形參str(新輸入的一行數據) new BufferedWriter（//重新寫進data.txt new FileWriter(file))); //覆蓋原來的數據 while((s3=in2.readLine())!= null) { out.println(s3); } out.close(); //System.out.println(”write data true.“); }catch(IOException e){} }else{ System.err.println(”File “data” Missing!“); } } public void clearData()//清除data.txt的所有數據的方法 throws IOException { File file = new File(”c:data.txt“); if(file.exists())//如果文件在{ try{ PrintWriter out = new PrintWriter（new BufferedWriter（new FileWriter(file))); out.print(”“);//在文件data.txt里寫進一個空字符,所以清除了原來的內容 out.close();//關閉文件 System.out.println(”clear data true!“); }catch(IOException e){} }else{ System.err.println(”File “data” Missing!“); } } public void deleteData(long deleteNumber)//刪除某條號碼數據 throws IOException,FileNotFoundException { isDelete = true; try{ DataMap mp = new DataMap();//生成一個自己編寫的容器 long j=0; String s1=”“,s2=”“,s3=”“; BufferedReader in = new BufferedReader（new FileReader(”c:data.txt“)); while((s1=in.readLine())!=null) { j=numberTokenizer(s1); mp.put(j,s1); } try{ if(mp.containsKey(String.valueOf(deleteNumber).toString())) { mp.remove(deleteNumber); }else throw new NumberNotFoundException(); Collection c = mp.values(); Iterator iter = c.iterator(); while(iter.hasNext()) { s1 =(String)iter.next(); s3 +=s1+”n“; } BufferedReader in2 = new BufferedReader（new StringReader(s3)); PrintWriter out = new PrintWriter（new BufferedWriter（new FileWriter(”c:data.txt“))); //System.out.println(”delete No“+deleteNumber); while((s1 = in2.readLine())!=null) { out.println(s1); } out.close();}catch(NumberNotFoundException e){ isDelete = false; System.out.println(deleteNumber+” no found :(“); } }catch(IOException e){} } public long numberTokenizer(String s) throws IOException { StringTokenizer st = new StringTokenizer(s,” “); return Integer.valueOf((st.nextToken())).longValue(); } public void findData(long find)//查找數據 throws IOException,NumberNotFoundException { isFind = true; String s = ”“,findString =”“;long i;DataMap dm = new DataMap();BufferedReader in = new BufferedReader（new FileReader(”c:data.txt“)); while((s=in.readLine())!=null) { i=numberTokenizer(s); dm.put(i,s); } //in.close(); try{ if(dm.containsKey(String.valueOf(find).toString())) { findString = dm.get(find); System.out.println(”學號“+find+”學生的資料是:“); System.out.println(findString); }else throw new NumberNotFoundException(); }catch(NumberNotFoundException e){ System.out.println(find+” no found :(“); isFind = false; } } public static void print()//讀取文本文件把數據打印到終端的方法 throws IOException { try{ BufferedReader in = new BufferedReader（new FileReader(”c:data.txt“)); String read = ”“; while((read = in.readLine())!=null) System.out.println(read); }catch(IOException e){} } public static void timeOut(double sec)//停頓短暫時間的一個方法完全可以不要這個功能 { double seconds = sec; long t = System.currentTimeMillis()+(int)(seconds*1000); while((System.currentTimeMillis()) ; } public void numSort()//按學號排序 throws IOException { long i = 0; String s = ”“; try{ DataArrayList dal = new DataArrayList(); BufferedReader in = new BufferedReader（new FileReader(”c:data.txt“)); while((s=in.readLine())!=null) { i=numberTokenizer(s); dal.add(i); } Collections.sort(dal); DataMap dm = new DataMap(); BufferedReader in2 = new BufferedReader（new FileReader(”c:data.txt“)); while((s=in2.readLine())!=null) { i=numberTokenizer(s); dm.put(i,s); } PrintWriter out = new PrintWriter（new BufferedWriter（new FileWriter(”c:data.txt“))); Iterator it = dal.iterator(); long temp = 0; String tempStr = ”“; while(it.hasNext()) { temp = Integer.valueOf((String)it.next()).longValue(); tempStr = dm.get(temp); out.println(tempStr); } out.close(); }catch(IOException e){} } public void rewrite() throws IOException,NumberNotFoundException { try{ System.out.print(”請輸入你要修改的學生號碼:“); BufferedReader in = new BufferedReader（new InputStreamReader(System.in)); String inputLine = in.readLine(); long num = Integer.valueOf(inputLine).longValue(); findData(num); if(isFind) { deleteData(num);System.out.print(”請重新輸入該號碼:“);String str = inputData(); addData(str); System.out.println(”rewrite true!“); } }catch(IOException e){} catch(NumberNotFoundException e){} } public int count() throws IOException { DataArrayList dal = new DataArrayList(); try{ String s = ”“; long i =0; BufferedReader in = new BufferedReader（new FileReader(”c:data.txt“)); while((s=in.readLine())!=null) { i=numberTokenizer(s); dal.add(i); } }catch(IOException e){} return dal.size(); } } /* * * @author RangWei * TODO 這是個寫的一個容器,繼承公共類HashMap * 大概的功能就相當一個數組 * */ class DataMap extends HashMap//一個存儲數據的Map { public void put(long i,String str)//把學號和數據放進這個Map { //以后一個學號(key)對應的是一個人的數據(value) put(String.valueOf(i).toString(),str); } public void remove(long i)//接收學號,然后刪除學號(key)和它對應的數據(value) { remove(String.valueOf(i).toString().toString()); } public String get(long i)//接收一個學號,然后返回這個key對應的value { String s = String.valueOf(i).toString(); if(!containsKey(s)) { System.err.println(”Not found Key: "+s); } return(String)get(s); } } /* * * @author RangWei * * TODO 這個類繼承ArrayList * 用來按數字排序,在用號碼排序時要用到它 * */ class DataArrayList extends ArrayList { public void add(long num) { String numToString = String.valueOf(num).toString(); add(numToString); } } /* * * @author RangWei * * TODO 增加的一個Exception,主要是在文件里沒有要找 * 的號碼就拋出 * */ class NumberNotFoundException extends Exception { public NumberNotFoundException() {} }第三篇：java數據結構測試題及答案解析
第四篇：數據結構實驗報告二線性表的順序存儲
第五篇：數據結構課程設計—java通訊錄管理系統
點擊咨詢 