- What is Java?
- History of Java
- Hello Java Program
- Features of Java
- Basic Syntax
- Java Setup
- Data Types in Java
- Java Variables
- Operators in Java
- Java If-else Statement
- Switch Case Statement
- Java Loops
- Do-While Loop
- Java While Loop
- Continue Statement
- Break Statement in Java
- Constructors in Java
- Oops Concept in Java
- Features of OOPs
- Exeception handeling
- Aggregation (HAS-A relationship) in Java
- Method Overriding in Java
- Method Overloading
- Java Static Keyword
- Java This Keyword
- Java Final Keyword
- Static Binding and Dynamic Binding
- Abstract class in Java
- Access Modifiers in Java
- Difference between abstract class and interface
- Interface in Java
- Garbage Collection in Java
- Java Package
- Serialization and Deserialization in Java
- Java Inner Classes
- Java Applets
- Multithreading in Java
- Thread Priorities in Java
- Thread Creation
- Inter Thread Communication
- Wrapper Classes in Java
- Java Input Output
- Java AWT Introduction
- Java Layout Manager
- Java Layout Policy
- Java AWT Events
- Collection Framework
- Collection Framework List Interface
- Swing in Java
- Swing Utility Classes
- Swing Layout Managers
- Java JDBC
- Hibernate Framework Overview – Architecture and Basics
- Spring Environment Setup
- Spring Boot CRUD REST API Project using IntelliJ IDEA | Postman | MySQL
- Dockerizing Spring Boot Application | Spring Boot Docker Tutorial
- spring-boot-restapidocumentation with swagger
- Spring Boot HttpClient Overview
- Apache HttpClient POST HTTP Request Example
- Apache HttpClient PUT HTTP Request Example
- Apache HttpClient DELETE HTTP Request Example
- Apache HttpClient HTML Form POST Request Example
- Spring Boot JSP Exampl
- Deploying Spring Boot WAR file with JSP to Tomcat
- Spring Boot Annotations
- Spring Core Annotations
- Spring MVC Annotations with Examples
- Spring Scheduling Annotations
- Spring - Java-based Container Configuration
- Spring Java Based Configuration Example
- Hibernate 5 hello world
- Hibernate- One to One Unidirectional Mapping Annotation Example
- Hibernate - Batch Processing
- Hibernate - Interceptors
- Hibernate 5 - Create, Read, Update and Delete (CRUD) Operations Example
- Hibernate Transaction Management
- Hibernate One to Many Unidirectional Mapping Example
- Hibernate One to Many Bidirectional Mapping Example
- Hibernate Many to Many Annotation Mapping Example
- Hibernate Primary KeyJoin Column
- Hibernate First Level Cache with Example
- Hibernate XML Configuration Example with Maven + Eclipse + MySQL Database
- Hibernate Java Configuration Example
- JPA 2 with Hibernate 5 Bootstrapping Example
- JPA and Hibernate Cascade Types
- Hibernate/JPA - Primary Key Generation
- Hibernate 5 - Enum Type Mapping Example
- Hibernate Component Mapping
- Hibernate Object States – Transient,Persistent and Detached
- Hibernate 5 - Save an Entity Example
- Hibernate 5 - Persist an Entity Example
- Hibernate 5 - saveOrUpdate() Method Example
- Hibernate 5 - get(), load() and byId() Method Examples
- Hibernate 5 - merge() Example
- Hibernate 5 - Delete or Remove an Entity Example
- Hibernate 5 - load() Method Example
- Hibernate Session Interface Methods
- Hibernate Session.clear() Method Example
- Introduction Of Java strutes to Architecture
- Struts 2 - Architecture
- Struts 2 - Configuration Files
- Struts 2 - Actions
- Struts 2 - Interceptors
- Struts 2 - Results & Result Types
- Struts 2 - Value Stack/OGNL
- Struts 2 - File Uploading
- Struts 2 - Database Access
- Struts 2 - Validations Framework
- JavaFX Tutorial
- Introduction to JavaFX Pane
- JavaFX Popup
- JavaFX group
- JavaFX Controller
- JavaFX Gradient Color
- JavaFX Scene
- JavaFX Stage
- JavaFX Timeline
- JavaFX Timer
- JavaFX Image
- JavaFX Background
- JavaFX dialog
- JavaFX Font
- JavaFX GUI
- JavaFX FXML
Java Input / Output
In Java, Input and Output (I/O) is used to process the input and produce the output.
This means an input stream can abstract many different input kinds: from a disk file, a keyboard or a network socket. Likewise, an output stream may refer to the console, a disk file, or a network connection.
Java programs perform I/O through streams. A stream is an abstraction that either produces or consumes information. A stream is linked to a physical device by the Java I/O system.
All streams behave in the same manner, even if the actual physical devices to which they are linked differ. Thus, the same I/O classes and methods can be applied to any device.
Streams are a clean way to deal with input/output without having every part of our code understand the difference between a keyboard and a network, for example. Java implements streams within class hierarchies defined in the java.io package.
The concept of sending data from one stream to another (like one pipe feeding into another pipe) has made streams in Java a powerful tool for file processing. We can build a complex file processing sequence using a series of simple stream operations.
This feature can be used to filter data along the pipeline of streams so that we obtain data in the desired format. For example, we can use one stream to get raw data in binary format and then use another stream in series to convert it into integers.
Input and Output Streams:-
Java streams are classified into two basic types: usually input streams and output streams. An input stream extracts (i.e. reads) data from the source and sends it to the program.
The program connects and opens an input stream on the data source and then reads the data serially. Similarly, the program connects and opens an output stream to the destination place of data and writes data out serially. In both cases, the program does not know the details of endpoints (i.e. source and destination).
Byte Streams and Character Streams-
Java2 defines two types of streams: Byte and Character. Byte streams provide a convenient means for handling input and output of bytes. Byte streams are used, for example, when reading or writing binary data. Character streams offer a convenient means for controlling input and output of character.
They use Unicode and therefore, can be internationalized. Also, in some cases, character streams are more efficient than byte streams. The original version of Java (Java 1.0) did not include character streams, and this, all I/O was byte-oriented.
Character streams were added by Java 1.1, and certain byte-oriented classes and methods were deprecated.
At the lowest level, all I/O is still byte-oriented. The character-based streams provide a convenient and efficient means for handling characters.
These two groups may be further classified base on their purposes. Byte Stream and Character Stream classes contain specialized classes to deal with input and output operations independently on various devices.
We can also cross-group the streams based on the type of source or destination they read from or write to. The source or goal may be a memory, a file or a pipe.
Overview of Byte Stream Classes:-
Byte stream classes are defined by using two-class hierarchies. At the top are two abstract classes:
(1) InputStream and (2) OutputStream
These abstract classes have several concrete subclasses that handle the differences between various devices, such as disk files, network connections and even memory buffers.
InputStream classes used to read 8-bit bytes include a superclass known as InputStream and several sub-classes to support various input-related functions.
The superclass InputStream is an abstract class, which defines methods for performing input functions such as:
- Reading bytes.
- Closing stream.
- Marking positions in streams.
- Skipping ahead in a stream.
- Finding the number of bytes in a stream.
Methods of InputStream class:
Gives the number of bytes available in the input (must be overridden by the subclasses). The available method for class InputStream always returns 0.
Closes this input stream and releases any system resources associated with the stream. The close method of InputStream does nothing.
void mark(int readlimit)
Marks the current position in this input stream. The mark method of InputStream does nothing.
Tests if this input stream supports the mark and resets methods. The markSupported method of InputStream returns false.
abstract int read()
Reads the next byte of data from the input stream. A subclass must provide an implementation of this method.
int read(byte b)
Reads some number of bytes from the input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer.
int read(byte b, int offset, int len)
Reads some bytes from the input stream and stores them into the buffer array b starting from position specified by the parameter. The number of bytes reads it returned as an integer.
Repositions this stream to the position when the mark method was last called on this input stream. The reset method of InputStream does nothing and always throws IOException.
long skip(long n)
Skips over and discards upto n bytes of data from this input stream and returns the number of bytes skipped.
The DataInput Interface:
The DataInput is an interface, which defines methods for reading primitives from an InputStream.
Methods of DataInput Interface:
Reads one input byte and returns true if that byte is non-zero and false if that byte is zero.
Reads and returns one byte input.
Reads an input character and returns its value.
Reads eight input bytes and returns a double value.
Reads four input bytes and returns a double value.
void readFully(byte b)
Reads some bytes from an input stream and stores them in a buffer array b. This method throws EOFException if this stream reaches the end before reading all the bytes.
void readFully(byte b, int off, int len)
Reads len bytes from an input stream and stores them in a buffer array b starting at the position specified by the off. This method throws EOFException if this stream reaches the end before reading all the bytes.
Reads four input bytes and returns an int value.
Reads the next line from the input stream.
Reads eight input bytes and returns a long value.
Reads two input bytes and returns a short value Strig readUTF( ) Reads in a string that has been encoded using a modified UTF-8 format.
int skipBytes(int n)
Attempt to skip over n bytes of data from the input stream, discarding the skipped bytes. The actual number of bytes skipped is returned.
Output stream classes are derived from the base class OutputStream, an abstract class and have many sub-classes for supporting various output-related functions.
The OutputStream class:-
The superclass OutputStream is an abstract class, which defines methods for performing output functions such as:
- Writing bytes
- Closing streams
- Flushing streams
Methods of OutputStream Class:-
Closes this output stream and releases any stream resources associated with this stream.
Flushes this output stream and forces any buffered output bytes to be written out.
void write(byte b)
Writes b. length bytes from the specified byte array to its output stream.
void write(byte b, int off, int len)
Writes len bytes from the specified byte array starting at offset off to its output stream.
abstract void write( int b)
Writes the specified byte to its output stream.
The DataOutput Interface:-
The DataOutput is an interface, which defines methods for writing primitives to an OutputStream.
Methods of DataOutput Interface:
void writeBoolean(boolean v)
Writes a boolean value to its output stream.
void writeByte(int v)
Writes to the output stream the eight low- order bits of the argument v.
void writeBytes(string s)
Writes the string to the output stream. For every character in the string s, taken in order, one byte is written to the output stream.
void writeChar(int v)
Writes a character value, which is comprised of two bytes, to the output stream.
void writeChars(string s)
The output stream writes every character in the string s in the order of eight bytes.
void writeDouble(double v)
Writes a double value, which is comprised of eight bytes, to the output stream.
void writeFloat(float v)
Writes a float value, which is comprised of four bytes, to the output stream.
void writeInt(int v)
Writes a int value, which is comprised of four bytes, to the output stream.
void writeLong(long v)
Writes a long value, which is comprised of eight bytes, to the output stream.
void writeShort(int v)
Writes a short value, which is comprised of two bytes, to the output stream.
void writeUTF(String str)
Writes two bytes of length information to the output stream, followed by the modified UTF-8 representation of every character in the string s.
Apply now for Advanced Java Training Course