Unzip into TreeMap in Java

My question is relativly simple. Does anybody know a free library (LGPL) that is capable of unzipping a zipped file structure into a TreeMap (or a similar iteratable structure) fo开发者_StackOverflow社区r Java?

Point is, that I could do this myself, but I don't want to reinvent already good riding wheels :)

Thanks in advance!

So my thing is, that i have a zip file, containing multiple files and directories which may contain more files. What i am looking for is a convinient way how to extract this tree structure into an object graph, whether it's a TreeMap or not. So for example: a HashMap : {'root' => 'HashMap : {'file1.png' => byte[] content}}

So my thing is, that i have a zip file, containing multiple files and directories which may contain more files. What i am looking for is a convinient way how to extract this tree structure into an object graph, whether it's a TreeMap or not. So for example: a HashMap : {'root', 'HashMap : {'file1.png' => byte[] content}}

As I answered some time ago on another question, there is no single "tree" data structure (tree interface) in the Java API, since every use needs other features. Your proposed HashMap-tree, for example, is not realizable in a type-save way - you would need wrapper objects somewhere.

I don't know if somewhere out there is already a tree-like view of a zip file, to (not) answer your question, but it is not really difficult to create as soon as you define your wished tree interface.

So, here is an example class which does what you want (from what I understand).

import java.io.*;
import java.util.*;
import java.util.zip.*;

/**
 * A immutable wrapper around {@link ZipEntry} allowing
 * simple access of the childs of directory entries.
 */
public class ZipNode {

    private ZipNode parent;
    private Map<String,ZipNode> children;
    private boolean directory;

    /**
     * the corresponding Zip entry. If null, this is the root entry.
     */
    private ZipEntry entry;

    /** the ZipFile from where the nodes came. */
    private ZipFile file;


    private ZipNode(ZipFile f, ZipEntry entry) {
        this.file = f;
        this.entry = entry;
        if(entry == null || entry.isDirectory()) {
            directory = true;
            children = new LinkedHashMap<String, ZipNode>();
        }
        else {
            directory = false;
            children = Collections.emptyMap();
        }
    }

    /**
     * returns the last component of the name of
     * the entry, i.e. the file name. If this is a directory node,
     * the name ends with '/'. If this is the root node, the name
     * is simply "/".
     */
    public String getName() {
        if(entry == null)
            return "/";
        String longName = entry.getName();
        return longName.substring(longName.lastIndexOf('/',
                                                       longName.length()-2)+1);
    }

    /**
     * gets the corresponding ZipEntry to this node.
     * @return {@code null} if this is the root node (which has no
     *    corresponding entry), else the corresponding ZipEntry.
     */
    public ZipEntry getEntry() {
        return entry;
    }

    /**
     * Gets the ZipFile, from where this ZipNode came.
     */
    public ZipFile getZipFile() {
        return file;
    }

    /**
     * returns true if this node is a directory node.
     */
    public boolean isDirectory() {
        return directory;
    }

    /**
     * returns this node's parent node (null, if this is the root node).
     */
    public ZipNode getParent() {
        return parent;
    }

    /**
     * returns an unmodifiable map of the children of this node,
     * mapping their relative names to the ZipNode objects.
     * (Names of subdirectories end with '/'.)
     * The map is empty if this node is not a directory node.
     */
    public Map<String,ZipNode> getChildren() {
        return Collections.unmodifiableMap(children);
    }

    /**
     * opens an InputStream on this ZipNode. This only works when
     * this is not a directory node, and only before the corresponding
     * ZipFile is closed.
     */
    public InputStream openStream()
        throws IOException
    {
        return file.getInputStream(entry);
    }

    /**
     * a string representation of this ZipNode.
     */
    public String toString() {
        return "ZipNode [" + entry.getName() + "] in [" + file.getName() + "]";
    }



    /**
     * creates a ZipNode tree from a ZipFile
     * and returns the root node.
     *
     * The nodes' {@link #openStream()} methods are only usable until the
     * ZipFile is closed, but the structure information remains valid.
     */
    public static ZipNode fromZipFile(ZipFile zf) {
        return new ZipFileReader(zf).process();
    }


    /**
     * Helper class for {@link ZipNode#fromZipFile}.
     * It helps creating a tree of ZipNodes from a ZipFile.
     */
    private static class ZipFileReader {
        /**
         * The file to be read.
         */
        private ZipFile file;

        /**
         * The nodes collected so far.
         */
        private Map<String, ZipNode> collected;

        /**
         * our root node.
         */
        private ZipNode root;

        /**
         * creates a new ZipFileReader from a ZipFile.
         */
        ZipFileReader(ZipFile f) {
            this.file = f;
            this.collected = new HashMap<String, ZipNode>();
            collected.put("", root);
            root = new ZipNode(f, null);
        }

        /**
         * reads all entries, creates the corresponding Nodes and
         * returns the root node.
         */
        ZipNode process() {
            for(Enumeration<? extends ZipEntry> entries = file.entries();
                entries.hasMoreElements(); ) {
                this.addEntry(entries.nextElement());
            }
            return root;
        }

        /**
         * adds an entry to our tree.
         *
         * This may create a new ZipNode and then connects
         * it to its parent node.
         * @returns the ZipNode corresponding to the entry.
         */
        private ZipNode addEntry(ZipEntry entry) {
            String name = entry.getName();
            ZipNode node = collected.get(name);
            if(node != null) {
                // already in the map
                return node;
            }
            node = new ZipNode(file, entry);
            collected.put(name, node);
            this.findParent(node);
            return node;
        }

        /**
         * makes sure that the parent of a
         * node is in the collected-list as well, and this node is
         * registered as a child of it.
         * If necessary, the parent node is first created
         * and added to the tree.
         */
        private void findParent(ZipNode node) {
            String nodeName = node.entry.getName();
            int slashIndex = nodeName.lastIndexOf('/', nodeName.length()-2);
            if(slashIndex < 0) {
                // top-level-node
                connectParent(root, node, nodeName);
                return;
            }
            String parentName = nodeName.substring(0, slashIndex+1);
            ZipNode parent = addEntry(file.getEntry(parentName));
            connectParent(parent, node, nodeName.substring(slashIndex+1));
        }

        /**
         * connects a parent node with its child node.
         */
        private void connectParent(ZipNode parent, ZipNode child,
                                   String childName) {
            child.parent = parent;
            parent.children.put(childName, child);
        }


    }  // class ZipFileReader

    /**
     * test method. Give name of zip file as command line argument.
     */
    public static void main(String[] params)
        throws IOException
    {
        if(params.length < 1) {
            System.err.println("Invocation:  java ZipNode zipFile.zip");
            return;
        }
        ZipFile file = new ZipFile(params[0]);
        ZipNode root = ZipNode.fromZipFile(file);
        file.close();
        root.printTree("", " ", "");
    }

    /**
     * prints a simple tree view of this ZipNode.
     */
    private void printTree(String prefix,
                           String self,
                           String sub) {
        System.out.println(prefix + self + this.getName());
        String subPrefix = prefix + sub;
        // the prefix strings for the next level.
        String nextSelf = " ├─ ";
        String nextSub =  " │ ";
        Iterator<ZipNode> iterator =
            this.getChildren().values().iterator();
        while(iterator.hasNext()) {
            ZipNode child = iterator.next();
            if(!iterator.hasNext() ) {
                // last item, without the "|"
                nextSelf = " ╰─ ";
                nextSub =  "   ";
            }
            child.printTree(subPrefix, nextSelf, nextSub);
        }
    }
}

It has a main method for test use, its output for one of my jar files is this:

 /
 ├─ META-INF/
 │  ╰─ MANIFEST.MF
 ╰─ de/
    ╰─ fencing_game/
       ├─ start/
       │  ├─ Runner.class
       │  ├─ ServerMain$1.class
       │  ├─ ServerMain.class
       │  ╰─ package-info.class
       ├─ log/
       │  ├─ Log$1.class
       │  ├─ Log.class
       │  ├─ LogImplClient.class
       │  ├─ Loggable.class
       │  ╰─ package-info.class
       ╰─ tools/
          ╰─ load/
             ├─ ServiceTools$1.class
             ├─ ServiceTools$2.class
             ├─ ServiceTools$3.class
             ├─ ServiceTools.class
             ╰─ TwoParentClassLoader.class

(You'll need an unicode-capable Terminal and an Unicode encoding for System.out, though.)

How about java.util.zip.ZipFile? It sounds like a pretty trivial wrapper around that should do what you want.

You can use ZipFile using java.util.ZipFile, get its content and cast current content to java.io.File and check if it is Dir and if so iterate inside that aslo, and you can store these in TreeMap as you go.

ZipFile myzip = new ZipFile (new File("pathToMyZipFile.zip"));
Enumeration zipEnumerator = myzip.entries();
while(zipEnumerator.hasMoreElements())
{
    ZipENtry ze= zipEnumerator.nextElement();
    if(ze.isDirectory())
    {
       // recurse
    }
    else {
       // add it to treeMap
    }
}