Using Libraries in Java
(Example: File Operations and Understanding Different Operations)
Introduction
In Java, libraries are reusable collections of classes and methods. They let developers avoid “reinventing the wheel” by
providing pre-built solutions for common tasks like file handling, networking, collections, and concurrency.
This note will cover:
What libraries are and why they exist
File operations (create, read, write, append, delete)
Who implements library functions
How to find and debug into library source code
Shipping software: what to bundle and what not
Why libraries are called “batteries included”
Best practices in using and managing libraries
What is a Library in Java?
A library is a collection of packages and classes with reusable functionality.
In Java:
Package → Group of related classes (e.g., [Link], [Link]).
Class → Defines attributes and methods (e.g., File, Scanner).
Example Libraries:
Standard Java Library: [Link], [Link], [Link], etc.
Third-Party Libraries: Apache Commons IO, Google Guava, Log4j.
Key Idea: Java ships with a rich standard library, but developers can also use external libraries.
Diagram — How Libraries Fit Into Java
Execution
Here’s a textual diagram to illustrate how your code interacts with libraries, JVM, and OS:
+--------------------------------------------------+
| Your Java Application |
| (Your Classes & Methods) |
+--------------------------------------------------+
| calls
v
+--------------------------------------------------+
| Java Libraries (Standard + External) |
| e.g., [Link], FileWriter, Scanner, etc. |
+--------------------------------------------------+
| executes via
v
+--------------------------------------------------+
| Java Virtual Machine (JVM Bytecode) |
| - Class Loader loads your classes + libraries |
| - Just-In-Time (JIT) Compiler optimizes code |
| - Handles memory, exceptions, garbage collection|
+--------------------------------------------------+
| translates to native calls
v
+--------------------------------------------------+
| Operating System (Windows/Linux/Mac) |
| - File System APIs (create, read, write files) |
| - Network APIs, Threads, Process Management |
+--------------------------------------------------+
File Handling in Java ([Link]
package)
Common Classes
1. File → Represents a file or directory.
2. FileReader / BufferedReader → Reading text.
3. FileWriter / BufferedWriter → Writing text.
4. PrintWriter → Writing formatted text.
5. Scanner (from [Link]) → Alternative for reading files.
File Operations Examples
1. Creating a File
import [Link];
import [Link];
public class CreateFileExample {
public static void main(String[] args) {
try {
File file = new File("[Link]");
if ([Link]()) {
[Link]("File created: " + [Link]());
} else {
[Link]("File already exists.");
}
} catch (IOException e) {
[Link]();
}
}
}
2. Writing to a File
import [Link];
import [Link];
public class WriteFileExample {
public static void main(String[] args) {
try (FileWriter writer = new FileWriter("[Link]")) {
[Link]("Hello, Java File Handling!\n");
[Link]("This is a new line of text.");
} catch (IOException e) {
[Link]();
}
}
}
3. Reading a File
import [Link];
import [Link];
import [Link];
public class ReadFileExample {
public static void main(String[] args) {
try {
File file = new File("[Link]");
Scanner reader = new Scanner(file);
while ([Link]()) {
[Link]([Link]());
}
[Link]();
} catch (FileNotFoundException e) {
[Link]();
}
}
}
4. Appending to a File
import [Link];
import [Link];
public class AppendFileExample {
public static void main(String[] args) {
try (FileWriter writer = new FileWriter("[Link]", true)) {
[Link]("\nAppended line of text.");
} catch (IOException e) {
[Link]();
}
}
}
5. Deleting a File
import [Link];
public class DeleteFileExample {
public static void main(String[] args) {
File file = new File("[Link]");
if ([Link]()) {
[Link]("Deleted: " + [Link]());
} else {
[Link]("Failed to delete.");
}
}
}
Who Implements These Library
Functions?
Standard Libraries: Written and maintained by the OpenJDK team (Oracle + contributors).
Third-Party Libraries: Written by open-source communities (e.g., Apache Foundation, Google) or companies.
Developers: You can also create custom libraries (JARs) and share them.
These functions are not “magic”; they’re just Java classes written by other programmers, tested, and bundled for reuse.
Finding Library Source Code
1. JDK Standard Library
Source code is open and part of OpenJDK.
Local JDK installation usually has [Link] → contains .java files.
Example path: /usr/lib/jvm/java-17-openjdk/[Link]
2. Third-Party Libraries
If open source → available on GitHub/GitLab.
If using Maven/Gradle → download *-[Link].
Can We Debug into Library Code?
Yes
Steps in IntelliJ IDEA / Eclipse:
1. Attach [Link] or *-[Link].
2. Place a breakpoint in your code.
3. Step into a library method (e.g., [Link]()).
4. IDE will show the library’s source.
⚠ Limitation: If source not available, you can still debug bytecode, but variable names may be missing.
Shipping Software — Do We Ship
Libraries Too?
Library Type Ship It?
Java Standard Library ([Link],
No — it comes with the JDK/JRE.
[Link], etc.)
Yes — must bundle them (Uber/Fat JAR,
Third-Party Libraries
libs folder).
Custom Libraries Yes — include your own .jar.
Ways to Bundle
Fat/Uber JAR → all code + dependencies in one .jar.
Dependencies folder → keep separate .jar files.
Self-contained distribution → ship with a private JRE.
Use Maven/Gradle to manage and package dependencies properly.
Purpose of Libraries — “Batteries
Included”
Libraries are meant to:
Save time (no need to re-implement).
Improve reliability (tested code).
Ensure consistency (same implementation everywhere).
Java’s standard library is often called “batteries included” → covers collections, IO, networking, security,
multithreading, math, etc.
Who Writes Library Source Code?
JDK Source → Maintained by OpenJDK developers (Oracle, Red Hat, community).
Apache, Google, etc. → Large open-source organizations maintain reusable libraries.
You → Anyone can write libraries. You package them as .jar files and publish to Maven Central or private
repos.
To see source:
Visit OpenJDK GitHub Repo ([Link]
Visit GitHub/GitLab projects for third-party libraries.
Comparison with Other Languages
Operation Java ([Link]) Python (os, open) C (stdio.h)
Create [Link]() open("[Link]","w") fopen("[Link]","w")
Read Scanner / FileReader open("[Link]","r") fopen("[Link]","r")
Write FileWriter open("[Link]","w") fprintf()
Append FileWriter("[Link]", true) open("[Link]","a") fopen("[Link]","a")
Delete [Link]() [Link]("[Link]") remove("[Link]")
Summary (Skill-Oriented Takeaways)
Libraries are reusable building blocks created by experienced developers.
Source code for Java standard library is open (OpenJDK). Attach source in IDE to debug into it.
When shipping:
Standard library → already included in JDK.
Third-party/custom libraries → must be bundled.
Libraries exist to provide a “batteries included” experience.
Always use dependency managers (Maven/Gradle) to handle which libraries to include.
Knowing how to trace into library source improves debugging and learning.
