jar(1) JDK Commands jar(1)
NAME
jar - create an archive for classes and resources, and manipulate or
restore individual classes or resources from an archive
SYNOPSIS
jar [OPTION ...] [ [--release VERSION] [-C dir] files] ...
DESCRIPTION
The jar command is a general-purpose archiving and compression tool,
based on the ZIP and ZLIB compression formats. Initially, the jar com-
mand was designed to package Java applets (not supported since JDK 11)
or applications; however, beginning with JDK 9, users can use the jar
command to create modular JARs. For transportation and deployment,
it's usually more convenient to package modules as modular JARs.
The syntax for the jar command resembles the syntax for the tar com-
mand. It has several main operation modes, defined by one of the
mandatory operation arguments. Other arguments are either options that
modify the behavior of the operation or are required to perform the op-
eration.
When modules or the components of an application (files, images and
sounds) are combined into a single archive, they can be downloaded by a
Java agent (such as a browser) in a single HTTP transaction, rather
than requiring a new connection for each piece. This dramatically im-
proves download times. The jar command also compresses files, which
further improves download time. The jar command also enables individu-
al entries in a file to be signed so that their origin can be authenti-
cated. A JAR file can be used as a class path entry, whether or not
it's compressed.
An archive becomes a modular JAR when you include a module descriptor,
module-info.class, in the root of the given directories or in the root
of the .jar archive. The following operations described in Operation
Modifiers Valid Only in Create and Update Modes are valid only when
creating or updating a modular jar or updating an existing non-modular
jar:
o --module-version
o --hash-modules
o --module-path
Note:
All mandatory or optional arguments for long options are also mandatory
or optional for any corresponding short options.
MAIN OPERATION MODES
When using the jar command, you must specify the operation for it to
perform. You specify the operation mode for the jar command by includ-
ing the appropriate operation arguments described in this section. You
can mix an operation argument with other one-letter options. Generally
the operation argument is the first argument specified on the command
line.
-c or --create
Creates the archive.
-i=FILE or --generate-index=FILE
Generates index information for the specified JAR file.
-t or --list
Lists the table of contents for the archive.
-u or --update
Updates an existing JAR file.
-x or --extract
Extracts the named (or all) files from the archive.
-d or --describe-module
Prints the module descriptor or automatic module name.
OPERATION MODIFIERS VALID IN ANY MODE
You can use the following options to customize the actions of any oper-
ation mode included in the jar command.
-C DIR Changes the specified directory and includes the files specified
at the end of the command line.
jar [OPTION ...] [ [--release VERSION] [-C dir] files]
-f=FILE or --file=FILE
Specifies the archive file name.
--release VERSION
Creates a multirelease JAR file. Places all files specified af-
ter the option into a versioned directory of the JAR file named
META-INF/versions/VERSION/, where VERSION must be must be a pos-
itive integer whose value is 9 or greater.
At run time, where more than one version of a class exists in
the JAR, the JDK will use the first one it finds, searching ini-
tially in the directory tree whose VERSION number matches the
JDK's major version number. It will then look in directories
with successively lower VERSION numbers, and finally look in the
root of the JAR.
-v or --verbose
Sends or prints verbose output to standard output.
OPERATION MODIFIERS VALID ONLY IN CREATE AND UPDATE MODES
You can use the following options to customize the actions of the cre-
ate and the update main operation modes:
-e=CLASSNAME or --main-class=CLASSNAME
Specifies the application entry point for standalone applica-
tions bundled into a modular or executable modular JAR file.
-m=FILE or --manifest=FILE
Includes the manifest information from the given manifest file.
-M or --no-manifest
Doesn't create a manifest file for the entries.
--module-version=VERSION
Specifies the module version, when creating or updating a modu-
lar JAR file, or updating a non-modular JAR file.
--hash-modules=PATTERN
Computes and records the hashes of modules matched by the given
pattern and that depend upon directly or indirectly on a modular
JAR file being created or a non-modular JAR file being updated.
-p or --module-path
Specifies the location of module dependence for generating the
hash.
@file Reads jar options and file names from a text file.
OPERATION MODIFIERS VALID ONLY IN CREATE, UPDATE, AND
GENERATE-INDEX MODES
You can use the following options to customize the actions of the cre-
ate (-c or --create) the update (-u or --update ) and the generate-in-
dex (-i or --generate-index=FILE) main operation modes:
-0 or --no-compress
Stores without using ZIP compression.
OTHER OPTIONS
The following options are recognized by the jar command and not used
with operation modes:
-h or --help[:compat]
Displays the command-line help for the jar command or optionally
the compatibility help.
--help-extra
Displays help on extra options.
--version
Prints the program version.
EXAMPLES OF JAR COMMAND SYNTAX
o Create an archive, classes.jar, that contains two class files,
Foo.class and Bar.class.
jar --create --file classes.jar Foo.class Bar.class
o Create an archive, classes.jar, by using an existing manifest, myman-
ifest, that contains all of the files in the directory foo/.
jar --create --file classes.jar --manifest mymanifest -C foo/
o Create a modular JAR archive,foo.jar, where the module descriptor is
located in classes/module-info.class.
jar --create --file foo.jar --main-class com.foo.Main --mod-
ule-version 1.0 -C foo/classes resources
o Update an existing non-modular JAR, foo.jar, to a modular JAR file.
jar --update --file foo.jar --main-class com.foo.Main --mod-
ule-version 1.0 -C foo/module-info.class
o Create a versioned or multi-release JAR, foo.jar, that places the
files in the classes directory at the root of the JAR, and the files
in the classes-10 directory in the META-INF/versions/10 directory of
the JAR.
In this example, the classes/com/foo directory contains two classes,
com.foo.Hello (the entry point class) and com.foo.NameProvider, both
compiled for JDK 8. The classes-10/com/foo directory contains a dif-
ferent version of the com.foo.NameProvider class, this one containing
JDK 10 specific code and compiled for JDK 10.
Given this setup, create a multirelease JAR file foo.jar by running
the following command from the directory containing the directories
classes and classes-10 .
jar --create --file foo.jar --main-class com.foo.Hel-
lo -C classes . --release 10 -C classes-10 .
The JAR file foo.jar now contains:
% jar -tf foo.jar
META-INF/
META-INF/MANIFEST.MF
com/
com/foo/
com/foo/Hello.class
com/foo/NameProvider.class
META-INF/versions/10/com/
META-INF/versions/10/com/foo/
META-INF/versions/10/com/foo/NameProvider.class
As well as other information, the file META-INF/MANIFEST.MF, will
contain the following lines to indicate that this is a multirelease
JAR file with an entry point of com.foo.Hello.
...
Main-Class: com.foo.Hello
Multi-Release: true
Assuming that the com.foo.Hello class calls a method on the
com.foo.NameProvider class, running the program using JDK 10 will en-
sure that the com.foo.NameProvider class is the one in META-INF/ver-
sions/10/com/foo/. Running the program using JDK 8 will ensure that
the com.foo.NameProvider class is the one at the root of the JAR, in
com/foo.
o Create an archive, my.jar, by reading options and lists of class
files from the file classes.list.
Note:
To shorten or simplify the jar command, you can specify arguments in
a separate text file and pass it to the jar command with the at sign
(@) as a prefix.
jar --create --file my.jar @classes.list
JDK 15 2020 jar(1)
openjdk 15.0.2 - Generated Thu Feb 25 15:21:17 CST 2021