# java.util.jar

***

**1. Create and Use a JAR file**

```java
// Create a JAR file
JarOutputStream jar = new JarOutputStream(new FileOutputStream("myjar.jar"));
jar.putNextEntry(new JarEntry("myfile.txt"));
jar.write("Hello world".getBytes());
jar.closeEntry();
jar.close();

// Use the JAR file
JarFile jarFile = new JarFile("myjar.jar");
JarEntry jarEntry = jarFile.getJarEntry("myfile.txt");
InputStream inputStream = jarFile.getInputStream(jarEntry);
byte[] data = inputStream.readAllBytes();
System.out.println(new String(data));
```

**2. Create a JAR file from a Directory**

```java
import java.io.File;
import java.io.IOException;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;

public class CreateJarFromDirectory {

    public static void main(String[] args) throws IOException {
        // Create a JAR file
        JarOutputStream jar = new JarOutputStream(new FileOutputStream("myjar.jar"));

        // Create a directory object
        File directory = new File("mydirectory");

        // Iterate over all files in the directory
        for (File file : directory.listFiles()) {
            // Create a JAR entry
            JarEntry jarEntry = new JarEntry(file.getName());

            // Put the JAR entry into the JAR file
            jar.putNextEntry(jarEntry);

            // Write the file data to the JAR entry
            jar.write(Files.readAllBytes(file.toPath()));

            // Close the JAR entry
            jar.closeEntry();
        }

        // Close the JAR file
        jar.close();
    }
}
```

**3. Read Files from a JAR File**

```java
import java.io.IOException;
import java.util.jar.JarFile;
import java.util.jar.JarEntry;

public class ReadFilesFromJar {

    public static void main(String[] args) throws IOException {
        // Open a JAR file
        JarFile jarFile = new JarFile("myjar.jar");

        // Get a list of all the JAR entries
        JarEntry[] jarEntries = jarFile.entries();

        // Iterate over all the JAR entries
        for (JarEntry jarEntry : jarEntries) {
            // Get the name of the JAR entry
            String name = jarEntry.getName();

            // Check if the JAR entry is a directory
            if (jarEntry.isDirectory()) {
                // Print the name of the directory
                System.out.println("Directory: " + name);
            } else {
                // Get the input stream for the JAR entry
                InputStream inputStream = jarFile.getInputStream(jarEntry);

                // Read the data from the input stream
                byte[] data = inputStream.readAllBytes();

                // Print the name of the JAR entry and the data it contains
                System.out.println("File: " + name + ", Data: " + new String(data));
            }
        }

        // Close the JAR file
        jarFile.close();
    }
}
```

**4. Extract Files from a JAR File**

```java
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

public class ExtractFilesFromJar {

    public static void main(String[] args) throws IOException {
        // Open a JAR file
        JarFile jarFile = new JarFile("myjar.jar");

        // Create a directory to extract the files to
        File directory = new File("extracted_files");
        directory.mkdir();

        // Iterate over all the JAR entries
        for (JarEntry jarEntry : jarFile.entries()) {
            // Get the name of the JAR entry
            String name = jarEntry.getName();

            // Check if the JAR entry is a directory
            if (jarEntry.isDirectory()) {
                // Create the directory
                File subDirectory = new File(directory, name);
                subDirectory.mkdir();
            } else {
                // Extract the file
                File file = new File(directory, name);
                FileOutputStream outputStream = new FileOutputStream(file);
                outputStream.write(jarFile.getInputStream(jarEntry).readAllBytes());
                outputStream.close();
            }
        }

        // Close the JAR file
        jarFile.close();
    }
}
```

**5. Create a JAR file with a Manifest**

```java
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;

public class CreateJarWithManifest {

    public static void main(String[] args) throws IOException {
        // Create a Manifest
        Manifest manifest = new Manifest();
        manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
        manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, "MyMainClass");

        // Create a JAR file
        JarOutputStream jar = new JarOutputStream(new FileOutputStream("myjar.jar"), manifest);

        // Create a JAR entry
        JarEntry jarEntry = new JarEntry("myfile.txt");

        // Put the JAR entry into the JAR file
        jar.putNextEntry(jarEntry);

        // Write data to the JAR entry
        jar.write("Hello world".getBytes());

        // Close the JAR entry
        jar.closeEntry();

        // Close the JAR file
        jar.close();
    }
}
```

**6. Create a JAR file with a Signature**

```java
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.security.AlgorithmParameters;
import java.security.GeneralSecurityException;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.Signature;
import java.security.cert.Certificate;
import java.security.cert.X509Certificate;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.jar.Attributes;
import java.util.jar.JarEntry;
import java.util.jar.JarOutputStream;
import java.util.jar.Manifest;

public class CreateJarWithSignature {

    public static void main(String[] args) throws IOException, GeneralSecurityException {
        // Get the private key
        byte[] privateKeyBytes = Base64.getDecoder().decode("-----BEGIN PRIVATE KEY----- ... -----END PRIVATE KEY-----");
        X509EncodedKeySpec privateKeySpec = new X509EncodedKeySpec(privateKeyBytes);
        PrivateKey privateKey = KeyFactory.getInstance("RSA").generatePrivate(privateKeySpec);

        // Get the certificate
        byte[] certificateBytes = Base64.getDecoder().decode("-----BEGIN CERTIFICATE----- ... -----END CERTIFICATE-----");
        X509Certificate certificate = (X509Certificate) Certificate.getInstance("X.509", certificateBytes);

        // Create a Manifest
        Manifest manifest = new Manifest();
        manifest.getMainAttributes().put(Attributes.Name.MANIFEST_VERSION, "1.0");
        manifest.getMainAttributes().put(Attributes.Name.MAIN_CLASS, "MyMainClass");

        // Create a Signature object
        Signature signature = Signature.getInstance("SHA256withRSA");
        signature.initSign(privateKey);

        // Sign the Manifest
        signature.update(manifest.toString().getBytes());
        byte[] signatureBytes = signature.sign();

        // Create a JAR file
        JarOutputStream jar = new JarOutputStream(new FileOutputStream("myjar.jar"), manifest);

        // Create a JAR entry
        JarEntry jarEntry = new JarEntry("myfile.txt");

        // Put the JAR entry into the JAR file
        jar.putNextEntry(jarEntry);

        // Write data to the JAR entry
        jar.write("Hello world".getBytes());

        // Close the JAR entry
        jar.closeEntry();

        // Create a Signature Block

```