0
# Compression Operations
1

2
ZIP file compression, decompression, and archive manipulation utilities through the ZipUtil class.
3

4
## Capabilities
5

6
### ZIP File Creation
7

8
Create ZIP archives from files and directories.
9

10
```java { .api }
11
/**
12
 * Compress file or directory to ZIP with same name
13
 * @param srcPath path to file or directory to compress
14
 * @return ZIP file created
15
 */
16
public static File zip(String srcPath);
17

18
/**
19
 * Compress file or directory to ZIP with charset
20
 * @param srcPath path to file or directory to compress
21
 * @param charset character encoding for file names
22
 * @return ZIP file created
23
 */
24
public static File zip(String srcPath, Charset charset);
25

26
/**
27
 * Compress file to ZIP
28
 * @param srcFile file or directory to compress
29
 * @return ZIP file created
30
 */
31
public static File zip(File srcFile);
32

33
/**
34
 * Compress file to specified ZIP path
35
 * @param srcPath source file or directory path
36
 * @param zipPath destination ZIP file path
37
 * @return ZIP file created
38
 */
39
public static File zip(String srcPath, String zipPath);
40

41
/**
42
 * Compress file to ZIP with directory inclusion control
43
 * @param srcPath source file or directory path
44
 * @param zipPath destination ZIP file path
45
 * @param withSrcDir whether to include source directory in ZIP
46
 * @return ZIP file created
47
 */
48
public static File zip(String srcPath, String zipPath, boolean withSrcDir);
49

50
/**
51
 * Compress multiple files to ZIP
52
 * @param zipFile destination ZIP file
53
 * @param withSrcDir whether to include source directories
54
 * @param srcFiles source files to compress
55
 * @return ZIP file created
56
 */
57
public static File zip(File zipFile, boolean withSrcDir, File... srcFiles);
58

59
/**
60
 * Compress files to ZIP with charset and filter
61
 * @param zipFile destination ZIP file
62
 * @param charset character encoding
63
 * @param withSrcDir whether to include source directories
64
 * @param filter file filter for selection
65
 * @param srcFiles source files to compress
66
 * @return ZIP file created
67
 */
68
public static File zip(File zipFile, Charset charset, boolean withSrcDir, FileFilter filter, File... srcFiles);
69
```
70

71
**Usage Examples:**
72

73
```java
74
import cn.hutool.core.util.ZipUtil;
75
import java.io.File;
76
import java.nio.charset.StandardCharsets;
77

78
// Simple compression
79
File zipFile = ZipUtil.zip("/path/to/source"); // Creates source.zip
80

81
// Compress to specific location
82
File customZip = ZipUtil.zip("/path/to/source", "/backup/archive.zip");
83

84
// Compress multiple files
85
File[] files = {new File("file1.txt"), new File("file2.txt")};
86
File multiZip = ZipUtil.zip(new File("archive.zip"), false, files);
87

88
// Compress with UTF-8 encoding
89
File utf8Zip = ZipUtil.zip("/path/to/source", StandardCharsets.UTF_8);
90
```
91

92
### ZIP File Extraction
93

94
Extract ZIP archives to directories.
95

96
```java { .api }
97
/**
98
 * Extract ZIP file to same directory
99
 * @param zipFilePath path to ZIP file
100
 * @return directory containing extracted files
101
 */
102
public static File unzip(String zipFilePath);
103

104
/**
105
 * Extract ZIP file with character encoding
106
 * @param zipFilePath path to ZIP file
107
 * @param charset character encoding for file names
108
 * @return directory containing extracted files
109
 */
110
public static File unzip(String zipFilePath, Charset charset);
111

112
/**
113
 * Extract ZIP file
114
 * @param zipFile ZIP file to extract
115
 * @return directory containing extracted files
116
 */
117
public static File unzip(File zipFile);
118

119
/**
120
 * Extract ZIP file to specific directory
121
 * @param zipFilePath path to ZIP file
122
 * @param outFileDir destination directory path
123
 * @return directory containing extracted files
124
 */
125
public static File unzip(String zipFilePath, String outFileDir);
126

127
/**
128
 * Extract ZIP file to directory with charset
129
 * @param zipFile ZIP file to extract
130
 * @param outFile destination directory
131
 * @param charset character encoding
132
 * @return directory containing extracted files
133
 */
134
public static File unzip(File zipFile, File outFile, Charset charset);
135

136
/**
137
 * Extract ZIP file with size limit
138
 * @param zipFile opened ZipFile
139
 * @param outFile destination directory
140
 * @param limit maximum bytes to extract
141
 * @return directory containing extracted files
142
 */
143
public static File unzip(ZipFile zipFile, File outFile, long limit);
144
```
145

146
**Usage Examples:**
147

148
```java
149
import cn.hutool.core.util.ZipUtil;
150
import java.io.File;
151
import java.nio.charset.StandardCharsets;
152

153
// Simple extraction
154
File extractedDir = ZipUtil.unzip("archive.zip");
155

156
// Extract to specific directory
157
File targetDir = ZipUtil.unzip("archive.zip", "/extract/here");
158

159
// Extract with UTF-8 encoding
160
File utf8Dir = ZipUtil.unzip("chinese-files.zip", StandardCharsets.UTF_8);
161

162
// Extract with size limit (security)
163
try (ZipFile zf = new ZipFile("large-archive.zip")) {
164
    File safeDir = ZipUtil.unzip(zf, new File("safe-extract"), 100_000_000); // 100MB limit
165
}
166
```
167

168
### ZIP Archive Manipulation
169

170
Modify existing ZIP archives by adding or reading entries.
171

172
```java { .api }
173
/**
174
 * Append file to existing ZIP archive
175
 * @param zipPath path to existing ZIP file
176
 * @param appendFilePath path to file to append
177
 * @param options copy options
178
 */
179
public static void append(Path zipPath, Path appendFilePath, CopyOption... options);
180

181
/**
182
 * Add string content as file to ZIP
183
 * @param zipFile ZIP file to modify
184
 * @param path internal path for the content
185
 * @param data string content to add
186
 * @return modified ZIP file
187
 */
188
public static File zip(File zipFile, String path, String data);
189

190
/**
191
 * Add content from InputStream to ZIP
192
 * @param zipFile ZIP file to modify
193
 * @param path internal path for the content
194
 * @param data InputStream containing data
195
 * @return modified ZIP file
196
 */
197
public static File zip(File zipFile, String path, InputStream data);
198
```
199

200
### ZIP Stream Operations
201

202
Work with ZIP data in memory using streams.
203

204
```java { .api }
205
/**
206
 * Compress to ZIP output stream
207
 * @param out output stream to write ZIP data
208
 * @param charset character encoding
209
 * @param withSrcDir whether to include source directories
210
 * @param filter file filter
211
 * @param srcFiles source files to compress
212
 */
213
public static void zip(OutputStream out, Charset charset, boolean withSrcDir, FileFilter filter, File... srcFiles);
214

215
/**
216
 * Compress string to GZIP bytes
217
 * @param content string content to compress
218
 * @param charset character encoding
219
 * @return compressed bytes
220
 */
221
public static byte[] gzip(String content, String charset);
222

223
/**
224
 * Decompress GZIP bytes to string
225
 * @param buf compressed bytes
226
 * @param charset character encoding
227
 * @return decompressed string
228
 */
229
public static String unGzip(byte[] buf, String charset);
230

231
/**
232
 * Compress bytes using deflate
233
 * @param data bytes to compress
234
 * @param level compression level (0-9)
235
 * @return compressed bytes
236
 */
237
public static byte[] deflate(byte[] data, int level);
238

239
/**
240
 * Decompress deflate compressed bytes
241
 * @param data compressed bytes
242
 * @return decompressed bytes
243
 */
244
public static byte[] undeflate(byte[] data);
245
```
246

247
**Usage Examples:**
248

249
```java
250
import cn.hutool.core.util.ZipUtil;
251
import java.io.ByteArrayOutputStream;
252
import java.nio.charset.StandardCharsets;
253

254
// GZIP compression
255
String text = "Hello, World! This is a long text to compress.";
256
byte[] compressed = ZipUtil.gzip(text, "UTF-8");
257
String decompressed = ZipUtil.unGzip(compressed, "UTF-8");
258

259
// Deflate compression
260
byte[] data = "Sample data".getBytes();
261
byte[] deflated = ZipUtil.deflate(data, 6); // Level 6 compression
262
byte[] inflated = ZipUtil.undeflate(deflated);
263

264
// Stream compression
265
ByteArrayOutputStream baos = new ByteArrayOutputStream();
266
File[] files = {new File("file1.txt"), new File("file2.txt")};
267
ZipUtil.zip(baos, StandardCharsets.UTF_8, false, null, files);
268
byte[] zipBytes = baos.toByteArray();
269
```
270

271
### ZIP File Reading
272

273
Read and inspect ZIP archive contents.
274

275
```java { .api }
276
/**
277
 * Get input stream for ZIP entry
278
 * @param zipFile opened ZIP file
279
 * @param zipEntry ZIP entry to read
280
 * @return InputStream for entry data
281
 */
282
public static InputStream getStream(ZipFile zipFile, ZipEntry zipEntry);
283

284
/**
285
 * Read ZIP entry names
286
 * @param zipFile ZIP file to inspect
287
 * @return list of entry names
288
 */
289
public static List<String> listFileNames(ZipFile zipFile);
290

291
/**
292
 * Get ZIP entries enumeration
293
 * @param zipFile ZIP file to inspect
294
 * @return enumeration of ZIP entries
295
 */
296
public static Enumeration<? extends ZipEntry> entries(ZipFile zipFile);
297

298
/**
299
 * Check if ZIP file contains entry
300
 * @param zipFile ZIP file to check
301
 * @param name entry name to find
302
 * @return true if entry exists
303
 */
304
public static boolean contains(ZipFile zipFile, String name);
305
```
306

307
## Common Types
308

309
```java { .api }
310
// Compression types
311
import java.util.zip.ZipFile;
312
import java.util.zip.ZipEntry;
313
import java.util.zip.ZipOutputStream;
314
import java.util.zip.ZipInputStream;
315
import java.io.FileFilter;
316
import java.nio.charset.Charset;
317
import java.nio.file.CopyOption;
318

319
// Compression levels
320
public static final int BEST_COMPRESSION = 9;
321
public static final int BEST_SPEED = 1;
322
public static final int DEFAULT_COMPRESSION = -1;
323
```