java.lang.Object
- java.io.OutputStream
- - java.io.FilterOutputStream
  - - kala.compress.archivers.ArchiveOutputStream<ZipArchiveEntry>
    - - kala.compress.archivers.zip.ZipArchiveOutputStream

All Implemented Interfaces:

java.io.Closeable, java.io.Flushable, java.lang.AutoCloseable

Direct Known Subclasses:

JarArchiveOutputStream
```
public class ZipArchiveOutputStream
extends ArchiveOutputStream<ZipArchiveEntry>
```
Reimplementation of java.util.zip.ZipOutputStream to handle the extended functionality of this package, especially internal/external file attributes and extra fields with different layouts for local file data and central directory entries.
This class will try to use SeekableByteChannel when it knows that the output is going to go to a file and no split archive shall be created.

If SeekableByteChannel cannot be used, this implementation will use a Data Descriptor to store size and CRC information for DEFLATED entries, you don't need to calculate them yourself. Unfortunately, this is not possible for the STORED method, where setting the CRC and uncompressed size information is required before putArchiveEntry(ZipArchiveEntry) can be called.

As of Apache Commons Compress 1.3, the class transparently supports Zip64 extensions and thus individual entries and archives larger than 4 GB or with more than 65,536 entries in most cases but explicit control is provided via setUseZip64(kala.compress.archivers.zip.Zip64Mode). If the stream cannot use SeekableByteChannel and you try to write a ZipArchiveEntry of unknown size, then Zip64 extensions will be disabled by default.

Nested Class Summary

Nested Classes
Modifier and Type	Class	Description
`private static class`	`ZipArchiveOutputStream.CurrentEntry`	Structure collecting information for the entry that is currently being written.
`private static class`	`ZipArchiveOutputStream.EntryMetaData`
`static class`	`ZipArchiveOutputStream.UnicodeExtraFieldPolicy`	enum that represents the possible policies for creating Unicode extra fields.

Field Summary

Fields
Modifier and Type	Field	Description
`(package private) static int`	`BUFFER_SIZE`
`private long`	`cdDiskNumberStart`	Disk number start of central directory.
`private long`	`cdLength`	Length of central directory.
`private long`	`cdOffset`	Start of central directory.
`private static int`	`CFH_COMMENT_LENGTH_OFFSET`
`private static int`	`CFH_COMPRESSED_SIZE_OFFSET`
`private static int`	`CFH_CRC_OFFSET`
`private static int`	`CFH_DISK_NUMBER_OFFSET`
`private static int`	`CFH_EXTERNAL_ATTRIBUTES_OFFSET`
`private static int`	`CFH_EXTRA_LENGTH_OFFSET`
`private static int`	`CFH_FILENAME_LENGTH_OFFSET`
`private static int`	`CFH_FILENAME_OFFSET`
`private static int`	`CFH_GPB_OFFSET`
`private static int`	`CFH_INTERNAL_ATTRIBUTES_OFFSET`
`private static int`	`CFH_LFH_OFFSET`
`private static int`	`CFH_METHOD_OFFSET`
`private static int`	`CFH_ORIGINAL_SIZE_OFFSET`
`(package private) static byte[]`	`CFH_SIG`	central file header signature
`private static int`	`CFH_SIG_OFFSET`
`private static int`	`CFH_TIME_OFFSET`
`private static int`	`CFH_VERSION_MADE_BY_OFFSET`
`private static int`	`CFH_VERSION_NEEDED_OFFSET`
`private java.lang.String`	`comment`	The file comment.
`private byte[]`	`copyBuffer`
`private ZipArchiveOutputStream.UnicodeExtraFieldPolicy`	`createUnicodeExtraFields`	whether to create UnicodePathExtraField-s for each entry.
`(package private) static byte[]`	`DD_SIG`	data descriptor signature
`protected java.util.zip.Deflater`	`def`	This Deflater object is used for output.
`static int`	`DEFAULT_COMPRESSION`	Default compression level for deflated entries.
`static int`	`DEFLATED`	Compression method for deflated entries.
`private java.nio.charset.Charset`	`encoding`	The encoding to use for file names and the file comment.
`private java.util.List<ZipArchiveEntry>`	`entries`	List of ZipArchiveEntries written so far.
`private ZipArchiveOutputStream.CurrentEntry`	`entry`	Current entry.
`(package private) static byte[]`	`EOCD_SIG`	end of central dir signature
`private long`	`eocdLength`	Length of end of central directory
`private boolean`	`fallbackToUTF8`	Whether to encode non-encodable file names as UTF-8.
`protected boolean`	`finished`	Deprecated. See `ArchiveOutputStream.isFinished()` and `finish()`.
`private boolean`	`hasCompressionLevelChanged`	Has the compression level changed when compared to the last entry?
`private boolean`	`hasUsedZip64`	Whether anything inside this archive has used a ZIP64 feature.
`private boolean`	`isSplitZip`	Whether we are creating a split zip
`private int`	`level`	Compression level for next entry.
`private static int`	`LFH_COMPRESSED_SIZE_OFFSET`
`private static int`	`LFH_CRC_OFFSET`
`private static int`	`LFH_EXTRA_LENGTH_OFFSET`
`private static int`	`LFH_FILENAME_LENGTH_OFFSET`
`private static int`	`LFH_FILENAME_OFFSET`
`private static int`	`LFH_GPB_OFFSET`
`private static int`	`LFH_METHOD_OFFSET`
`private static int`	`LFH_ORIGINAL_SIZE_OFFSET`
`(package private) static byte[]`	`LFH_SIG`	local file header signature
`private static int`	`LFH_SIG_OFFSET`
`private static int`	`LFH_TIME_OFFSET`
`private static int`	`LFH_VERSION_NEEDED_OFFSET`
`private static byte[]`	`LZERO`	Helper, a 0 as ZipLong.
`private java.util.Map<ZipArchiveEntry,ZipArchiveOutputStream.EntryMetaData>`	`metaData`	Holds some book-keeping data for each entry.
`private int`	`method`	Default compression method for next entry.
`private java.util.Map<java.lang.Integer,java.lang.Integer>`	`numberOfCDInDiskData`	Holds the number of Central Directories on each disk.
`private static byte[]`	`ONE`
`static int`	`STORED`	Compression method for stored entries.
`private StreamCompressor`	`streamCompressor`
`private boolean`	`useLanguageEncodingFlag`	Whether to set the language encoding flag if the file name encoding is UTF-8.
`private static byte[]`	`ZERO`	Helper, a 0 as ZipShort.
`(package private) static byte[]`	`ZIP64_EOCD_LOC_SIG`	ZIP64 end of central dir locator signature
`(package private) static byte[]`	`ZIP64_EOCD_SIG`	ZIP64 end of central dir signature
`private Zip64Mode`	`zip64Mode`

Fields inherited from class java.io.FilterOutputStream
out

Constructor Summary

Constructors
Constructor	Description
`ZipArchiveOutputStream(java.io.OutputStream out)`	Creates a new ZIP OutputStream filtering the underlying stream.
`ZipArchiveOutputStream(java.io.OutputStream out, java.nio.charset.Charset encoding)`	Creates a new ZIP OutputStream filtering the underlying stream.
`ZipArchiveOutputStream(java.nio.channels.SeekableByteChannel channel)`	Creates a new ZIP OutputStream writing to a SeekableByteChannel.
`ZipArchiveOutputStream(java.nio.file.Path path, long zipSplitSize)`	Creates a split ZIP Archive.
`ZipArchiveOutputStream(java.nio.file.Path file, java.nio.file.OpenOption... options)`	Creates a new ZIP OutputStream writing to a Path.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`void`	`addRawArchiveEntry(ZipArchiveEntry entry, java.io.InputStream rawStream)`	Adds an archive entry with a raw input stream.
`private void`	`addUnicodeExtraFields(ZipArchiveEntry ze, boolean encodable, java.nio.ByteBuffer name)`	Adds UnicodeExtra fields for name and file comment if mode is ALWAYS or the data cannot be encoded using the configured encoding.
`boolean`	`canWriteEntryData(ArchiveEntry ae)`	Whether this stream is able to write the given entry.
`private boolean`	`checkIfNeedsZip64(Zip64Mode effectiveMode)`	Verifies the sizes aren't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
`void`	`close()`	Closes this output stream and releases any system resources associated with the stream.
`void`	`closeArchiveEntry()`	Writes all necessary data for this entry.
`private void`	`closeCopiedEntry(boolean phased)`	Writes all necessary data for this entry.
`private void`	`closeEntry(boolean actuallyNeedsZip64, boolean phased)`
`private void`	`copyFromZipInputStream(java.io.InputStream src, boolean phased)`
`ZipArchiveEntry`	`createArchiveEntry(java.nio.file.Path inputPath, java.lang.String entryName, java.nio.file.LinkOption... options)`	Creates a new ZIP entry taking some information from the given file and using the provided name.
`private byte[]`	`createCentralFileHeader(ZipArchiveEntry ze)`
`private byte[]`	`createCentralFileHeader(ZipArchiveEntry ze, java.nio.ByteBuffer name, ZipArchiveOutputStream.EntryMetaData entryMetaData, boolean needsZip64Extra)`	Writes the central file header entry.
`private byte[]`	`createLocalFileHeader(ZipArchiveEntry ze, java.nio.ByteBuffer name, boolean encodable, boolean phased, long archiveOffset)`
`protected void`	`deflate()`	Writes next block of compressed data to the output stream.
`(package private) void`	`destroy()`	Closes the underlying stream/file without finishing the archive, the result will likely be a corrupt archive.
`void`	`finish()`	Finishes the addition of entries to this stream, without closing it.
`void`	`flush()`	Flushes this output stream and forces any buffered output bytes to be written out to the stream.
`private void`	`flushDeflater()`	Ensures all bytes sent to the deflater are written to the stream.
`long`	`getBytesWritten()`	Returns the total number of bytes written to this stream.
`private Zip64Mode`	`getEffectiveZip64Mode(ZipArchiveEntry ze)`	If the mode is AsNeeded and the entry is a compressed entry of unknown size that gets written to a non-seekable stream then change the default to Never.
`java.nio.charset.Charset`	`getEncoding()`	The encoding to use for file names and the file comment.
`private java.nio.charset.Charset`	`getEntryEncoding(ZipArchiveEntry ze)`
`private GeneralPurposeBit`	`getGeneralPurposeBits(boolean utfFallback, boolean usesDataDescriptor)`
`private java.nio.ByteBuffer`	`getName(ZipArchiveEntry ze)`
`private Zip64ExtendedInformationExtraField`	`getZip64Extra(ZipArchiveEntry ze)`	Gets the existing ZIP64 extended information extra field or create a new one and add it to the entry.
`private boolean`	`handleSizesAndCrc(long bytesWritten, long crc, Zip64Mode effectiveMode)`	Ensures the current entry's size and CRC information is set to the values just written, verifies it isn't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
`private void`	`handleZip64Extra(ZipArchiveEntry ze, long lfhOffset, boolean needsZip64Extra)`	If the entry needs Zip64 extra information inside the central directory then configure its data.
`private boolean`	`hasZip64Extra(ZipArchiveEntry ze)`	Is there a ZIP64 extended information extra field for the entry?
`boolean`	`isSeekable()`	This method indicates whether this archive is writing to a seekable stream (i.e., to a random access file).
`private boolean`	`isTooLargeForZip32(ZipArchiveEntry zipArchiveEntry)`
`private boolean`	`isZip64Required(ZipArchiveEntry entry1, Zip64Mode requestedMode)`
`private void`	`preClose()`
`void`	`putArchiveEntry(ZipArchiveEntry archiveEntry)`	Writes the headers for an archive entry to the output stream.
`private void`	`putArchiveEntry(ZipArchiveEntry archiveEntry, boolean phased)`	Writes the headers for an archive entry to the output stream.
`private void`	`rewriteSizesAndCrc(boolean actuallyNeedsZip64)`	When using random access output, write the local file header and potentially the ZIP64 extra containing the correct CRC and compressed/uncompressed sizes.
`void`	`setComment(java.lang.String comment)`	Sets the file comment.
`void`	`setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy b)`	Whether to create Unicode Extra Fields.
`private void`	`setDefaults(ZipArchiveEntry entry)`	Provides default values for compression method and last modification time.
`void`	`setEncoding(java.nio.charset.Charset encoding)`	The encoding to use for file names and the file comment.
`void`	`setFallbackToUTF8(boolean b)`	Whether to fall back to UTF and the language encoding flag if the file name cannot be encoded using the specified encoding.
`void`	`setLevel(int level)`	Sets the compression level for subsequent entries.
`void`	`setMethod(int method)`	Sets the default compression method for subsequent entries.
`void`	`setUseLanguageEncodingFlag(boolean b)`	Whether to set the language encoding flag if the file name encoding is UTF-8.
`void`	`setUseZip64(Zip64Mode mode)`	Whether Zip64 extensions will be used.
`private boolean`	`shouldAddZip64Extra(ZipArchiveEntry entry, Zip64Mode mode)`	Whether to add a Zip64 extended information extra field to the local file header.
`private boolean`	`shouldUseZip64EOCD()`	4.4.1.4 If one of the fields in the end of central directory record is too small to hold required data, the field SHOULD be set to -1 (0xFFFF or 0xFFFFFFFF) and the ZIP64 format record SHOULD be created.
`private boolean`	`usesDataDescriptor(int zipMethod, boolean phased)`
`private boolean`	`usesUTF8ForNames()`
`private void`	`validateIfZip64IsNeededInEOCD()`	If the Zip64 mode is set to never, then all the data in End Of Central Directory should not exceed their limits.
`private void`	`validateSizeInformation(Zip64Mode effectiveMode)`	Throws an exception if the size is unknown for a stored entry that is written to a non-seekable output or the entry is too big to be written without Zip64 extra but the mode has been set to Never.
`private int`	`versionNeededToExtract(int zipMethod, boolean zip64, boolean usedDataDescriptor)`
`private int`	`versionNeededToExtractMethod(int zipMethod)`
`void`	`write(byte[] b, int offset, int length)`	Writes bytes to ZIP entry.
`protected void`	`writeCentralDirectoryEnd()`	Writes the "End of central dir record".
`private void`	`writeCentralDirectoryInChunks()`
`protected void`	`writeCentralFileHeader(ZipArchiveEntry ze)`	Writes the central file header entry.
`private void`	`writeCounted(byte[] data)`	Write bytes to output or random access file.
`protected void`	`writeDataDescriptor(ZipArchiveEntry ze)`	Writes the data descriptor entry.
`protected void`	`writeLocalFileHeader(ZipArchiveEntry ze)`	Writes the local file header entry
`private void`	`writeLocalFileHeader(ZipArchiveEntry ze, boolean phased)`
`protected void`	`writeOut(byte[] data)`	Write bytes to output or random access file.
`protected void`	`writeOut(byte[] data, int offset, int length)`	Write bytes to output or random access file.
`void`	`writePreamble(byte[] preamble)`	Write preamble data.
`void`	`writePreamble(byte[] preamble, int offset, int length)`	Write preamble data.
`protected void`	`writeZip64CentralDirectory()`	Writes the "ZIP64 End of central dir record" and "ZIP64 End of central dir locator".

Methods inherited from class kala.compress.archivers.ArchiveOutputStream
checkFinished, checkOpen, count, count, isClosed, isFinished, write

Methods inherited from class java.io.FilterOutputStream
write

Methods inherited from class java.io.OutputStream
nullOutputStream

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - BUFFER_SIZE
```
static final int BUFFER_SIZE
```
    See Also:
    
    Constant Field Values
  - LFH_SIG_OFFSET
```
private static final int LFH_SIG_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_VERSION_NEEDED_OFFSET
```
private static final int LFH_VERSION_NEEDED_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_GPB_OFFSET
```
private static final int LFH_GPB_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_METHOD_OFFSET
```
private static final int LFH_METHOD_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_TIME_OFFSET
```
private static final int LFH_TIME_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_CRC_OFFSET
```
private static final int LFH_CRC_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_COMPRESSED_SIZE_OFFSET
```
private static final int LFH_COMPRESSED_SIZE_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_ORIGINAL_SIZE_OFFSET
```
private static final int LFH_ORIGINAL_SIZE_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_FILENAME_LENGTH_OFFSET
```
private static final int LFH_FILENAME_LENGTH_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_EXTRA_LENGTH_OFFSET
```
private static final int LFH_EXTRA_LENGTH_OFFSET
```
    See Also:
    
    Constant Field Values
  - LFH_FILENAME_OFFSET
```
private static final int LFH_FILENAME_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_SIG_OFFSET
```
private static final int CFH_SIG_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_VERSION_MADE_BY_OFFSET
```
private static final int CFH_VERSION_MADE_BY_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_VERSION_NEEDED_OFFSET
```
private static final int CFH_VERSION_NEEDED_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_GPB_OFFSET
```
private static final int CFH_GPB_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_METHOD_OFFSET
```
private static final int CFH_METHOD_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_TIME_OFFSET
```
private static final int CFH_TIME_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_CRC_OFFSET
```
private static final int CFH_CRC_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_COMPRESSED_SIZE_OFFSET
```
private static final int CFH_COMPRESSED_SIZE_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_ORIGINAL_SIZE_OFFSET
```
private static final int CFH_ORIGINAL_SIZE_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_FILENAME_LENGTH_OFFSET
```
private static final int CFH_FILENAME_LENGTH_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_EXTRA_LENGTH_OFFSET
```
private static final int CFH_EXTRA_LENGTH_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_COMMENT_LENGTH_OFFSET
```
private static final int CFH_COMMENT_LENGTH_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_DISK_NUMBER_OFFSET
```
private static final int CFH_DISK_NUMBER_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_INTERNAL_ATTRIBUTES_OFFSET
```
private static final int CFH_INTERNAL_ATTRIBUTES_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_EXTERNAL_ATTRIBUTES_OFFSET
```
private static final int CFH_EXTERNAL_ATTRIBUTES_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_LFH_OFFSET
```
private static final int CFH_LFH_OFFSET
```
    See Also:
    
    Constant Field Values
  - CFH_FILENAME_OFFSET
```
private static final int CFH_FILENAME_OFFSET
```
    See Also:
    
    Constant Field Values
  - DEFLATED
```
public static final int DEFLATED
```
    Compression method for deflated entries.
    
    See Also:
    
    Constant Field Values
  - DEFAULT_COMPRESSION
```
public static final int DEFAULT_COMPRESSION
```
    Default compression level for deflated entries.
    
    See Also:
    
    Constant Field Values
  - STORED
```
public static final int STORED
```
    Compression method for stored entries.
    
    See Also:
    
    Constant Field Values
  - ZERO
```
private static final byte[] ZERO
```
    Helper, a 0 as ZipShort.
  - LZERO
```
private static final byte[] LZERO
```
    Helper, a 0 as ZipLong.
  - ONE
```
private static final byte[] ONE
```
  - LFH_SIG
```
static final byte[] LFH_SIG
```
    local file header signature
  - DD_SIG
```
static final byte[] DD_SIG
```
    data descriptor signature
  - CFH_SIG
```
static final byte[] CFH_SIG
```
    central file header signature
  - EOCD_SIG
```
static final byte[] EOCD_SIG
```
    end of central dir signature
  - ZIP64_EOCD_SIG
```
static final byte[] ZIP64_EOCD_SIG
```
    ZIP64 end of central dir signature
  - ZIP64_EOCD_LOC_SIG
```
static final byte[] ZIP64_EOCD_LOC_SIG
```
    ZIP64 end of central dir locator signature
  - finished
```
@Deprecated
protected boolean finished
```
    Deprecated.
    See ArchiveOutputStream.isFinished() and finish().
    
    Indicates if this archive is finished. protected for use in Jar implementation.
  - entry
```
private ZipArchiveOutputStream.CurrentEntry entry
```
    Current entry.
  - comment
```
private java.lang.String comment
```
    The file comment.
  - level
```
private int level
```
    Compression level for next entry.
  - hasCompressionLevelChanged
```
private boolean hasCompressionLevelChanged
```
    Has the compression level changed when compared to the last entry?
  - method
```
private int method
```
    Default compression method for next entry.
  - entries
```
private final java.util.List<ZipArchiveEntry> entries
```
    List of ZipArchiveEntries written so far.
  - streamCompressor
```
private final StreamCompressor streamCompressor
```
  - cdOffset
```
private long cdOffset
```
    Start of central directory.
  - cdLength
```
private long cdLength
```
    Length of central directory.
  - cdDiskNumberStart
```
private long cdDiskNumberStart
```
    Disk number start of central directory.
  - eocdLength
```
private long eocdLength
```
    Length of end of central directory
  - metaData
```
private final java.util.Map<ZipArchiveEntry,ZipArchiveOutputStream.EntryMetaData> metaData
```
    Holds some book-keeping data for each entry.
  - encoding
```
private java.nio.charset.Charset encoding
```
    The encoding to use for file names and the file comment.
    For a list of possible values see Supported Encodings. Defaults to UTF-8.
  - def
```
protected final java.util.zip.Deflater def
```
    This Deflater object is used for output.
  - useLanguageEncodingFlag
```
private boolean useLanguageEncodingFlag
```
    Whether to set the language encoding flag if the file name encoding is UTF-8.
  - fallbackToUTF8
```
private boolean fallbackToUTF8
```
    Whether to encode non-encodable file names as UTF-8.
  - createUnicodeExtraFields
```
private ZipArchiveOutputStream.UnicodeExtraFieldPolicy createUnicodeExtraFields
```
    whether to create UnicodePathExtraField-s for each entry.
  - hasUsedZip64
```
private boolean hasUsedZip64
```
    Whether anything inside this archive has used a ZIP64 feature.
    
    Since:
    
    1.3
  - zip64Mode
```
private Zip64Mode zip64Mode
```
  - copyBuffer
```
private final byte[] copyBuffer
```
  - isSplitZip
```
private final boolean isSplitZip
```
    Whether we are creating a split zip
  - numberOfCDInDiskData
```
private final java.util.Map<java.lang.Integer,java.lang.Integer> numberOfCDInDiskData
```
    Holds the number of Central Directories on each disk. This is used when writing Zip64 End Of Central Directory and End Of Central Directory.
- Constructor Detail
  - ZipArchiveOutputStream
```
public ZipArchiveOutputStream(java.io.OutputStream out)
```
    Creates a new ZIP OutputStream filtering the underlying stream.
    
    Parameters:
    
    out - the outputstream to zip
  - ZipArchiveOutputStream
```
public ZipArchiveOutputStream(java.io.OutputStream out,
                              java.nio.charset.Charset encoding)
```
    Creates a new ZIP OutputStream filtering the underlying stream.
    
    Parameters:
    
    out - the outputstream to zip
    
    encoding - the encoding to use for file names, use null for the UTF-8
    
    Since:
    
    1.27.1-0
  - ZipArchiveOutputStream
```
public ZipArchiveOutputStream(java.nio.file.Path path,
                              long zipSplitSize)
                       throws java.io.IOException
```
    Creates a split ZIP Archive.
    The files making up the archive will use Z01, Z02, ... extensions and the last part of it will be the given file.
    
    Even though the stream writes to a file this stream will behave as if no random access was possible. This means the sizes of stored entries need to be known before the actual entry data is written.
    
    Parameters:
    
    path - the path to the file that will become the last part of the split archive
    
    zipSplitSize - maximum size of a single part of the split archive created by this stream. Must be between 64kB and about 4GB.
    
    Throws:
    
    java.io.IOException - on error
    
    java.lang.IllegalArgumentException - if zipSplitSize is not in the required range
    
    Since:
    
    1.22
  - ZipArchiveOutputStream
```
public ZipArchiveOutputStream(java.nio.file.Path file,
                              java.nio.file.OpenOption... options)
                       throws java.io.IOException
```
    Creates a new ZIP OutputStream writing to a Path. Will use random access if possible.
    
    Parameters:
    
    file - the file to ZIP to
    
    options - options specifying how the file is opened.
    
    Throws:
    
    java.io.IOException - on error
    
    Since:
    
    1.21
  - ZipArchiveOutputStream
```
public ZipArchiveOutputStream(java.nio.channels.SeekableByteChannel channel)
```
    Creates a new ZIP OutputStream writing to a SeekableByteChannel.
    SeekableInMemoryByteChannel allows you to write to an in-memory archive using random access.
    
    Parameters:
    
    channel - the channel to ZIP to
    
    Since:
    
    1.13
- Method Detail
  - addRawArchiveEntry
```
public void addRawArchiveEntry(ZipArchiveEntry entry,
                               java.io.InputStream rawStream)
                        throws java.io.IOException
```
    Adds an archive entry with a raw input stream.
    If crc, size and compressed size are supplied on the entry, these values will be used as-is. Zip64 status is re-established based on the settings in this stream, and the supplied value is ignored.
    
    The entry is put and closed immediately.
    
    Parameters:
    
    entry - The archive entry to add
    
    rawStream - The raw input stream of a different entry. May be compressed/encrypted.
    
    Throws:
    
    java.io.IOException - If copying fails
  - addUnicodeExtraFields
```
private void addUnicodeExtraFields(ZipArchiveEntry ze,
                                   boolean encodable,
                                   java.nio.ByteBuffer name)
                            throws java.io.IOException
```
    Adds UnicodeExtra fields for name and file comment if mode is ALWAYS or the data cannot be encoded using the configured encoding.
    
    Throws:
    
    java.io.IOException
  - canWriteEntryData
```
public boolean canWriteEntryData(ArchiveEntry ae)
```
    Whether this stream is able to write the given entry.
    May return false if it is set up to use encryption or a compression method that hasn't been implemented yet.
    
    Overrides:
    
    canWriteEntryData in class ArchiveOutputStream<ZipArchiveEntry>
    
    Parameters:
    
    ae - the entry to test
    
    Returns:
    
    This implementation always returns true.
    
    Since:
    
    1.1
  - checkIfNeedsZip64
```
private boolean checkIfNeedsZip64(Zip64Mode effectiveMode)
                           throws java.util.zip.ZipException
```
    Verifies the sizes aren't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
    
    Throws:
    
    java.util.zip.ZipException
  - close
```
public void close()
           throws java.io.IOException
```
    Closes this output stream and releases any system resources associated with the stream.
    
    Specified by:
    
    close in interface java.lang.AutoCloseable
    
    Specified by:
    
    close in interface java.io.Closeable
    
    Overrides:
    
    close in class ArchiveOutputStream<ZipArchiveEntry>
    
    Throws:
    
    java.io.IOException - if an I/O error occurs.
    
    Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
  - closeArchiveEntry
```
public void closeArchiveEntry()
                       throws java.io.IOException
```
    Writes all necessary data for this entry.
    
    Specified by:
    
    closeArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
    
    Throws:
    
    java.io.IOException - on error
    
    Zip64RequiredException - if the entry's uncompressed or compressed size exceeds 4 GByte and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
  - closeCopiedEntry
```
private void closeCopiedEntry(boolean phased)
                       throws java.io.IOException
```
    Writes all necessary data for this entry.
    
    Parameters:
    
    phased - This entry is second phase of a 2-phase ZIP creation, size, compressed size and crc are known in ZipArchiveEntry
    
    Throws:
    
    java.io.IOException - on error
    
    Zip64RequiredException - if the entry's uncompressed or compressed size exceeds 4 GByte and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
  - closeEntry
```
private void closeEntry(boolean actuallyNeedsZip64,
                        boolean phased)
                 throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - copyFromZipInputStream
```
private void copyFromZipInputStream(java.io.InputStream src,
                                    boolean phased)
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - createArchiveEntry
```
public ZipArchiveEntry createArchiveEntry(java.nio.file.Path inputPath,
                                          java.lang.String entryName,
                                          java.nio.file.LinkOption... options)
                                   throws java.io.IOException
```
    Creates a new ZIP entry taking some information from the given file and using the provided name.
    The name will be adjusted to end with a forward slash "/" if the file is a directory. If the file is not a directory a potential trailing forward slash will be stripped from the entry name.
    
    Must not be used if the stream has already been closed.
    
    Specified by:
    
    createArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
    
    Parameters:
    
    inputPath - path to create the entry from.
    
    entryName - name of the entry.
    
    options - options indicating how symbolic links are handled.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    java.io.IOException - if an I/O error occurs.
    
    Since:
    
    1.21
  - createCentralFileHeader
```
private byte[] createCentralFileHeader(ZipArchiveEntry ze)
                                throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - createCentralFileHeader
```
private byte[] createCentralFileHeader(ZipArchiveEntry ze,
                                       java.nio.ByteBuffer name,
                                       ZipArchiveOutputStream.EntryMetaData entryMetaData,
                                       boolean needsZip64Extra)
                                throws java.io.IOException
```
    Writes the central file header entry.
    
    Parameters:
    
    ze - the entry to write
    
    name - The encoded name
    
    entryMetaData - meta data for this file
    
    Throws:
    
    java.io.IOException - on error
  - createLocalFileHeader
```
private byte[] createLocalFileHeader(ZipArchiveEntry ze,
                                     java.nio.ByteBuffer name,
                                     boolean encodable,
                                     boolean phased,
                                     long archiveOffset)
```
  - deflate
```
protected final void deflate()
                      throws java.io.IOException
```
    Writes next block of compressed data to the output stream.
    
    Throws:
    
    java.io.IOException - on error
  - destroy
```
void destroy()
      throws java.io.IOException
```
    Closes the underlying stream/file without finishing the archive, the result will likely be a corrupt archive.
    This method only exists to support tests that generate corrupt archives so they can clean up any temporary files.
    
    Throws:
    
    java.io.IOException
  - finish
```
public void finish()
            throws java.io.IOException
```
    Finishes the addition of entries to this stream, without closing it. Additional data can be written, if the format supports it.
    
    Overrides:
    
    finish in class ArchiveOutputStream<ZipArchiveEntry>
    
    Throws:
    
    Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
    
    java.io.IOException - Maybe thrown by subclasses if the user forgets to close the entry.
  - flush
```
public void flush()
           throws java.io.IOException
```
    Flushes this output stream and forces any buffered output bytes to be written out to the stream.
    
    Specified by:
    
    flush in interface java.io.Flushable
    
    Overrides:
    
    flush in class java.io.FilterOutputStream
    
    Throws:
    
    java.io.IOException - if an I/O error occurs.
  - flushDeflater
```
private void flushDeflater()
                    throws java.io.IOException
```
    Ensures all bytes sent to the deflater are written to the stream.
    
    Throws:
    
    java.io.IOException
  - getBytesWritten
```
public long getBytesWritten()
```
    Returns the total number of bytes written to this stream.
    
    Overrides:
    
    getBytesWritten in class ArchiveOutputStream<ZipArchiveEntry>
    
    Returns:
    
    the number of written bytes
    
    Since:
    
    1.22
  - getEffectiveZip64Mode
```
private Zip64Mode getEffectiveZip64Mode(ZipArchiveEntry ze)
```
    If the mode is AsNeeded and the entry is a compressed entry of unknown size that gets written to a non-seekable stream then change the default to Never.
    
    Since:
    
    1.3
  - getEncoding
```
public java.nio.charset.Charset getEncoding()
```
    The encoding to use for file names and the file comment.
    
    Returns:
    
    null if using the platform's default character encoding.
    
    Since:
    
    1.27.1-0
  - getEntryEncoding
```
private java.nio.charset.Charset getEntryEncoding(ZipArchiveEntry ze)
```
  - usesUTF8ForNames
```
private boolean usesUTF8ForNames()
```
  - getGeneralPurposeBits
```
private GeneralPurposeBit getGeneralPurposeBits(boolean utfFallback,
                                                boolean usesDataDescriptor)
```
  - getName
```
private java.nio.ByteBuffer getName(ZipArchiveEntry ze)
                             throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - getZip64Extra
```
private Zip64ExtendedInformationExtraField getZip64Extra(ZipArchiveEntry ze)
```
    Gets the existing ZIP64 extended information extra field or create a new one and add it to the entry.
    
    Since:
    
    1.3
  - handleSizesAndCrc
```
private boolean handleSizesAndCrc(long bytesWritten,
                                  long crc,
                                  Zip64Mode effectiveMode)
                           throws java.util.zip.ZipException
```
    Ensures the current entry's size and CRC information is set to the values just written, verifies it isn't too big in the Zip64Mode.Never case and returns whether the entry would require a Zip64 extra field.
    
    Throws:
    
    java.util.zip.ZipException
  - handleZip64Extra
```
private void handleZip64Extra(ZipArchiveEntry ze,
                              long lfhOffset,
                              boolean needsZip64Extra)
```
    If the entry needs Zip64 extra information inside the central directory then configure its data.
  - hasZip64Extra
```
private boolean hasZip64Extra(ZipArchiveEntry ze)
```
    Is there a ZIP64 extended information extra field for the entry?
    
    Since:
    
    1.3
  - isSeekable
```
public boolean isSeekable()
```
    This method indicates whether this archive is writing to a seekable stream (i.e., to a random access file).
    For seekable streams, you don't need to calculate the CRC or uncompressed size for STORED entries before invoking putArchiveEntry(ZipArchiveEntry).
    
    Returns:
    
    true if seekable
  - isTooLargeForZip32
```
private boolean isTooLargeForZip32(ZipArchiveEntry zipArchiveEntry)
```
  - isZip64Required
```
private boolean isZip64Required(ZipArchiveEntry entry1,
                                Zip64Mode requestedMode)
```
  - preClose
```
private void preClose()
               throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - putArchiveEntry
```
public void putArchiveEntry(ZipArchiveEntry archiveEntry)
                     throws java.io.IOException
```
    Writes the headers for an archive entry to the output stream. The caller must then write the content to the stream and call ArchiveOutputStream.closeArchiveEntry() to complete the process.
    
    Specified by:
    
    putArchiveEntry in class ArchiveOutputStream<ZipArchiveEntry>
    
    Parameters:
    
    archiveEntry - describes the entry
    
    Throws:
    
    java.lang.ClassCastException - if entry is not an instance of ZipArchiveEntry
    
    Zip64RequiredException - if the entry's uncompressed or compressed size is known to exceed 4 GByte and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
    
    java.io.IOException - if an I/O error occurs
  - putArchiveEntry
```
private void putArchiveEntry(ZipArchiveEntry archiveEntry,
                             boolean phased)
                      throws java.io.IOException
```
    Writes the headers for an archive entry to the output stream. The caller must then write the content to the stream and call closeArchiveEntry() to complete the process.
    
    Parameters:
    
    archiveEntry - The archiveEntry
    
    phased - If true size, compressedSize and crc required to be known up-front in the archiveEntry
    
    Throws:
    
    java.lang.ClassCastException - if entry is not an instance of ZipArchiveEntry
    
    Zip64RequiredException - if the entry's uncompressed or compressed size is known to exceed 4 GByte and setUseZip64(kala.compress.archivers.zip.Zip64Mode) is Zip64Mode.Never.
    
    java.io.IOException
  - rewriteSizesAndCrc
```
private void rewriteSizesAndCrc(boolean actuallyNeedsZip64)
                         throws java.io.IOException
```
    When using random access output, write the local file header and potentially the ZIP64 extra containing the correct CRC and compressed/uncompressed sizes.
    
    Throws:
    
    java.io.IOException
  - setComment
```
public void setComment(java.lang.String comment)
```
    Sets the file comment.
    
    Parameters:
    
    comment - the comment
  - setCreateUnicodeExtraFields
```
public void setCreateUnicodeExtraFields(ZipArchiveOutputStream.UnicodeExtraFieldPolicy b)
```
    Whether to create Unicode Extra Fields.
    Defaults to NEVER.
    
    Parameters:
    
    b - whether to create Unicode Extra Fields.
  - setDefaults
```
private void setDefaults(ZipArchiveEntry entry)
```
    Provides default values for compression method and last modification time.
  - setEncoding
```
public void setEncoding(java.nio.charset.Charset encoding)
```
    The encoding to use for file names and the file comment.
    For a list of possible values see Supported Encodings. Defaults to UTF-8.
    
    Parameters:
    
    encoding - the encoding to use for file names, use null for the UTF-8
    
    Since:
    
    1.27.1-0
  - setFallbackToUTF8
```
public void setFallbackToUTF8(boolean b)
```
    Whether to fall back to UTF and the language encoding flag if the file name cannot be encoded using the specified encoding.
    Defaults to false.
    
    Parameters:
    
    b - whether to fall back to UTF and the language encoding flag if the file name cannot be encoded using the specified encoding.
  - setLevel
```
public void setLevel(int level)
```
    Sets the compression level for subsequent entries.
    Default is Deflater.DEFAULT_COMPRESSION.
    
    Parameters:
    
    level - the compression level.
    
    Throws:
    
    java.lang.IllegalArgumentException - if an invalid compression level is specified.
  - setMethod
```
public void setMethod(int method)
```
    Sets the default compression method for subsequent entries.
    Default is DEFLATED.
    
    Parameters:
    
    method - an int from java.util.zip.ZipEntry
  - setUseLanguageEncodingFlag
```
public void setUseLanguageEncodingFlag(boolean b)
```
    Whether to set the language encoding flag if the file name encoding is UTF-8.
    Defaults to true.
    
    Parameters:
    
    b - whether to set the language encoding flag if the file name encoding is UTF-8
  - setUseZip64
```
public void setUseZip64(Zip64Mode mode)
```
    Whether Zip64 extensions will be used.
    When setting the mode to Never, putArchiveEntry(kala.compress.archivers.zip.ZipArchiveEntry), closeArchiveEntry(), finish() or close() may throw a Zip64RequiredException if the entry's size or the total size of the archive exceeds 4GB or there are more than 65,536 entries inside the archive. Any archive created in this mode will be readable by implementations that don't support Zip64.
    
    When setting the mode to Always, Zip64 extensions will be used for all entries. Any archive created in this mode may be unreadable by implementations that don't support Zip64 even if all its contents would be.
    
    When setting the mode to AsNeeded, Zip64 extensions will transparently be used for those entries that require them. This mode can only be used if the uncompressed size of the ZipArchiveEntry is known when calling putArchiveEntry(kala.compress.archivers.zip.ZipArchiveEntry) or the archive is written to a seekable output (i.e. you have used the {@link #ZipArchiveOutputStream) File-arg constructor}) - this mode is not valid when the output stream is not seekable and the uncompressed size is unknown when putArchiveEntry(kala.compress.archivers.zip.ZipArchiveEntry) is called.
    
    If no entry inside the resulting archive requires Zip64 extensions then Never will create the smallest archive. AsNeeded will create a slightly bigger archive if the uncompressed size of any entry has initially been unknown and create an archive identical to Never otherwise. Always will create an archive that is at least 24 bytes per entry bigger than the one Never would create.
    
    Defaults to AsNeeded unless putArchiveEntry(kala.compress.archivers.zip.ZipArchiveEntry) is called with an entry of unknown size and data is written to a non-seekable stream - in this case the default is Never.
    
    Parameters:
    
    mode - Whether Zip64 extensions will be used.
    
    Since:
    
    1.3
  - shouldAddZip64Extra
```
private boolean shouldAddZip64Extra(ZipArchiveEntry entry,
                                    Zip64Mode mode)
```
    Whether to add a Zip64 extended information extra field to the local file header.
    Returns true if
    
    mode is Always
    
    or we already know it is going to be needed
    
    or the size is unknown and we can ensure it won't hurt other implementations if we add it (i.e. we can erase its usage
  - shouldUseZip64EOCD
```
private boolean shouldUseZip64EOCD()
```
    4.4.1.4 If one of the fields in the end of central directory record is too small to hold required data, the field SHOULD be set to -1 (0xFFFF or 0xFFFFFFFF) and the ZIP64 format record SHOULD be created.
    
    Returns:
    
    true if zip64 End Of Central Directory is needed
  - usesDataDescriptor
```
private boolean usesDataDescriptor(int zipMethod,
                                   boolean phased)
```
  - validateIfZip64IsNeededInEOCD
```
private void validateIfZip64IsNeededInEOCD()
                                    throws Zip64RequiredException
```
    If the Zip64 mode is set to never, then all the data in End Of Central Directory should not exceed their limits.
    
    Throws:
    
    Zip64RequiredException - if Zip64 is actually needed
  - validateSizeInformation
```
private void validateSizeInformation(Zip64Mode effectiveMode)
                              throws java.util.zip.ZipException
```
    Throws an exception if the size is unknown for a stored entry that is written to a non-seekable output or the entry is too big to be written without Zip64 extra but the mode has been set to Never.
    
    Throws:
    
    java.util.zip.ZipException
  - versionNeededToExtract
```
private int versionNeededToExtract(int zipMethod,
                                   boolean zip64,
                                   boolean usedDataDescriptor)
```
  - versionNeededToExtractMethod
```
private int versionNeededToExtractMethod(int zipMethod)
```
  - write
```
public void write(byte[] b,
                  int offset,
                  int length)
           throws java.io.IOException
```
    Writes bytes to ZIP entry.
    
    Overrides:
    
    write in class java.io.FilterOutputStream
    
    Parameters:
    
    b - the byte array to write
    
    offset - the start position to write from
    
    length - the number of bytes to write
    
    Throws:
    
    java.io.IOException - on error
  - writeCentralDirectoryEnd
```
protected void writeCentralDirectoryEnd()
                                 throws java.io.IOException
```
    Writes the "End of central dir record".
    
    Throws:
    
    java.io.IOException - on error
    
    Zip64RequiredException - if the archive's size exceeds 4 GByte or there are more than 65535 entries inside the archive and setUseZip64(Zip64Mode) is Zip64Mode.Never.
  - writeCentralDirectoryInChunks
```
private void writeCentralDirectoryInChunks()
                                    throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeCentralFileHeader
```
protected void writeCentralFileHeader(ZipArchiveEntry ze)
                               throws java.io.IOException
```
    Writes the central file header entry.
    
    Parameters:
    
    ze - the entry to write
    
    Throws:
    
    java.io.IOException - on error
    
    Zip64RequiredException - if the archive's size exceeds 4 GByte and setUseZip64(Zip64Mode) is Zip64Mode.Never.
  - writeCounted
```
private void writeCounted(byte[] data)
                   throws java.io.IOException
```
    Write bytes to output or random access file.
    
    Parameters:
    
    data - the byte array to write
    
    Throws:
    
    java.io.IOException - on error
  - writeDataDescriptor
```
protected void writeDataDescriptor(ZipArchiveEntry ze)
                            throws java.io.IOException
```
    Writes the data descriptor entry.
    
    Parameters:
    
    ze - the entry to write
    
    Throws:
    
    java.io.IOException - on error
  - writeLocalFileHeader
```
protected void writeLocalFileHeader(ZipArchiveEntry ze)
                             throws java.io.IOException
```
    Writes the local file header entry
    
    Parameters:
    
    ze - the entry to write
    
    Throws:
    
    java.io.IOException - on error
  - writeLocalFileHeader
```
private void writeLocalFileHeader(ZipArchiveEntry ze,
                                  boolean phased)
                           throws java.io.IOException
```
    Throws:
    
    java.io.IOException
  - writeOut
```
protected final void writeOut(byte[] data)
                       throws java.io.IOException
```
    Write bytes to output or random access file.
    
    Parameters:
    
    data - the byte array to write
    
    Throws:
    
    java.io.IOException - on error
  - writeOut
```
protected final void writeOut(byte[] data,
                              int offset,
                              int length)
                       throws java.io.IOException
```
    Write bytes to output or random access file.
    
    Parameters:
    
    data - the byte array to write
    
    offset - the start position to write from
    
    length - the number of bytes to write
    
    Throws:
    
    java.io.IOException - on error
  - writePreamble
```
public void writePreamble(byte[] preamble)
                   throws java.io.IOException
```
    Write preamble data. For most of the time, this is used to make self-extracting zips.
    
    Parameters:
    
    preamble - data to write
    
    Throws:
    
    java.io.IOException - if an entry already exists
    
    Since:
    
    1.21
  - writePreamble
```
public void writePreamble(byte[] preamble,
                          int offset,
                          int length)
                   throws java.io.IOException
```
    Write preamble data. For most of the time, this is used to make self-extracting zips.
    
    Parameters:
    
    preamble - data to write
    
    offset - the start offset in the data
    
    length - the number of bytes to write
    
    Throws:
    
    java.io.IOException - if an entry already exists
    
    Since:
    
    1.21
  - writeZip64CentralDirectory
```
protected void writeZip64CentralDirectory()
                                   throws java.io.IOException
```
    Writes the "ZIP64 End of central dir record" and "ZIP64 End of central dir locator".
    
    Throws:
    
    java.io.IOException - on error
    
    Since:
    
    1.3

Class ZipArchiveOutputStream

Nested Class Summary

Field Summary

Fields inherited from class java.io.FilterOutputStream

Constructor Summary

Method Summary

Methods inherited from class kala.compress.archivers.ArchiveOutputStream

Methods inherited from class java.io.FilterOutputStream

Methods inherited from class java.io.OutputStream

Methods inherited from class java.lang.Object

Field Detail

BUFFER_SIZE

LFH_SIG_OFFSET

LFH_VERSION_NEEDED_OFFSET

LFH_GPB_OFFSET

LFH_METHOD_OFFSET

LFH_TIME_OFFSET

LFH_CRC_OFFSET

LFH_COMPRESSED_SIZE_OFFSET

LFH_ORIGINAL_SIZE_OFFSET

LFH_FILENAME_LENGTH_OFFSET

LFH_EXTRA_LENGTH_OFFSET

LFH_FILENAME_OFFSET

CFH_SIG_OFFSET

CFH_VERSION_MADE_BY_OFFSET

CFH_VERSION_NEEDED_OFFSET

CFH_GPB_OFFSET

CFH_METHOD_OFFSET

CFH_TIME_OFFSET

CFH_CRC_OFFSET

CFH_COMPRESSED_SIZE_OFFSET

CFH_ORIGINAL_SIZE_OFFSET

CFH_FILENAME_LENGTH_OFFSET

CFH_EXTRA_LENGTH_OFFSET

CFH_COMMENT_LENGTH_OFFSET

CFH_DISK_NUMBER_OFFSET

CFH_INTERNAL_ATTRIBUTES_OFFSET

CFH_EXTERNAL_ATTRIBUTES_OFFSET

CFH_LFH_OFFSET

CFH_FILENAME_OFFSET

DEFLATED

DEFAULT_COMPRESSION

STORED

ZERO

LZERO

ONE

LFH_SIG

DD_SIG

CFH_SIG

EOCD_SIG

ZIP64_EOCD_SIG

ZIP64_EOCD_LOC_SIG

finished

entry

comment

level

hasCompressionLevelChanged

method

entries

streamCompressor

cdOffset

cdLength

cdDiskNumberStart

eocdLength

metaData

encoding

def

useLanguageEncodingFlag

fallbackToUTF8

createUnicodeExtraFields

hasUsedZip64

zip64Mode

copyBuffer

isSplitZip

numberOfCDInDiskData

Constructor Detail

ZipArchiveOutputStream

ZipArchiveOutputStream

ZipArchiveOutputStream

ZipArchiveOutputStream