TarArchive

• Open Markdown

• ---

• Open in ChatGPT
• Open in Claude
• Open in Perplexity

Inheritance: java.lang.Object

All Implemented Interfaces: com.aspose.zip.IArchive, java.lang.AutoCloseable

public class TarArchive implements IArchive, AutoCloseable

Denna klass representerar en tar-arkivfil. Använd den för att skapa, extrahera eller uppdatera tar-arkiv.

Konstruktörer

Konstruktor	Beskrivning
TarArchive()	Initierar en ny instans av klassen TarArchive.
TarArchive(InputStream sourceStream)	Initierar en ny instans av klassen Archive och sammanställer en postlista som kan extraheras från arkivet.
TarArchive(String path)	Initierar en ny instans av klassen TarArchive och skapar en postlista som kan extraheras från arkivet.

Metoder

Metod	Beskrivning
close()	{@inheritDoc}
createEntries(File directory)	Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.
createEntries(File directory, boolean includeRootDirectory)	Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.
createEntries(String sourceDirectory)	Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.
createEntries(String sourceDirectory, boolean includeRootDirectory)	Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.
createEntry(String name, File file)	Skapar en enskild post i arkivet.
createEntry(String name, File file, boolean openImmediately)	Skapar en enskild post i arkivet.
createEntry(String name, InputStream source)	Skapar en enskild post i arkivet.
createEntry(String name, InputStream source, File file)	Skapar en enskild post i arkivet.
createEntry(String name, String path)	Skapar en enskild post i arkivet.
createEntry(String name, String path, boolean openImmediately)	Skapar en enskild post i arkivet.
deleteEntry(TarEntry entry)	Tar bort den första förekomsten av en specifik post från postlistan.
deleteEntry(int entryIndex)	Tar bort posten från postlistan efter index.
extractToDirectory(String destinationDirectory)	Extraherar alla filer i arkivet till den angivna katalogen.
fromGZip(InputStream source)	Extraherar angivet gzip-arkiv och skapar ett TarArchive från den extraherade datan.
fromGZip(String path)	Extraherar angivet gzip-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZ4(InputStream source)	Extraherar angivet LZ4-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZ4(String path)	Extraherar angivet LZ4-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZMA(InputStream source)	Extraherar angivet LZMA-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZMA(String path)	Extraherar angivet LZMA-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZip(InputStream source)	Extraherar angivet lzip-arkiv och skapar ett TarArchive från den extraherade datan.
fromLZip(String path)	Extraherar angivet lzip-arkiv och skapar ett TarArchive från den extraherade datan.
fromXz(InputStream source)	Extraherar angivet xz-formatarkiv och skapar ett TarArchive från den extraherade datan.
fromXz(String path)	Extraherar angivet xz-formatarkiv och skapar ett TarArchive från den extraherade datan.
fromZ(InputStream source)	Extraherar angivet Z-formatarkiv och skapar ett TarArchive från den extraherade datan.
fromZ(String path)	Extraherar angivet Z-formatarkiv och skapar ett TarArchive från den extraherade datan.
fromZstandard(InputStream source)	Extraherar angivet Zstandard-arkiv och skapar ett TarArchive från den extraherade datan.
fromZstandard(String path)	Extraherar angivet Zstandard-arkiv och skapar ett TarArchive från den extraherade datan.
getEntries()	Hämtar poster av typen TarEntry som utgör arkivet.
getFileEntries()	Hämtar poster av typen IArchiveFileEntry som utgör tar-arkivet.
getFormat()	Hämtar arkivformatet.
save(OutputStream output)	Sparar arkivet till den angivna strömmen.
save(OutputStream output, TarFormat format)	Sparar arkivet till den angivna strömmen.
save(String destinationFileName)	Sparar arkivet till den angivna destinationsfilen.
save(String destinationFileName, TarFormat format)	Sparar arkivet till den angivna destinationsfilen.
saveGzipped(OutputStream output)	Sparar arkivet till strömmen med gzip-komprimering.
saveGzipped(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med gzip-komprimering.
saveGzipped(String path)	Sparar arkivet till filen via sökväg med gzip-komprimering.
saveGzipped(String path, TarFormat format)	Sparar arkivet till filen via sökväg med gzip-komprimering.
saveLZ4Compressed(OutputStream output)	Sparar arkivet till strömmen med LZ4-komprimering.
saveLZ4Compressed(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med LZ4-komprimering.
saveLZ4Compressed(String path)	Sparar arkivet till filen via sökväg med LZ4-komprimering.
saveLZ4Compressed(String path, TarFormat format)	Sparar arkivet till filen via sökväg med LZ4-komprimering.
saveLZMACompressed(OutputStream output)	Sparar arkivet till strömmen med LZMA-komprimering.
saveLZMACompressed(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med LZMA-komprimering.
saveLZMACompressed(String path)	Sparar arkivet till filen via sökväg med lzma-komprimering.
saveLZMACompressed(String path, TarFormat format)	Sparar arkivet till filen via sökväg med lzma-komprimering.
saveLzipped(OutputStream output)	Sparar arkivet till strömmen med lzip-komprimering.
saveLzipped(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med lzip-komprimering.
saveLzipped(String path)	Sparar arkivet till filen via sökväg med lzip-komprimering.
saveLzipped(String path, TarFormat format)	Sparar arkivet till filen via sökväg med lzip-komprimering.
saveXzCompressed(OutputStream output)	Sparar arkivet till strömmen med xz-komprimering.
saveXzCompressed(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med xz-komprimering.
saveXzCompressed(OutputStream output, TarFormat format, XzArchiveSettings settings)	Sparar arkivet till strömmen med xz-komprimering.
saveXzCompressed(String path)	Sparar arkivet till filen via sökväg med xz-komprimering.
saveXzCompressed(String path, TarFormat format)	Sparar arkivet till filen via sökväg med xz-komprimering.
saveXzCompressed(String path, TarFormat format, XzArchiveSettings settings)	Sparar arkivet till filen via sökväg med xz-komprimering.
saveZCompressed(OutputStream output)	Sparar arkivet till strömmen med Z-komprimering.
saveZCompressed(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med Z-komprimering.
saveZCompressed(String path)	Sparar arkivet till filen via sökväg med Z-komprimering.
saveZCompressed(String path, TarFormat format)	Sparar arkivet till filen via sökväg med Z-komprimering.
saveZstandard(OutputStream output)	Sparar arkivet till strömmen med Zstandard-komprimering.
saveZstandard(OutputStream output, TarFormat format)	Sparar arkivet till strömmen med Zstandard-komprimering.
saveZstandard(String path)	Sparar arkivet till filen via sökväg med Zstandard-komprimering.
saveZstandard(String path, TarFormat format)	Sparar arkivet till filen via sökväg med Zstandard-komprimering.

TarArchive()

public TarArchive()

Initierar en ny instans av klassen TarArchive.

Följande exempel visar hur man komprimerar en fil.

try (TarArchive archive = new TarArchive()) { archive.createEntry(first.bin, “data.bin”); archive.save(“archive.tar”); }

### TarArchive(InputStream sourceStream) {#TarArchive-java.io.InputStream-}

public TarArchive(InputStream sourceStream)

Initializes a new instance of the [Archive](../../com.aspose.zip/archive) class and composes an entry list can be extracted from the archive.

The following example shows how to extract all the entries to a directory.

     try (TarArchive archive = new TarArchive(new FileInputStream("archive.tar"))) {
             archive.extractToDirectory("C:\\extracted");
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```

Den här konstruktorn packar inte upp någon post. Se [TarEntry.open()](../../com.aspose.zip/tarentry\#open--) metod för uppackning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| sourceStream | java.io.InputStream | källan till arkivet |

### TarArchive(String path) {#TarArchive-java.lang.String-}
```
public TarArchive(String path)
```


Initierar en ny instans av klassen [TarArchive](../../com.aspose.zip/tararchive) och skapar en postlista som kan extraheras från arkivet.

Följande exempel visar hur man extraherar alla poster till en katalog.

```

try (TarArchive archive = new TarArchive(“archive.tar”)) { archive.extractToDirectory("C:\\extracted"); }

This constructor does not unpack any entry. See [TarEntry.open()](../../com.aspose.zip/tarentry\#open--) method for unpacking.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path to the archive file |

### close() {#close--}

public void close()

### createEntries(File directory) {#createEntries-java.io.File-}

public final TarArchive createEntries(File directory)

Adds to the archive all the files and directories recursively in the directory given.

     try (FileOutputStream tarFile = new FileOutputStream("archive.tar")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntries(new java.io.File("C:\\folder"), false);
             archive.save(tarFile);
         }
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| directory | java.io.File | katalog att komprimera |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with entries composed
### createEntries(File directory, boolean includeRootDirectory) {#createEntries-java.io.File-boolean-}
```
public final TarArchive createEntries(File directory, boolean includeRootDirectory)
```


Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.

```

try (FileOutputStream tarFile = new FileOutputStream(“archive.tar”)) { try (TarArchive archive = new TarArchive()) { archive.createEntries(new java.io.File(“C:\folder”), false); archive.save(tarFile); } } catch (IOException ex) { System.out.println(ex); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| directory | java.io.File | directory to compress |
| includeRootDirectory | boolean | indicates whether to include the root directory itself or not |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with entries composed
### createEntries(String sourceDirectory) {#createEntries-java.lang.String-}

public final TarArchive createEntries(String sourceDirectory)

Adds to the archive all the files and directories recursively in the directory given.

     try (FileOutputStream tarFile = new FileOutputStream("archive.tar")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntries("C:\\folder", false);
             archive.save(tarFile);
         }
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| sourceDirectory | java.lang.String | katalog att komprimera |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with entries composed
### createEntries(String sourceDirectory, boolean includeRootDirectory) {#createEntries-java.lang.String-boolean-}
```
public final TarArchive createEntries(String sourceDirectory, boolean includeRootDirectory)
```


Lägger till alla filer och kataloger rekursivt i den angivna katalogen i arkivet.

```

try (FileOutputStream tarFile = new FileOutputStream(“archive.tar”)) { try (TarArchive archive = new TarArchive()) { archive.createEntries(“C:\folder”, false); archive.save(tarFile); } } catch (IOException ex) { System.out.println(ex); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| sourceDirectory | java.lang.String | directory to compress |
| includeRootDirectory | boolean | indicates whether to include the root directory itself or not |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with entries composed
### createEntry(String name, File file) {#createEntry-java.lang.String-java.io.File-}

public final TarEntry createEntry(String name, File file)

Creates a single entry within the archive.

     File fi = new File("data.bin");
     try (TarArchive archive = new TarArchive()) {
         archive.createEntry("data.bin", fi);
         archive.save(tarFile);
     }
 
```

Postnamnet sätts enbart i `name`-parametern. Filnamnet som anges i `file`-parametern påverkar inte postnamnet.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| namn | java.lang.String | namnet på posten |
| file | java.io.File | metadata för fil eller mapp som ska komprimeras |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### createEntry(String name, File file, boolean openImmediately) {#createEntry-java.lang.String-java.io.File-boolean-}
```
public final TarEntry createEntry(String name, File file, boolean openImmediately)
```


Skapar en enskild post i arkivet.

```

File fi = new File(“data.bin”); try (TarArchive archive = new TarArchive()) { archive.createEntry(“data.bin”, fi); archive.save(tarFile); }

The entry name is solely set within `name` parameter. The file name provided in `file` parameter does not affect the entry name.

If the file is opened immediately with `openImmediately` parameter it becomes blocked until archive is disposed.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| name | java.lang.String | the name of the entry |
| file | java.io.File | the metadata of file or folder to be compressed |
| openImmediately | boolean | true, if open the file immediately, otherwise open the file on archive saving |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### createEntry(String name, InputStream source) {#createEntry-java.lang.String-java.io.InputStream-}

public final TarEntry createEntry(String name, InputStream source)

Creates a single entry within the archive.

     try (TarArchive archive = new TarArchive()) {
         archive.createEntry("bytes", new ByteArrayInputStream(new byte[] {0x00, (byte) 0xFF}));
         archive.save(tarFile);
     }
 
```

Postnamnet sätts enbart i `name`-parametern.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| namn | java.lang.String | namnet på posten |
| source | java.io.InputStream | indataströmmen för posten |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### createEntry(String name, InputStream source, File file) {#createEntry-java.lang.String-java.io.InputStream-java.io.File-}
```
public final TarEntry createEntry(String name, InputStream source, File file)
```


Skapar en enskild post i arkivet.

```

try (TarArchive archive = new TarArchive()) { archive.createEntry(“bytes”, new ByteArrayInputStream(new byte[] {0x00, (byte) 0xFF})); archive.save(tarFile); }

The entry name is solely set within `name` parameter. The file name provided in `file` parameter does not affect the entry name.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| name | java.lang.String | the name of the entry |
| source | java.io.InputStream | the input stream for the entry |
| file | java.io.File | the metadata of file or folder to be compressed |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### createEntry(String name, String path) {#createEntry-java.lang.String-java.lang.String-}

public final TarEntry createEntry(String name, String path)

Creates a single entry within the archive.

     try (TarArchive archive = new TarArchive()) {
             archive.createEntry(first.bin, "data.bin");
             archive.save(outputTarFile);
     }
 
```

Postnamnet sätts enbart i `name`-parametern. Filnamnet som anges i `path`-parametern påverkar inte postnamnet.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| namn | java.lang.String | namnet på posten |
| path | java.lang.String | sökväg till fil som ska komprimeras |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### createEntry(String name, String path, boolean openImmediately) {#createEntry-java.lang.String-java.lang.String-boolean-}
```
public final TarEntry createEntry(String name, String path, boolean openImmediately)
```


Skapar en enskild post i arkivet.

```

try (TarArchive archive = new TarArchive()) { archive.createEntry(first.bin, “data.bin”); archive.save(outputTarFile); }

The entry name is solely set within `name` parameter. The file name provided in `path` parameter does not affect the entry name.

If the file is opened immediately with `openImmediately` parameter it becomes blocked until archive is disposed.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| name | java.lang.String | the name of the entry |
| path | java.lang.String | path to file to be compressed |
| openImmediately | boolean | true, if open the file immediately, otherwise open the file on archive saving |

**Returns:**
[TarEntry](../../com.aspose.zip/tarentry) - Tar entry instance
### deleteEntry(TarEntry entry) {#deleteEntry-com.aspose.zip.TarEntry-}

public final TarArchive deleteEntry(TarEntry entry)

Removes the first occurrence of a specific entry from the entry list.

Here is how you can remove all entries except the last one:

     try (TarArchive archive = new TarArchive("archive.tar")) {
         while (archive.getEntries().size() > 1)
             archive.deleteEntry(archive.getEntries().get_Item(0));
         archive.save(outputTarFile);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| entry | [TarEntry](../../com.aspose.zip/tarentry) | posten att ta bort från postlistan |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with the entry deleted
### deleteEntry(int entryIndex) {#deleteEntry-int-}
```
public final TarArchive deleteEntry(int entryIndex)
```


Tar bort posten från postlistan efter index.

```

try (TarArchive archive = new TarArchive(“two_files.tar”)) { archive.deleteEntry(0); archive.save(“single_file.tar”); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| entryIndex | int | the zero-based index of the entry to remove |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - the archive with the entry deleted
### extractToDirectory(String destinationDirectory) {#extractToDirectory-java.lang.String-}

public final void extractToDirectory(String destinationDirectory)

Extracts all the files in the archive to the directory provided.

     try (TarArchive archive = new TarArchive("archive.tar")) {
         archive.extractToDirectory("C:\\extracted");
     }
 
```

Om katalogen inte finns kommer den att skapas.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| destinationDirectory | java.lang.String | sökvägen till katalogen där de extraherade filerna ska placeras |

### fromGZip(InputStream source) {#fromGZip-java.io.InputStream-}
```
public static TarArchive fromGZip(InputStream source)
```


Extraherar angivet gzip-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: gzip-arkivet extraheras helt inom denna metod, dess innehåll hålls internt. Var medveten om minnesanvändning.

GZip-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet erbjuder möjlighet att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromGZip(String path) {#fromGZip-java.lang.String-}
```
public static TarArchive fromGZip(String path)
```


Extraherar angivet gzip-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: gzip-arkivet extraheras helt inom denna metod, dess innehåll hålls internt. Var medveten om minnesanvändning.

GZip-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet erbjuder möjlighet att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZ4(InputStream source) {#fromLZ4-java.io.InputStream-}
```
public static TarArchive fromLZ4(InputStream source)
```


Extraherar angivet LZ4-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: LZ4-arkivet extraheras helt inom denna metod, dess innehåll hålls internt. Var medveten om minnesanvändning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | source | java.io.InputStream | Källan till arkivet. |

LZ4-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - An instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZ4(String path) {#fromLZ4-java.lang.String-}
```
public static TarArchive fromLZ4(String path)
```


Extraherar angivet LZ4-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: LZ4-arkivet extraheras helt inom denna metod, dess innehåll hålls internt. Var medveten om minnesanvändning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | path | java.lang.String | Sökvägen till arkivfilen. |

LZ4-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - An instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZMA(InputStream source) {#fromLZMA-java.io.InputStream-}
```
public static TarArchive fromLZMA(InputStream source)
```


Extraherar angivet LZMA-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: LZMA-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

LZMA-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZMA(String path) {#fromLZMA-java.lang.String-}
```
public static TarArchive fromLZMA(String path)
```


Extraherar angivet LZMA-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: LZMA-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

LZMA-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZip(InputStream source) {#fromLZip-java.io.InputStream-}
```
public static TarArchive fromLZip(InputStream source)
```


Extraherar angivet lzip-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: lzip-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

Lzip-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromLZip(String path) {#fromLZip-java.lang.String-}
```
public static TarArchive fromLZip(String path)
```


Extraherar angivet lzip-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: lzip-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

Lzip-extraktionsström är inte sökbar på grund av komprimeringsalgoritmens natur. Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen. |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromXz(InputStream source) {#fromXz-java.io.InputStream-}
```
public static TarArchive fromXz(InputStream source)
```


Extraherar angivet xz-formatarkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: xz-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromXz(String path) {#fromXz-java.lang.String-}
```
public static TarArchive fromXz(String path)
```


Extraherar angivet xz-formatarkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: xz-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

Tar-arkivet tillhandahåller en funktion för att extrahera godtycklig post, så det måste arbeta med en sökbar ström under huven.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromZ(InputStream source) {#fromZ-java.io.InputStream-}
```
public static TarArchive fromZ(InputStream source)
```


Extraherar angivet Z-formatarkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: Z-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromZ(String path) {#fromZ-java.lang.String-}
```
public static TarArchive fromZ(String path)
```


Extraherar angivet Z-formatarkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: Z-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromZstandard(InputStream source) {#fromZstandard-java.io.InputStream-}
```
public static TarArchive fromZstandard(InputStream source)
```


Extraherar angivet Zstandard-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: Zstandard-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| source | java.io.InputStream | källan till arkivet |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### fromZstandard(String path) {#fromZstandard-java.lang.String-}
```
public static TarArchive fromZstandard(String path)
```


Extraherar angivet Zstandard-arkiv och skapar ett [TarArchive](../../com.aspose.zip/tararchive) från den extraherade datan.

Viktigt: Zstandard-arkivet extraheras helt inom denna metod, dess innehåll lagras internt. Se upp för minnesförbrukning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivfilen |

**Returns:**
[TarArchive](../../com.aspose.zip/tararchive) - an instance of [TarArchive](../../com.aspose.zip/tararchive)
### getEntries() {#getEntries--}
```
public final List<TarEntry> getEntries()
```


Hämtar poster av typen [TarEntry](../../com.aspose.zip/tarentry) som utgör arkivet.

**Returns:**
java.util.List&lt;com.aspose.zip.TarEntry&gt; - poster av typen [TarEntry](../../com.aspose.zip/tarentry) som utgör arkivet
### getFileEntries() {#getFileEntries--}
```
public final Iterable<IArchiveFileEntry> getFileEntries()
```


Hämtar poster av typen [IArchiveFileEntry](../../com.aspose.zip/iarchivefileentry) som utgör tar-arkivet.

**Returns:**
java.lang.Iterable&lt;com.aspose.zip.IArchiveFileEntry&gt; - poster av typen [IArchiveFileEntry](../../com.aspose.zip/iarchivefileentry) som utgör tar-arkivet
### getFormat() {#getFormat--}
```
public final ArchiveFormat getFormat()
```


Hämtar arkivformatet.

**Returns:**
[ArchiveFormat](../../com.aspose.zip/archiveformat) - the archive format
### save(OutputStream output) {#save-java.io.OutputStream-}
```
public final void save(OutputStream output)
```


Sparar arkivet till den angivna strömmen.

```

try (FileOutputStream tarFile = new FileOutputStream(“archive.tar”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry("entry1", "data.bin"); archive.save(tarFile); } } catch (IOException ex) { System.out.println(ex); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output` must be writable |

### save(OutputStream output, TarFormat format) {#save-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void save(OutputStream output, TarFormat format)

Saves archive to the stream provided.

     try (FileOutputStream tarFile = new FileOutputStream("archive.tar")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry1", "data.bin");
             archive.save(tarFile);
         }
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output` måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### save(String destinationFileName) {#save-java.lang.String-}
```
public final void save(String destinationFileName)
```


Sparar arkivet till den angivna destinationsfilen.

```

try (TarArchive archive = new TarArchive()) { archive.createEntry("entry1", "data.bin"); archive.save(“myarchive.tar”); }

It is possible to save an archive to the same path as it was loaded from. However, this is not recommended because this approach uses copying to a temporary file

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| destinationFileName | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten. |

### save(String destinationFileName, TarFormat format) {#save-java.lang.String-com.aspose.zip.TarFormat-}

public final void save(String destinationFileName, TarFormat format)

Saves archive to the destination file provided.

     try (TarArchive archive = new TarArchive()) {
         archive.createEntry("entry1", "data.bin");
         archive.save("myarchive.tar");
     }
 
```

Det är möjligt att spara ett arkiv till samma sökväg som det laddades från. Detta rekommenderas dock inte eftersom detta tillvägagångssätt använder kopiering till en temporär fil

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| destinationFileName | java.lang.String | sökvägen för arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över. |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveGzipped(OutputStream output) {#saveGzipped-java.io.OutputStream-}
```
public final void saveGzipped(OutputStream output)
```


Sparar arkivet till strömmen med gzip-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.gz”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveGzipped(result); } } } catch (IOException ex) { System.out.println(ex); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output` must be writable |

### saveGzipped(OutputStream output, TarFormat format) {#saveGzipped-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveGzipped(OutputStream output, TarFormat format)

Saves archive to the stream with gzip compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.gz")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveGzipped(result);
             }
         }
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output` måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveGzipped(String path) {#saveGzipped-java.lang.String-}
```
public final void saveGzipped(String path)
```


Sparar arkivet till filen via sökväg med gzip-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveGzipped(“result.tar.gz”); } } catch (IOException ex) { System.out.println(ex); }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |

### saveGzipped(String path, TarFormat format) {#saveGzipped-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveGzipped(String path, TarFormat format)

Saves archive to the file by path with gzip compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveGzipped("result.tar.gz");
         }
     } catch (IOException ex) {
         System.out.println(ex);
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveLZ4Compressed(OutputStream output) {#saveLZ4Compressed-java.io.OutputStream-}
```
public final void saveLZ4Compressed(OutputStream output)
```


Sparar arkivet till strömmen med LZ4-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.lz4”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLZ4Compressed(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | Destination stream. |

### saveLZ4Compressed(OutputStream output, TarFormat format) {#saveLZ4Compressed-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveLZ4Compressed(OutputStream output, TarFormat format)

Saves archive to the stream with LZ4 compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.lz4")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveLZ4Compressed(result);
             }
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| utdata | java.io.OutputStream | Destinationsström. |
| format | [TarFormat](../../com.aspose.zip/tarformat) | Definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt. |

### saveLZ4Compressed(String path) {#saveLZ4Compressed-java.lang.String-}
```
public final void saveLZ4Compressed(String path)
```


Sparar arkivet till filen via sökväg med LZ4-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLZ4Compressed(“result.tar.lz4”); } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | The path of the archive to be created. If the specified file name points to an existing file, it will be overwritten. |

### saveLZ4Compressed(String path, TarFormat format) {#saveLZ4Compressed-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveLZ4Compressed(String path, TarFormat format)

Saves archive to the file by path with LZ4 compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveLZ4Compressed("result.tar.lz4");
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | Sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över. |
| format | [TarFormat](../../com.aspose.zip/tarformat) | Definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt. |

### saveLZMACompressed(OutputStream output) {#saveLZMACompressed-java.io.OutputStream-}
```
public final void saveLZMACompressed(OutputStream output)
```


Sparar arkivet till strömmen med LZMA-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.lzma”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLZMACompressed(result); } } } catch (IOException ex) { }

Important: tar archive is composed then compressed within this method, its content is kept internally. Beware of memory consumption.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output` must be writable |

### saveLZMACompressed(OutputStream output, TarFormat format) {#saveLZMACompressed-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveLZMACompressed(OutputStream output, TarFormat format)

Saves archive to the stream with LZMA compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.lzma")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveLZMACompressed(result);
             }
         }
     } catch (IOException ex) {
     }
 
```

Viktigt: tar-arkivet skapas och komprimeras sedan inom denna metod, dess innehåll hålls internt. Se upp för minnesanvändning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output` måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveLZMACompressed(String path) {#saveLZMACompressed-java.lang.String-}
```
public final void saveLZMACompressed(String path)
```


Sparar arkivet till filen via sökväg med lzma-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLZMACompressed(“result.tar.lzma”); } } catch (IOException ex) { }

Important: tar archive is composed then compressed within this method, its content is kept internally. Beware of memory consumption.

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |

### saveLZMACompressed(String path, TarFormat format) {#saveLZMACompressed-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveLZMACompressed(String path, TarFormat format)

Saves archive to the file by path with lzma compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveLZMACompressed("result.tar.lzma");
         }
     } catch (IOException ex) {
     }
 
```

Viktigt: tar-arkivet skapas och komprimeras sedan inom denna metod, dess innehåll hålls internt. Se upp för minnesanvändning.

**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveLzipped(OutputStream output) {#saveLzipped-java.io.OutputStream-}
```
public final void saveLzipped(OutputStream output)
```


Sparar arkivet till strömmen med lzip-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.lz”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLzipped(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output` must be writable |

### saveLzipped(OutputStream output, TarFormat format) {#saveLzipped-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveLzipped(OutputStream output, TarFormat format)

Saves archive to the stream with lzip compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.lz")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveLzipped(result, TarFormat.Gnu);
             }
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output` måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveLzipped(String path) {#saveLzipped-java.lang.String-}
```
public final void saveLzipped(String path)
```


Sparar arkivet till filen via sökväg med lzip-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveLzipped(“result.tar.lz”); } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |

### saveLzipped(String path, TarFormat format) {#saveLzipped-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveLzipped(String path, TarFormat format)

Saves archive to the file by path with lzip compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveLzipped("result.tar.lz", TarFormat.Gnu);
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveXzCompressed(OutputStream output) {#saveXzCompressed-java.io.OutputStream-}
```
public final void saveXzCompressed(OutputStream output)
```


Sparar arkivet till strömmen med xz-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.xz”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveXzCompressed(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output`The stream must be writable |

### saveXzCompressed(OutputStream output, TarFormat format) {#saveXzCompressed-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveXzCompressed(OutputStream output, TarFormat format)

Saves archive to the stream with xz compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.xz")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveXzCompressed(result);
             }
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output`Strömmen måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveXzCompressed(OutputStream output, TarFormat format, XzArchiveSettings settings) {#saveXzCompressed-java.io.OutputStream-com.aspose.zip.TarFormat-com.aspose.zip.XzArchiveSettings-}
```
public final void saveXzCompressed(OutputStream output, TarFormat format, XzArchiveSettings settings)
```


Sparar arkivet till strömmen med xz-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.xz”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveXzCompressed(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output`The stream must be writable |
| format | [TarFormat](../../com.aspose.zip/tarformat) | defines the tar header format. Null value will be treated as USTar when possible |
| settings | [XzArchiveSettings](../../com.aspose.zip/xzarchivesettings) | set of setting particular xz archive: dictionary size, block size, check type |

### saveXzCompressed(String path) {#saveXzCompressed-java.lang.String-}

public final void saveXzCompressed(String path)

Saves archive to the file by path with xz compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveXzCompressed("result.tar.xz");
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |

### saveXzCompressed(String path, TarFormat format) {#saveXzCompressed-java.lang.String-com.aspose.zip.TarFormat-}
```
public final void saveXzCompressed(String path, TarFormat format)
```


Sparar arkivet till filen via sökväg med xz-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveXzCompressed(“result.tar.xz”); } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |
| format | [TarFormat](../../com.aspose.zip/tarformat) | defines tar header format. Null value will be treated as USTar when possible |

### saveXzCompressed(String path, TarFormat format, XzArchiveSettings settings) {#saveXzCompressed-java.lang.String-com.aspose.zip.TarFormat-com.aspose.zip.XzArchiveSettings-}

public final void saveXzCompressed(String path, XzArchiveSettings settings)

Saves archive to the file by path with xz compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveXzCompressed("result.tar.xz");
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |
| settings | [XzArchiveSettings](../../com.aspose.zip/xzarchivesettings) | uppsättning av specifika inställningar för xz-arkivet: ordboksstorlek, blockstorlek, kontrolltyp |

### saveZCompressed(OutputStream output) {#saveZCompressed-java.io.OutputStream-}
```
public final void saveZCompressed(OutputStream output)
```


Sparar arkivet till strömmen med Z-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.Z”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveZCompressed(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | the destination stream |

### saveZCompressed(OutputStream output, TarFormat format) {#saveZCompressed-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveZCompressed(OutputStream output, TarFormat format)

Saves archive to the stream with Z compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.Z")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveZCompressed(result);
             }
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| utdata | java.io.OutputStream | destinationsströmmen |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveZCompressed(String path) {#saveZCompressed-java.lang.String-}
```
public final void saveZCompressed(String path)
```


Sparar arkivet till filen via sökväg med Z-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveZCompressed(“result.tar.Z”); } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |

### saveZCompressed(String path, TarFormat format) {#saveZCompressed-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveZCompressed(String path, TarFormat format)

Saves archive to the file by path with Z compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveZCompressed("result.tar.Z");
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveZstandard(OutputStream output) {#saveZstandard-java.io.OutputStream-}
```
public final void saveZstandard(OutputStream output)
```


Sparar arkivet till strömmen med Zstandard-komprimering.

```

try (FileOutputStream result = new FileOutputStream(“result.tar.zst”)) { try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveZstandard(result); } } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| output | java.io.OutputStream | destination stream.

`output` must be writable |

### saveZstandard(OutputStream output, TarFormat format) {#saveZstandard-java.io.OutputStream-com.aspose.zip.TarFormat-}

public final void saveZstandard(OutputStream output, TarFormat format)

Saves archive to the stream with Zstandard compression.

     try (FileOutputStream result = new FileOutputStream("result.tar.zst")) {
         try (FileInputStream source = new FileInputStream("data.bin")) {
             try (TarArchive archive = new TarArchive()) {
                 archive.createEntry("entry.bin", source);
                 archive.saveZstandard(result);
             }
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
|  | utdata | java.io.OutputStream | destinationsström. |

`output` måste vara skrivbar |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |

### saveZstandard(String path) {#saveZstandard-java.lang.String-}
```
public final void saveZstandard(String path)
```


Sparar arkivet till filen via sökväg med Zstandard-komprimering.

```

try (FileInputStream source = new FileInputStream(“data.bin”)) { try (TarArchive archive = new TarArchive()) { archive.createEntry(“entry.bin”, source); archive.saveZstandard(“result.tar.zst”); } } catch (IOException ex) { }

**Parameters:**
| Parameter | Type | Description |
| --- | --- | --- |
| path | java.lang.String | the path of the archive to be created. If the specified file name points to an existing file, it will be overwritten |

### saveZstandard(String path, TarFormat format) {#saveZstandard-java.lang.String-com.aspose.zip.TarFormat-}

public final void saveZstandard(String path, TarFormat format)

Saves archive to the file by path with Zstandard compression.

     try (FileInputStream source = new FileInputStream("data.bin")) {
         try (TarArchive archive = new TarArchive()) {
             archive.createEntry("entry.bin", source);
             archive.saveZstandard("result.tar.zst");
         }
     } catch (IOException ex) {
     }
 
```



**Parameters:**
| Parameter | Typ | Beskrivning |
| --- | --- | --- |
| path | java.lang.String | sökvägen till arkivet som ska skapas. Om det angivna filnamnet pekar på en befintlig fil kommer den att skrivas över |
| format | [TarFormat](../../com.aspose.zip/tarformat) | definierar tar-huvudformatet. Nullvärde kommer att behandlas som USTar när det är möjligt |