2008年4月16日
#
1 . 用Executors構(gòu)造一個新的線程池
ExecutorService executor = Executors.newCachedThreadPool();
方法 newCachedThreadPool();
創(chuàng)建一個可根據(jù)需要創(chuàng)建新線程的線程池，但是在以前構(gòu)造的線程可用時將重用它們，并在需要時使用提供的 ThreadFactory 創(chuàng)建新線程。
2. 用構(gòu)造的線程池創(chuàng)建ExecutorFilter
ExecutorFilter es= new ExecutorFilter(executor));
在ExecutorFilter內(nèi)部:
只需要將相應(yīng)的事件分發(fā)到到線程池的相應(yīng)線程即可，但是SessionCreated事件只能在主線程中，不能分發(fā)
觸發(fā)方法
1 .
首先構(gòu)造一個IoFilterEvent，這個IoFilterEvent包含1、事件的類型，2、下一個過濾器
然后觸發(fā)該時間的處理方法。
if (eventTypes.contains(IoEventType.SESSION_OPENED)) 
{
fireEvent(new IoFilterEvent(nextFilter, IoEventType.SESSION_OPENED,
session, null));
}
2 .
從線程池中取出一個線程執(zhí)行事件處理
protected void fireEvent(IoFilterEvent event) {
getExecutor().execute(event);
}
在構(gòu)造ExecutorFilter 時如果沒有傳入IoEventType則默認(rèn)只對如下幾種幾件感興趣
EXCEPTION_CAUGHT
MESSAGE_RECEIVED
MESSAGE_SENT
SESSION_CLOSED
SESSION_IDLE
SESSION_OPENED
當(dāng)然還需要覆蓋相應(yīng)的事件處理方法 如上所示
參數(shù)db_block_size；
這個參數(shù)只能設(shè)置成底層操作系統(tǒng)物理塊大小的整數(shù)倍，最好是2的n次方倍。
如WINDOWS下4KB，8KB,16KB
且該參數(shù)需要在建庫的時候指定，一旦指定不能更改。
雖然在ORACLE9I以上可以指定表空間的數(shù)據(jù)庫大小，允許同時使用包括非默認(rèn)大小在內(nèi)的數(shù)據(jù)庫塊大小。不過需要設(shè)置指定大小數(shù)據(jù)塊的buffer_cache.
小的塊：
小的塊降低塊競爭，因為每個塊中的行較少.
小的塊對于小的行有益.
小的塊對于隨意的訪問較好.如果一個塊不太可能在讀入內(nèi)存后被修改，那么塊的大小越小使用buffer cache越有效率。當(dāng)內(nèi)存資源很珍貴時尤為重要，因為數(shù)據(jù)庫的buffer cache是被限制大小的。
劣勢：
小塊的管理消費相對大.
因為行的大小你可能只在塊中存儲很小數(shù)目的行，這可能導(dǎo)致額外的I/O。
小塊可能導(dǎo)致更多的索引塊被讀取
大的塊
好處：
更少的管理消費和更多存儲數(shù)據(jù)的空間.
大塊對于有順序的讀取較好. 譬如說全表掃描
大塊對很大的行較好
大塊改進了索引讀取的性能.大的塊可以在一個塊中容納更多的索引條目,降低了大的索引級的數(shù)量.越少的index level意味著在遍歷索引分支的時候越少的I/O。
劣勢：
大塊不適合在OLTP中用作索引塊,因為它們增加了在索引葉塊上的塊競爭。
如果你是隨意的訪問小的行并有大的塊，buffer cache就被浪費了。例如，8 KB的block size 和50 byte row size,你浪費了7,950
將進酒 杯莫停 -------> 亭名： 悲默亭
全球通史
《詩經(jīng)·采薇》
昔我往矣,楊柳依依 今我來思,雨雪霏霏
摘要: <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance...
閱讀全文
在搜索引擎中，切詞語是一個重要的部分，其中包括專有名詞的提取、詞的分割、詞的格式化等等。
TokenStream 類幾乎是所有這些類的基類
有兩個需要被子類實現(xiàn)的方法Token next() 和 close()
首先來看analysis包，這個包主要是提供一些簡單的詞匯化處理
以Tokenizer結(jié)尾的類是將要處理的字符串進行分割成Token流，而根據(jù)分割的依據(jù)的又產(chǎn)生了以下幾個Tokenizer類
首先Tokenizer類是所有以Tokenizer結(jié)尾的類的基類
然后是CharTokenizer，所有的以Tokenizer結(jié)尾的類都是從這個類繼承的
這個類中有一個抽象方法
protected abstract boolean isTokenChar(char c);
另外一個需要被子類覆寫的方法
protected char normalize(char c) {}；
是對單個字符進行處理的方法譬如說將英文字母全部轉(zhuǎn)化為小寫
還有一個變量
protected Reader input;
這個讀取器是這些類所處理的數(shù)據(jù)的 數(shù)據(jù)源
輸入一個Reader ，產(chǎn)生一個Token流
這個方法是是否進行切分的依據(jù)，依次讀取char流，然后用這個方法對每個char進行檢測，如果返回false則將預(yù)先存儲在
詞匯緩沖區(qū)中的char數(shù)組作為一個Token返回
LetterTokenizer ：
protected boolean isTokenChar(char c) {
return Character.isLetter(c);
}
WhitespaceTokenizer：
protected boolean isTokenChar(char c) {
return !Character.isWhitespace(c);
}
LowerCaseTokenizer extends LetterTokenizer：
protected char normalize(char c) {
return Character.toLowerCase(c);
}
在構(gòu)造函數(shù)中調(diào)用super(in);進行和 LetterTokenizer同樣的操作，但是在詞匯化之前所有的詞都轉(zhuǎn)化為小寫了
然后是以Filter結(jié)尾的類，這個類簇主要是對已經(jīng)詞匯化的Token流進行進一步的處理
輸入是Token流 , 輸出仍然是Token流。
TokenFilter extends TokenStream 是所有這些類的父類
protected TokenStream input;
在TokenFilter 中有一個TokenStream 變量，是Filter類簇處理的數(shù)據(jù)源，而Filter類簇又是繼承了TokenStream 類的
有一個public final Token next()方法,這個方法以TokenStream.next()產(chǎn)生的Token流 為處理源，產(chǎn)生的仍然是Token流
只不過中間有一些處理的過程
LowerCaseFilter：將所有的Token流的轉(zhuǎn)化為小寫
t.termText = t.termText.toLowerCase();
StopFilter：過濾掉一些停止詞，這些停止詞由構(gòu)造函數(shù)指定
for (Token token = input.next(); token != null; token = input.next())
if (!stopWords.contains(token.termText))
return token;
比較一下Tokenizer類簇和Filter類簇，可以知道
Tokenizer類簇主要是對輸入的Reader流，實際上是字符流按照一定的規(guī)則進行分割，產(chǎn)生出Token流
其輸入是字符串的Reader流形式，輸出是Token流
Filter類簇主要是對輸入的Token流進行更進一步的處理，如去除停止詞，轉(zhuǎn)化為小寫
主要為一些格式化操作。
由于Filter類簇的輸入輸出相同，所以可以嵌套幾個不同的Filter類，以達(dá)到預(yù)期的處理目的。
前一個Filter類的輸出作為后一個Filter類的輸入
而Tokenizer類簇由于輸入輸出不同，所以不能嵌套
在JAVA JDK1.5以后具有的自動裝箱與拆箱的功能，所謂的自動裝箱
與拆箱也就是把基本的數(shù)據(jù)類型自動的轉(zhuǎn)為封裝類型。
如：自動裝箱，它可以直接把基本類型賦值給封裝類型
Integer num = 10 ;
Double d = 2d ;
自動拆箱，它可以把封裝類型賦值給基本類型
int num = new Integer(10);
double d = new Double(2d);
自動裝箱與拆箱的功能事實上是編譯器來幫您的忙，編譯器在編譯時期依您所編寫的語法，決定是否進行裝箱或拆箱動作。在自動裝箱時對于值從-128到127之間的值，它們被裝箱為Integer對象后，會存在內(nèi)存中被重用，所以范例4.6中使用==進行比較時，i1 與 i2實際上參考至同一個對象。如果超過了從-128到127之間的值，被裝箱后的Integer對象并不會被重用，即相當(dāng)于每次裝箱時都新建一個Integer對象，所以范例4.7使用==進行比較時，i1與i2參考的是不同的對象。所以不要過分依賴自動裝箱與拆箱，您還是必須知道基本數(shù)據(jù)類型與對象的差異。
public void testBoxingUnboxing() {
int i = 10;
Integer inta = i;
inta++;
inta += 1;
int j = inta;
assertTrue(j == inta);結(jié)果是：true//junit里面的方法
assertTrue(j == new Integer(j)); 結(jié)果是：true
assertTrue(10000 == new Integer(10000)); 結(jié)果是：true
}
Integer i = 100.相當(dāng)于編譯器自動為您作以下的語法編譯：
Integer i = new Integer(100).所以自動裝箱與拆箱的功能是所謂的“編譯器蜜糖”(Compiler Sugar)，雖然使用這個功能很方便，但在程序運行階段您得了解Java的語義。例如下面的程序是可以通過編譯的：
Integer i = null.int j = i.這樣的語法在編譯時期是合法的，但是在運行時期會有錯誤，因為這種寫法相當(dāng)于：
Integer i = null.int j = i.intValue().null表示i沒有參考至任何的對象實體，它可以合法地指定給對象參考名稱。由于實際上i并沒有參考至任何的對象，所以也就不可能操作intValue()方法，這樣上面的寫法在運行時會出現(xiàn)NullPointerException錯誤。
自動裝箱、拆箱的功能提供了方便性，但隱藏了一些細(xì)節(jié)，所以必須小心。再來看范例4.6，您認(rèn)為結(jié)果是什么呢？
Ü. 范例4.6 AutoBoxDemo2.java
public class AutoBoxDemo2 {
public static void main(String[] args) {
Integer i1 = 100;
Integer i2 = 100;
if (i1 == i2)
System.out.println("i1 == i2");
else
System.out.println("i1 != i2").
}
}
從自動裝箱與拆箱的機制來看，可能會覺得結(jié)果是顯示i1 == i2，您是對的。那么范例4.7的這個程序，您覺得結(jié)果是什么？
Ü. 范例4.7 AutoBoxDemo3.java
public class AutoBoxDemo3 {
public static void main(String[] args) {
Integer i1 = 200;
Integer i2 = 200;
if (i1 == i2)
System.out.println("i1 == i2");
else
System.out.println("i1 != i2");
}
}
結(jié)果是顯示i1 != i2，這有些令人驚訝，兩個范例語法完全一樣，只不過改個數(shù)值而已，結(jié)果卻相反。
其實這與==運算符的比較有關(guān)，在第3章中介紹過==是用來比較兩個基本數(shù)據(jù)類型的變量值是否相等，事實上==也用于判斷兩個對象引用名稱是否參考至同一個對象。
在自動裝箱時對于值從–128到127之間的值，它們被裝箱為Integer對象后，會存在內(nèi)存中被重用，所以范例4.6中使用==進行比較時，i1 與 i2實際上參考至同一個對象。如果超過了從–128到127之間的值，被裝箱后的Integer對象并不會被重用，即相當(dāng)于每次裝箱時都新建一個Integer對象，所以范例4.7使用==進行比較時，i1與i2參考的是不同的對象。
所以不要過分依賴自動裝箱與拆箱，您還是必須知道基本數(shù)據(jù)類型與對象的差異。范例4.7最好還是依正規(guī)的方式來寫，而不是依賴編譯器蜜糖(Compiler Sugar)。例如范例4.7必須改寫為范例4.8才是正確的。
Ü. 范例4.8 AutoBoxDemo4.java
public class AutoBoxDemo4 {
public static void main(String[] args) {
Integer i1 = 200;
Integer i2 = 200;
if (i1.equals(i2))
System.out.println("i1 == i2");
else
System.out.println("i1 != i2");
}
}
結(jié)果這次是顯示i1 == i2。使用這樣的寫法，相信也會比較放心一些，對于這些方便但隱藏細(xì)節(jié)的功能到底要不要用呢？基本上只有一個原則：如果您不確定就不要用。
在IndexWriter中有3個重要的性能參數(shù)
mergeFactor 默認(rèn)為10
minMergeDocs 默認(rèn)為10
maxMergeDocs 默認(rèn)為Integer.maxValue
maxMergeDocs 一個段中所能包含的最大的doc數(shù)，達(dá)到這個數(shù)目即不再將段進行合并 一般不改變這個值
minMergeDocs 是指在RAMDirectory中保存的Doc的個數(shù)，達(dá)到minMergeDocs 個即要合并到硬盤上去（在硬盤上新建一個段）
mergeFactor 合并因子，是控制硬盤上的段的合并的，每次在硬盤上新建一個段之后即執(zhí)行
targetMergeDocs*=mergeFactor（一開始targetMergeDocs=minMergeDocs） 如果硬盤上的doc數(shù)目大于等于 targetMergeDocs則將硬盤上最后建立的mergeFactor個段進行合并成一個段
拿默認(rèn)的參數(shù)舉例：
如果硬盤上面已經(jīng)有9個段 每個段分別存儲了10個Document,共（90個DOC），這時候如果程序再向硬盤合并一個新的段（含10個DOC），合并完之后targetMergeDocs=10*10 程序檢查已經(jīng)合并的最后（按照創(chuàng)建的時間先后順序）mergeFactor個段的document的總和100是否大于等于targetMergeDocs（這里是100，剛好滿足要求）于是程序又將硬盤上面的后10個段合并為一個新的段。
另外一個例子：
doc數(shù)目 段數(shù)目
1000---------------9個
100-----------------9個
10 ----------------9個
這時如果再象硬盤中新建一個新的包含了10個doc的段
doc數(shù)目 段數(shù)目
(1) 1000----------------9個
(2) 100-----------------9個
(3) 10 ----------------9個
(4) 10 ----------------1個
這時候(3)(4)首先合并成一個新的段(3-4)包含100個doc
然后(2)(3-4)和并成一個新段（2-3-4）包含1000個doc
然后(1)(2-3-4)合并成一個新的段 包含10000個doc
最后合并成一個段
private final void maybeMergeSegments() throws IOException {
long targetMergeDocs = minMergeDocs;
while (targetMergeDocs <= maxMergeDocs) {
// find segments smaller than current target size
int minSegment = segmentInfos.size();
int mergeDocs = 0;
while (--minSegment >= 0) {
SegmentInfo si = segmentInfos.info(minSegment);
if (si.docCount >= targetMergeDocs)
break;
mergeDocs += si.docCount;
}
if (mergeDocs >= targetMergeDocs) // found a merge to do
mergeSegments(minSegment+1);
else
break;
targetMergeDocs *= mergeFactor; // increase target size
System.out.println("- -- - -targetMergeDocs:"+targetMergeDocs);
try {Thread.sleep(5000);} catch(Exception e) {};
}
}
HIBERNATE一多對關(guān)聯(lián)中 要求在持久化類中定義集合類屬性時，必須把屬性聲明為接口，因為HIBERNATE在調(diào)用持久化類的SET/GET方法時傳遞的是HIBERNATE自己定義的集合類。
在定義集合時，一般先初始化為集合實現(xiàn)類的一個實例 ： private Set orders=new HashSet()，這樣可以避免訪問空集合出現(xiàn)NullPointerException.
segments文件的格式： （段的信息）
int: =-1 查看文件是否是Lucene合法的文件格式
long: 版本號，每更新一次該文件將會將版本號加1
int: 用來命名新段
int: 段的數(shù)目
String + int 段的信息 String是段的名稱 int是段中所含的doc數(shù)目
String + int 同上
.fnm的文件格式： （Field的信息）
int: Field的個數(shù)，最少為1，最少有一個Field("",false)，在初始化的時候?qū)懭?暫時不知道原因); 名稱為空字符串，未索引， 未 向 量化。readVInt()讀取
String: byte String是 Field的名稱 byte指示該Field 是否被索引，是否向量化 （值有：11，10，01）第一個1代表被索引，第二個代表被向量化
String: byte Field 同上
.fdx的文件格式：主要是提供對.fdt中存儲的document的隨即讀取
long : 第一個document在.fdt文件中的位置
long: 第二個document在.fdt文件中的位置
.fdt的文件格式： .fdt文件存儲了一系列document的信息
VInt: 該document中的isStored屬性為true的域的個數(shù)
(VInt:) 如果該field的isStored屬性為true則得到該field的fieldNumber，暫時不知道這個fieldNumber是怎么產(chǎn)生的，有什么用，初步估計是按照field創(chuàng)建的順序產(chǎn)生的，每次再上一個field的fieldNumber基礎(chǔ)上加1。
byte: 如果該field的isTokenized屬性為true寫入1否則寫入false。
String: 該field的stringValue()值。
一個document結(jié)束，下面的數(shù)據(jù)將會開始一個新的document，每個新的document的開始點的文件位置都會在.fdx中有記載，便于隨即訪問
final class SegmentInfos extends Vector
可以看出該類實際上是一個Vector 以及封裝了對該Vevtor的一些操作
實際上封裝的是對segments文件的一些讀寫操作
先來看下segments文件的格式
segments文件的格式：
int: =-1 文件是否是Lucene合法的文件格式正常情況下為 -1
long: 版本號，每更新一次該文件將會將版本號加1
int: 用來命名新段
int: 段的數(shù)目
String + int 段的信息 String是段的名稱 int是段中所含的doc數(shù)目
String + int 同上
所以用Lucene的API，我們可以簡單的打印出其segments的所有信息
try {
//DataInputStream fis = new DataInputStream(new FileInputStream("C:\\sf\\snow\\segments"));
FSDirectory dir=FSDirectory.getDirectory("C:/sf/snow", false);
InputStream input = dir.openFile("segments");
System.out.println("Format:"+input.readInt()); //得到文件標(biāo)志，是否為正常的segments文件
System.out.println("version:"+input.readLong()); //得到版本號
System.out.println("name:"+input.readInt()); //得到用來重命名新段的int，暫時不知道有什么用
int n=input.readInt(); //段的數(shù)目
System.out.println("SegmentNum:"+n);
for(int i=0;i<n;i++) { //用循環(huán)打印出所有段的信息 名稱和長度
System.out.println("segment "+i+" - name:"+input.readString()+" num:"+input.readInt());
}
} catch (Exception e) {
}
當(dāng)然,該類提供了更為復(fù)雜的訪問和更新segments文件的方法
final void read(Directory directory) 將所有的段信息保存在本vector中
final void write(Directory directory) 跟新該segment文件的內(nèi)容，主要是為了添加段，
主要是更新 版本號 段的數(shù)目，跟新完這些后即可往segment文件后添加新段的信息。
segment(段)的信息
該類比較簡單，貼出其全部代碼
import org.apache.lucene.store.Directory;
final class SegmentInfo {
public String name; //在索引目錄中唯一的名稱
public int docCount; // 該段中doc的數(shù)目
public Directory dir; // 該段所存在的Dirrectory
public SegmentInfo(String name, int docCount, Directory dir) {
this.name = name;
this.docCount = docCount;
this.dir = dir;
}
}
該類是從RAMFile中讀數(shù)據(jù)用的
最重要的一個方法：
該方法存在著從RAMFile的多個byte[1024]中讀取數(shù)據(jù)的情況，所以應(yīng)該在循環(huán)中進行處理
public void readInternal(byte[] dest, int destOffset, int len) {
int remainder = len;
int start = pointer;
while (remainder != 0) {
int bufferNumber = start/BUFFER_SIZE; // buffer的序號
int bufferOffset = start%BUFFER_SIZE; // buffer偏移量
int bytesInBuffer = BUFFER_SIZE - bufferOffset;// 在當(dāng)前buffer中剩下的字節(jié)數(shù)
//如果緩沖區(qū)中剩余的字節(jié)大于len，則讀出len長度的字節(jié)，如果不夠則讀出剩余的字節(jié)數(shù)
// bytesToCopy表示實際讀出的字節(jié)數(shù)
int bytesToCopy = bytesInBuffer >= remainder ? remainder : bytesInBuffer;
byte[] buffer = (byte[])file.buffers.elementAt(bufferNumber);
System.arraycopy(buffer, bufferOffset, dest, destOffset, bytesToCopy);
destOffset += bytesToCopy; //增加已經(jīng)復(fù)制的byte數(shù)據(jù)長度 到 dest中的偏移量
start += bytesToCopy; //RAMFile文件指針，用來確定bufferNumber 和bytesInBuffer 相當(dāng)于內(nèi)存中的分頁
remainder -= bytesToCopy; //剩余的還未復(fù)制的字節(jié)數(shù)
}
pointer += len;//文件指針位置
}
這是OutputStream的一個子類，其輸出設(shè)備是內(nèi)存，準(zhǔn)確來說是RAMFile，即將數(shù)據(jù)寫入到RAMFile的Vector中去。
該類有一個最重要的方法，現(xiàn)在把它整個貼出來
public void flushBuffer(byte[] src, int len) {
int bufferNumber = pointer/BUFFER_SIZE; //buffer序列，即當(dāng)前所寫B(tài)uffer在RAMFile中的Vector中的序列號
int bufferOffset = pointer%BUFFER_SIZE; //偏移量，即當(dāng)前所寫字節(jié)在當(dāng)前Buffer中的偏移量。
int bytesInBuffer = BUFFER_SIZE - bufferOffset; //當(dāng)前Buffer的剩余可寫字節(jié)數(shù)
//bytesToCopy是實際寫入的字節(jié)數(shù)，如果當(dāng)前Bufer的剩余字節(jié)數(shù)大于需要寫的字節(jié)的總數(shù)則寫入所有字節(jié)
//否則，將當(dāng)前Buffer寫滿即可，剩余的字節(jié)將寫入下一個Buffer
int bytesToCopy = bytesInBuffer >= len ? len : bytesInBuffer;
if (bufferNumber == file.buffers.size())
file.buffers.addElement(new byte[BUFFER_SIZE]); //在RAMFile中添加新的byte[1024]元素
byte[] buffer = (byte[])file.buffers.elementAt(bufferNumber);
System.arraycopy(src, 0, buffer, bufferOffset, bytesToCopy);
if (bytesToCopy < len) { // not all in one buffer,
int srcOffset = bytesToCopy;
bytesToCopy = len - bytesToCopy; // remaining bytes 剩余的未寫入的字節(jié)數(shù)
bufferNumber++; //將buffer數(shù)增加1
if (bufferNumber == file.buffers.size())
file.buffers.addElement(new byte[BUFFER_SIZE]);
buffer = (byte[])file.buffers.elementAt(bufferNumber); //剩余字節(jié)寫入下一個Buffer
System.arraycopy(src, srcOffset, buffer, 0, bytesToCopy);
}
pointer += len;
if (pointer > file.length)
file.length = pointer; //移位文件指針 在原有的基礎(chǔ)上加上實際寫入的字節(jié)總數(shù)
file.lastModified = System.currentTimeMillis(); //修改文件的最后修改時間為當(dāng)前時間
}
從指定的字節(jié)數(shù)組復(fù)制指定長度的字節(jié)到RAMFile中去。由于RAMFile中Vector的元素是byte[1024]所以可能存在做一次該操作
要操作兩個Vector元素的情況。即先將當(dāng)前byte[1024]數(shù)組填滿，再新建一個元素裝載剩余的字節(jié)。
另外還有一個writeTo(OutputStream out)方法，將RAMFile中的數(shù)據(jù)輸出到另一個輸出流
這個類比較簡單
import java.util.Vector;
class RAMFile {
Vector buffers = new Vector();
long length;
long lastModified = System.currentTimeMillis();
}
可以理解為一個存儲在內(nèi)存中的文件，buffers是存儲數(shù)據(jù)的容器，length是容器中數(shù)據(jù)的總的字節(jié)數(shù)
lastModified 是最后修改時間。
在實際使用過程中容器buffers存放的對象是一個byte[1024]數(shù)組。
OutputStream
這是一個Abstract類，是Lucene自己的一個文件輸出流的基類
BUFFER_SIZE = 1024 緩沖區(qū) 大小為 1024bit
bufferStart = 0 文件位置指針
bufferPosition = 0 內(nèi)存緩沖區(qū)指針
public final void writeByte(byte b) throws IOException {
if (bufferPosition >= BUFFER_SIZE)
flush();
buffer[bufferPosition++] = b;
}
幾乎所有的寫入函數(shù)都要調(diào)用這個函數(shù)，如果緩沖區(qū)的當(dāng)前容量已經(jīng)等于他的最大容量，則將緩沖區(qū)中的數(shù)據(jù)寫入文件。
public final void writeBytes(byte[] b, int length) throws IOException
批量寫byte進入內(nèi)存緩沖
public final void writeInt(int i) throws IOException
寫入整形數(shù)據(jù)
public final void writeLong(long i) throws IOException
寫入長整型數(shù)據(jù)，即結(jié)合移位運算調(diào)用兩次writeInt(int i)
另外，最值得注意的是在該類中有兩個最特殊的函數(shù)
writeVInt（int i） / writeVLong(long i),
先說
writeVInt(int i ) {
while ((i & ~0x7F) != 0) {
writeByte((byte)((i & 0x7f) | 0x80));
i >>>= 7;
}
writeByte((byte)i);
}
~0x7F==~(0111 1111)==(1000 0000)==0x80
((i & ~0x7F) != 0) 這一句判斷i是否大于0x80，如果不是則說明該int只有一個字節(jié)的有效數(shù)據(jù)，其他字節(jié)都是0，直接轉(zhuǎn)化為Byte寫入。
如果大于0x80則
(i & 0x7f) | 0x80
i&0x7f 只對后7位進行處理，|0x80將第8位置1，與前面的7個bit構(gòu)成一個字節(jié)，置1的原因是說明該字節(jié)并不是一個完整的整形數(shù)，需要與其他的字節(jié)合起來才能構(gòu)成一個整形數(shù)字。
這個算法相當(dāng)于將一個32bit的整形數(shù)字按照每7位編碼成一個字節(jié)進行存儲，將按照整形數(shù)的大小存儲1-5個字節(jié)。
writeVLong(long i)方法大致與其相同。
final void writeChars(String s, int start, int length)
將字符串轉(zhuǎn)化成UTF-8編碼的格式進行存儲。
附：
UNICODE值 UTF-8編碼
U-00000000 - U-0000007F: 0xxxxxxx
U-00000080 - U-000007FF: 110xxxxx 10xxxxxx
U-00000800 - U-0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
可見對于在 0x00-0x7F范圍內(nèi)的UNICODE值（最大有效數(shù)位：7位），將會編碼成單字節(jié)的，會大大節(jié)約存儲空間。
對于在 0x80-0x7FF范圍內(nèi)的UNICODE（最大有效數(shù)位：11位），會編碼成雙字節(jié)的。先存儲原字節(jié)低5位的數(shù)位，且將最高位和次高位都置1，再次高位置0（writeByte((byte)(0xC0 | (code >> 6)));）。然后存儲后6位的字節(jié)，將前兩位置10（writeByte((byte)(0x80 | (code & 0x3F)));）
對于其他的UNICODE值則
writeByte((byte)(0xE0 | (code >>> 12))); 4位
writeByte((byte)(0x80 | ((code >> 6) & 0x3F))); 5位
writeByte((byte)(0x80 | (code & 0x3F))); 3- 5位
final void writeString(String s) throws IOException
該函數(shù)首先用s.length()判斷該String總共有多少個字符
然后首先調(diào)用writeVInt寫入這個字符長度
再調(diào)用writeChars(s,s.length())寫入字符
在inputStream中的readString()方法則與其相反，首先用readVInt()方法讀取字符長度len 然后讀取len長度的字符
protected final void flush() throws IOException
該方法調(diào)用另外一個方法flushBuffer將緩沖區(qū)中的數(shù)據(jù)輸出，然后清空緩沖區(qū)；
abstract void flushBuffer(byte[] b, int len) throws IOException
可見flushBuffer方法是abstract的，即需要其子類對該方法進行覆寫，以定位該輸出流的輸出方式。
final long getFilePointer() throws IOException
得到文件指針的位置，即得到輸出流已經(jīng)輸出的字節(jié)數(shù)。
public void seek(long pos) throws IOException
輸出緩沖區(qū)的內(nèi)容，然后將文件指針定位到long所指示的文件位置。
abstract long length() throws IOException
返回文件中已有的字節(jié)數(shù)。需要子類實現(xiàn)。