manpagez: man pages & more
man jar(1)
Home | html | info | man
jar(1)                           JDK Commands                           jar(1)


       jar  -  create  an archive for classes and resources, and manipulate or
       restore individual classes or resources from an archive


       jar [OPTION ...] [ [--release VERSION] [-C dir] files] ...


       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-

       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

       o --module-version

       o --hash-modules

       o --module-path


       All mandatory or optional arguments for long options are also mandatory
       or optional for any corresponding short options.


       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

       -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.


       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.


       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.

              Specifies  the module version, when creating or updating a modu-
              lar JAR file, or updating a non-modular JAR file.

              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

       @file  Reads jar options and file names from a text file.



       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.


       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.

              Displays help on extra options.

              Prints the program version.


       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 --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 --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,  (the entry point class) and, both
         compiled for JDK 8.  The classes-10/com/foo directory contains a dif-
         ferent version of the 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
                lo -C classes . --release 10 -C classes-10 .

         The JAR file foo.jar now contains:

                % jar -tf foo.jar


         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

                Multi-Release: true

         Assuming   that  the  class  calls  a  method  on  the class, running the program using JDK 10 will en-
         sure  that the class is the one in META-INF/ver-
         sions/10/com/foo/.  Running the program using JDK 8 will ensure  that
         the class is the one at the root of the JAR, in

       o Create an archive, my.jar, by reading  options  and  lists  of  class
         files from the file classes.list.


         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
© 2000-2023
Individual documents may contain additional copyright information.