Kotlin में ZIP/आर्काइव के साथ काम: बनाना, पढ़ना और निकालना

Kotlin में ZIP/आर्काइव के साथ काम

Kotlin (JVM और Android दोनों के लिए) में आधुनिक डेवलपमेंट में अक्सर फ़ाइलों को ZIP आर्काइव में पैक करना या उनसे डेटा निकालना ज़रूरी हो जाता है। Java की स्टैंडर्ड लाइब्रेरी (java.util.zip) में सभी ज़रूरी क्लासेज़ मौजूद हैं, जो Kotlin में भी बढ़िया काम करती हैं। इस लेख में हम तीन मुख्य ऑपरेशनों को विस्तार से समझेंगे: आर्काइव बनाना, कंटेंट पढ़ना और फ़ाइलें निकालना।

1. ZIP आर्काइव बनाना (फ़ाइलें पैक करना)

आर्काइव बनाने के लिए ZipOutputStream का उपयोग किया जाता है। हर फ़ाइल को एक अलग एंट्री (ZipEntry) के रूप में जोड़ा जाता है। आइए एक उदाहरण देखें जो कई फ़ाइलों को एक आर्काइव में पैक करता है।

import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.util.zip.ZipEntry
import java.util.zip.ZipOutputStream

fun createZip(
    filesToZip: List<File>,
    outputZipFile: File
) {
    ZipOutputStream(FileOutputStream(outputZipFile)).use { zipOut ->
        for (file in filesToZip) {
            // फ़ाइल नाम के साथ एंट्री बनाएँ
            val entry = ZipEntry(file.name)
            zipOut.putNextEntry(entry)

            // मूल फ़ाइल पढ़ें और आर्काइव में लिखें
            FileInputStream(file).use { fis ->
                fis.copyTo(zipOut)
            }
            zipOut.closeEntry()
        }
    }
}

fun main() {
    val files = listOf(
        File("document.txt"),
        File("image.png"),
        File("data.json")
    )
    val archive = File("my_archive.zip")
    createZip(files, archive)
    println("आर्काइव बन गया: ${archive.absolutePath}")
}

ध्यान दें कि .use { ... } का उपयोग किया गया है — यह Java के try-with-resources के समान, रिसोर्सेज़ को सुरक्षित रूप से बंद करता है। अगर आपको सबडायरेक्ट्रीज़ से फ़ाइलें पैक करनी हैं, तो डायरेक्ट्रीज़ को रिकर्सिवली ट्रैवर्स करना होगा और ZipEntry के नाम में रिलेटिव पथ रखना होगा।

2. आर्काइव की सामग्री पढ़ना (फ़ाइलों की सूची देखना)

कभी-कभी बिना निकाले केवल यह देखना होता है कि आर्काइव के अंदर कौन सी फ़ाइलें हैं। इसके लिए ZipFile या ZipInputStream का उपयोग किया जाता है। पहला विकल्प तब सुविधाजनक है जब आर्काइव पहले से मौजूद हो और बहुत बड़ा न हो।

import java.io.File
import java.util.zip.ZipFile

fun listZipContent(zipFile: File) {
    ZipFile(zipFile).use { zip ->
        val entries = zip.entries()
        while (entries.hasMoreElements()) {
            val entry = entries.nextElement()
            println("${entry.name} (${entry.size} बाइट्स)")
        }
    }
}

fun main() {
    val archive = File("my_archive.zip")
    if (archive.exists()) {
        listZipContent(archive)
    } else {
        println("फ़ाइल नहीं मिली")
    }
}

entries() मेथड सभी एंट्रीज़ की एक गणना लौटाता है। प्रत्येक एंट्री के लिए नाम, आकार, संशोधन तिथि और फ़्लैग (जैसे, क्या एंट्री एक डायरेक्ट्री है) उपलब्ध हैं।

3. ZIP आर्काइव को निकालना (फ़ाइलें एक्सट्रैक्ट करना)

फ़ाइलें निकालने के लिए ZipInputStream का उपयोग करना सुविधाजनक है। यह आर्काइव को क्रमिक रूप से, एक एंट्री के बाद एक, पढ़ता है। नीचे दिए गए उदाहरण में निर्दिष्ट फ़ोल्डर में पूरी तरह से निकाला गया है।

import java.io.File
import java.io.FileInputStream
import java.io.FileOutputStream
import java.util.zip.ZipInputStream

fun extractZip(
    zipFile: File,
    outputDir: File
) {
    if (!outputDir.exists()) {
        outputDir.mkdirs()
    }

    ZipInputStream(FileInputStream(zipFile)).use { zis ->
        var entry = zis.nextEntry
        while (entry != null) {
            val targetFile = File(outputDir, entry.name)

            // ज़रूरत पड़ने पर पैरेंट डायरेक्ट्रीज़ बनाएँ
            targetFile.parentFile?.mkdirs()

            // अगर एंट्री एक डायरेक्ट्री है, तो बस इसे बनाएँ
            if (entry.isDirectory) {
                targetFile.mkdirs()
            } else {
                // फ़ाइल निकालें
                FileOutputStream(targetFile).use { fos ->