Manifest (Java SE 12 & JDK 12 )
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 Detail

    - #### 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 Detail

    - #### 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`