UNIT 1

JAVA I/O SREAMING -FILTER AND PIPE STREAMS-BYTE CODE INTERPRETATION-

THREADING-SWING.

Java I/O Streaming: Explained Simply

Java I/O (Input/Output) streams handle the flow of data between a program
and external sources like files, keyboards, or networks. Think of it as water
flowing through pipes, where the data is the water and the streams are the
pipes.

What Are Streams?

A stream is a sequence of data. In Java:
1. Input Stream: Brings data into the program (e.g., reading a file).
2. Output Stream: Sends data out from the program (e.g., writing to a file).

Types of Streams
1. Byte Streams:
o Handles raw binary data (like images, audio files).
o Classes: InputStream (for input) and OutputStream (for output).
2. Character Streams:
o Handles text (characters) efficiently, supporting Unicode.
o Classes: Reader (for input) and Writer (for output).

Key Classes in Java I/O

1. Byte Streams
 InputStream:
 o Reads data as bytes.
o Example: FileInputStream (read data from a file).
 OutputStream:
o Writes data as bytes.
o Example: FileOutputStream (write data to a file).
2. Character Streams
 Reader:
o Reads data as characters.
o Example: FileReader (read characters from a file).
 Writer:
o Writes data as characters.
o Example: FileWriter (write characters to a file).

Using Streams
Here’s how to use Java I/O streams in basic tasks:
1. Reading from a File
2. Writing to a File
Buffering Streams
 Reading and writing one byte/character at a time can be slow.
 Buffered streams (e.g., BufferedReader, BufferedWriter) make it faster by
handling chunks of data.
Example of Buffered Reader

Advanced Streams
1. Data Streams: Handle primitive data types (e.g., DataInputStream,
DataOutputStream).
2. Object Streams: Read/write objects to files (e.g., ObjectInputStream,
ObjectOutputStream).
3. Piped Streams: Connect two threads for communication.
Comparison: Byte vs Character Streams
Feature Byte Streams Character Streams
Data type handled Binary data (bytes) Text data (characters)
Classes used InputStream, OutputStream Reader, Writer
Example use cases Images, audio files Text files, documents

Why Use Java I/O Streams?

 Versatile: Handle files, network data, user input, etc.
 Efficient: Process large amounts of data using buffering.
 Flexible: Choose byte or character streams based on the data type.
Think of streams as tools that make it easy to send and receive data in a
structured way!

STREAMS AND PIPES

Filters and Pipes in Programming (and Java)

Filters and pipes are concepts used to process data in a streamlined and
efficient way. Imagine a factory where raw materials go through several
machines (filters) on a conveyor belt (pipes) to produce a final product. The
same idea applies to how data flows and is processed in software.

What Are Filters?

Filters are components (programs, methods, or processes) that take input data,
process it, and produce output. They act as "processing units" to transform or
manipulate the data in some way.
 Example:
o Input: A list of numbers: [1, 2, 3, 4, 5].
 o Filter: Select only even numbers.
o Output: [2, 4].

What Are Pipes?

Pipes connect filters and allow data to flow between them. They pass the
output of one filter as the input to the next, creating a "pipeline" of processing
steps.
 Example:
o Step 1: Filter out even numbers → [2, 4].
o Step 2: Multiply each by 10 → [20, 40].
o Pipe connects these two steps.

Filters and Pipes in Java

In Java, filters and pipes are implemented in the I/O system to process streams
of data. Here's how they work:
Filters in Java
 Java provides Filter Streams, which are used to modify or filter data
while reading or writing.
 They extend FilterInputStream and FilterOutputStream.
Examples of Filter Streams:
1. BufferedInputStream: Speeds up reading by buffering the data.
2. DataInputStream: Reads primitive data types from a stream.
3. ObjectInputStream: Reads objects from a stream.
Pipes in Java
 Pipes are used for communication between two threads.
 The PipedInputStream and PipedOutputStream classes create a pipe for
data flow.
Example: Filters in Java
Reading a File with a Filter

Here, BufferedInputStream is a filter that improves the efficiency of reading.

Example: Pipes in Java

Communication Between Threads
Here, PipedOutputStream sends data, and PipedInputStream receives it. The
pipe connects the two threads.

Benefits of Filters and Pipes

1. Modularity: Each filter does one specific task, making the system easier
to build and debug.
2. Reusability: Filters can be reused in different pipelines.
3. Flexibility: You can combine filters in different ways to create new
workflows.
4. Thread Communication: Pipes allow threads to exchange data efficiently.

Everyday Analogy
Think of making tea:
 Filters: The teabag filters the tea leaves, and a sieve removes particles.
  Pipes: Water flows through the filters to create the final tea.
In programming, filters and pipes make it easier to process and transform data
step by step!

Bytecode Interpretation in Java: A Simple Explanation

When you write a Java program, it doesn’t run directly on your computer's
hardware. Instead, it goes through several steps to be executed, and one key
step involves bytecode interpretation.

What is Bytecode?
Bytecode is a special, machine-independent code that Java programs are
converted into during compilation. Think of it as a set of instructions that are
understood by the Java Virtual Machine (JVM), not by your computer's
processor.
 Human Code (Java Source Code): What you write (.java file).
 Bytecode: What Java compiles your code into (.class file).
 Machine Code: The actual instructions that your computer can execute.

Why Bytecode?
1. Portability: Bytecode can run on any system with a JVM, whether it’s
Windows, macOS, or Linux.
o This makes Java write once, run anywhere (WORA).
2. Efficiency: Bytecode is compact and optimized for the JVM.

How Bytecode is Created?

1. Write Code: You write your Java program (e.g., HelloWorld.java).
 2. Compile: The Java Compiler (javac) converts the source code into
bytecode, creating a .class file.

How is Bytecode Interpreted?

The JVM reads and executes the bytecode in two main ways:
1. Interpretation
 The JVM has a component called the bytecode interpreter.
 It reads the bytecode instructions one at a time and executes them
directly.
 Analogy: Think of it as a teacher reading each line of a recipe to a
student who follows the instructions step by step.
2. Just-In-Time (JIT) Compilation
 To speed things up, the JVM uses JIT to translate frequently used
bytecode into machine code.
 Once translated, the machine code can run directly on the processor,
bypassing interpretation.

Bytecode Example
Here's a simple Java program:
  Each instruction (e.g., getstatic, ldc) is part of the bytecode that the JVM
interprets.

Key Components in Bytecode Interpretation

1. Class Loader: Loads the .class file containing bytecode into memory.
2. Bytecode Verifier: Checks the bytecode for errors or malicious code
(e.g., ensuring proper memory usage).
3. Execution Engine: Executes the bytecode:
o Uses the interpreter for direct execution.
o Uses JIT compilation for optimized execution.

Benefits of Bytecode Interpretation

1. Platform Independence: The same bytecode runs on any device with a
JVM.
2. Security: The verifier ensures no harmful operations occur.
3. Performance: JIT compilation improves execution speed over time.
Analogy
Imagine you write a recipe in your language (Java source code). You give it to a
universal translator (Java Compiler), who converts it into a language (bytecode)
that all chefs (JVMs) can understand. When a chef reads it, they either follow it
step by step (interpretation) or remember it for future use (JIT compilation).

Summary
 Bytecode is a middle step between your Java code and machine code.
 The JVM interprets or compiles the bytecode to run your program.
 This system makes Java portable, secure, and efficient!

Threading in Java: A Simple Explanation

Threading is a way to make a Java program do multiple things simultaneously.
It’s like having multiple workers (threads) completing tasks at the same time to
make the work faster and more efficient.

What is a Thread?
 A thread is a small unit of a process.
 Process: A running program (e.g., your Java application).
 Thread: A part of the program that can execute tasks independently.
By default, every Java program runs in a single thread called the main thread.

Why Use Threads?

1. Improved Performance: Threads can run tasks in parallel (e.g.,
downloading a file while updating the progress bar).
 2. Responsiveness: Keeps applications responsive (e.g., a video player
playing a video while processing user inputs).
3. Efficient Resource Use: Threads share memory and resources of the
process they belong to.

How Threading Works

1. Single-threaded: Tasks are executed one after the other.
o Example: Cooking a meal where you prepare each dish
sequentially.
2. Multi-threaded: Tasks are executed in parallel.
o Example: Cooking a meal with different chefs working on dishes
simultaneously.

Creating Threads in Java

There are two main ways to create threads in Java:
1. Extending the Thread Class
 Create a class that extends Thread and override the run() method (the
task to perform).
2. Implementing the Runnable Interface
 Create a class that implements Runnable and define the run() method.

Key Thread Methods

 start(): Starts the thread and calls the run() method.
 run(): Contains the code the thread executes.
  sleep(milliseconds): Pauses the thread for a specific time.
 join(): Makes one thread wait until another thread finishes.
 isAlive(): Checks if a thread is still running.

Thread States
A thread can be in one of these states:
1. New: Created but not yet started (e.g., new Thread()).
2. Runnable: Ready to run but waiting for the CPU.
3. Running: Actively executing.
4. Blocked/Waiting: Paused, waiting for resources or signals.
5. Terminated: Finished execution.

Thread Synchronization
When multiple threads access shared data, there can be conflicts.
Synchronization ensures that only one thread accesses the shared resource at a
time.
Example: Synchronized Block
class Counter {
private int count = 0;
Thread Priority
Threads can have priorities (low, medium, high), which the JVM considers when
scheduling threads. Use setPriority() to change it.

Advantages of Threads
1. Parallelism: Perform multiple tasks simultaneously.
2. Resource Sharing: Threads share memory and resources of the parent
process.
3. Better Performance: Tasks complete faster with multiple threads.

Challenges of Threads
1. Complexity: Managing multiple threads can be tricky.
2. Data Issues: Without synchronization, threads might interfere with each
other.
3. Deadlocks: Threads waiting indefinitely for resources can freeze the
program.

Analogy
Imagine a pizza restaurant:
 Single-threaded: One chef makes pizzas, one at a time.
 Multi-threaded: Multiple chefs work in parallel on different pizzas,
making the process faster.
Threads in Java allow programs to "hire" multiple workers to handle tasks
simultaneously!

Swing in Java: A Simple Explanation

Swing is a part of Java used to create Graphical User Interfaces (GUIs) for
desktop applications. It provides a set of tools (classes) to design and manage
windows, buttons, text fields, menus, and other visual components that make
up a user-friendly application.

What is Swing?
 Swing is a part of the Java Foundation Classes (JFC).
 It’s a library for building modern, interactive GUI applications in Java.
 Swing is built on top of the older Abstract Window Toolkit (AWT) but is
more powerful and flexible.

Why Use Swing?

1. Platform Independence: Swing apps look and behave the same on any
operating system with Java installed.
2. Rich Components: Offers many ready-to-use components like buttons,
text boxes, tables, and trees.
3. Customizable: You can change how components look and behave.
4. Lightweight: Doesn’t rely on the operating system for rendering
components.

Key Features of Swing

1. Components: Swing provides UI elements like JButton, JLabel, JTextField,
JTable, etc.
2. Containers: Hold and organize components (JFrame, JPanel, JScrollPane).
3. Layouts: Control the arrangement of components (e.g., FlowLayout,
BorderLayout).
4. Event Handling: Responds to user actions like button clicks or typing.

Basic Swing Components

 JFrame: The main window of your application.
  JPanel: A container for grouping components.
 JButton: A clickable button.
 JLabel: Displays text or images.
 JTextField: A single-line text input.
 JTextArea: A multi-line text input.
 JComboBox: A drop-down menu.
 JTable: A table for displaying data.

Creating a Simple Swing Application

Let’s create a basic GUI with a window and a button:
Understanding the Code
1. JFrame:
o Creates the main window where components will be placed.
o setSize() sets its width and height.
o setDefaultCloseOperation() ensures the program closes when the
window is closed.
2. JButton:
o A button the user can click.
o It’s added to the frame using frame.add().
3. setVisible(true):
o Makes the window visible.

Adding Interactivity (Event Handling)

To make the button respond to clicks:
Layouts in Swing
Layouts control how components are arranged in a container. Common layouts
include:
1. FlowLayout: Arranges components in a row.
2. BorderLayout: Divides the container into five regions (North, South, East,
West, Center).
3. GridLayout: Arranges components in a grid.
Example of Layout:
Advanced Swing Features
1. Menus:
o Create menus using JMenuBar, JMenu, and JMenuItem.
o Example: File, Edit, Help menus.
2. Dialogs:
o Pop-up messages or input boxes (JOptionPane).
3. Custom Look and Feel:
o Change the appearance of your application to match a specific
style.
4. Tables and Trees:
o Display and manipulate tabular or hierarchical data.

Swing vs AWT
Feature Swing AWT
Components Lightweight (Java-rendered) Heavyweight (OS-rendered)
Features Rich and customizable Basic and limited
Portability Fully portable May vary by OS

Analogy
Think of Swing as a box of LEGOs:
 Each LEGO piece (component) can be put together to build a larger
structure (GUI).
 You can choose where and how to place the pieces (using layouts).
 You can even paint and reshape the pieces (customization).

Summary
 Swing is a toolkit for building GUI applications in Java.
 It provides components like buttons, windows, and text fields.
 You can customize layouts, add interactivity, and make responsive
applications.
 While Swing is not the latest (JavaFX is newer), it remains widely used for
lightweight desktop applications.