1. Overview
We’ve learned about getting class names from a JAR file. Further, in that tutorial, we’ve discussed how to get the classes’ names in a JAR file in a Java application.
In this tutorial, we’ll learn another way to list a JAR file’s content from the command-line.
We’ll also see several GUI tools for viewing more detailed contents of a JAR file — for example, the Java source code.
2. Example JAR File
In this tutorial, we’ll still take the stripe-0.0.1-SNAPSHOT.jar file as an example to address how to view the content in a JAR file:
3. Reviewing the jar Command
We’ve learned that we can use the jar command shipped with the JDK to check the content of a JAR file:
$ jar tf stripe-0.0.1-SNAPSHOT.jar
META-INF/
META-INF/MANIFEST.MF
...
templates/result.html
templates/checkout.html
application.properties
com/baeldung/stripe/StripeApplication.class
com/baeldung/stripe/ChargeRequest.class
com/baeldung/stripe/StripeService.class
com/baeldung/stripe/ChargeRequest$Currency.class
If we want to filter the output to get only the information we want, for example, class names or properties files, we can pipe the output to filter tools such as grep.
The jar command is pretty convenient to use if our system has a JDK installed.
However, sometimes, we want to examine a JAR file’s content on a system without a JDK installed. In this case, the jar command is not available.
We’ll take a look at this next.
4. Using the unzip Command
JAR files are packaged in the ZIP file format. In other words, if a utility can read a ZIP file, we can use it to view a JAR file as well.
The unzip command is a commonly used utility for working with ZIP files from the Linux command-line.
Therefore, we can use the -l option of the unzip command to list the content of a JAR file without extracting it:
$ unzip -l stripe-0.0.1-SNAPSHOT.jar
Archive: stripe-0.0.1-SNAPSHOT.jar
Length Date Time Name
--------- ---------- ----- ----
0 2020-10-16 20:53 META-INF/
...
137 2020-10-16 20:53 static/index.html
677 2020-10-16 20:53 templates/result.html
1323 2020-10-16 20:53 templates/checkout.html
37 2020-10-16 20:53 application.properties
715 2020-10-16 20:53 com/baeldung/stripe/StripeApplication.class
3375 2020-10-16 20:53 com/baeldung/stripe/ChargeRequest.class
2033 2020-10-16 20:53 com/baeldung/stripe/StripeService.class
1146 2020-10-16 20:53 com/baeldung/stripe/ChargeRequest$Currency.class
2510 2020-10-16 20:53 com/baeldung/stripe/ChargeController.class
1304 2020-10-16 20:53 com/baeldung/stripe/CheckoutController.class
...
--------- -------
15394 23 files
Thanks to the unzip command, we can view the content of a JAR file without the JDK.
The output above is pretty clear. It lists the files in the JAR file in a tabular format.
5. Exploring JAR Files Using GUI Utilities
Both the jar and the unzip commands are handy, but they only list the filenames in a JAR file.
Sometimes, we would like to know more information about files in the JAR file, for example, examining the Java source code of a class.
In this section, we’ll introduce several platform-independent GUI tools to help us to look at files inside a JAR file.
5.1. Using JD-GUI
First, let’s have a look at JD-GUI.
The JD-GUI is a nice open-source GUI utility to explore Java source code decompiled by the Java decompiler JD-Core.
JD-GUI ships a JAR file. We can start the utility by using the java command with the -jar option, for instance:
$ java -jar jd-gui-1.6.6.jar
When we see the main window of JD-GUI, we can either open our JAR file by navigating the menu “File -> Open File…” or just drag-and-drop the JAR file in the window.
Once we open a JAR file, all the classes in the JAR file will be decompiled.
Then we can select the files we’re interested in on the left side to examine their source code:
As we can see in the above demo, in the outline on the left side, the classes and the members of each class such as methods and fields are listed, too, just like we usually see in an IDE.
It’s pretty handy to locate methods or fields, particularly when we need to check some classes with many lines of code.
When we click through different classes on the left side, each class will be opened in a tab on the right side.
The tab feature is helpful if we need to switch among several classes.
5.2. Using Jar Explorer
Jar Explorer is another open-source GUI tool for viewing the contents of JAR files. It ships a jar file and a start script “Jar Explorer.sh“. It also supports the drag-and-drop feature, making opening a JAR file pretty easy.
Another nice feature provided by Jar Explorer is that it supports three different Java decompilers: JD-Core, Procyon, and Fernflower.
We can switch among the decompilers when we examine source code:
Jar Explorer is pretty easy to use. The decompiler switching feature is nice, too. However, the outline on the left side stops at the class level.
Also, since Jar Explorer doesn’t provide the tab feature, we can only open a single file at a time.
Moreover, every time we select a class on the left side, the class will be decompiled by the currently selected decompiler.
5.3. Using Luyten
Luyten is a nice open-source GUI utility for Java decompiler Procyon that provides downloads for different platforms, for example, the .exe format and the JAR format.
Once we’ve downloaded the JAR file, we can start Luyten using the java -jar command:
$ java -jar luyten-0.5.4.jar
We can drag and drop our JAR file into Luyten and explore the contents in the JAR file:
Using Luyten, we cannot choose different Java decompilers. But, as the demo above shows, Luyten provides various options for decompiling. Also, we can open multiple files in tabs.
Apart from that, Luyten supports a nice theme system, and we can choose a comfortable theme while examining the source codes.
However, Luyten lists the structure of the JAR file only to the file level.
6. Conclusion
In this article, we’ve learned how to list files in a JAR file from the command-line. Later, we’ve seen three GUI utilities to view more detailed contents of a JAR file.
If we want to decompile the classes and examine the JAR file’s source code, picking a GUI tool may be the most straightforward approach.