optimize code

Author: robinhood-jim

core/src/main/java/com/robin/core/compress/util/CompressDecoder.java

@@ -10,75 +10,63 @@
 import org.apache.commons.compress.compressors.brotli.BrotliCompressorInputStream;
 import org.apache.commons.compress.compressors.bzip2.BZip2CompressorInputStream;
 import org.apache.commons.compress.compressors.zstandard.ZstdCompressorInputStream;
-import org.tukaani.xz.LZMAInputStream;
 import org.tukaani.xz.XZInputStream;
 import org.xerial.snappy.SnappyInputStream;
 
-import java.io.BufferedInputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.ZipInputStream;
 
 
 public class CompressDecoder {
-    private CompressDecoder(){
+    private CompressDecoder() {
 
     }
-    public static InputStream getInputStreamByCompressType(String path, InputStream rawstream) throws IOException{
+
+    public static InputStream getInputStreamByCompressType(String path, InputStream rawstream) throws IOException {
         InputStream inputStream;
-        FileUtils.FileContent content=FileUtils.parseFile(path);
-        Const.CompressType type=content.getCompressType();
-        switch (type){
+        FileUtils.FileContent content = FileUtils.parseFile(path);
+        Const.CompressType type = content.getCompressType();
+        switch (type) {
             case COMPRESS_TYPE_GZ:
-                inputStream=new GZIPInputStream(wrapInputStream(rawstream));
+                inputStream = new GZIPInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_BZ2:
-                inputStream=new BZip2CompressorInputStream(wrapInputStream(rawstream));
+                inputStream = new BZip2CompressorInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_LZO:
                 LzoAlgorithm algorithm = LzoAlgorithm.LZO1X;
                 LzoDecompressor decompressor = LzoLibrary.getInstance().newDecompressor(algorithm, null);
-                inputStream = new LzoInputStream(wrapInputStream(rawstream), decompressor);
+                inputStream = new LzoInputStream(rawstream, decompressor);
                 break;
             case COMPRESS_TYPE_SNAPPY:
-                inputStream=new SnappyInputStream(wrapInputStream(rawstream));
+                inputStream = new SnappyInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_ZIP:
-                ZipInputStream stream1=new ZipInputStream(wrapInputStream(rawstream));
+                ZipInputStream stream1 = new ZipInputStream(rawstream);
                 stream1.getNextEntry();
-                inputStream=stream1;
+                inputStream = stream1;
                 break;
             case COMPRESS_TYPE_LZ4:
-                inputStream=new LZ4FrameInputStream(wrapInputStream(rawstream));
+                inputStream = new LZ4FrameInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_LZMA:
-                inputStream=new XZInputStream(wrapInputStream(rawstream));
+                inputStream = new XZInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_ZSTD:
-                inputStream=new ZstdCompressorInputStream(wrapInputStream(rawstream));
+                inputStream = new ZstdCompressorInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_BROTLI:
-                inputStream=new BrotliCompressorInputStream(wrapInputStream(rawstream));
+                inputStream = new BrotliCompressorInputStream(rawstream);
                 break;
             case COMPRESS_TYPE_XZ:
-                inputStream=new XZInputStream(wrapInputStream(rawstream));
+                inputStream = new XZInputStream(rawstream);
                 break;
             default:
-                inputStream=wrapInputStream(rawstream);
+                inputStream = rawstream;
 
         }
         return inputStream;
     }
-    private static InputStream wrapInputStream(InputStream instream){
-        InputStream in=null;
-        if(instream instanceof BufferedInputStream){
-            in=instream;
-        }else{
-            in=new BufferedInputStream(instream);
-        }
-        return in;
-    }
 }

core/src/main/java/com/robin/core/compress/util/CompressEncoder.java

@@ -3,90 +3,78 @@
 import com.robin.core.base.util.Const;
 import com.robin.core.base.util.FileUtils;
 import net.jpountz.lz4.LZ4FrameOutputStream;
-import org.anarres.lzo.*;
-
-import org.apache.commons.compress.compressors.brotli.BrotliCompressorInputStream;
+import org.anarres.lzo.LzoAlgorithm;
+import org.anarres.lzo.LzoCompressor;
+import org.anarres.lzo.LzoLibrary;
+import org.anarres.lzo.LzoOutputStream;
 import org.apache.commons.compress.compressors.bzip2.BZip2CompressorOutputStream;
 import org.apache.commons.compress.compressors.xz.XZCompressorOutputStream;
 import org.apache.commons.compress.compressors.zstandard.ZstdCompressorOutputStream;
 import org.tukaani.xz.LZMA2Options;
-import org.tukaani.xz.LZMAOutputStream;
 import org.tukaani.xz.XZOutputStream;
 import org.xerial.snappy.SnappyOutputStream;
 
-import java.io.BufferedOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
 import java.io.OutputStream;
-import java.util.ArrayList;
-import java.util.List;
 import java.util.zip.GZIPOutputStream;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipOutputStream;
 
 
 public class CompressEncoder {
-    private CompressEncoder(){
+    private CompressEncoder() {
 
     }
 
-        /**
-         *wrap OutputStream with specify compress Format  (Zip file can only support One file)
-         * @param path   file path
-         * @param rawstream  raw outputstream
-         * @return  wrap outputStream
-         */
-    public static OutputStream getOutputStreamByCompressType(String path,OutputStream rawstream) throws IOException{
+    /**
+     * wrap OutputStream with specify compress Format  (Zip file can only support One file)
+     *
+     * @param path      file path
+     * @param rawstream raw outputstream
+     * @return wrap outputStream
+     */
+    public static OutputStream getOutputStreamByCompressType(String path, OutputStream rawstream) throws IOException {
         OutputStream outputStream;
-        FileUtils.FileContent content=FileUtils.parseFile(path);
-        Const.CompressType type=content.getCompressType();
-        switch (type){
+        FileUtils.FileContent content = FileUtils.parseFile(path);
+        Const.CompressType type = content.getCompressType();
+        switch (type) {
             case COMPRESS_TYPE_GZ:
-                outputStream=new GZIPOutputStream(wrapOutputStream(rawstream));
+                outputStream = new GZIPOutputStream(rawstream);
                 break;
             case COMPRESS_TYPE_BZ2:
-                outputStream=new BZip2CompressorOutputStream(wrapOutputStream(rawstream));
+                outputStream = new BZip2CompressorOutputStream(rawstream);
                 break;
             case COMPRESS_TYPE_LZO:
                 LzoAlgorithm algorithm = LzoAlgorithm.LZO1X;
                 LzoCompressor compressor = LzoLibrary.getInstance().newCompressor(algorithm, null);
-                outputStream = new LzoOutputStream(wrapOutputStream(rawstream), compressor);
+                outputStream = new LzoOutputStream(rawstream, compressor);
                 break;
             case COMPRESS_TYPE_SNAPPY:
-                outputStream=new SnappyOutputStream(wrapOutputStream(rawstream));
+                outputStream = new SnappyOutputStream(rawstream);
                 break;
             case COMPRESS_TYPE_ZIP:
-                ZipOutputStream stream1=new ZipOutputStream(wrapOutputStream(rawstream));
-                stream1.putNextEntry(new ZipEntry(content.getFileName()+"."+content.getFileFormat()));
-                outputStream=stream1;
+                ZipOutputStream stream1 = new ZipOutputStream(rawstream);
+                stream1.putNextEntry(new ZipEntry(content.getFileName() + "." + content.getFileFormat()));
+                outputStream = stream1;
                 break;
             case COMPRESS_TYPE_LZ4:
-                outputStream=new LZ4FrameOutputStream(wrapOutputStream(rawstream));
+                outputStream = new LZ4FrameOutputStream(rawstream);
                 break;
             case COMPRESS_TYPE_LZMA:
-                outputStream=new XZOutputStream(wrapOutputStream(rawstream),new LZMA2Options());
+                outputStream = new XZOutputStream(rawstream, new LZMA2Options());
                 break;
             case COMPRESS_TYPE_ZSTD:
-                outputStream=new ZstdCompressorOutputStream(wrapOutputStream(rawstream));
+                outputStream = new ZstdCompressorOutputStream(rawstream);
                 break;
             case COMPRESS_TYPE_BROTLI:
                 throw new IOException("BROTLI encode not support now!");
             case COMPRESS_TYPE_XZ:
-                outputStream=new XZCompressorOutputStream(wrapOutputStream(rawstream));
+                outputStream = new XZCompressorOutputStream(rawstream);
                 break;
             default:
-                outputStream=rawstream;
+                outputStream = rawstream;
         }
 
         return outputStream;
     }
-    private static OutputStream wrapOutputStream(OutputStream outputStream){
-        OutputStream out=null;
-        if(outputStream instanceof BufferedOutputStream){
-            out=outputStream;
-        }else{
-            out=new BufferedOutputStream(outputStream);
-        }
-        return out;
-    }
 }