Package com.chilkatsoft.chilkat2

Class Zip

java.lang.Object
com.chilkatsoft.chilkat2.ChilkatObject
com.chilkatsoft.chilkat2.Zip
All Implemented Interfaces:
AutoCloseable
public class Zip extends ChilkatObject
<section class="zip-summary">

Create, read, modify, encrypt, and extract ZIP archives.

Chilkat.Zip provides a comprehensive API for working with ZIP archives from files, memory, BinData, embedded resources, and Windows self-extracting EXEs. It can create new archives, open existing ZIPs, add files or in-memory data, inspect entries, extract selectively, and write the final archive to disk or memory.

Create ZIP archives

Add files, directories, strings, byte arrays, BinData, and StringBuilder content.

Open ZIPs from many sources

Open archives from disk, memory, BinData, embedded Windows resources, or Chilkat-created self-extracting EXEs.

Control stored paths

Use options such as AppendFromDir, DiscardPaths, PathPrefix, and saveExtraPath.

Extract selectively

Extract all files, matching entries, newer files, or flatten all output into a single directory.

Encryption support

Work with WinZip-compatible AES encryption and legacy Zip 2.0 password protection.

Large archive support

ZIP64 is used automatically when older ZIP limits are exceeded.

Important: Many methods update the in-memory ZIP object first. The archive is not written until a method such as WriteZip, WriteZipAndClose, WriteBd, or WriteToMemory is called.

For an extended overview, see Zip Class Overview.

</section>

Event-capable: long-running methods report progress through a ProgressListener installed with setProgressListener(ProgressListener), onAbortCheck(BooleanSupplier), onPercentDone(IntPredicate) or onProgressInfo(BiConsumer).

Instances hold a native Chilkat object: close them with ChilkatObject.close() (try-with-resources) when done; an unclosed instance is freed when it becomes unreachable.

See Also:
Online reference

  • Constructor Details

    • Zip

      public Zip()
      Creates a new Zip object.

  • Method Details

    • getAbortCurrent

      public boolean getAbortCurrent()
      Stops the currently executing operation when set to true.
      • Used to cancel long-running operations such as compression or extraction.
      • Can be triggered from another thread.
      • Automatically resets to false after the operation stops.
      Returns:
      the value of the AbortCurrent property

    • setAbortCurrent

      public void setAbortCurrent​(boolean value)
      Sets the AbortCurrent property; see getAbortCurrent().
      Parameters:
      value - the new value

    • getAppendFromDir

      public String getAppendFromDir()
      Specifies a base directory when adding files to the ZIP.
      • This portion of the path is not included in stored ZIP entry paths.
      • Useful for controlling relative paths inside the archive.

      For example, to add all files under c:/abc/123/myAppDir, this property could be set to c:/abc/123, and myAppDir/* would be passed to AppendFiles.

      The path stored in the ZIP would begin with myAppDir/.

      Returns:
      the value of the AppendFromDir property

    • setAppendFromDir

      public void setAppendFromDir​(String value)
      Sets the AppendFromDir property; see getAppendFromDir().
      Parameters:
      value - the new value (not null)

    • getAutoRun

      public String getAutoRun()
      (Windows only, for creating self-extracting EXE's)

      Specifies the name of an executable inside a self-extracting EXE that runs automatically after extraction.

      Returns:
      the value of the AutoRun property

    • setAutoRun

      public void setAutoRun​(String value)
      Sets the AutoRun property; see getAutoRun().
      Parameters:
      value - the new value (not null)

    • getAutoRunParams

      public String getAutoRunParams()
      (Windows only, for creating self-extracting EXE's)

      Command-line arguments passed to the AutoRun executable.

      Returns:
      the value of the AutoRunParams property

    • setAutoRunParams

      public void setAutoRunParams​(String value)
      Sets the AutoRunParams property; see getAutoRunParams().
      Parameters:
      value - the new value (not null)

    • getAutoTemp

      public boolean getAutoTemp()
      (Windows only, for creating self-extracting EXE's)

      If true, the EXE being created will automatically select and create a temporary directory for unzipping.

      This property is often used together with AutoRun to create a self-extracting EXE that automatically unzips to a temporary directory and runs a setup program, such as setup.exe, without user interaction.

      Note: To create a self-extracting EXE with no user interaction, set the following properties:

      ExeSilentProgress = false
      ExeNoInterface = true
      ExeFinishNotifier = false

      The default value is false.

      Returns:
      the value of the AutoTemp property

    • setAutoTemp

      public void setAutoTemp​(boolean value)
      Sets the AutoTemp property; see getAutoTemp().
      Parameters:
      value - the new value

    • getCaseSensitive

      public boolean getCaseSensitive()
      Controls whether filename matching is case-sensitive.
      • Affects methods such as EntryMatching and UnzipMatching.
      • Default: false
      Returns:
      the value of the CaseSensitive property

    • setCaseSensitive

      public void setCaseSensitive​(boolean value)
      Sets the CaseSensitive property; see getCaseSensitive().
      Parameters:
      value - the new value

    • getClearArchiveAttribute

      public boolean getClearArchiveAttribute()
      (Windows only)

      If true, clears the Windows archive attribute after files are successfully added to the ZIP.

      The archive attribute indicates that a file has changed since the last backup.

      The default value is false.

      Returns:
      the value of the ClearArchiveAttribute property

    • setClearArchiveAttribute

      public void setClearArchiveAttribute​(boolean value)
      Sets the ClearArchiveAttribute property; see getClearArchiveAttribute().
      Parameters:
      value - the new value

    • getClearReadOnlyAttr

      public boolean getClearReadOnlyAttr()
      If true, removes the read-only attribute from extracted files.

      If false, the read-only attribute remains unchanged.

      The default value is false.

      Returns:
      the value of the ClearReadOnlyAttr property

    • setClearReadOnlyAttr

      public void setClearReadOnlyAttr​(boolean value)
      Sets the ClearReadOnlyAttr property; see getClearReadOnlyAttr().
      Parameters:
      value - the new value

    • getComment

      public String getComment()
      Sets or retrieves the global ZIP file comment.

      The default value is the empty string.

      Returns:
      the value of the Comment property

    • setComment

      public void setComment​(String value)
      Sets the Comment property; see getComment().
      Parameters:
      value - the new value (not null)

    • getDecryptPassword

      public String getDecryptPassword()
      Password used to extract encrypted ZIP archives.
      • Required to unzip encrypted entries.
      • Encrypted ZIP files may still be opened without a password, but their contents cannot be extracted until the correct password is provided.

      The default value is the empty string.

      Returns:
      the value of the DecryptPassword property

    • setDecryptPassword

      public void setDecryptPassword​(String value)
      Sets the DecryptPassword property; see getDecryptPassword().
      Parameters:
      value - the new value (not null)

    • getDiscardPaths

      public boolean getDiscardPaths()
      If true, removes all directory path information when adding files.

      Only filenames are stored in the ZIP.

      The default value is false.

      Returns:
      the value of the DiscardPaths property

    • setDiscardPaths

      public void setDiscardPaths​(boolean value)
      Sets the DiscardPaths property; see getDiscardPaths().
      Parameters:
      value - the new value

    • getEncryptKeyLength

      public int getEncryptKeyLength()
      Specifies the AES encryption key length.
      • Valid values: 128, 192, or 256

      The default value is 128.

      Returns:
      the value of the EncryptKeyLength property

    • setEncryptKeyLength

      public void setEncryptKeyLength​(int value)
      Sets the EncryptKeyLength property; see getEncryptKeyLength().
      Parameters:
      value - the new value

    • getEncryptPassword

      public String getEncryptPassword()
      Password used when creating encrypted ZIP archives.

      The default value is the empty string.

      Returns:
      the value of the EncryptPassword property

    • setEncryptPassword

      public void setEncryptPassword​(String value)
      Sets the EncryptPassword property; see getEncryptPassword().
      Parameters:
      value - the new value (not null)

    • getEncryption

      public int getEncryption()
      Specifies encryption mode:
      • 0 → No encryption
      • 4 → WinZip-compatible AES encryption

      Important: Encryption and PasswordProtect are mutually exclusive.

      If PasswordProtect = true, then Encryption should be 0.

      The default value is 0.

      Returns:
      the value of the Encryption property

    • setEncryption

      public void setEncryption​(int value)
      Sets the Encryption property; see getEncryption().
      Parameters:
      value - the new value

    • getExeDefaultDir

      public String getExeDefaultDir()
      (Windows only, for creating self-extracting EXE's)

      Default extraction directory shown in the self-extracting EXE user interface.

      The default value is the empty string.

      Returns:
      the value of the ExeDefaultDir property

    • setExeDefaultDir

      public void setExeDefaultDir​(String value)
      Sets the ExeDefaultDir property; see getExeDefaultDir().
      Parameters:
      value - the new value (not null)

    • getExeFinishNotifier

      public boolean getExeFinishNotifier()
      (Windows only, for creating self-extracting EXE's)

      If true, displays a completion dialog after extraction finishes.

      The default value is false.

      Returns:
      the value of the ExeFinishNotifier property

    • setExeFinishNotifier

      public void setExeFinishNotifier​(boolean value)
      Sets the ExeFinishNotifier property; see getExeFinishNotifier().
      Parameters:
      value - the new value

    • getExeIconFile

      public String getExeIconFile()
      (Windows only, for creating self-extracting EXE's)

      Path to an .ico file used as the EXE icon.

      This feature is only available when the application creating the EXE is 32-bit.

      The default value is the empty string.

      Returns:
      the value of the ExeIconFile property

    • setExeIconFile

      public void setExeIconFile​(String value)
      Sets the ExeIconFile property; see getExeIconFile().
      Parameters:
      value - the new value (not null)

    • getExeNoInterface

      public boolean getExeNoInterface()
      (Windows only, for creating self-extracting EXE's)

      If true, runs the self-extracting EXE without displaying the main user interface.

      The default value is false.

      Returns:
      the value of the ExeNoInterface property

    • setExeNoInterface

      public void setExeNoInterface​(boolean value)
      Sets the ExeNoInterface property; see getExeNoInterface().
      Parameters:
      value - the new value

    • getExeSilentProgress

      public boolean getExeSilentProgress()
      (Windows only, for creating self-extracting EXE's)

      Controls whether a progress dialog is shown during extraction.

      If ExeNoInterface = false, the progress bar appears within the main dialog and this property has no effect.

      The default value is false.

      Returns:
      the value of the ExeSilentProgress property

    • setExeSilentProgress

      public void setExeSilentProgress​(boolean value)
      Sets the ExeSilentProgress property; see getExeSilentProgress().
      Parameters:
      value - the new value

    • getExeTitle

      public String getExeTitle()
      (Windows only, for creating self-extracting EXE's)

      Title displayed in the self-extracting EXE dialog.

      The default value is the empty string.

      Returns:
      the value of the ExeTitle property

    • setExeTitle

      public void setExeTitle​(String value)
      Sets the ExeTitle property; see getExeTitle().
      Parameters:
      value - the new value (not null)

    • getExeUnzipCaption

      public String getExeUnzipCaption()
      (Windows only, for creating self-extracting EXE's)

      Caption text displayed in the self-extracting EXE dialog.

      The default value is the empty string.

      Returns:
      the value of the ExeUnzipCaption property

    • setExeUnzipCaption

      public void setExeUnzipCaption​(String value)
      Sets the ExeUnzipCaption property; see getExeUnzipCaption().
      Parameters:
      value - the new value (not null)

    • getExeUnzipDir

      public String getExeUnzipDir()
      (Windows only, for creating self-extracting EXE's)

      Specifies a predefined extraction directory.

      • Supports environment variables such as %TEMP%.
      • UNC paths are not supported.

      The default value is the empty string.

      Returns:
      the value of the ExeUnzipDir property

    • setExeUnzipDir

      public void setExeUnzipDir​(String value)
      Sets the ExeUnzipDir property; see getExeUnzipDir().
      Parameters:
      value - the new value (not null)

    • getExeWaitForSetup

      public boolean getExeWaitForSetup()
      If true, waits for the AutoRun executable to finish before exiting.

      If false, the self-extracting EXE may exit before the AutoRun executable completes.

      The default value is true.

      Returns:
      the value of the ExeWaitForSetup property

    • setExeWaitForSetup

      public void setExeWaitForSetup​(boolean value)
      Sets the ExeWaitForSetup property; see getExeWaitForSetup().
      Parameters:
      value - the new value

    • getExeXmlConfig

      public String getExeXmlConfig()
      Allows for an XML config document to be used to specify all possible options for self-extracting EXEs. This property is a string containing the XML config document.

      The XML should have this format:

      <SfxConfig>

      <ErrPwdTitle>Title for incorrect password dialog</ErrPwdTitle>

      <ErrPwdCaption>Caption for incorrect password dialog</ErrPwdCaption>

      <FinOkBtn>Text on finish notifier button</FinOkBtn>

      <PwdOkBtn>Text on password challenge dialog's "OK" button.</PwdOkBtn>

      <PwdCancelBtn>Text on password challenge dialog's Cancel button.</PwdCancelBtn>

      <ErrInvalidPassword>Incorrect password error message.</ErrInvalidPassword>

      <MainUnzipBtn>Text on main dialog's unzip button. Note: The MainUnzipLabel must also be set for this to take effect.</MainUnzipBtn>

      <MainCloseBtn>Text on main dialog's quit/exit button. Note: The MainUnzipLabel must also be set for this to take effect.</MainCloseBtn>

      <MainBrowseBtn>Text on main dialog's browse-for-directory button. Note: The MainUnzipLabel must also be set for this to take effect.</MainBrowseBtn>

      <MainUnzipLabel>Caption displayed in main dialog.</MainUnzipLabel>

      <AutoTemp>0 or 1 (Maps to the AutoTemp property)</AutoTemp>

      <Cleanup>0 or 1 (If 1, extracted files are deleted after the SetupExe is run.)</Cleanup>

      <Debug>0 or 1 (If 1, the EXE will not extract any files.)</Debug>

      <Verbose>0 or 1 (If 1, verbose information is written to the log.)</Verbose>

      <ShowFin>0 or 1 (Maps to the ExeFinishNotifier property)</ShowFin>

      <ShowMain>0 or 1 (Maps to the ExeNoInterface property)</ShowMain>

      <ShowProgress>0 or 1 (Maps to the ExeSilentProgress property)</ShowProgress>

      <WaitForSetup>0 or 1 (Maps to the ExeWaitForSetup property)</WaitForSetup>

      <Encryption>0 or 1 (1 = Yes, 0 = No)</Encryption>

      <KeyLength>128|192|256</KeyLength>

      <SetupExe>EXE to run after extracting. (Maps to the AutoRun property)</SetupExe>

      <UnzipDir>Pre-defined unzip directory. (Maps to the ExeUnzipDir property. UNC paths, such as \\servername\path, are not supported.)</UnzipDir>

      <DefaultDir>Default unzip directory to appear in the main dialog. (Maps to the ExeDefaultDir property)</DefaultDir>

      <IconFile>Icon file to be used (Maps to the ExeIconFile property)</IconFile>

      <MainTitle>Maps to the ExeTitle property.</MainTitle>

      <MainCaption>Maps to the ExeUnzipCaption property.</MainCaption>

      <FinTitle>Title for the finish notifier dialog.</FinTitle>

      <FinCaption>Caption for the finish notifier dialog.</FinCaption>

      <ProgressTitle>Title for the progress dialog.</ProgressTitle>

      <ProgressCaption>Caption for the progress dialog.</ProgressCaption>

      <PwTitle>Title for the password challenge dialog.</PwTitle>

      <PwCaption>Caption for the password challenge dialog.</PwCaption>

      </SfxConfig>

      A self-extracting EXE can be run from the command line with the -log {logFilePath} option to create a log with information for debugging.

      Returns:
      the value of the ExeXmlConfig property

    • setExeXmlConfig

      public void setExeXmlConfig​(String value)
      Sets the ExeXmlConfig property; see getExeXmlConfig().
      Parameters:
      value - the new value (not null)

    • getFileCount

      public int getFileCount()
      Number of files in the ZIP, excluding directory entries.
      Returns:
      the value of the FileCount property (read-only)

    • getFileName

      public String getFileName()
      Path of the ZIP file to be written or overwritten.

      The default value is the empty string.

      Returns:
      the value of the FileName property

    • setFileName

      public void setFileName​(String value)
      Sets the FileName property; see getFileName().
      Parameters:
      value - the new value (not null)

    • getHasZipFormatErrors

      public boolean getHasZipFormatErrors()
      Indicates whether minor ZIP format problems were detected when opening the ZIP archive.
      Returns:
      the value of the HasZipFormatErrors property (read-only)

    • getHeartbeatMs

      public int getHeartbeatMs()
      Interval, in milliseconds, between abort-check callbacks.

      If set to 0, abort callbacks are disabled.

      The default value is 0.

      Returns:
      the value of the HeartbeatMs property

    • setHeartbeatMs

      public void setHeartbeatMs​(int value)
      Sets the HeartbeatMs property; see getHeartbeatMs().
      Parameters:
      value - the new value

    • getIgnoreAccessDenied

      public boolean getIgnoreAccessDenied()
      If true, files that cannot be read, written, or created due to filesystem permission errors are skipped.

      If false, any access-denied error causes the ZIP operation to fail.

      The default value is true.

      Returns:
      the value of the IgnoreAccessDenied property

    • setIgnoreAccessDenied

      public void setIgnoreAccessDenied​(boolean value)
      Sets the IgnoreAccessDenied property; see getIgnoreAccessDenied().
      Parameters:
      value - the new value

    • getMaxDate

      public String getMaxDate()
      Maximum last-modified timestamp for files processed during add or extract operations.

      Files having modification timestamps later than this value are skipped.

      Supports ISO 8601 date/time formats, including:

      • YYYY-MM-DD
        Example: 2024-07-31
      • YYYY-MM-DDTHH:MM:SS±HH:MM
        Example: 2024-07-31T12:34:56+02:00
      • YYYY-MM-DDTHH:MM:SSZ
        Example: 2024-07-31T12:34:56Z

      The default value is the empty string, meaning no maximum date restriction.

      Returns:
      the value of the MaxDate property

    • setMaxDate

      public void setMaxDate​(String value)
      Sets the MaxDate property; see getMaxDate().
      Parameters:
      value - the new value (not null)

    • getMaxUncompressSize

      public long getMaxUncompressSize()
      Prevents extraction of files larger than the specified uncompressed size.

      A value of 0 means no size limit.

      The default value is 0.

      Returns:
      the value of the MaxUncompressSize property

    • setMaxUncompressSize

      public void setMaxUncompressSize​(long value)
      Sets the MaxUncompressSize property; see getMaxUncompressSize().
      Parameters:
      value - the new value (0 .. 4294967295)

    • getMinDate

      public String getMinDate()
      Minimum last-modified timestamp for files processed during add or extract operations.

      Supports ISO 8601 date/time formats, including:

      • YYYY-MM-DD
        Example: 2024-07-31
      • YYYY-MM-DDTHH:MM:SS±HH:MM
        Example: 2024-07-31T12:34:56+02:00
      • YYYY-MM-DDTHH:MM:SSZ
        Example: 2024-07-31T12:34:56Z

      The default value is the empty string, meaning no minimum date restriction.

      Returns:
      the value of the MinDate property

    • setMinDate

      public void setMinDate​(String value)
      Sets the MinDate property; see getMinDate().
      Parameters:
      value - the new value (not null)

    • getNumEntries

      public int getNumEntries()
      Total number of entries in the ZIP, including both files and directories.
      Returns:
      the value of the NumEntries property (read-only)

    • getOemCodePage

      public int getOemCodePage()
      Specifies the OEM code page used for ZIP filename encoding.

      Defaults to the OEM code page of the current computer.

      Returns:
      the value of the OemCodePage property

    • setOemCodePage

      public void setOemCodePage​(int value)
      Sets the OemCodePage property; see getOemCodePage().
      Parameters:
      value - the new value

    • getOverwriteExisting

      public boolean getOverwriteExisting()
      If true, existing files are overwritten during extraction.

      The default value is true.

      Returns:
      the value of the OverwriteExisting property

    • setOverwriteExisting

      public void setOverwriteExisting​(boolean value)
      Sets the OverwriteExisting property; see getOverwriteExisting().
      Parameters:
      value - the new value

    • getPasswordProtect

      public boolean getPasswordProtect()
      Indicates whether the ZIP uses legacy Zip 2.0 password protection.

      This property is set automatically when a ZIP archive is opened by any of the Open* methods, such as OpenZip, OpenFromMemory, OpenBd, and related methods.

      Important: PasswordProtect and Encryption are mutually exclusive.

      If PasswordProtect = true, then Encryption should be 0.

      The default value is false.

      Returns:
      the value of the PasswordProtect property

    • setPasswordProtect

      public void setPasswordProtect​(boolean value)
      Sets the PasswordProtect property; see getPasswordProtect().
      Parameters:
      value - the new value

    • getPathPrefix

      public String getPathPrefix()
      Gets or sets a path prefix that is prepended to ZIP entry paths for files appended from the local filesystem.

      This is useful when you want all extracted files to appear under a specific subdirectory.

      This property affects only the following methods:

      • AppendFiles
      • AppendFilesEx
      • AddFile
      • AppendOneFileOrDir

      The PathPrefix value is prepended to the stored ZIP path for each appended filesystem file.

      For example, set PathPrefix to subdir/ so that files are stored in the ZIP with subdir/ prepended to their paths. When extracted, the files will be placed under the subdir directory.

      This property does not affect entries added entirely from memory, such as entries added using:

      • AddString
      • AddData
      • AddBd
      • AddSb

      For in-memory entries, the ZIP entry path is determined solely by the filename/path argument passed to the method.

      The default value is the empty string.

      Returns:
      the value of the PathPrefix property

    • setPathPrefix

      public void setPathPrefix​(String value)
      Sets the PathPrefix property; see getPathPrefix().
      Parameters:
      value - the new value (not null)

    • getPercentDoneScale

      public int getPercentDoneScale()
      Controls the granularity of PercentDone event callbacks.

      This property is only applicable in programming environments that support event callbacks.

      The value specifies what should be considered 100% complete for progress reporting purposes.

      • A value of 100 provides whole-percent progress updates.
      • A value of 1000 provides tenth-percent granularity.
      • For example, with a scale of 1000, a PercentDone callback value of 453 represents 45.3% complete.

      Increasing this value allows for more frequent and finer-grained progress callbacks during long-running operations.

      The value is automatically clamped to the range:

      • Minimum: 10
      • Maximum: 100000

      The default value is 100.

      Returns:
      the value of the PercentDoneScale property

    • setPercentDoneScale

      public void setPercentDoneScale​(int value)
      Sets the PercentDoneScale property; see getPercentDoneScale().
      Parameters:
      value - the new value

    • getPwdProtCharset

      public String getPwdProtCharset()
      Specifies the character encoding used to convert the decrypt password into its binary byte representation for legacy password-protected ZIP archives that use Zip 2.0 encryption.

      The default value is ansi.

      Other possible values include:

      • cp850
      • cp437
      • Any supported Windows or OEM code page listed at the link below.

      This property applies only to older Zip 2.0 password protection and is not used for AES-encrypted ZIP archives.

      Returns:
      the value of the PwdProtCharset property

    • setPwdProtCharset

      public void setPwdProtCharset​(String value)
      Sets the PwdProtCharset property; see getPwdProtCharset().
      Parameters:
      value - the new value (not null)

    • getTempDir

      public String getTempDir()
      Directory used for temporary files during ZIP operations.

      When overwriting an existing ZIP file, a temporary file is used to avoid corrupting the original ZIP if an error occurs.

      The default value depends on the runtime environment.

      Returns:
      the value of the TempDir property

    • setTempDir

      public void setTempDir​(String value)
      Sets the TempDir property; see getTempDir().
      Parameters:
      value - the new value (not null)

    • getUncommonOptions

      public String getUncommonOptions()
      Advanced options for uncommon scenarios.
      • ForceZip64 → Forces ZIP64 format even when not required.

      The default value is the empty string.

      Returns:
      the value of the UncommonOptions property

    • setUncommonOptions

      public void setUncommonOptions​(String value)
      Sets the UncommonOptions property; see getUncommonOptions().
      Parameters:
      value - the new value (not null)

    • getZipx

      public boolean getZipx()
      If true, creates ZIPX archives using the most appropriate compression method for each file.

      The default value is false.

      Returns:
      the value of the Zipx property

    • setZipx

      public void setZipx​(boolean value)
      Sets the Zipx property; see getZipx().
      Parameters:
      value - the new value

    • getZipxDefaultAlg

      public String getZipxDefaultAlg()
      Default compression algorithm used when creating ZIPX archives.
      • Possible values include:
        • deflate
        • ppmd
        • lzma
        • bzip2
        • deflate64

      The default value is deflate.

      Returns:
      the value of the ZipxDefaultAlg property

    • setZipxDefaultAlg

      public void setZipxDefaultAlg​(String value)
      Sets the ZipxDefaultAlg property; see getZipxDefaultAlg().
      Parameters:
      value - the new value (not null)

    • addBd

      public void addBd​(String pathInZip, BinData bd)
      Adds the contents of a BinData object as a new entry in the ZIP archive.
      • pathInZip specifies the filename and optional directory path stored within the ZIP.
      • The bytes contained in bd become the contents of the ZIP entry.
      • The entry is added to the in-memory ZIP object and is not written to disk until WriteZip, WriteZipAndClose, WriteBd, or WriteToMemory is called.

      Parameters:
      pathInZip - the pathInZip argument (not null)
      bd - the bd argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addEmpty

      public void addEmpty​(boolean isDir, String pathInZip)
      Adds an empty file or directory entry to the ZIP archive.
      • If isDir = true, an empty directory entry is created.
      • If isDir = false, an empty file entry is created.
      • pathInZip specifies the path stored in the ZIP archive.

      This method is useful when directory structure entries must exist even if no files are present.

      Parameters:
      isDir - the isDir argument
      pathInZip - the pathInZip argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addEncoded

      public void addEncoded​(String pathInZip, String encoding, String data)
      Adds encoded binary data as a ZIP entry.
      • encoding specifies how data is encoded.
      • Common encodings include base64 and hex.
      • The decoded binary bytes become the contents of the ZIP entry.

      This method is useful when binary data already exists in textual encoded form.

      Parameters:
      pathInZip - the pathInZip argument (not null)
      encoding - the encoding argument (not null)
      data - the data argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addFile

      public void addFile​(String localPath, boolean saveExtraPath)
      Adds a file or directory from the local filesystem to the ZIP archive.
      • If localPath is an absolute path and saveExtraPath = true, the stored ZIP path includes the relative directory structure.
      • If saveExtraPath = false, only the filename is stored.
      • If localPath is already relative, the relative path is stored as-is regardless of saveExtraPath.

      This method adds a reference to the file or directory in the local filesystem. The file data is not immediately read or compressed.

      The actual file contents are consumed only when a Write* method is called, such as:

      • WriteZip
      • WriteZipAndClose
      • WriteBd
      • WriteToMemory

      This allows files and data entries to be accumulated in the in-memory ZIP object prior to writing the final ZIP archive.

      Parameters:
      localPath - the localPath argument (not null)
      saveExtraPath - the saveExtraPath argument
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addNoCompressExtension

      public void addNoCompressExtension​(String fileExtension)
      Adds a file extension to the internal "no-compression" list.

      Files having these extensions are stored without compression because they are already compressed or because compression would provide little benefit.

      For example:

      • .zip
      • .jpg
      • .png
      • .gz

      The extension may be specified with or without the leading dot.

      Additional extensions remain active for the lifetime of the Zip object unless removed with RemoveNoCompressExtension.

      Parameters:
      fileExtension - the fileExtension argument (not null)

    • addSb

      public void addSb​(String pathInZip, StringBuilder sb, String charset)
      Adds the contents of a StringBuilder object as a text entry in the ZIP archive.
      • The text is converted to bytes using the specified charset.
      • pathInZip specifies the filename stored in the ZIP.

      Parameters:
      pathInZip - the pathInZip argument (not null)
      sb - the sb argument (not null)
      charset - the charset argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • addString

      public void addString​(String pathInZip, String content, String charset)
      Adds a string as a text file entry in the ZIP archive.
      • The string is converted to bytes using the specified charset.
      • pathInZip specifies the path stored within the ZIP archive.

      This method is useful for dynamically generating text files directly in memory.

      Parameters:
      pathInZip - the pathInZip argument (not null)
      content - the content argument (not null)
      charset - the charset argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • appendFiles

      public void appendFiles​(String filePattern, boolean recurse)
      Adds one or more files matching a wildcard pattern.
      • The wildcard character * matches zero or more characters.
      • If recurse = true, subdirectories are processed recursively.
      • If recurse = false, only the current directory is searched.

      For example:

      AppendFiles("c:/temp/*.txt", false)

      This method only updates the in-memory ZIP object. The ZIP file itself is not written until a Write* method is called.

      Parameters:
      filePattern - the filePattern argument (not null)
      recurse - the recurse argument
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • appendFilesEx

      public void appendFilesEx​(String filePattern, boolean recurse, boolean saveExtraPath, boolean archiveOnly, boolean includeHidden, boolean includeSystem)
      Advanced version of AppendFiles with additional filtering and path options.
      • saveExtraPath controls whether the extra leading path information from the filePattern is preserved in the ZIP.
      • archiveOnly applies only on Windows and limits processing to files having the archive attribute set.
      • includeHidden controls whether hidden files are included.
      • includeSystem controls whether files with the System attribute are included.

      This method adds references to files in the in-memory ZIP object. No ZIP file is written until a Write* method is called.

      Parameters:
      filePattern - the filePattern argument (not null)
      recurse - the recurse argument
      saveExtraPath - the saveExtraPath argument
      archiveOnly - the archiveOnly argument
      includeHidden - the includeHidden argument
      includeSystem - the includeSystem argument
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • appendZip

      public void appendZip​(String zipPath)
      Note: This method is currently not working and will be fixed in v11.5.0

      Adds all entries from another existing ZIP archive into the current ZIP object.

      The zipPath argument specifies the path of a ZIP file located in the local filesystem.

      All entries from the specified ZIP archive are appended to the current in-memory ZIP object.

      The ZIP archive itself is not rewritten until a Write* method is called.

      This method is useful for merging the contents of multiple ZIP archives into a single ZIP.

      Parameters:
      zipPath - the zipPath argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • closeZip

      public void closeZip()
      Closes the currently open ZIP archive and clears all entries from the Zip object.

      This method has the same effect as calling NewZip without specifying a filename.

    • deleteEntry

      public void deleteEntry​(ZipEntry entry)
      Removes a ZIP entry from the current ZIP object.

      The ZIP file itself is not rewritten until a Write* method is called.

      Parameters:
      entry - the entry argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • entryAt

      public void entryAt​(int index, ZipEntry entry)
      Retrieves the ZIP entry at the specified zero-based index.
      • The first entry is at index 0.
      • The matching entry is returned in the supplied ZipEntry object.

      Parameters:
      index - the index argument
      entry - the entry argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • entryById

      public void entryById​(int id, ZipEntry entry)
      Finds a ZIP entry by its unique EntryID.

      The matching entry is returned in the supplied ZipEntry object.

      Parameters:
      id - the id argument
      entry - the entry argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • entryMatching

      public void entryMatching​(String pattern, ZipEntry entry)
      Finds the first ZIP entry whose stored path matches a wildcard pattern.
      • The wildcard character * matches zero or more characters.
      • The comparison is performed against the full stored ZIP path.

      Parameters:
      pattern - the pattern argument (not null)
      entry - the entry argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • entryOf

      public boolean entryOf​(String pathInZip, ZipEntry entry)
      Finds a ZIP entry whose stored path exactly matches pathInZip.

      The matching entry is returned in the supplied ZipEntry object.

      Parameters:
      pathInZip - the pathInZip argument (not null)
      entry - the entry argument (not null)
      Returns:
      the result; this method never throws ChilkatException

    • excludeDir

      public void excludeDir​(String dirName)
      Adds a directory name to the exclusion list used by recursive append operations.
      • All directories having the specified name are skipped.
      • The comparison is case-insensitive.
      • Call multiple times to exclude multiple directory names.

      This affects methods such as AppendFiles and AppendFilesEx.

      Parameters:
      dirName - the dirName argument (not null)

    • extractExe

      public void extractExe​(String exePath, String dirPath)
      Extracts files from a Chilkat-created self-extracting EXE.
      • Files are extracted into dirPath.
      • Subdirectories are automatically created as needed.
      • If the EXE is encrypted, DecryptPassword must be set before extraction.

      Parameters:
      exePath - the exePath argument (not null)
      dirPath - the dirPath argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getDirectoryAsXML

      public String getDirectoryAsXML()
      Returns the ZIP directory structure as an XML document.

      The returned XML contains information about the entries currently contained within the ZIP archive, including files and directories.

      This method is useful for inspecting ZIP contents without extracting files.

      Returns the XML document as a string.

      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getExeConfigParam

      public String getExeConfigParam​(String name)
      (Windows only, for creating self-extracting EXE's)

      Returns the value of a configuration parameter embedded within a self-extracting EXE.

      The name argument should be one of the XML tag names described in the ExeXmlConfig property documentation.

      For example:

      • MainTitle
      • MainCaption
      • SetupExe

      Returns the parameter value as a string.

      Parameters:
      name - the name argument (not null)
      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • getMaxUncompressedSize

      public String getMaxUncompressedSize()
      Returns the largest uncompressed file size contained within the ZIP archive.

      The size is returned as a string rather than an integer because the value may exceed the range of a 32-bit integer.

      This method is useful when:

      • Checking for extremely large files before extraction
      • Estimating required disk space
      • Detecting unusually large compressed entries

      Returns the size as a decimal string.

      Returns:
      the result (never null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • isNoCompressExtension

      public boolean isNoCompressExtension​(String fileExtension)
      Checks whether a file extension is contained in the internal "no-compression" extension list.

      Files having extensions in this list are stored without compression because they are typically already compressed.

      The extension may be specified with or without the leading dot.

      For example, both of the following are valid:

      • .jpg
      • jpg

      Returns true if the extension exists in the list, otherwise returns false.

      Parameters:
      fileExtension - the fileExtension argument (not null)
      Returns:
      the result; this method never throws ChilkatException

    • isPasswordProtected

      public boolean isPasswordProtected​(String zipPath)
      Checks whether a ZIP archive uses legacy Zip 2.0 password protection.

      The zipPath argument specifies the path of a ZIP file in the local filesystem.

      This method checks only for traditional Zip 2.0 password protection.

      Returns true if the ZIP archive is password protected, otherwise returns false.

      Parameters:
      zipPath - the zipPath argument (not null)
      Returns:
      the result; this method never throws ChilkatException

    • newZip

      public void newZip​(String zipPath)
      Initializes a new empty ZIP archive.
      • If another ZIP archive is currently open, it is closed.
      • All existing in-memory ZIP entries are discarded.
      • The FileName property is set to zipPath.

      No ZIP file is actually created until a Write* method is called.

      This method resets the Zip object to a clean empty state.

      Parameters:
      zipPath - the zipPath argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • openBd

      public void openBd​(BinData binData)
      Opens a ZIP archive contained entirely within a BinData object.

      This method allows ZIP archives to be processed entirely in memory without requiring a filesystem file.

      When a ZIP archive is opened:

      • PasswordProtect is automatically set if legacy Zip 2.0 encryption is detected.
      • Encryption is automatically set if strong encryption is detected.
      • A value of 4 for Encryption indicates WinZip-compatible AES encryption.

      Parameters:
      binData - the binData argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • openEmbedded

      public void openEmbedded​(String exeFilename, String resourceName)
      (Windows only)

      Opens a ZIP archive embedded as a resource within a Windows executable.

      • exeFilename specifies the EXE file path.
      • resourceName specifies the embedded resource name containing the ZIP data.

      This method is useful when ZIP archives are packaged within Windows applications.

      Parameters:
      exeFilename - the exeFilename argument (not null)
      resourceName - the resourceName argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • openZip

      public void openZip​(String zipPath)
      Opens a ZIP archive from the local filesystem.

      The zipPath argument specifies the path of the ZIP file to open.

      Encrypted ZIP archives may be opened without providing a password, but encrypted entries cannot be extracted until the correct password is provided using DecryptPassword.

      When the ZIP archive is opened:

      • PasswordProtect is automatically set if legacy Zip 2.0 encryption is detected.
      • Encryption is automatically set if strong encryption is detected.
      • Encryption = 4 indicates WinZip-compatible AES encryption.

      Parameters:
      zipPath - the zipPath argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • quickAppend

      public void quickAppend​(String zipPath)
      Efficiently appends additional entries to an existing ZIP archive.

      The zipPath argument specifies the path of an existing ZIP archive in the local filesystem.

      This method avoids rewriting existing entries.

      • Existing ZIP entries remain unchanged.
      • New entries are appended to the end of the ZIP archive.
      • The ZIP central directory is updated accordingly.

      This method is typically faster than rebuilding the entire ZIP archive.

      Parameters:
      zipPath - the zipPath argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • removeNoCompressExtension

      public void removeNoCompressExtension​(String fileExtension)
      Removes a file extension from the internal "no-compression" extension list.

      After removal, files having this extension may be compressed normally.

      The extension may be specified with or without the leading dot.

      Parameters:
      fileExtension - the fileExtension argument (not null)

    • setCompressionLevel

      public void setCompressionLevel​(int level)
      Sets the compression level for all file and data entries currently contained within the ZIP object.
      • 0 → No compression
      • 9 → Maximum compression

      The default compression level is 6.

      Important: This method should be called after files or data entries have already been added to the ZIP object.

      The compression level cannot be changed for mapped entries originating from an already-open ZIP archive.

      Parameters:
      level - the level argument

    • setExclusions

      public void setExclusions​(StringArray excludePatterns)
      Specifies a collection of wildcard exclusion patterns used when adding files to the ZIP archive.

      Each pattern may use the wildcard character * to match zero or more characters.

      Files matching any exclusion pattern are skipped.

      Parameters:
      excludePatterns - the excludePatterns argument (not null)

    • setExeConfigParam

      public void setExeConfigParam​(String paramName, String paramValue)
      (Windows only, for creating self-extracting EXE's)

      Sets a configuration parameter embedded within a self-extracting EXE created by WriteExe or WriteExe2.

      The paramName should be one of the XML configuration tag names described in the ExeXmlConfig property documentation.

      For example:

      SetExeConfigParam("MainUnzipBtn","Extract")

      This changes the text displayed on the self-extractor's main unzip button.

      Parameters:
      paramName - the paramName argument (not null)
      paramValue - the paramValue argument (not null)

    • unzip

      public int unzip​(String dirPath)
      Extracts all files and directories from the ZIP archive.
      • dirPath specifies the destination directory.
      • Subdirectories are automatically created as needed.

      Returns the number of files extracted.

      Returns -1 if a failure occurs.

      Parameters:
      dirPath - the dirPath argument (not null)
      Returns:
      the result (see ChilkatObject.getLastMethodSuccess() where the description mentions failure)

    • unzipInto

      public int unzipInto​(String dirPath)
      Extracts all files into a single directory.

      All directory path information stored within the ZIP archive is ignored.

      If multiple files have the same filename, later extracted files overwrite earlier ones.

      Returns the number of files extracted, or -1 on failure.

      Parameters:
      dirPath - the dirPath argument (not null)
      Returns:
      the result (see ChilkatObject.getLastMethodSuccess() where the description mentions failure)

    • unzipMatching

      public int unzipMatching​(String dirPath, String pattern, boolean verbose)
      Extracts only entries whose stored paths match a wildcard pattern.
      • The wildcard character * matches zero or more characters.
      • If no wildcard is used, an exact filename match is required.

      Subdirectories are automatically created as needed.

      Returns the number of files extracted, or -1 on failure.

      Parameters:
      dirPath - the dirPath argument (not null)
      pattern - the pattern argument (not null)
      verbose - the verbose argument
      Returns:
      the result (see ChilkatObject.getLastMethodSuccess() where the description mentions failure)

    • unzipMatchingInto

      public int unzipMatchingInto​(String dirPath, String pattern, boolean verbose)
      Extracts matching entries into a single directory while ignoring all stored ZIP path information.

      Matching behavior is identical to UnzipMatching.

      If duplicate filenames occur, later extracted files overwrite earlier ones.

      Returns the number of files extracted, or -1 on failure.

      Parameters:
      dirPath - the dirPath argument (not null)
      pattern - the pattern argument (not null)
      verbose - the verbose argument
      Returns:
      the result (see ChilkatObject.getLastMethodSuccess() where the description mentions failure)

    • unzipNewer

      public int unzipNewer​(String dirPath)
      Extracts only files that:
      • Do not already exist
      • Or have older modification timestamps than the ZIP entry

      Subdirectories are automatically created as needed.

      Returns the number of files extracted, or -1 on failure.

      Parameters:
      dirPath - the dirPath argument (not null)
      Returns:
      the result (see ChilkatObject.getLastMethodSuccess() where the description mentions failure)

    • verifyPassword

      public boolean verifyPassword()
      Verifies that the current DecryptPassword value is correct for the currently opened ZIP archive.

      This method allows password validation before attempting extraction.

      Returns true if the password is valid, otherwise returns false.

      Returns:
      the result; this method never throws ChilkatException

    • writeBd

      public void writeBd​(BinData binData)
      Writes the ZIP archive to a BinData object instead of a filesystem file.

      The generated ZIP archive exists entirely in memory.

      The ZIP data written by this method may later be opened using OpenBd.

      Parameters:
      binData - the binData argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • writeExe

      public void writeExe​(String exeFilename)
      (Windows only, for creating self-extracting EXE's)

      Creates a Windows self-extracting executable (EXE).

      The generated EXE contains both the extraction logic and the ZIP archive data.

      There are no limitations on:

      • Total ZIP size
      • Individual file size
      • Number of files

      The generated EXE supports the following command-line arguments:

      • -log logFileName
      • -unzipDir unzipDirectoryPath
      • -pwd password
      • -ap autoRunParams

      Parameters:
      exeFilename - the exeFilename argument (not null)
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • writeZip

      public void writeZip()
      Saves the Zip to a file and implictly re-opens it so further operations can continue. Use WriteZipAndClose to write and close the Zip. There is no limitation on the size of files that may be contained within a .zip, the total number of files in a .zip, or the total size of a .zip. If necessary, WriteZip will use the ZIP64 file format extensions when 4GB or file count limitations of the old zip file format are exceeded.
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • writeZipAndClose

      public void writeZipAndClose()
      Saves the Zip to a file and closes it. On return, the Zip object will be in the state as if NewZip had been called. There is no limitation on the size of files that may be contained within a .zip, the total number of files in a .zip, or the total size of a .zip. If necessary, WriteZip will use the ZIP64 file format extensions when 4GB or file count limitations of the old zip file format are exceeded.
      Throws:
      ChilkatException - if the operation fails; ChilkatException.getLastErrorText() says why

    • setProgressListener

      public void setProgressListener​(ProgressListener listener)
      Installs the listener that receives this object's progress events (abortCheck, percentDone, progressInfo) during its long-running methods; replaces any listener or lambda installed before; null removes it.
      Parameters:
      listener - the listener, or null
      Throws:
      IllegalStateException - if called from inside one of this object's own callbacks

    • getProgressListener

      public ProgressListener getProgressListener()
      Returns the installed listener, or null.
      Returns:
      the listener installed with setProgressListener(ProgressListener) or one of the on... methods

    • onAbortCheck

      public void onAbortCheck​(BooleanSupplier callback)
      Installs a listener whose only callback is abortCheck: called every HeartbeatMs milliseconds during a long-running method; return true to abort it. Replaces any listener installed before.
      Parameters:
      callback - the callback, or null to remove the listener

    • onPercentDone

      public void onPercentDone​(IntPredicate callback)
      Installs a listener whose only callback is percentDone: called with the completion percentage (0..100) as a long-running method progresses; return true to abort it. Replaces any listener installed before.
      Parameters:
      callback - the callback, or null to remove the listener

    • onProgressInfo

      public void onProgressInfo​(BiConsumer<String,​String> callback)
      Installs a listener whose only callback is progressInfo: called with a name/value pair of progress information as a long-running method proceeds. Replaces any listener installed before.
      Parameters:
      callback - the callback, or null to remove the listener