Go语言视频零基础入门到精通

javalearner

1. 
   
2. /*
   
3. * LZW.java
   
4. *
   
5. * Created on 01 Dec 2005
   
6. *
   
7. * Implementation of LZW compression/decompression algorithm
   
8. */
   
9. import java.io.* ;
   
10. /**
    
11. *
    
12. * @author  Moshe Fresko
    
13. * @course        Algorithmic Programming 1
    
14. * @exercise        3
    
15. */
    
16. public class LZW implements Compression
    
17. {
    
18.         boolean stopped = false ;
    
19.         Dict dict ;
    
20.                 // The bits that should be written for each code
    
21.         int numOfBits ;
    
22.                 // The previous string that we should remember
    
23.                 // in order to insert into the dictionary
    
24.         final ByteArray emptyBA = new ByteArray() ;
    
25.         ByteArray w=emptyBA ;
    
26.                 // Constructor gets the number of bits to be written for each code
    
27.         public LZW()
    
28.         {
    
29.                 numOfBits = 12 ;
    
30.                         // Create a new Limited Dictionary
    
31.                         // For maximum of 2^bits entries
    
32.                 dict = new LimitedDict(1<< umOfBits) ;
    
33.                         // Add all ascii characters to the dictionary
    
34.                 for (int i=0;i<256;++i)
    
35.                         dict.add(new ByteArray((byte)i)) ;
    
36.         }
    
37.                 // Encodes the next character.
    
38.                 // If there is a code generated returns it.
    
39.                 // If not returns -1.
    
40.         int encodeOneChar(int n) {
    
41.                 byte c = (byte) n ;
    
42.                 ByteArray nw = w.conc(c) ;
    
43.                 int code = dict.numFromStr(nw) ;
    
44.                         // if it exists then we continue to search for a longer string
    
45.                 if (code!=-1) {
    
46.                         w = nw ;
    
47.                         return -1 ;
    
48.                 } else {
    
49.                         dict.add(nw) ;
    
50.                         nw = w ;
    
51.                         w = new ByteArray(c) ;
    
52.                         return dict.numFromStr(nw) ;
    
53.                 }
    
54.         }
    
55.                 // If there is something left in w, returns its code
    
56.         int encodeLast() {
    
57.                 ByteArray nw = w ;
    
58.                 w = emptyBA ;
    
59.                 return dict.numFromStr(nw) ;
    
60.         }
    
61.                 // Write the code in bits into output stream
    
62.         void writeCode(OutputStream os, int code) throws IOException
    
63.         {
    
64.                 for (int i=0;i< numOfBits;++i) {
    
65.                         os.write(code&1) ;
    
66.                         code /= 2 ;
    
67.                 }
    
68.         }
    
69.         int readCode(InputStream is) throws IOException
    
70.         {
    
71.                 int num = 0 ;
    
72.                 for (int i=0;i< numOfBits;++i) {
    
73.                         int next = is.read() ;
    
74.                         if (next<0)
    
75.                                 return -1 ;
    
76.                         num += next<< i ;
    
77.                 }
    
78.                 return num ;
    
79.         }
    
80.                 // We need to call the close() method of BitOutputStream,
    
81.                 // but without closing the encompassing OutputStream
    
82.         private class UnClosedOutputStream extends FilterOutputStream {
    
83.                 public UnClosedOutputStream(OutputStream os)
    
84.                         { super(os) ; }
    
85.     public void write(byte b[], int off, int len) throws IOException
    
86.             { out.write(b,off,len) ; }
    
87.             // Does not close anything
    
88.                 public void close() throws IOException
    
89.                         { }
    
90.         }
    
91.         public void compress(InputStream is, OutputStream os) throws IOException {
    
92.                 os = new BitOutputStream(new UnClosedOutputStream(os)) ;
    
93.                 int next ;        // next input character
    
94.                 int code ;        // next code generated
    
95.                 while ((next=is.read())>=0) {
    
96.                         if (stopped)
    
97.                                 break ;
    
98.                         code = encodeOneChar(next) ;
    
99.                         if (code>=0)
    
100.                                 writeCode(os,code) ;
     
101.                 }
     
102.                 code = encodeLast() ;
     
103.                 if (code>=0)
     
104.                         writeCode(os,code) ;
     
105.     os.close() ;
     
106.         }
     
107.         ByteArray decodeOne(int code) {
     
108.                         // Either "ABA" or null, w="AB"
     
109.                 ByteArray str = dict.strFromNum(code) ;
     
110.                 if (str==null) {
     
111.                         str = w.conc(w.getAt(0)) ;
     
112.                         dict.add(str) ;
     
113.                 } else
     
114.                         if (! w.isEmpty())
     
115.                                 dict.add(w.conc(str.getAt(0))) ;
     
116.             w = str ;
     
117.                 return w ;
     
118.         }
     
119.         public void decompress(InputStream is, OutputStream os) throws IOException {
     
120.                 is = new BitInputStream(is) ;
     
121.                 ByteArray str ;        // Next entry
     
122.                 int code ;                // Next code to be read
     
123.                 while ((code=readCode(is))>=0) {
     
124.                         if (stopped)
     
125.                                 break ;
     
126.                         str = decodeOne(code) ;
     
127.                         os.write(str.getBytes()) ;
     
128.                 }
     
129.         }
     
130.         public void stop()
     
131.                 { stopped = true ; }
     
132.        public static void main(String args[]){//简单的测试
     
133.           LZW lzw=new LZW();
     
134.           try{
     
135.             lzw.compress(new FileInputStream("LZW.JAVA"),new FileOutputStream("lzw.lzw"));
     
136.             lzw.decompress(new FileInputStream("lzw.lzw"),new FileOutputStream("lzw1.java"));
     
137.           }catch(Exception e){}
     
138.        }
     
139. }
     
141. 其它文件请下载。

复制代码

  
  
   
   

     
   

     
   
  



源码下载：http://file.javaxxz.com/2014/10/2/051343266.zip