Special case: primitive types

 

Special case: primitive types

Java determines the size of each primitive type. These sizes don’t change from one machine

architecture to another as they do in most languages. This size invariance is one reason Java

programs are more portable than programs in most other languages.

 

 

All numeric types are signed, so don’t look for unsigned types.

The size of the boolean type is not explicitly specified; it is only defined to be able to take the literal values true or false.

The “wrapper” classes for the primitive data types allow you to make a non-primitive object on the heap to represent that primitive type. For example:

char c = 'x';

Character ch = new Character(c);

Or you could also use:

Character ch = new Character('x');

Java SE5 autoboxing will automatically convert from a primitive to a wrapper type:

Character ch = 'x';

and back:

char c = ch;

The reasons for wrapping primitives will be shown in a later chapter.

High-precision numbers

Java includes two classes for performing high-precision arithmetic: BigInteger and

BigDecimal. Although these approximately fit into the same category as the “wrapper” classes, neither one has a primitive analogue.

Both classes have methods that provide analogues for the operations that you perform on

primitive types. That is, you can do anything with a BigInteger or BigDecimal that you can with an int or float, it’s just that you must use method calls instead of operators. Also, since there’s more involved, the operations will be slower. You’re exchanging speed for accuracy.

BigInteger supports arbitrary-precision integers. This means that you can accurately represent integral values of any size without losing any information during operations.

BigDecimal is for arbitrary-precision fixed-point numbers; you can use these for accurate

monetary calculations, for example.

 

OX123＝1×16²＋2×16¹＋3×16⁰

posted @ 2008-05-20 13:12 九寶 閱讀(203) | 評論 (0) | 編輯 收藏

整型數(shù)據(jù)

三種形式的整型常量數(shù)據(jù)：
1.十進(jìn)制
2.八進(jìn)制，以o開頭O123＝1×8²＋1×8¹＋3×8⁰＝十進(jìn)制的83
3.十六進(jìn)制 ，以ox開頭  OX123＝1×16²＋2×16¹＋3×16⁰

posted @ 2008-05-20 13:10 九寶 閱讀(165) | 評論 (0) | 編輯 收藏

Introduction to Objects

1.The hidden implementation
The goal of the class creator is to build a class that exposes only what is necessary to the client programmer and keeps everything else hidden. Why?
(1)Becuase if it is hidden, the client programmer can't access it, which means that the class creator can change the hidden portion at will withou worring about the impact on anyone else.
(2)The hidden portion usually reprsents the tender insides of an object that could easily be corrupted by a careless or uninformed client programmer, so hiding the implementation reduces program bugs.

2.Reusing the implementation
The simplest way to reuse a class is to just use an object of that class directly, but you can also place an object of that class inside a new class. We call this "creating a member object." Your new class can be made up of any mumber and type of other objectss, in any combination that you need to achieve the fuctionality desired in your new class. Because you are composing a new class from existing classes, this conception is called composition. Compositon is often referred to as a "has-a" relationship, as "A car has an engine."
Because inheritance is so important in OOP, it is often highly emphasized, and the new programmer can get the idea that inheritance should be used everywhere. This can result in awkward and overly complicated designs. Instead, you should first look to composition when creating new classes, since it is simpler and more flexible. If you take this approach,your designer will be cleaner. Once you have had some experience, it will be reasonably obvious when you need inheritance.

3.Inheritance
You have two ways to differentiate your new derived class from the original base class.
The first is quite straightforward: You simply add brand new methods to the derived class. This means that the base class simply didn't as much as you wanted it to, so you added more methods. This simple and primitive use for inheritance is, at times, the perfect solution to your problem. However, you should look closely for the posiblilty that your base class might also need these additional methods. This process of discovery and iteration of your design happens regularly in OOP.
The second and more important way to differentiate your new class is to change the behavior of an existing base-class method. This is referred to as overriding that method. To override a method, you simply create a new definition for the method in the derived class. You are saying, "I am using the same interface method here, but I want it to do something different for my new type."

4.Is-a vs. is-like-a relationships

5.Interchangeable objects with polymorphism

6The single rooted hierarchy
All objects have a single rooted hierarchy can be guaranteed to have certain functionality. You know you can perform certain basic operations on every object in your system. All objects can easy be created on the heap, and argument passing is greatly simplified.
A single rooted hierarchy makes it much easier to implement a garbage collector, which is one of the fundamental improvements of Java over C++. And since information about the type of an object is guaranteed to be in all objects, you'll never end up with an object whose type you cannot determine. This is especially important with system-level operations, such as exception handling, and to allow greater flexibility in programming.

7.Containers

8.Parameterized types(generics)
One of the big changes in Java SE5 is the addition of parameterized types, called generics in java. you will recongize the use of generics by angle brackets with types inside.

9.Object creation & lifetime
How can you possibly know when to destroy the objects?
(1).C++ takes the approach that control of efficiency is the most important issue, so it give the programmer a choice.
(2).Java, in heap

10 Exception handling: dealing with errors

posted @ 2008-05-20 13:10 九寶 閱讀(234) | 評論 (0) | 編輯 收藏

java byte類型為什么是（127—— －128）

所有的整數(shù)類型（除了char 類型之外）都是有符號的整數(shù)

因為， java的byte是8bit（位），就是8個0/1 來表示。
但是第一位是符號位，表示正數(shù)還是負(fù)數(shù)。所以：
0000 0001表示1，     （1×  2⁰）
0000 0000表示0，     （0×  2⁰）

計算機(jī)中負(fù)數(shù)的二進(jìn)制碼是是負(fù)數(shù)的絕對值取反，然后加1.
例如－1的二進(jìn)制：
－1的絕對值是1（0000 0001）;
取反是（1111 1110）;
再加 1（0000 0001 ）；
結(jié)果是（1111 1111）

要對一個負(fù)數(shù)的二進(jìn)制進(jìn)行解碼，首先對其所有的位取反，然后加1。
例如－1的 二進(jìn)制   （1111 1111）
取反：  0000 0000 是0
再加1：（0＋1＝1）
符號位是1，是負(fù)數(shù)，所以是－1

1000 0000 表示－128，   （解碼過程：位取反是0111 1111＝＝》127，然后加1＝＝》128，符號位為1,是負(fù)數(shù)，表示－128）

posted @ 2008-05-20 12:48 九寶 閱讀(1502) | 評論 (0) | 編輯 收藏

軟件安裝過程淺釋（轉(zhuǎn)）

軟件在安裝時，到底做了些什么？ 大家每天都在用電腦，可能也經(jīng)常在自己的電腦上安裝軟件。就算自己沒安裝過，至少也看到人家安裝過軟件。在這里，我不是想教你怎么安裝軟件，而是想向你展示，軟件在安裝的過程中，到底都做了些什么動作？為什么有些軟件要安裝，直接拷貝過去卻不能用？為什么一些軟件安裝或卸載之后要重啟。下面要討論的就是這些問題。

    首先，我們探討一下軟件安裝的共通部分，說共通，就是在不同版本的操作系統(tǒng)上，如WINDOWS98，WIN2K和WINXP等上它們都有共同點的地方。這個文章也試圖不針對具體的某個操作系統(tǒng)，而對共同的規(guī)律來探討，不過我自己用的是WINDOWS98，所以有時一些例子可能會用WINDOWS98上的實例來說明，而大多數(shù)情況下這些特***在WIN2K和WINXP上也是類似的。

    那么，我先來歸納一下，典型的軟件安裝過程都有可能做哪些事情。由于我們是討論軟件在安裝時的行為，所以開始安裝前的設(shè)置和選項我們就暫不討論，只說到軟件真正開始安裝那個時候起的動作：

①文件從安裝源位置拷貝到目標(biāo)位置。

②往系統(tǒng)目錄寫入一些必要的動態(tài)連接庫(DLL)。(可選)

③往系統(tǒng)注冊表中寫入相應(yīng)的設(shè)置項。(可選)

④建立開始菜單里的程序組和桌面快捷方式。(可選)

⑤其他動作。(可選)

     下面我們再詳細(xì)來分析上面歸納出來的這些動作：

1)拷貝軟件本身需要的文件。源位置指軟件未安裝之前的位置，例如光盤，下載的目錄等，目標(biāo)位置指你指定的安裝位置。

這是幾乎所有的軟件安裝過程一定會做的一件事。而如果一個軟件，在安裝時只要這一步，不需要后面的其他幾步，我們可以認(rèn)為這個軟件就是綠色軟件。或者反過來說綠色軟件就是只要拷貝文件，不需要依賴于某個DLL，或者它依賴的DLL在幾乎所有的系統(tǒng)中都一定有的，并且它也不依賴于注冊表里面的設(shè)置項的軟件。

2)這一步，可以說至少有一半軟件在安裝時都會做，一些軟件，需要用到某個DLL，特別是那些軟件作者開發(fā)的DLL，或者系統(tǒng)中不常用的DLL，一般都會隨軟件的安裝拷到系統(tǒng)目錄。所謂系統(tǒng)目錄，在WIN98下一般是在WINDOWS\SYSTEM這個目錄，而WIN2K是在WINNT\SYSTEM32，WINXP是在WINDOWS\SYSTEM32。還有，一些軟件如QQ游戲，中游等，它們也用到一些DLL，由于這些DLL只是這個軟件自己用到，別的其他軟件不會用到，所以它們并不一定存在于系統(tǒng)目錄，而是放在軟件安裝目錄里面，這樣的DLL已經(jīng)在上一步中被拷貝，所以和這一步說的情況不一樣。

3)這一步同樣至少有一半軟件會做，一般在安裝前用戶的設(shè)置和一些選項，在安裝時就會把這些設(shè)置寫到注冊表里。另外就是有時在上一步把DLL拷貝到系統(tǒng)目錄時，一些DLL需要向系統(tǒng)注冊，這些DLL的注冊信息也會寫在注冊表里。還有，一些軟件有時可能安裝時并不寫注冊表，而是在第一次運行時才把一些設(shè)置寫到注冊表。

4)這個非常簡單，大概不需要怎么解釋。建立這些快捷方式一方面是便于用戶執(zhí)行，另外在時也會把卸載的快捷方式放在程序組里。關(guān)于卸載后面我們再來討論。

5)這個就是除了上面說的以外的其他情況。例如有些軟件安裝時會先把所有文件(或一部分文件)先解壓到臨時目錄，那么安裝完之后就要把這些文件刪除掉。

    那么我們再總結(jié)一下：

一、一個典型的軟件在安裝過程一般都會執(zhí)行上面的1-4項。這樣可以認(rèn)為是一個完整的安裝過程。

二、除了第1項之外，其他的都不是必要的。只需要第一項的軟件，我們可以把它叫做綠色軟件。

三、有些軟件安裝時是執(zhí)行了1、2、4，有些軟件是執(zhí)行了1、3、4，有些軟件是執(zhí)行了1、4。

四、一個特殊的情況，一般的驅(qū)動程序，只會執(zhí)行2和3，沒有1和4。

五、理論上，任何軟件，如果你非常確切地知道了它在上面的那幾步都具體做了些什么，特別是2和3，那么，理論上你可以把這個軟件的安裝文件拷貝到另一臺機(jī)子，把必要的DLL從系統(tǒng)目錄拷貝到那一臺機(jī)子的系統(tǒng)目錄，再把注冊表里軟件寫入的項目導(dǎo)出來(必要時還要修改一下)再導(dǎo)入到那臺機(jī)子的注冊表中，那么，就算不是綠色軟件，你也能這樣把它移植給另一臺機(jī)。但有時特別是一些共享軟件，一般都會有注冊表中設(shè)置比較隱蔽的項目，不容易查找，所以除非你對系統(tǒng)非常熟悉，否則不是綠色軟件的軟件要移植還是有一定的難度的。

     那么，下面我們再來看看，為什么一些軟件安裝后要重啟。

在WINDOWS操作系統(tǒng)上，一般一個正在運行中的程序，操作系統(tǒng)是不讓你修改它的，修改包括替換，改動和刪除。那么有時，一些軟件需要向系統(tǒng)目錄中寫入一個DLL，而系統(tǒng)目錄中原來已經(jīng)有同名的DLL并且這個DLL目前正在被系統(tǒng)使用，因此不能用新版本去替換它，這個時候就需要重啟，在重啟的過程中，在這個DLL舊的版本被使用之前用新版本替換它。這就是為什么要重啟的原因。

你能看到這里，說明你很有耐心，并且對技術(shù)的探討很有興趣，那么我就再說得更詳細(xì)些。在WIN98中，上面說的這個替換是由系統(tǒng)的一個工具來實現(xiàn)的，這個工具叫WININIT.EXE。安裝程序在檢測到需要寫入的DLL或其他程序文件正在使用時，會把要寫入的DLL文件先定一個臨時的文件名，然后在WINDOWS目錄中往WININIT.INI寫入一個改寫項，比如，一個叫ABCD.DLL的動態(tài)連接庫現(xiàn)在正在使用中，而安裝程序要往系統(tǒng)中寫入新版本的ABCD.DLL，這時安裝程序會把新版本ABCD.DLL先定一個臨時文件名，例如AAAA.LLL，然后在WININIT.INI中的[rename]一節(jié)中寫入這一項： 篩l罉枓犮
 C:\windows\system\abcd.dll=C:\windows\system\aaaa.lll CX=B)
 這樣，在重啟時，進(jìn)入WINDOWS圖形界面之前，WININIT.EXE在檢測到WINDOWS目錄中有WININIT.INI存在時，就執(zhí)行里面的操作，在上面的例子中，是用C:\windows\system\aaaa.lll去替換掉C:\windows\system\abcd.dll這個文件，并且把WININIT.INI改名為WININIT.BAK。

     另外，有些軟件，在安裝時，是把所有文件包括SETUP.EXE解壓到臨時文件里面再執(zhí)行SETUP.EXE進(jìn)行安裝的，按理來說安裝完要把所有的臨時文件刪除掉，這個操作當(dāng)然也是由安裝程序SETUP.EXE來完成，但它自己正在運行，也刪不了它自己，所以也要重啟來刪除，做法和上面差不多，只是改成類似這樣子的： 怦S?vH燁?
 NUL=C:\WINDOWS\TEMP\SETUP.EXE

    在WIN2K和WINXP中，存在類似的機(jī)制，不過并不是用WININIT.EXE和WININIT.INI來實現(xiàn)，具體的做法我也不是很清楚，長期以來我大多數(shù)時候都是在用WIN98，所以沒認(rèn)真研究過，但軟件安裝過程要重啟的現(xiàn)象在2K和XP上是仍然存在的，原理也是在重啟時替換或修改正在使用的文件，只是實現(xiàn)的方式不同。

    最后，我們再來看看有關(guān)卸載方面的內(nèi)容。一般卸載有好幾種方式：

1)早期的安裝程序，一般會在安裝過程記錄了上面說的安裝過程的1234四個步驟中具體拷貝的文件和DLL以及注冊表項，把它保存在INSTALL.LOG之類的文件中，再在軟件的安裝目錄(或WINDOWS目錄中)放一個UNINST.EXE之類的卸載程序。然后要么在程序組里為這個UNINST.EXE建一個快捷方式，要么在注冊表中為這個UNINST.EXE建一個快捷方式(這誑刂潑姘宓奶砑由境絳蚓湍蕓吹餃砑男對叵?，并把INSTALL.LOG做為它的參數(shù)，這樣就實現(xiàn)卸載了。

2)現(xiàn)在比較多的安裝程序是用新版的INSTALLSHIELD生成的，安裝時的記錄和卸載程序一般是會放在C:\Program Files\InstallShield Installation Information這個文件夾(隱藏屬***)里，同樣也會在程序組和注冊表中建立卸載項。

    另外，在卸載時，也會遇到文件(一般是DLL文件)正在使用的情況。所以有時卸載的時候也要重啟，就是要在重啟過程中刪掉這些正在使用的DLL文件。

    關(guān)于軟件的安裝過程，大概就想到這里，以后再有想到什么的，我再補(bǔ)充，大家有什么看不懂的也可以把問題提出來。

posted @ 2008-05-05 15:04 九寶 閱讀(222) | 評論 (0) | 編輯 收藏

FC命令查看安裝程序時都向注冊表干了些什么

    安裝新軟件前，打開注冊表編輯器，選擇“注冊表→導(dǎo)出注冊表文件”，利用“全部”選項，將結(jié)果文件保存為Before.txt（不要使用REG擴(kuò)展名）。安裝新軟件或進(jìn)行用戶想跟蹤的其他任何更改后，打開注冊表編輯器，再導(dǎo)出整個注冊表，這一次將導(dǎo)出的文件命名為After.txt文件。接著打開MS-DOS命令窗口，轉(zhuǎn)換到有那兩個文本文件的目錄中，然后執(zhí)行以下命令：

    FC Before.txt After.txt > Diff.txt

    關(guān)閉DOS窗口，在“記事本”中打開Diff.txt文件，這里會顯示在注冊表所發(fā)現(xiàn)的所有不同之處。

posted @ 2008-05-05 15:00 九寶 閱讀(465) | 評論 (0) | 編輯 收藏

Java入門 解析配置文件的文件問題(轉(zhuǎn))

我們在解析配置文件的時候,常常會為路徑發(fā)愁,我就遇到過這樣的情況
　　 　
　　如上圖所示：
　　
　　ParseProperties.java是配置文件database.properties的解析類，那么我們怎樣去取得它的路徑并解析起配置呢？看解析類ParseProperties的源代碼如下：
　　
　　package zy.pro.sc.db;
　　
　　import java.util.*;
　　import java.io.*;
　　
　　public class ParseProperties {
　　
　　Properties properties = new Properties();
　　
　　public ParseProperties() {
　　try{
　　this.parseProp();
　　}catch(Exception e){
　　e.printStackTrace();
　　}
　　}
　　
　　public Properties parseProp()throws　IOException　{
　　InputStream is=this.getClass().getResourceAsStream("database.properties");
/*          
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
InputStream in = classLoader.getSystemResourceAsStream(fileName);
 */
　　properties.load(is);
　　is.close();
　　return null;
　　}
　　public　String　getProperties(String　propStr){
　　return properties.getProperty(propStr);
　　}
　　public static void main(String[] args) {
　　ParseProperties　pp=new ParseProperties();
　　String　driver=pp.getProperties("jdbc.driver");
　　System.out.println(driver);
　　}
　　}
　　看粗體部分，this.getClass()方法可以得到了當(dāng)前類的Class對象，也可以用ParseProperties.class.getClass()方法來實現(xiàn)同樣的效果。之后調(diào)用其getResourceAsStream("database.properties")方法來解析配置文件。getResourceAsStream（）方法解析文件時候的相對路徑是當(dāng)前類的包路徑。
　　
　　就當(dāng)前的包來說，zy.pro.sc.db對應(yīng)的路徑是src/zy/pro/sc/db。由于我們要解析的文件和解析類在同一目錄下，所以我們的路徑是"database.properties"。
　　
　　如果我們的解析文件和解析類不在同一目錄下呢，如以下目錄結(jié)構(gòu)：
　　
　　那么先看一下我們解析類的代碼：
　　
　　InputStream is=this.getClass().getResourceAsStream("/database.properties");
　　
　　解析路徑變成了"/database.properties",　“/“表示取當(dāng)前類所在的包的根路徑下的database.properties文件，也就是相對于ParsePropertie.class的包的根路徑下的 database.properties文件。
　　
　　用這種方法更有靈活性。此地要認(rèn)真體會。不用這種方法，你的解析類只能在目錄結(jié)構(gòu)不發(fā)生改變的情況下使用。否則將發(fā)生異常。例如：你的解析類在servlet中調(diào)用的時候就會拋出找不到文件的異常。
　　
　　此路徑的定位方法也可以使用于解析XML的文件。詳細(xì)情況同上。

posted @ 2008-04-28 13:21 九寶 閱讀(310) | 評論 (0) | 編輯 收藏

JProfiler試用手記（轉(zhuǎn)）

 JProfiler是一款Java的性能監(jiān)控工具。可以查看當(dāng)前應(yīng)用的對象、對象引用、內(nèi)存、CPU使用情況、線程、線程運行情況（阻塞、等待等），同時可以查找應(yīng)用內(nèi)存使用得熱點，即：哪個對象占用的內(nèi)存比較多；或者CPU熱點，即：哪兒方法占用的較大得CPU資源。我使用的是4.3.2版本，以前試用過3**版本，不過那個bug比較多，容易死，4**版本穩(wěn)定多了。

     有了上面那些信息對于系統(tǒng)的調(diào)優(yōu)會有很大幫助。這里提供有幾篇文章供參考：獲取、介紹，簡單入門，使用JProfiler解決實際問題。這幾篇文章基本介紹了常見東西了，下面說點心得。

1. JProfiler監(jiān)控是要消耗系統(tǒng)資源的，所以一般情況下不要用于性能測試時候的監(jiān)控。
   
2. 如果要用于相對大壓力情況下，可以有選擇的打開監(jiān)控項，不用所有都打開。主要有兩個，一個是內(nèi)存監(jiān)控，打開的情況下可以查找內(nèi)存分配熱點。一個是CPU監(jiān)控，打開的情況下可以查看CPU使用熱點。
   如圖所示，紅筆標(biāo)注部分。如果兩個都關(guān)閉的話，還是可以跑一定壓力的，同時還可以監(jiān)控對象數(shù)量。
   
3. 個人認(rèn)為最好用的（也是用的最多的）是查詢當(dāng)前的對象的數(shù)量。數(shù)量監(jiān)控很重要，如果你使用了單例，那么你只會看到有一個對象存在，如果多了就說明程序有問題了。同樣，如果應(yīng)用進(jìn)行一系列操作，檢查一下該銷毀的對象是否還繼續(xù)存在，如果沒有釋放，就得考慮是否存在內(nèi)存溢出了。
   
4. JProfiler還提供了一個比較好的檢查內(nèi)存溢出得工具。他可以查找某個對象的引用情況，即：當(dāng)你發(fā)現(xiàn)某個該釋放掉的對象沒有釋放，就可以看一下哪個實例在引用它，找到了根即找到了溢出點。
   具體操作如下：在 “Memory Views”界面中右鍵選擇你要監(jiān)控的對象，選擇第一項“Take Heap Snapshot for Selection”，選擇完成后會進(jìn)入“Heap Walker”界面，界面下面提供幾個功能，選擇“References”即可 。如圖：
   
   
5. JProfiler提供不同的觀察粒度，提供對類的監(jiān)控、對包的監(jiān)控、對J2EE組件的監(jiān)控，同時過濾器也比較好用，直接定位你關(guān)注的包或類即可。
   
6. JProfiler的監(jiān)控可能與應(yīng)用之間存在一定時間差，所以有些時候需要等待刷新，才能顯示正確系統(tǒng)情況。

posted @ 2008-04-22 15:19 九寶 閱讀(498) | 評論 (1) | 編輯 收藏

利用JProfiler對應(yīng)用服務(wù)器內(nèi)存泄漏問題診斷一例（轉(zhuǎn)）

posted @ 2008-04-22 13:24 九寶 閱讀(335) | 評論 (0) | 編輯 收藏

從jar中讀取文件

Sample1,利用Menifest文件讀取jar中的文件
/*
1.文件目錄
test--
     --a.text
     --b.gif

2. Menifest文件內(nèi)容:
Manifest-Version: 1.0
abc: test/a.txt
iconname: test/Anya.jpg
注意:manifest.mf文件最后一行要打一回車
Another Notification:
如果manifest文件內(nèi)容是:
Manifest-Version: 1.0
Main-Class: com.DesignToolApp
Class-path: lib/client.jar lib/j2ee.jar
在MANIFEST.MF文件的最后，要留兩個空行（也就是回車），才可以識別到Class-Path這一行，如果只有一個空行，那么只識別到Main-Class這一行。Class-Path中的庫名用空格格開，使用和jar包相對的路徑，發(fā)布時把jar包和其他用到的類庫一起交給用戶就可以了。


3.打jar包
test.jar
*/ 
String iconpath = jar.getManifest().getMainAttributes().getValue("abc");
    InputStream in = jar.getInputStream(jar.getJarEntry(iconpath));
     //Image img = ImageIO.read(in);
    InputStreamReader isr =  new InputStreamReader(in);
       BufferedReader reader = new BufferedReader(isr);
       String line;
       while ((line = reader.readLine()) != null) {
           System.out.println(line);
       }
       reader.close();

Sample2,讀取JAR 文件列表及各項的名稱、大小和壓縮后的大小

public class JarFileInfoRead {
 public static void main (String args[])
  throws IOException {
  String jarpath="d://temp//test.jar";
  JarFile jarFile = new JarFile(jarpath);
  Enumeration enu = jarFile.entries();
  while (enu.hasMoreElements()) {
      process(enu.nextElement());
  }
}

private static void process(Object obj) {
  JarEntry entry = (JarEntry)obj;
  String name = entry.getName();
  long size = entry.getSize();
  long compressedSize = entry.getCompressedSize();
  System.out.println(name + "\t" + size + "\t" + compressedSize);
}
}

Sample3,讀取JAR中 文件的內(nèi)容
public class JarFileRead {
    public static void main (String args[])
        throws IOException {
      String jarpath="d://temp//test.jar";
      JarFile jarFile = new JarFile(jarpath);
        Enumeration enu = jarFile.entries();
        while (enu.hasMoreElements()) {
         JarEntry entry = (JarEntry)enu.nextElement();
            String name = entry.getName();
            //System.out.println(name);
            if(name.equals("test/a.txt")){
            InputStream input = jarFile.getInputStream(entry);
            process(input);
            }
        }       
        jarFile.close();
    }
    private static void process(InputStream input)
        throws IOException {
        InputStreamReader isr =
            new InputStreamReader(input);
        BufferedReader reader = new BufferedReader(isr);
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();
    }
}

posted @ 2008-03-06 12:51 九寶 閱讀(903) | 評論 (0) | 編輯 收藏