UNIT 5 – Arrays, Strings and File Handling Notes

By /

Programming is not just about writing instructions—it is about managing data effectively. In Java, three essential building blocks of data management come together in Unit 5: Arrays, Strings, and File Handling. This unit equips learners with the ability to organize large amounts of information, process textual data efficiently, and persist data for future use. From array operations to advanced file input/output, Unit 5 offers skills that bridge academic learning with industry-level programming practices.

Download UNIT 5 – Arrays, Strings and File Handling Notes

Get simplified revision notes for this unit:
Download Unit 5 Notes PDF

Arrays: The Foundation of Structured Data

At its core, an array is a collection of elements of the same type, stored in contiguous memory locations. Arrays allow developers to process bulk data systematically, avoiding repetitive variable declarations.

Declaring and Using Arrays

int[] numbers = {10, 20, 30, 40, 50};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}

This simple loop shows how Java makes handling multiple values easier and more efficient.

Operations on Arrays

Arrays support a variety of operations, such as:

  • Traversal: Iterating through elements with loops.

  • Searching: Finding specific values using linear or binary search.

  • Sorting: Ordering data with algorithms like bubble sort or by using utility methods such as Arrays.sort().

  • Multidimensional Arrays: Storing tabular data in grid form, useful in applications like matrices or board games.

By mastering arrays, learners develop the ability to manage structured data in real-world programs.

Strings: Handling Textual Data

Text is central to most software systems, and in Java, Strings are first-class citizens. A String in Java is an immutable sequence of characters, meaning once created, it cannot be changed.

Common String Operations

String name = "Java Programming";
System.out.println(name.toLowerCase()); // java programming
System.out.println(name.substring(0, 4)); // Java
System.out.println(name.contains("Pro")); // true

Methods such as length(), charAt(), concat(), and equalsIgnoreCase() make Strings versatile for everyday tasks like input validation, searching, and formatting.

StringBuffer and StringBuilder

While Strings are immutable, StringBuffer and StringBuilder classes provide mutable alternatives, allowing modifications without creating new objects.

StringBuffer sb = new StringBuffer("Hello");
sb.append(" World");
System.out.println(sb); // Hello World

  • StringBuffer is thread-safe, making it suitable for multithreaded environments.

  • StringBuilder is faster but not synchronized, perfect for single-threaded operations.

This distinction highlights Java’s balance between safety and performance.

File Handling: Persisting Information

Modern applications must store data for future use—whether it’s saving user preferences, reading configuration files, or logging system activity. Java’s file handling mechanisms allow seamless interaction with the file system.

FileReader and FileWriter

These classes are the basic tools for reading and writing character data:

try {
FileWriter writer = new FileWriter("output.txt");
writer.write("Hello, File Handling!");
writer.close();
} catch (IOException e) {
e.printStackTrace();
}

Similarly, FileReader allows reading character streams from a file.

BufferedReader and BufferedWriter

To improve performance, Java offers buffered streams:

BufferedReader br = new BufferedReader(new FileReader("input.txt"));
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
br.close();

Buffered classes reduce the number of I/O operations by reading and writing chunks of data, making them more efficient for large files.

Serialization: Saving Objects for the Future

Beyond text files, Java also supports serialization—the process of converting an object into a byte stream so it can be saved to disk or transmitted over a network.

import java.io.*;

class Student implements Serializable {
int id;
String name;
Student(int id, String name) {
this.id = id;
this.name = name;
}
}

class Test {
public static void main(String[] args) throws Exception {
Student s1 = new Student(101, “Alice”);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“student.ser”));
out.writeObject(s1);
out.close();
}
}

Serialization allows applications to preserve the state of objects, enabling features like session persistence in web applications and communication in distributed systems.

Why Unit 5 Matters

Arrays, Strings, and File Handling may seem like separate topics, but together they form the data management toolkit of Java programmers. Arrays teach structure, Strings handle the text-rich nature of modern applications, and file handling ensures permanence and continuity.

For example, an e-commerce platform might use arrays to store product IDs in memory, Strings to process customer reviews, and file handling to log transaction histories. Serialization can even save entire shopping carts as objects for future retrieval.

Leave a Comment

Your email address will not be published. Required fields are marked *

Scroll to Top