| Types java app |
|---|
| Data Types and Operators |
|---|
| (Primitive Data Types) |
|---|
| (Non-Primitive Data Types) |
|---|
| Control Flow Statements |
|---|
| Conditional Statements |
|---|
| Looping Statements |
|---|
| Branching Statements |
|---|
| Object-Oriented Programming (OOP) |
|---|
| Classes and Objects |
|---|
| Inheritance |
|---|
| Polymorphism |
|---|
| Encapsulation |
|---|
| Abstraction |
|---|
| Exception Handling |
|---|
| Introduction to Exceptions |
|---|
| Collections Framework |
|---|
| Overview of Collections |
|---|
| Commonly Used Collections |
|---|
| Iterators |
|---|
| Java I/O |
|---|
| File Handling |
|---|
| Serialization |
|---|
| Multithreading |
|---|
| Introduction to Threads |
|---|
| Thread Synchronization |
|---|
| GUI Programming with Swing |
|---|
| Introduction to Swing |
|---|
| Event Handling |
|---|
| Advanced Topics |
|---|
| Java Database Connectivity (JDBC) |
|---|
| JAVA CODE |
|---|
|
Java Basics
|
|
Working with Objects
|
|
Arrays, Conditionals, and Loops
|
|
Creating Classes and Applications in Java
|
|
More About Methods
|
|
Java Applet Basics
|
|
Graphics, Fonts, and Color
|
|
Simple Animation and Threads
|
|
More Animation, Images, and Sound
|
|
Managing Simple Events and Interactivity
|
|
Creating User Interfaces with the awt
|
|
Windows, Networking, and Other Tidbits
|
|
Modifiers, Access Control, and Class Design
|
|
Packages and Interfaces
|
|
Exceptions
|
|
Multithreading
|
|
Streams and I/O
|
|
Using Native Methods and Libraries
|
|
Under the Hood
|
|
Java Programming Tools
|
|
Working with Data Structures in Java
|
|
Advanced Animation and Media
|
|
Fun with Image Filters
|
|
Client/Server Networking in Java
|
|
Emerging Technologies
|
|
appendix A :- Language Summary
|
|
appendix B :- Class Hierarchy Diagrams
|
|
appendix C The Java Class Library
|
|
appendix D Bytecodes Reference
|
|
appendix E java.applet Package Reference
|
|
appendix F java.awt Package Reference
|
|
appendix G java.awt.image Package Reference
|
|
appendix H java.awt.peer Package Reference
|
|
appendix I java.io Package Reference
|
|
appendix J java.lang Package Reference
|
|
appendix K java.net Package Reference
|
|
appendix L java.util Package Reference
|
File handling in Java is essential for many applications, allowing programs to read from and write to files on the file system. Java provides the ‘java.io‘ package for file I/O operations, including classes like ‘File‘, ‘FileReader‘, ‘FileWriter‘, ‘BufferedReader‘, ‘BufferedWriter‘, and ‘Files‘.
Reading Files
Using 'FileReader' and 'BufferedReader'
‘FileReader‘ is a class used to read the contents of a file as a stream of characters. To improve efficiency, it is often wrapped with ‘BufferedReader‘.
Here's an example of reading a file line by line using 'BufferedReader':
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FileReadExample {
public static void main(String[] args) {
String filePath = "example.txt";
try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Using Files Class
Java 7 introduced the ‘java.nio.file‘ package, which provides the ‘Files‘ class for reading and writing files. This class simplifies many common file operations.
Here's an example of reading all lines from a file using the 'Files' class:
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.io.IOException;
public class FileReadExampleNIO {
public static void main(String[] args) {
String filePath = "example.txt";
try {
List<String> lines = Files.readAllLines(Paths.get(filePath));
for (String line : lines) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Writing Files
Using 'FileWriter' and 'BufferedWriter'
‘FileWriter‘ is a class used to write characters to a file. To improve efficiency, it is often wrapped with ‘BufferedWriter‘.
Here's an example of writing to a file using 'BufferedWriter':
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriteExample {
public static void main(String[] args) {
String filePath = "output.txt";
try (BufferedWriter bw = new BufferedWriter(new FileWriter(filePath))) {
bw.write("Hello, World!");
bw.newLine();
bw.write("This is a second line.");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Using Files Class
The Files class also provides methods for writing to files. Here's an example:
import java.nio.file.Files;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
public class FileWriteExampleNIO {
public static void main(String[] args) {
String filePath = "output.txt";
List<String> lines = Arrays.asList("Hello, World!", "This is a second line.");
try {
Files.write(Paths.get(filePath), lines);
} catch (IOException e) {
e.printStackTrace();
}
}
}
File Handling with File Class
The ‘File‘ class provides methods to work with file attributes, file creation, deletion, and directory operations.
Example: Checking if a File Exists and Getting File Information
import java.io.File;
public class FileExample {
public static void main(String[] args) {
File file = new File("example.txt");
if (file.exists()) {
System.out.println("File name: " + file.getName());
System.out.println("Absolute path: " + file.getAbsolutePath());
System.out.println("Writeable: " + file.canWrite());
System.out.println("Readable: " + file.canRead());
System.out.println("File size in bytes: " + file.length());
} else {
System.out.println("The file does not exist.");
}
}
}
Example: Creating and Deleting a File
import java.io.File;
import java.io.IOException;
public class CreateDeleteFileExample {
public static void main(String[] args) {
File file = new File("newfile.txt");
try {
if (file.createNewFile()) {
System.out.println("File created: " + file.getName());
} else {
System.out.println("File already exists.");
}
if (file.delete()) {
System.out.println("Deleted the file: " + file.getName());
} else {
System.out.println("Failed to delete the file.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
These examples cover the basics of reading and writing files in Java. Depending on your needs, you can choose different classes and methods provided by the ‘java.io‘ and ‘java.nio.file‘ packages to handle files more efficiently and effectively.
