File size: 31,190 Bytes
34f4058 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 |
<?xml version="1.0"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one or more
contributor license agreements. See the NOTICE file distributed with
this work for additional information regarding copyright ownership.
The ASF licenses this file to You under the Apache License, Version 2.0
(the "License"); you may not use this file except in compliance with
the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
-->
<document xmlns="http://maven.apache.org/XDOC/2.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 https://maven.apache.org/xsd/xdoc-2.0.xsd">
<properties>
<title>Commons Compress ZIP package</title>
<author email="dev@commons.apache.org">Apache Commons Team</author>
</properties>
<body>
<section name="The ZIP package">
<p>The ZIP package provides features not found
in <code>java.util.zip</code>:</p>
<ul>
<li>Support for encodings other than UTF-8 for filenames and
comments. Starting with Java7 this is supported
by <code>java.util.zip</code> as well.</li>
<li>Access to internal and external attributes (which are used
to store Unix permission by some zip implementations).</li>
<li>Structured support for extra fields.</li>
</ul>
<p>In addition to the information stored
in <code>ArchiveEntry</code> a <code>ZipArchiveEntry</code>
stores internal and external attributes as well as extra
fields which may contain information like Unix permissions,
information about the platform they've been created on, their
last modification time and an optional comment.</p>
<subsection name="ZipArchiveInputStream vs ZipFile">
<p>ZIP archives store a archive entries in sequence and
contain a registry of all entries at the very end of the
archive. It is acceptable for an archive to contain several
entries of the same name and have the registry (called the
central directory) decide which entry is actually to be used
(if any).</p>
<p>In addition the ZIP format stores certain information only
inside the central directory but not together with the entry
itself, this is:</p>
<ul>
<li>internal and external attributes</li>
<li>different or additional extra fields</li>
</ul>
<p>This means the ZIP format cannot really be parsed
correctly while reading a non-seekable stream, which is what
<code>ZipArchiveInputStream</code> is forced to do. As a
result <code>ZipArchiveInputStream</code></p>
<ul>
<li>may return entries that are not part of the central
directory at all and shouldn't be considered part of the
archive.</li>
<li>may return several entries with the same name.</li>
<li>will not return internal or external attributes.</li>
<li>may return incomplete extra field data.</li>
<li>may return unknown sizes and CRC values for entries
until the next entry has been reached if the archive uses
the data descriptor feature (see below).</li>
<li>can not skip over bytes that occur before the real zip
stream. This means self-extracting zips as they are created
by some tools can not be read using
<code>ZipArchiveInputStream</code> at all. This also applies
to Chrome extension archives, for example.</li>
</ul>
<p><code>ZipArchiveInputStream</code> shares these limitations
with <code>java.util.zip.ZipInputStream</code>.</p>
<p><code>ZipFile</code> is able to read the central directory
first and provide correct and complete information on any
ZIP archive.</p>
<p>ZIP archives know a feature called the data descriptor
which is a way to store an entry's length after the entry's
data. This can only work reliably if the size information
can be taken from the central directory or the data itself
can signal it is complete, which is true for data that is
compressed using the DEFLATED compression algorithm.</p>
<p><code>ZipFile</code> has access to the central directory
and can extract entries using the data descriptor reliably.
The same is true for <code>ZipArchiveInputStream</code> as
long as the entry is DEFLATED. For STORED
entries <code>ZipArchiveInputStream</code> can try to read
ahead until it finds the next entry, but this approach is
not safe and has to be enabled by a constructor argument
explicitly. For example it will completely fail if the
stored entry is a ZIP archive itself. Starting with Compress 1.19
<code>ZipArchiveInputStream</code> will perform a few sanity
checks for STORED entries with data descriptors and throw an
exception if they fail.</p>
<p>If possible, you should <strong>always</strong> prefer <code>ZipFile</code>
over <code>ZipArchiveInputStream</code>.</p>
<p><code>ZipFile</code> requires a
<code>SeekableByteChannel</code> that will be obtained
transparently when reading from a file. The class
<code>org.apache.commons.compress.utils.SeekableInMemoryByteChannel</code>
allows you to read from an in-memory archive.</p>
</subsection>
<subsection name="ZipArchiveOutputStream" id="ZipArchiveOutputStream">
<p><code>ZipArchiveOutputStream</code> has four constructors,
two of them uses a <code>File</code> argument, one a
<code>SeekableByteChannel</code> and the last uses an
<code>OutputStream</code>.</p>
<p>The constructor accepting a <code>File</code> and a size is
used exclusively for creating a split ZIP archive and is
described in the next section. For the remainder of this
section this constructor is equivalent to the one using the
<code>OutputStream</code> argument and thus it is not possible
to add uncompressed entries of unknown size.</p>
<p>Of the remaining three constructors the <code>File</code> version will
try to use <code>SeekableByteChannel</code> and fall back to
using a <code>FileOutputStream</code> internally if that
fails.</p>
<p>If <code>ZipArchiveOutputStream</code> can
use <code>SeekableByteChannel</code> it can employ some
optimizations that lead to smaller archives. It also makes
it possible to add uncompressed (<code>setMethod</code> used
with <code>STORED</code>) entries of unknown size when
calling <code>putArchiveEntry</code> - this is not allowed
if <code>ZipArchiveOutputStream</code> has to use
an <code>OutputStream</code>.</p>
<p>If you know you are writing to a file, you should always
prefer the <code>File</code>- or
<code>SeekableByteChannel</code>-arg constructors. The class
<code>org.apache.commons.compress.utils.SeekableInMemoryByteChannel</code>
allows you to write to an in-memory archive.</p>
</subsection>
<subsection name="Multi Volume Archives">
<p>The ZIP format knows so called split and spanned
archives. Spanned archives cross several removable media and
are not supported by Commons Compress.</p>
<p>Split archives consist of multiple files that reside in the
same directory with the same base name (the file name without
the file extension). The last file of the archive has the
extension <code>zip</code> the remaining files conventionally
use extensions <code>z01</code>, <code>z02</code> and so
on. Support for splitted archives has been added with Compress
1.20.</p>
<p>If you want to create a split ZIP archive you use the
constructor of <code>ZipArchiveOutputStream</code> that
accepts a <code>File</code> argument and a size. The size
determines the maximum size of a split segment - the size must
be between 64kB and 4GB. While creating the archive, this will
create several files following the naming convention described
above. The name of the <code>File</code> argument used inside
of the constructor must use the extension
<code>zip</code>.</p>
<p>It is currently not possible to write split archives with
more than 64k segments. When creating split archives with more
than 100 segments you will need to adjust the file names as
<code>ZipArchiveOutputStream</code> assumes extensions will be
three characters long.</p>
<p>If you want to read a split archive you must create a
<code>ZipSplitReadOnlySeekableByteChannel</code> from the
parts. Both <code>ZipFile</code> and
<code>ZipArchiveInputStream</code> support reading streams of
this type, in the case of <code>ZipArchiveInputStream</code>
you need to use a constructor where you can set
<code>skipSplitSig</code> to true.</p>
</subsection>
<subsection name="Extra Fields">
<p>Inside a ZIP archive, additional data can be attached to
each entry. The <code>java.util.zip.ZipEntry</code> class
provides access to this via the <code>get/setExtra</code>
methods as arrays of <code>byte</code>s.</p>
<p>Actually the extra data is supposed to be more structured
than that and Compress' ZIP package provides access to the
structured data as <code>ZipExtraField</code> instances. Only
a subset of all defined extra field formats is supported by
the package, any other extra field will be stored
as <code>UnrecognizedExtraField</code>.</p>
<p>Prior to version 1.1 of this library trying to read an
archive with extra fields that didn't follow the recommended
structure for those fields would cause Compress to throw an
exception. Starting with version 1.1 these extra fields
will now be read
as <code>UnparseableExtraFieldData</code>.</p>
<p>Prior to version 1.19 of this library trying to read an
archive with extra fields that Compress expects to
understand but that used a different content than expected
would cause Compress to throw an exception. Starting with
version 1.19 these extra fields will now be read as
<code>UnrecognizedExtraField</code>. Using
<code>ZipArchiveEntry.getExtraFields(ExtraFieldParsingBehavior)</code>
you have a more fine grained control over the parser.</p>
</subsection>
<subsection name="Encoding" id="encoding">
<p>Traditionally the ZIP archive format uses CodePage 437 as
encoding for file name, which is not sufficient for many
international character sets.</p>
<p>Over time different archivers have chosen different ways to
work around the limitation - the <code>java.util.zip</code>
packages simply uses UTF-8 as its encoding for example.</p>
<p>Ant has been offering the encoding attribute of the zip and
unzip task as a way to explicitly specify the encoding to
use (or expect) since Ant 1.4. It defaults to the
platform's default encoding for zip and UTF-8 for jar and
other jar-like tasks (war, ear, ...) as well as the unzip
family of tasks.</p>
<p>More recent versions of the ZIP specification introduce
something called the "language encoding flag"
which can be used to signal that a file name has been
encoded using UTF-8. All ZIP-archives written by Compress
will set this flag, if the encoding has been set to UTF-8.
Our interoperability tests with existing archivers didn't
show any ill effects (in fact, most archivers ignore the
flag to date), but you can turn off the "language encoding
flag" by setting the attribute
<code>useLanguageEncodingFlag</code> to <code>false</code> on the
<code>ZipArchiveOutputStream</code> if you should encounter
problems.</p>
<p>The <code>ZipFile</code>
and <code>ZipArchiveInputStream</code> classes will
recognize the language encoding flag and ignore the encoding
set in the constructor if it has been found.</p>
<p>The InfoZIP developers have introduced new ZIP extra fields
that can be used to add an additional UTF-8 encoded file
name to the entry's metadata. Most archivers ignore these
extra fields. <code>ZipArchiveOutputStream</code> supports
an option <code>createUnicodeExtraFields</code> which makes
it write these extra fields either for all entries
("always") or only those whose name cannot be encoded using
the specified encoding (not-encodable), it defaults to
"never" since the extra fields create bigger archives.</p>
<p>The fallbackToUTF8 attribute
of <code>ZipArchiveOutputStream</code> can be used to create
archives that use the specified encoding in the majority of
cases but UTF-8 and the language encoding flag for filenames
that cannot be encoded using the specified encoding.</p>
<p>The <code>ZipFile</code>
and <code>ZipArchiveInputStream</code> classes recognize the
Unicode extra fields by default and read the file name
information from them, unless you set the constructor parameter
<code>scanForUnicodeExtraFields</code> to false.</p>
<h4>Recommendations for Interoperability</h4>
<p>The optimal setting of flags depends on the archivers you
expect as consumers/producers of the ZIP archives. Below
are some test results which may be superseded with later
versions of each tool.</p>
<ul>
<li>The java.util.zip package used by the jar executable or
to read jars from your CLASSPATH reads and writes UTF-8
names, it doesn't set or recognize any flags or Unicode
extra fields.</li>
<li>Starting with Java7 <code>java.util.zip</code> writes
UTF-8 by default and uses the language encoding flag. It
is possible to specify a different encoding when
reading/writing ZIPs via new constructors. The package
now recognizes the language encoding flag when reading and
ignores the Unicode extra fields.</li>
<li>7Zip writes CodePage 437 by default but uses UTF-8 and
the language encoding flag when writing entries that
cannot be encoded as CodePage 437 (similar to the zip task
with fallbacktoUTF8 set to true). It recognizes the
language encoding flag when reading and ignores the
Unicode extra fields.</li>
<li>WinZIP writes CodePage 437 and uses Unicode extra fields
by default. It recognizes the Unicode extra field and the
language encoding flag when reading.</li>
<li>Windows' "compressed folder" feature doesn't recognize
any flag or extra field and creates archives using the
platforms default encoding - and expects archives to be in
that encoding when reading them.</li>
<li>InfoZIP based tools can recognize and write both, it is
a compile time option and depends on the platform so your
mileage may vary.</li>
<li>PKWARE zip tools recognize both and prefer the language
encoding flag. They create archives using CodePage 437 if
possible and UTF-8 plus the language encoding flag for
file names that cannot be encoded as CodePage 437.</li>
</ul>
<p>So, what to do?</p>
<p>If you are creating jars, then java.util.zip is your main
consumer. We recommend you set the encoding to UTF-8 and
keep the language encoding flag enabled. The flag won't
help or hurt java.util.zip prior to Java7 but archivers that
support it will show the correct file names.</p>
<p>For maximum interop it is probably best to set the encoding
to UTF-8, enable the language encoding flag and create
Unicode extra fields when writing ZIPs. Such archives
should be extracted correctly by java.util.zip, 7Zip,
WinZIP, PKWARE tools and most likely InfoZIP tools. They
will be unusable with Windows' "compressed folders" feature
and bigger than archives without the Unicode extra fields,
though.</p>
<p>If Windows' "compressed folders" is your primary consumer,
then your best option is to explicitly set the encoding to
the target platform. You may want to enable creation of
Unicode extra fields so the tools that support them will
extract the file names correctly.</p>
</subsection>
<subsection name="Encryption and Alternative Compression Algorithms"
id="encryption">
<p>In most cases entries of an archive are not encrypted and
are either not compressed at all or use the DEFLATE
algorithm, Commons Compress' ZIP archiver will handle them
just fine. As of version 1.7, Commons Compress can also
decompress entries compressed with the legacy SHRINK and
IMPLODE algorithms of PKZIP 1.x. Version 1.11 of Commons
Compress adds read-only support for BZIP2. Version 1.16 adds
read-only support for DEFLATE64 - also known as "enhanced DEFLATE".</p>
<p>The ZIP specification allows for various other compression
algorithms and also supports several different ways of
encrypting archive contents. Neither of those methods is
currently supported by Commons Compress and any such entry can
not be extracted by the archiving code.</p>
<p><code>ZipFile</code>'s and
<code>ZipArchiveInputStream</code>'s
<code>canReadEntryData</code> methods will return false for
encrypted entries or entries using an unsupported encryption
mechanism. Using this method it is possible to at least
detect and skip the entries that can not be extracted.</p>
<table>
<thead>
<tr>
<th>Version of Apache Commons Compress</th>
<th>Supported Compression Methods</th>
<th>Supported Encryption Methods</th>
</tr>
</thead>
<tbody>
<tr>
<td>1.0 to 1.6</td>
<td>STORED, DEFLATE</td>
<td>-</td>
</tr>
<tr>
<td>1.7 to 1.10</td>
<td>STORED, DEFLATE, SHRINK, IMPLODE</td>
<td>-</td>
</tr>
<tr>
<td>1.11 to 1.15</td>
<td>STORED, DEFLATE, SHRINK, IMPLODE, BZIP2</td>
<td>-</td>
</tr>
<tr>
<td>1.16 and later</td>
<td>STORED, DEFLATE, SHRINK, IMPLODE, BZIP2, DEFLATE64
(enhanced deflate)</td>
<td>-</td>
</tr>
</tbody>
</table>
</subsection>
<subsection name="Zip64 Support" id="zip64">
<p>The traditional ZIP format is limited to archive sizes of
four gibibyte (actually 2<sup>32</sup> - 1 bytes ≈
4.3 GB) and 65635 entries, where each individual entry is
limited to four gibibyte as well. These limits seemed
excessive in the 1980s.</p>
<p>Version 4.5 of the ZIP specification introduced the so
called "Zip64 extensions" to push those limitations for
compressed or uncompressed sizes of up to 16 exbibyte
(actually 2<sup>64</sup> - 1 bytes ≈ 18.5 EB, i.e
18.5 x 10<sup>18</sup> bytes) in archives that themselves
can take up to 16 exbibyte containing more than
18 x 10<sup>18</sup> entries.</p>
<p>Apache Commons Compress 1.2 and earlier do not support
Zip64 extensions at all.</p>
<p>Starting with Apache Commons Compress
1.3 <code>ZipArchiveInputStream</code>
and <code>ZipFile</code> transparently support Zip64
extensions. By default <code>ZipArchiveOutputStream</code>
supports them transparently as well (i.e. it adds Zip64
extensions if needed and doesn't use them for
entries/archives that don't need them) if the compressed and
uncompressed sizes of the entry are known
when <code>putArchiveEntry</code> is called
or <code>ZipArchiveOutputStream</code>
uses <code>SeekableByteChannel</code>
(see <a href="#ZipArchiveOutputStream">above</a>). If only
the uncompressed size is
known <code>ZipArchiveOutputStream</code> will assume the
compressed size will not be bigger than the uncompressed
size.</p>
<p><code>ZipArchiveOutputStream</code>'s
<code>setUseZip64</code> can be used to control the behavior.
<code>Zip64Mode.AsNeeded</code> is the default behavior
described in the previous paragraph.</p>
<p>If <code>ZipArchiveOutputStream</code> is writing to a
non-seekable stream it has to decide whether to use Zip64
extensions or not before it starts writing the entry data.
This means that if the size of the entry is unknown
when <code>putArchiveEntry</code> is called it doesn't have
anything to base the decision on. By default it will not
use Zip64 extensions in order to create archives that can be
extracted by older archivers (it will later throw an
exception in <code>closeEntry</code> if it detects Zip64
extensions had been needed). It is possible to
instruct <code>ZipArchiveOutputStream</code> to always
create Zip64 extensions by using
the <code>setUseZip64</code> with an argument
of <code>Zip64Mode.Always</code>; use this if you are
writing entries of unknown size to a stream and expect some
of them to be too big to fit into the traditional
limits.</p>
<p><code>Zip64Mode.Always</code> creates archives that use
Zip64 extensions for all entries, even those that don't
require them. Such archives will be slightly bigger than
archives created with one of the other modes and not be
readable by unarchivers that don't support Zip64
extensions.</p>
<p><code>Zip64Mode.Never</code> will not use any Zip64
extensions at all and may lead to
a <code>Zip64RequiredException</code> to be thrown
if <code>ZipArchiveOutputStream</code> detects that one of
the format's limits is exceeded. Archives created in this
mode will be readable by all unarchivers; they may be
slightly smaller than archives created
with <code>SeekableByteChannel</code>
in <code>Zip64Mode.AsNeeded</code> mode if some of the
entries had unknown sizes.</p>
<p>The <code>java.util.zip</code> package and the
<code>jar</code> command of Java5 and earlier can not read
Zip64 extensions and will fail if the archive contains any.
So if you intend to create archives that Java5 can consume
you must set the mode to <code>Zip64Mode.Never</code></p>
<h4>Known Limitations</h4>
<p>Some of the theoretical limits of the format are not
reached because Apache Commons Compress' own API
(<code>ArchiveEntry</code>'s size information uses
a <code>long</code>) or its usage of Java collections
or <code>SeekableByteChannel</code> internally. The table
below shows the theoretical limits supported by Apache
Commons Compress. In practice it is very likely that you'd
run out of memory or your file system won't allow files that
big long before you reach either limit.</p>
<table>
<thead>
<tr>
<th/>
<th>Max. Size of Archive</th>
<th>Max. Compressed/Uncompressed Size of Entry</th>
<th>Max. Number of Entries</th>
</tr>
</thead>
<tbody>
<tr>
<td>ZIP Format Without Zip 64 Extensions</td>
<td>2<sup>32</sup> - 1 bytes ≈ 4.3 GB</td>
<td>2<sup>32</sup> - 1 bytes ≈ 4.3 GB</td>
<td>65535</td>
</tr>
<tr>
<td>ZIP Format using Zip 64 Extensions</td>
<td>2<sup>64</sup> - 1 bytes ≈ 18.5 EB</td>
<td>2<sup>64</sup> - 1 bytes ≈ 18.5 EB</td>
<td>2<sup>64</sup> - 1 ≈ 18.5 x 10<sup>18</sup></td>
</tr>
<tr>
<td>Commons Compress 1.2 and earlier</td>
<td>unlimited in <code>ZipArchiveInputStream</code>
and <code>ZipArchiveOutputStream</code> and
2<sup>32</sup> - 1 bytes ≈ 4.3 GB
in <code>ZipFile</code>.</td>
<td>2<sup>32</sup> - 1 bytes ≈ 4.3 GB</td>
<td>unlimited in <code>ZipArchiveInputStream</code>,
65535 in <code>ZipArchiveOutputStream</code>
and <code>ZipFile</code>.</td>
</tr>
<tr>
<td>Commons Compress 1.3 and later</td>
<td>unlimited in <code>ZipArchiveInputStream</code>
and <code>ZipArchiveOutputStream</code> and
2<sup>63</sup> - 1 bytes ≈ 9.2 EB
in <code>ZipFile</code>.</td>
<td>2<sup>63</sup> - 1 bytes ≈ 9.2 EB</td>
<td>unlimited in <code>ZipArchiveInputStream</code>,
2<sup>31</sup> - 1 ≈ 2.1 billion
in <code>ZipArchiveOutputStream</code>
and <code>ZipFile</code>.</td>
</tr>
</tbody>
</table>
<h4>Known Interoperability Problems</h4>
<p>The <code>java.util.zip</code> package of OpenJDK7 supports
Zip 64 extensions but its <code>ZipInputStream</code> and
<code>ZipFile</code> classes will be unable to extract
archives created with Commons Compress 1.3's
<code>ZipArchiveOutputStream</code> if the archive contains
entries that use the data descriptor, are smaller than 4 GiB
and have Zip 64 extensions enabled. I.e. the classes in
OpenJDK currently only support archives that use Zip 64
extensions only when they are actually needed. These classes
are used to load JAR files and are the base for the
<code>jar</code> command line utility as well.</p>
</subsection>
<subsection name="Consuming Archives Completely">
<p>Prior to version 1.5 <code>ZipArchiveInputStream</code>
would return null from <code>getNextEntry</code> or
<code>getNextZipEntry</code> as soon as the first central
directory header of the archive was found, leaving the whole
central directory itself unread inside the stream. Starting
with version 1.5 <code>ZipArchiveInputStream</code> will try
to read the archive up to and including the "end of central
directory" record effectively consuming the archive
completely.</p>
</subsection>
<subsection name="Symbolic Links" id="symlinks">
<p>Starting with Compress 1.5 <code>ZipArchiveEntry</code>
recognizes Unix Symbolic Link entries written by InfoZIP's
zip.</p>
<p>The <code>ZipFile</code> class contains a convenience
method to read the link name of an entry. Basically all it
does is read the contents of the entry and convert it to
a string using the given file name encoding of the
archive.</p>
</subsection>
<subsection name="Parallel zip creation" id="parallel">
<p>Starting with Compress 1.10 there is now built-in support for
parallel creation of zip archives</p>
<p>Multiple threads can write
to their own <code>ScatterZipOutputStream</code>
instance that is backed to file or to some user-implemented form of
storage (implementing <code>ScatterGatherBackingStore</code>).</p>
<p>When the threads finish, they can join these streams together
to a complete zip file using the <code>writeTo</code> method
that will write a single <code>ScatterOutputStream</code> to a target
<code>ZipArchiveOutputStream</code>.</p>
<p>To assist this process, clients can use
<code>ParallelScatterZipCreator</code> that will handle threads
pools and correct memory model consistency so the client
can avoid these issues.</p>
<p>Until version 1.18, there was no guarantee of order of the entries when writing a Zip
file with <code>ParallelScatterZipCreator</code>. In consequence, when writing well-formed
Zip files this way, it was usually necessary to keep a
separate <code>ScatterZipOutputStream</code> that received all directories
and wrote this to the target <code>ZipArchiveOutputStream</code> before
the ones created through <code>ParallelScatterZipCreator</code>. This was the responsibility of the client.</p>
<p>Starting with version 1.19, entries order is kept, then this specific handling of directories is not
necessary any more.</p>
<p>
See the examples section for a code sample demonstrating how to make a zip file.
</p>
</subsection>
<subsection name="Zstandard Support" id="zstd">
<p>
Starting with Compress 1.28.0, <code>org.apache.commons.compress.archivers.zip</code> supports reading and writing using the Zstandard method.
Zstandard method <code>93</code> and the deprecated <code>20</code> are supported.
</p>
</subsection>
</section>
</body>
</document>
|