Manifest (Java SE 15 & JDK 15)
Description: declaration: module: java.base, package: java.util.jar, class: Manifest
Keywords: java.util.jar.Manifest class

Module java.base
Package java.util.jar

# Class Manifest

java.lang.Object
java.util.jar.Manifest

All Implemented Interfaces:
  `Cloneable`

    public class Manifest
    extends Object
    implements Cloneable

The Manifest class is used to maintain Manifest entry names and their associated Attributes. There are main Manifest Attributes as well as per-entry Attributes. For information on the Manifest format, please see the Manifest format specification.

Since:
  1.2
See Also:
  `Attributes`

- ## Constructor Summary

  Constructors
  Constructor | Description
  --- | ---
  `Manifest()` | Constructs a new, empty Manifest.
  `Manifest​(InputStream is)` | Constructs a new Manifest from the specified input stream.
  `Manifest​(Manifest man)` | Constructs a new Manifest that is a copy of the specified Manifest.

- ## Method Summary

  Modifier and Type | Method | Description
  --- | --- | ---
  `void` | `clear()` | Clears the main Attributes as well as the entries in this Manifest.
  `Object` | `clone()` | Returns a shallow copy of this Manifest.
  `boolean` | `equals​(Object o)` | Returns true if the specified Object is also a Manifest and has the same main Attributes and entries.
  `Attributes` | `getAttributes​(String name)` | Returns the Attributes for the specified entry name.
  `Map<String,​Attributes>` | `getEntries()` | Returns a Map of the entries contained in this Manifest.
  `Attributes` | `getMainAttributes()` | Returns the main Attributes for the Manifest.
  `int` | `hashCode()` | Returns the hash code for this Manifest.
  `void` | `read​(InputStream is)` | Reads the Manifest from the specified InputStream.
  `void` | `write​(OutputStream out)` | Writes the Manifest to the specified OutputStream.

  ### Methods declared in class java.lang.Object

  `finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- ## Constructor Details

  - ### Manifest

    public Manifest()
    Constructs a new, empty Manifest.

  - ### Manifest

    public Manifest​(InputStream is) throws IOException
    Constructs a new Manifest from the specified input stream.
    Parameters:
      `is` - the input stream containing manifest data
    Throws:
      `IOException` - if an I/O error has occurred

  - ### Manifest

    public Manifest​(Manifest man)
    Constructs a new Manifest that is a copy of the specified Manifest.
    Parameters:
      `man` - the Manifest to copy

- ## Method Details

  - ### getMainAttributes

    public Attributes getMainAttributes()
    Returns the main Attributes for the Manifest.
    Returns:
      the main Attributes for the Manifest

  - ### getEntries

    public Map<String,​Attributes> getEntries()
    Returns a Map of the entries contained in this Manifest. Each entry is represented by a String name (key) and associated Attributes (value). The Map permits the `null` key, but no entry with a null key is created by `read(java.io.InputStream)`, nor is such an entry written by using `write(java.io.OutputStream)`.
    Returns:
      a Map of the entries contained in this Manifest

  - ### getAttributes

    public Attributes getAttributes​(String name)
    Returns the Attributes for the specified entry name. This method is defined as:

              return (Attributes)getEntries().get(name)

    Though `null` is a valid `name`, when `getAttributes(null)` is invoked on a `Manifest` obtained from a jar file, `null` will be returned. While jar files themselves do not allow `null`-named attributes, it is possible to invoke `getEntries()` on a `Manifest`, and on that result, invoke `put` with a null key and an arbitrary value. Subsequent invocations of `getAttributes(null)` will return the just-`put` value.

    Note that this method does not return the manifest's main attributes; see `getMainAttributes()`.

    Parameters:
      `name` - entry name
    Returns:
      the Attributes for the specified entry name

  - ### clear

    public void clear()
    Clears the main Attributes as well as the entries in this Manifest.

  - ### write

    public void write​(OutputStream out) throws IOException
    Writes the Manifest to the specified OutputStream. Attributes.Name.MANIFEST_VERSION must be set in MainAttributes prior to invoking this method.
    Parameters:
      `out` - the output stream
    Throws:
      `IOException` - if an I/O error has occurred
    See Also:
      `getMainAttributes()`

  - ### read

    public void read​(InputStream is) throws IOException
    Reads the Manifest from the specified InputStream. The entry names and attributes read will be merged in with the current manifest entries.
    Parameters:
      `is` - the input stream
    Throws:
      `IOException` - if an I/O error has occurred

  - ### equals

    public boolean equals​(Object o)
    Returns true if the specified Object is also a Manifest and has the same main Attributes and entries.
    Overrides:
      `equals` in class `Object`
    Parameters:
      `o` - the object to be compared
    Returns:
      true if the specified Object is also a Manifest and has the same main Attributes and entries
    See Also:
      `Object.hashCode()`, `HashMap`

  - ### hashCode

    public int hashCode()
    Returns the hash code for this Manifest.
    Overrides:
      `hashCode` in class `Object`
    Returns:
      a hash code value for this object.
    See Also:
      `Object.equals(java.lang.Object)`, `System.identityHashCode(java.lang.Object)`

  - ### clone

    public Object clone()
    Returns a shallow copy of this Manifest. The shallow copy is implemented as follows:

             public Object clone() { return new Manifest(this); }

    Overrides:
      `clone` in class `Object`
    Returns:
      a shallow copy of this Manifest
    See Also:
      `Cloneable`