Unit 6

File Handling and Design Patterns

6.1 File Handling: Introduction

In programming, we may require some specific input data to be generated several numbers of times. Sometimes, it is not enough to only display the data on the console. The data to be displayed may be very large, and only a limited amount of data can be displayed on the console, and since the memory is volatile, it is impossible to recover the programmatically generated data again and again. However, if we need to do so, we may store it onto the local file system which is volatile and can be accessed every time. Here, comes the need of file handling in C.

File handling in C enables us to create, update, read, and delete the files stored on the local file system through our C program. The following operations can be performed on a file.

• Creation of the new file
• Opening an existing file
• Reading from the file
• Writing to the file
• Deleting the file

Functions for file handling

There are many functions in the C library to open, read, write, search and close the file. A list of file functions are given below:

Opening File: fopen()

We must open a file before it can be read, write, or update. The fopen() function is used to open a file. The syntax of the fopen() is given below.

1. FILE *fopen( const char * filename, const char * mode );  

The fopen() function accepts two parameters:

• The file name (string). If the file is stored at some specific location, then we must mention the path at which the file is stored. For example, a file name can be like "c://some_folder/some_file.ext".
• The mode in which the file is to be opened. It is a string.

We can use one of the following modes in the fopen() function.

The fopen function works in the following way.

• Firstly, It searches the file to be opened.
• Then, it loads the file from the disk and place it into the buffer. The buffer is used to provide efficiency for the read operations.
• It sets up a character pointer which points to the first character of the file.

Consider the following example which opens a file in write mode.

1. #include<stdio.h>  
2. Void main( )  
3. {  
4. FILE *fp ;  
5. Char ch ;  
6. Fp = fopen("file_handle.c","r") ;  
7. While ( 1 )  
8. {  
9. Ch = fgetc ( fp ) ;  
10. If ( ch == EOF )  
11. Break ;  
12. Printf("%c",ch) ;  
13. }  
14. Fclose (fp ) ;  
15. }  

Output

The content of the file will be printed.

#include;

Void main( )

{

FILE *fp; // file pointer

Char ch;

Fp = fopen("file_handle.c","r");

While ( 1 )

{

Ch = fgetc ( fp ); //Each character of the file is read and stored in the character file. 

If ( ch == EOF )

Break;

Printf("%c",ch);

}

Fclose (fp );

}

Closing File: fclose()

The fclose() function is used to close a file. The file must be closed after performing all the operations on it. The syntax of fclose() function is given below:

1. Int fclose( FILE *fp );  

C fprintf() and fscanf()

C fputc() and fgetc()

C fputs() and fgets()

C fseek()

6.2 Concepts of Stream

We are using the iostream standard library, it provides cin and cout methods for reading from input and writing to output respectively.

To read and write from a file we are using the standard C++ library called fstream. Let us see the data types define in fstream library is:

FileStream example: writing to a file

Let's see the simple example of writing to a text file testout.txt using C++ FileStream programming.

1. #include <iostream>  
2. #include <fstream>  
3. Using namespace std;  
4. Int main () {  
5.  Ofstream filestream("testout.txt");  
6.  If (filestream.is_open())  
7.  {  
8.    Filestream << "Welcome to javaTpoint.\n";  
9.    Filestream << "C++ Tutorial.\n";  
10.    Filestream.close();  
11.  }  
12.  Else cout <<"File opening is fail.";  
13.  Return 0;  
14. }  

Output:

The content of a text file testout.txt is set with the data:

Welcome to javaTpoint.

C++ Tutorial.

FileStream example: reading from a file

Let's see the simple example of reading from a text file testout.txt using C++ FileStream programming.

1. #include <iostream>  
2. #include <fstream>  
3. Using namespace std;  
4. Int main () {  
5.  String srg;  
6.  Ifstream filestream("testout.txt");  
7.  If (filestream.is_open())  
8.  {  
9.    While ( getline (filestream,srg) )  
10.    {  
11.      Cout << srg <<endl;  
12.    }  
13.    Filestream.close();  
14.  }  
15.  Else {  
16.      Cout << "File opening is fail."<<endl;   
17.    }  
18.  Return 0;  
19. }  

Note: Before running the code a text file named as "testout.txt" is need to be created and the content of a text file is given below:
Welcome to javaTpoint.
C++ Tutorial.

Output:

Welcome to javaTpoint.

C++ Tutorial.

Read and Write Example

Let's see the simple example of writing the data to a text file testout.txt and then reading the data from the file using C++ FileStream programming.

1. #include <fstream>  
2. #include <iostream>  
3. Using namespace std;  
4. Int main () {  
5.   Char input[75];  
6.   Ofstream os;  
7.   Os.open("testout.txt");  
8.   Cout <<"Writing to a text file:" << endl;  
9.   Cout << "Please Enter your name: ";   
10.   Cin.getline(input, 100);  
11.   Os << input << endl;  
12.   Cout << "Please Enter your age: ";   
13.   Cin >> input;  
14.   Cin.ignore();  
15.   Os << input << endl;  
16.   Os.close();  
17.   Ifstream is;   
18.   String line;  
19.   Is.open("testout.txt");   
20.   Cout << "Reading from a text file:" << endl;   
21.   While (getline (is,line))  
22.   {  
23.   Cout << line << endl;  
24.   }      
25.   Is.close();  
26.   Return 0;  
27. }  

Output:

Writing to a text file: 

Please Enter your name: Nakul Jain   

Please Enter your age: 22 

Reading from a text file:   Nakul Jain 

22

6.3 Stream Classes

In C++ stream refers to the stream of characters that are transferred between the program thread and i/o.

Stream classes in C++ are used to input and output operations on files and io devices. These classes have specific features and to handle input and output of the program.

The iostream.h library holds all the stream classes in the C++ programming language.

Let's see the hierarchy and learn about them,

Now, let’s learn about the classes of the iostream library.

Ios class − This class is the base class for all stream classes. The streams can be input or output streams. This class defines members that are independent of how the templates of the class are defined.

Istream Class − The istream class handles the input stream in c++ programming language. These input stream objects are used to read and interpret the input as a sequence of characters. The cin handles the input.

Ostream class − The ostream class handles the output stream in c++ programming language. These output stream objects are used to write data as a sequence of characters on the screen. Cout and puts handle the out streams in c++ programming language.

Example

OUT STREAM

COUT

#include <iostream>

Using namespace std;

Int main(){

Cout<<"This output is printed on screen";

}

Output

This output is printed on screen

PUTS

#include <iostream>

Using namespace std;

Int main(){

Puts("This output is printed using puts");

}

Output

This output is printed using puts

IN STREAM

CIN

#include <iostream>

Using namespace std;

Int main(){

Int no;

Cout<<"Enter a number ";

Cin>>no;

Cout<<"Number entered using cin is "<

Output

Enter a number 3453

Number entered using cin is 3453

Gets

#include <iostream>

Using namespace std;

Int main(){

Char ch[10];

Puts("Enter a character array");

Gets(ch);

Puts("The character array entered using gets is : ");

Puts(ch);

}

Output

Enter a character array

Thdgf

The character array entered using gets is :

Thdgf

6.4 Byte Stream Classes

These handle data in bytes (8 bits) i.e., the byte stream classes read/write data of 8 bits. Using these you can store characters, videos, audios, images etc.

The InputStream and OutputStream classes (abstract) are the super classes of all the input/output stream classes: classes that are used to read/write a stream of bytes. Following are the byte array stream classes provided by Java −

Example

Following Java program reads data from a particular file using FileInputStream and writes it to another, using FileOutputStream.

Import java.io.File;

Import java.io.FileInputStream;

Import java.io.FileOutputStream;

Import java.io.IOException;

Public class IOStreamsExample {

Public static void main(String args[]) throws IOException {

//Creating FileInputStream object

File file = new File("D:/myFile.txt");

FileInputStream fis = new FileInputStream(file);

Byte bytes[] = new byte[(int) file.length()];

//Reading data from the file

Fis.read(bytes);

//Writing data to another file

File out = new File("D:/CopyOfmyFile.txt");

FileOutputStream outputStream = new FileOutputStream(out);

//Writing data to the file

OutputStream.write(bytes);

OutputStream.flush();

System.out.println("Data successfully written in the specified file");

}

}

Output

Data successfully written in the specified file

6.5 Character Stream

Character Streams − These handle data in 16 bit Unicode. Using these you can read and write text data only.

The Reader and Writer classes (abstract) are the super classes of all the character stream classes: classes that are used to read/write character streams. Following are the character array stream classes provided by Java −

Example

The following Java program reads data from a particular file using FileReader and writes it to another, using FileWriter.

Import java.io.File;

Import java.io.FileReader;

Import java.io.FileWriter;

Import java.io.IOException;

Public class IOStreamsExample {

Public static void main(String args[]) throws IOException {

//Creating FileReader object

File file = new File("D:/myFile.txt");

FileReader reader = new FileReader(file);

Char chars[] = new char[(int) file.length()];

//Reading data from the file

Reader.read(chars);

//Writing data to another file

File out = new File("D:/CopyOfmyFile.txt");

FileWriter writer = new FileWriter(out);

//Writing data to the file

Writer.write(chars);

Writer.flush();

System.out.println("Data successfully written in the specified file");

}

}

Output

Data successfully written in the specified file

6.6 Classes Using Stream

A stream can be defined as a sequence of data. The InputStream is used to read data from a source and the OutputStream is used for writing data to a destination. InputStream and OutputStream are the basic stream classes in Java.

All the other streams just add capabilities to the basics, like the ability to read a whole chunk of data at once for performance reasons (BufferedInputStream) or convert from one kind of character set to Java's native unicode (Reader), or say where the data is coming from (FileInputStream, SocketInputStream and ByteArrayInputStream, etc.)

Why we need Stream Classes?

To perform read and write operation on binary files we need a mechanism to read that binary data on file/to write binary data (i.e. in the form of byte). These classes are capable to read and write one byte on binary files. That’s why we use Stream Classes.

Figure 1: Stream Classes

Stream Classes:

Hierarchy of classes for Input and Output streams.

Here Object is the sequence of character i.e. Stream.

1. FileInputStream and FileOutputStream Classes:

FileInputStream Class:

A FileInputStream is an InputStream to obtain bytes from a file. It is used for reading inputs of raw bytes such as image data. It can read byte oriented data.

Constructor to take file for input:

InputStream f=new FileInputStream(“C:/JavaProg/Demo”);

Here, f is an object of InputStream class and argument of FileInputStream is that path where our file is located.

Methods of FileInputStream:

Listing 1: Demo of FileInputStream Class

Import java.io.*;

Public class fileInputStreamDemo {

Public static void main (String args[]){

Try {

Byte bWrite [] = {10, 20,30,40,50};

OutputStream os = new FileOutputStream("C:/test.txt");

For(int x=0; x < bWrite.length ; x++){

Os.write( bWrite[x] ); // writes the bytes

}

Os.close();

InputStream is = new FileInputStream("C:/test.txt");

Int size = is.available();

For(int i=0; i< size; i++){

System.out.print((char)is.read() + "  ");

}

Is.close();

}catch(IOException e){

System.out.print("Exception");

} 

}

}

Output of the program is:

10 20 30 40 50

A FileOutputStream is used to create a file and write data into it. The stream would create a file, if it doesn't already exist, before opening it for output.

Constructors for FileOutputStream Class:

Methods of FileOutStream:

Example:

Listing 2: Program to demonstrate FileOutputStream Class

Import java.io.FileInputStream;

Import java.io.FileOutputStream;

Import java.io.IOException;

Public class FileOutputStreamDemo {

Public static void main(String[] args) throws IOException {

FileOutputStream fos = null;

FileInputStream fis = null;

Int i=0;

Char c;

Try{

// create new file output stream

Fos=new FileOutputStream("C://test.txt");

// writes byte to the output stream

Fos.write(b, 2, 3);

// flushes the content to the underlying stream

Fos.flush();

// create new file input stream

Fis = new FileInputStream("C://test.txt");

// read till the end of the file

While ((i=fis.read())!=-1)

{

// convert integer to character

c=(char)i;

// prints

System.out.print(c);

}

// if an error occurs

e.printStackTrace ();

} finally {

// closes and releases system resources from stream

If(fos!=null)

Fos.close();

If(fis!=null)

Fis.close();

}

}

}

Output of the Program is:

CDE

2. ByteArrayInputStream and ByteArrayOutputStream Class:

ByteArrayInputStream:

This class contains an internal buffer that contains bytes that may be read from the stream. An internal counter keeps track of the next byte to be supplied by the read method. The methods in this class can be called after the stream has been closed without generating an IOException.

Constructors for ByteArrayInputStream:

Methods of ByteArrayInputStream:

ByteArrayOutputStream:

This class implements an output stream in which the data is written into a byte array. The buffer automatically grows as data is written to it. The methods in this class can be called after the stream has been closed without generating an IOException.

Constructors for ByteArrayInputStream:

Methods of ByteArrayInputStream:

Example:

Listing 3: Program to demonstrate ByteArrayInputStream and ByteArrayOutputStream:

Import java.io.*;

Public class ByteStreamTest {

Public static void main(String args[])throws IOException {

ByteArrayOutputStream bOutput = new ByteArrayOutputStream(12);

While( bOutput.size()!= 10 ) {

// Gets the inputs from the user

BOutput.write(System.in.read());

}

Byte b [] = bOutput.toByteArray();

System.out.println("Print the content");

For(int x= 0 ; x < b.length; x++) {

// printing the characters

System.out.print((char)b[x]  + "   ");

}

System.out.println("   ");

Int c;

ByteArrayInputStream bInput = new ByteArrayInputStream(b);

System.out.println("Converting characters to Upper case " );

For(int y = 0 ; y < 1; y++ ) {

While(( c= bInput.read())!= -1) {

System.out.println(Character.toUpperCase((char)c));

}

BInput.reset();

}

}

}

Output of the Program is:

Asdfghjkly
Print the content
a s d f g h j k l y
Converting characters to Upper case
A
S
D
F
G
H
J
K
L
Y

Conclusion

FileInput and FileOutput streams are the streams that are used to read/write byte of data to a file. While ByteInputArray and ByteOutputArray read/write bytes of data at a time because it deals with array of byte and works faster than FileInput and FileOutput Stream.

6.7 Other Useful I/O Classes

The java.io package contains nearly every class you might ever need to perform input and output (I/O) in Java. All these streams represent an input source and an output destination. The stream in the java.io package supports many data such as primitives, object, localized characters, etc.

Stream

A stream can be defined as a sequence of data. There are two kinds of Streams −

• InPutStream − The InputStream is used to read data from a source.
• OutPutStream − The OutputStream is used for writing data to a destination.

Java provides strong but flexible support for I/O related to files and networks but this tutorial covers very basic functionality related to streams and I/O. We will see the most commonly used examples one by one −

Byte Streams

Java byte streams are used to perform input and output of 8-bit bytes. Though there are many classes related to byte streams but the most frequently used classes are, FileInputStream and FileOutputStream. Following is an example which makes use of these two classes to copy an input file into an output file −

Example

Import java.io.*;

Public class CopyFile {

Public static void main(String args[]) throws IOException { 

FileInputStream in = null;

FileOutputStream out = null;

Try {

In = new FileInputStream("input.txt");

Out = new FileOutputStream("output.txt");

Int c;

While ((c = in.read()) != -1) {

Out.write(c);

}

}finally {

If (in != null) {

In.close();

}

If (out != null) {

Out.close();

}

}

}

}

Now let's have a file input.txt with the following content −

This is test for copy file.

As a next step, compile the above program and execute it, which will result in creating output.txt file with the same content as we have in input.txt. So let's put the above code in CopyFile.java file and do the following −

$javac CopyFile.java

$java CopyFile

Character Streams

Java Byte streams are used to perform input and output of 8-bit bytes, whereas Java Character streams are used to perform input and output for 16-bit unicode. Though there are many classes related to character streams but the most frequently used classes are, FileReader and FileWriter. Though internally FileReader uses FileInputStream and FileWriter uses FileOutputStream but here the major difference is that FileReader reads two bytes at a time and FileWriter writes two bytes at a time.

We can re-write the above example, which makes the use of these two classes to copy an input file (having unicode characters) into an output file −

Example

Import java.io.*;

Public class CopyFile {

Public static void main(String args[]) throws IOException {

FileReader in = null;

FileWriter out = null;

Try {

In = new FileReader("input.txt");

Out = new FileWriter("output.txt");

Int c;

While ((c = in.read()) != -1) {

Out.write(c);

}

}finally {

If (in != null) {

In.close();

}

If (out != null) {

Out.close();

}

}

}

}

Now let's have a file input.txt with the following content −

This is test for copy file.

As a next step, compile the above program and execute it, which will result in creating output.txt file with the same content as we have in input.txt. So let's put the above code in CopyFile.java file and do the following −

$javac CopyFile.java

$java CopyFile

Standard Streams

All the programming languages provide support for standard I/O where the user's program can take input from a keyboard and then produce an output on the computer screen. If you are aware of C or C++ programming languages, then you must be aware of three standard devices STDIN, STDOUT and STDERR. Similarly, Java provides the following three standard streams −

• Standard Input − This is used to feed the data to user's program and usually a keyboard is used as standard input stream and represented as System.in.
• Standard Output − This is used to output the data produced by the user's program and usually a computer screen is used for standard output stream and represented as System.out.
• Standard Error − This is used to output the error data produced by the user's program and usually a computer screen is used for standard error stream and represented as System.err.

Following is a simple program, which creates InputStreamReader to read standard input stream until the user types a "q" −

Example

Import java.io.*;

Public class ReadConsole {

Public static void main(String args[]) throws IOException {

InputStreamReader cin = null;

Try {

Cin = new InputStreamReader(System.in);

System.out.println("Enter characters, 'q' to quit.");

Char c;

Do {

c = (char) cin.read();

System.out.print(c);

} while(c != 'q');

}finally {

If (cin != null) {

Cin.close();

}

}

}

}

Let's keep the above code in ReadConsole.java file and try to compile and execute it as shown in the following program. This program continues to read and output the same character until we press 'q' −

$javac ReadConsole.java

$java ReadConsole

Enter characters, 'q' to quit.

1

1

e

e

q

q

Reading and Writing Files

As described earlier, a stream can be defined as a sequence of data. The InputStream is used to read data from a source and the OutputStream is used for writing data to a destination.

Here is a hierarchy of classes to deal with Input and Output streams.

The two important streams are FileInputStream and FileOutputStream, which would be discussed in this tutorial.

FileInputStream

This stream is used for reading data from the files. Objects can be created using the keyword new and there are several types of constructors available.

Following constructor takes a file name as a string to create an input stream object to read the file −

InputStream f = new FileInputStream("C:/java/hello");

Following constructor takes a file object to create an input stream object to read the file. First we create a file object using File() method as follows −

File f = new File("C:/java/hello");

InputStream f = new FileInputStream(f);

Once you have InputStream object in hand, then there is a list of helper methods which can be used to read to stream or to do other operations on the stream.

There are other important input streams available, for more detail you can refer to the following links −

• ByteArrayInputStream
• DataInputStream

FileOutputStream

FileOutputStream is used to create a file and write data into it. The stream would create a file, if it doesn't already exist, before opening it for output.

Here are two constructors which can be used to create a FileOutputStream object.

Following constructor takes a file name as a string to create an input stream object to write the file −

OutputStream f = new FileOutputStream("C:/java/hello")

Following constructor takes a file object to create an output stream object to write the file. First, we create a file object using File() method as follows −

File f = new File("C:/java/hello");

OutputStream f = new FileOutputStream(f);

Once you have OutputStream object in hand, then there is a list of helper methods, which can be used to write to stream or to do other operations on the stream.

There are other important output streams available, for more detail you can refer to the following links −

• ByteArrayOutputStream
• DataOutputStream

Example

Following is the example to demonstrate InputStream and OutputStream −

Import java.io.*;

Public class fileStreamTest {

Public static void main(String args[]) {

Try {

Byte bWrite [] = {11,21,3,40,5};

OutputStream os = new FileOutputStream("test.txt");

For(int x = 0; x < bWrite.length ; x++) {

Os.write( bWrite[x] );   // writes the bytes

}

Os.close();

InputStream is = new FileInputStream("test.txt");

Int size = is.available();

For(int i = 0; i < size; i++) {

System.out.print((char)is.read() + "  ");

}

Is.close();

} catch (IOException e) {

System.out.print("Exception");

} 

}

}

The above code would create file test.txt and would write given numbers in binary format. Same would be the output on the stdout screen.

File Navigation and I/O

There are several other classes that we would be going through to get to know the basics of File Navigation and I/O.

• File Class
• FileReader Class
• FileWriter Class

Directories in Java

A directory is a File which can contain a list of other files and directories. You use File object to create directories, to list down files available in a directory. For complete detail, check a list of all the methods which you can call on File object and what are related to directories.

Creating Directories

There are two useful File utility methods, which can be used to create directories −

• The mkdir( ) method creates a directory, returning true on success and false on failure. Failure indicates that the path specified in the File object already exists, or that the directory cannot be created because the entire path does not exist yet.
• The mkdirs() method creates both a directory and all the parents of the directory.

Following example creates "/tmp/user/java/bin" directory −

Example

Import java.io.File;

Public class CreateDir {

Public static void main(String args[]) {

String dirname = "/tmp/user/java/bin";

File d = new File(dirname);

// Create directory now.

d.mkdirs();

}

}

Compile and execute the above code to create "/tmp/user/java/bin".

Note − Java automatically takes care of path separators on UNIX and Windows as per conventions. If you use a forward slash (/) on a Windows version of Java, the path will still resolve correctly.

Listing Directories

You can use list( ) method provided by File object to list down all the files and directories available in a directory as follows −

Example

Import java.io.File;

Public class ReadDir {

Public static void main(String[] args) {

File file = null;

String[] paths;

Try {     

// create new file object

File = new File("/tmp");

// array of files and directory

Paths = file.list();

// for each name in the path array

For(String path:paths) {

// prints filename and directory name

System.out.println(path);

}

} catch (Exception e) {

// if any error occurs

e.printStackTrace();

}

}

}

This will produce the following result based on the directories and files available in your /tmp directory −

Output

Test1.txt

Test2.txt

ReadDir.java

ReadDir.class

6.8 Using the File Class

The File class is an abstract representation of file and directory pathname. A pathname can be either absolute or relative.

The File class have several methods for working with directories and files such as creating new directories or files, deleting and renaming directories or files, listing the contents of a directory etc.

Fields

Constructors

Useful Methods

Java File Example 1

1. Import java.io.*;  
2. Public class FileDemo {  
3.    Public static void main(String[] args) {  
4.  
5.        Try {  
6.            File file = new File("javaFile123.txt");  
7.            If (file.createNewFile()) {  
8.                System.out.println("New File is created!");  
9.            } else {  
10.                System.out.println("File already exists.");  
11.            }  
12.        } catch (IOException e) {  
13.            e.printStackTrace();  
14.        }  
15.  
16.    }  
17. }  

Output:

New File is created!

Java File Example 2

1. Import java.io.*;  
2. Public class FileDemo2 {  
3.    Public static void main(String[] args) {  
4.  
5.        String path = "";  
6.        Boolean bool = false;  
7.        Try {  
8.            // createing  new files  
9.            File file  = new File("testFile1.txt");  
10.            File.createNewFile();  
11.            System.out.println(file);  
12.            // createing new canonical from file object  
13.            File file2 = file.getCanonicalFile();  
14.            // returns true if the file exists  
15.            System.out.println(file2);  
16.            Bool = file2.exists();  
17.            // returns absolute pathname  
18.            Path = file2.getAbsolutePath();  
19.            System.out.println(bool);  
20.            // if file exists  
21.            If (bool) {  
22.                // prints  
23.                System.out.print(path + " Exists? " + bool);  
24.            }  
25.        } catch (Exception e) {  
26.            // if any error occurs  
27.            e.printStackTrace();  
28.        }  
29.    }  
30. }  

Output:

TestFile1.txt

/home/Work/Project/File/testFile1.txt

True

/home/Work/Project/File/testFile1.txt Exists? true

Java File Example 3

1. Import java.io.*;  
2. Public class FileExample {  
3. Public static void main(String[] args) {  
4.    File f=new File("/Users/sonoojaiswal/Documents");  
5.    String filenames[]=f.list();  
6.    For(String filename:filenames){  
7.        System.out.println(filename);  
8.    }  
9. }  
10. }  

Output:

"info.properties"

"info.properties".rtf

.DS_Store

.localized

Alok news

Apache-tomcat-9.0.0.M19

Apache-tomcat-9.0.0.M19.tar

Bestreturn_org.rtf

BIODATA.pages

BIODATA.pdf

BIODATA.png

Struts2jars.zip

Workspace

Java File Example 4

1. Import java.io.*;  
2. Public class FileExample {  
3. Public static void main(String[] args) {  
4.    File dir=new File("/Users/sonoojaiswal/Documents");  
5.    File files[]=dir.listFiles();  
6.    For(File file:files){  
7.        System.out.println(file.getName()+" Can Write: "+file.canWrite()+"   
8.        Is Hidden: "+file.isHidden()+" Length: "+file.length()+" bytes");  
9.    }  
10. }  
11. }  

Output:

"info.properties" Can Write: true Is Hidden: false Length: 15 bytes

"info.properties".rtf Can Write: true Is Hidden: false Length: 385 bytes

.DS_Store Can Write: true Is Hidden: true Length: 36868 bytes

.localized Can Write: true Is Hidden: true Length: 0 bytes

Alok news Can Write: true Is Hidden: false Length: 850 bytes

Apache-tomcat-9.0.0.M19 Can Write: true Is Hidden: false Length: 476 bytes

Apache-tomcat-9.0.0.M19.tar Can Write: true Is Hidden: false Length: 13711360 bytes

Bestreturn_org.rtf Can Write: true Is Hidden: false Length: 389 bytes

BIODATA.pages Can Write: true Is Hidden: false Length: 707985 bytes

BIODATA.pdf Can Write: true Is Hidden: false Length: 69681 bytes

BIODATA.png Can Write: true Is Hidden: false Length: 282125 bytes

Workspace Can Write: true Is Hidden: false Length: 1972 bytes

6.9 Input/output Exceptions

Introduction

The java.io.Exceptions provides for system input and output through data streams, serialization and the file system.

Interface Summary

6.10 Creation of Files

Creating a file is easy by using pre-defined classes and packages. There are three ways to create a file.

• Using File.createNewFile() method
• Using FileOutputStream class
• Using File.createFile() method

Java File.createNewFile() method

The File.createNewFile() is a method of File class which belongs to a java.io package. It does not accept any argument. The method automatically creates a new, empty file. The method returns a boolean value:

• True, if the file created successfully.
• False, if the file already exists.

When we initialize File class object, we provide the file name and then we can call createNewFile() method of the File class to create a new file in Java.

The File.createNewFile() method throws java.io.IOException if an I/O error occurred. It also throws SecurityException if a security manager exists and its SecurityManager.checkWriter(java.lang.String) method denies write access to the file. The signature of the method is:

1. Public boolean createNewFile() throws IOException  

We can pass the file name or absolute path or relative path as an argument in the File class object. For a non-absolute path, File object tries to locate the file in the current directory.

Example

The following example creates a new, empty text file. The first run creates music.txt successfully while on the second run it failed. We can create any type of file by changing the file extension only.

1. Import java.io.File;  
2. Import java.io.IOException;  
3. Public class CreateFileExample1   
4. {  
5. Public static void main(String[] args)   
6. {     
7. File file = new File("C:\\demo\\music.txt"); //initialize File object and passing path as argument  
8. Boolean result;  
9. Try   
10. {  
11. Result = file.createNewFile();  //creates a new file  
12. If(result)      // test if successfully created a new file  
13. {  
14. System.out.println("file created "+file.getCanonicalPath()); //returns the path string  
15. }  
16. Else  
17. {  
18. System.out.println("File already exist at location: "+file.getCanonicalPath());  
19. }  
20. }   
21. Catch (IOException e)   
22. {  
23. e.printStackTrace();    //prints exception if any  
24. }         
25. }  
26. }  

Output

When file does not exists.

When file already exists.

Java FileOutputStream

A file Output stream writes data to a file. Java FileOutputStream class also provide support for files. It belongs to the java.io package. It stores the data into bytes. We use FileOutputStream class when we need to write some data into the created file. The FileOutputStream class provides a constructor to create a file. The signature of the constructor is:

1. Public FileOutputStream(String name, boolean append) throws FileNotFoundException  

Parameters

Name: is the file name

Append: if true, byte will be written to the end of the file, not in the beginning.

Example

In the following example, we have created a file using FileOutputStream.

1. Import java.io.FileOutputStream;  
2. Import java.util.Scanner;  
3. Public class CreateFileExample  
4. {  
5. Public static void main(String args[])  
6. {  
7. Try  
8. {  
9. Scanner sc=new Scanner(System.in);         //object of Scanner class  
10. System.out.print("Enter the file name: ");  
11. String name=sc.nextLine();              //variable name to store the file name  
12. FileOutputStream fos=new FileOutputStream(name, true);  // true for append mode  
13. System.out.print("Enter file content: ");         
14. String str=sc.nextLine()+"\n";      //str stores the string which we have entered  
15. Byte[] b= str.getBytes();       //converts string into bytes  
16. Fos.write(b);           //writes bytes into file  
17. Fos.close();            //close the file  
18. System.out.println("file saved.");  
19. }  
20. Catch(Exception e)  
21. {  
22. e.printStackTrace();          
23. }  
24. }  
25. }  

Output

Java File.createFile() method

The File.createFile() is a method of File class which belongs to java.nio.file package. It also provides support for files. The nio package is buffer-oriented. The createFile() method is also used to create a new, empty file. We don't need to close the resources when using this method. It is an advantage. The signature of the method is:

1. Public static Path createFile(Path, Attribute) throws IOException  

Path: The path of the file.

Attribute: An optional list of file attributes.

The method returns the file.

The following example also creates a new, empty file. We create a Path instance using a static method in the Paths class (java.nio.file.Paths) named Paths.get(). Notice the following statement:

Path path = Paths.get("C:\\demo\\javaprogram.txt");

In the above line Path is an interface and Paths is a class. Both belongs to same package. The Paths.get() method creates the Path Instance.

1. Import java.io.IOException;  
2. Import java.nio.file.*;  
3. Public class CreateFileExample3  
4. {  
5. Public static void main(String[] args)   
6. {  
7. Path path = Paths.get("C:\\demo\\javaprogram.txt"); //creates Path instance  
8. Try   
9. {  
10. Path p= Files.createFile(path);     //creates file at specified location  
11. System.out.println("File Created at Path: "+p);  
12. }   
13. Catch (IOException e)   
14. {  
15. e.printStackTrace();  
16. }  
17. }  
18. }  

Output

6.11 Reading/Writing Character

Character Streams − These handle data in 16 bit Unicode. Using these you can read and write text data only.

The Reader and Writer classes (abstract) are the super classes of all the character stream classes: classes that are used to read/write character streams. Following are the character array stream classes provided by Java −

Example

The following Java program reads data from a particular file using FileReader and writes it to another, using FileWriter.

Import java.io.File;

Import java.io.FileReader;

Import java.io.FileWriter;

Import java.io.IOException;

Public class IOStreamsExample {

Public static void main(String args[]) throws IOException {

//Creating FileReader object

File file = new File("D:/myFile.txt");

FileReader reader = new FileReader(file);

Char chars[] = new char[(int) file.length()];

//Reading data from the file

Reader.read(chars);

//Writing data to another file

File out = new File("D:/CopyOfmyFile.txt");

FileWriter writer = new FileWriter(out);

//Writing data to the file

Writer.write(chars);

Writer.flush();

System.out.println("Data successfully written in the specified file");

}

}

Output

Data successfully written in the specified file

6.12 Reading/Writing Bytes

Usually data is much more complicated than the data for the example program. But the program shows the outer logic that is needed to read most files. Sometimes the data in a file represents something other than a primitive Java type. For example, word processor files contain various arrangements of bytes that encode fonts, page formats, special symbols, and graphics.

The DataOutputStream and DataInputStream classes have several methods for reading and writing single bytes.

WriteByte() writes the least significant byte of its int argument to the output stream. ReadUnsignedByte() reads a byte from the input stream and puts it in the least significant byte of its return value.

DataOutputStream:

Public final void writeByte(int b) throws IOException

DataInputStream:

Public final int readUnsignedByte() throws IOException

6.13 Handling Primitive Data Types

Not everything in Java is an object. There is a special group of data types (also known as primitive types) that will be used quite often in programming. For performance reasons, the designers of the Java language decided to include these primitive types. Java determines the size of each primitive type. These sizes do not change from one operating system to another. This is one of the key features of the language that makes Java so portable. Java defines eight primitive types of data: byte, short, int, long, char, float, double, and boolean. The primitive types are also commonly referred to as simple types which can be put in four groups

• Integers: This group includes byte, short, int, and long, which are for whole-valued signed numbers.
• Floating-point numbers: This group includes float and double, which represent numbers with fractional precision.
• Characters: This group includes char, which represents symbols in a character set, like letters and numbers.
• Boolean: This group includes boolean, which is a special type for representing true/false values.

Let’s discuss each in details:

Byte

The smallest integer type is byte. It has a minimum value of -128 and a maximum value of 127 (inclusive). The byte data type can be useful for saving memory in large arrays, where the memory savings actually matters. Byte variables are declared by use of the byte keyword. For example, the following declares and initialize byte variables called b:

Byte  b =100;

Short:

The short data type is a 16-bit signed two's complement integer. It has a minimum value of -32,768 and a maximum value of 32,767 (inclusive). As with byte, the same guidelines apply: you can use a short to save memory in large arrays, in situations where the memory savings actually matters. Following example declares and initialize short variable called s:

Short  s =123;

Int:

The most commonly used integer type is int. It is a signed 32-bit type that has a range from –2,147,483,648 to 2,147,483,647. In addition to other uses, variables of type int are commonly employed to control loops and to index arrays. This data type will most likely be large enough for the numbers your program will use, but if you need a wider range of values, use long instead.

Int  v = 123543;

Int  calc = -9876345;

Long:

Long is a signed 64-bit type and is useful for those occasions where an int type is not large enough to hold the desired value. It has a minimum value of -9,223,372,036,854,775,808 and a maximum value of 9,223,372,036,854,775,807 (inclusive). Use of this data type might be in banking application when large amount is to be calculated and stored.

Long  amountVal = 1234567891;

Float:

Floating-point numbers, also known as real numbers, are used when evaluating expressions that require fractional precision. For example interest rate calculation or calculating square root. The float data type is a single-precision 32-bit IEEE 754 floating point. As with the recommendations for byte and short, use a float (instead of double) if you need to save memory in large arrays of floating point numbers. The type float specifies a single-precision value that uses 32 bits of storage. Single precision is faster on some processors and takes half as much space as double precision. The declaration and initialization syntax for float variables given below, please note “f” after value initialization.

Float  intrestRate = 12.25f;

Double:

Double precision, as denoted by the double keyword, uses 64 bits to store a value. Double precision is actually faster than single precision on some modern processors that have been optimized for high-speed mathematical calculations. All transcendental math functions, such as sin( ), cos( ), and sqrt( ), return double values. The declaration and initialization syntax for double variables given below, please note “d” after value initialization.

Double  sineVal = 12345.234d;

Boolean:

The boolean data type has only two possible values: true and false. Use this data type for simple flags that track true/false conditions. This is the type returned by all relational operators, as in the case of a < b. Boolean is also the type required by the conditional expressions that govern the control statements such as if or while.

Boolean  flag = true;

Booleanval  = false;

Char:

In Java, the data type used to store characters is char. The char data type is a single 16-bit Unicode character. It has a minimum value of '\u0000' (or 0) and a maximum value of '\uffff' (or 65,535 inclusive). There are no negative chars.

Char ch1 = 88; // code for X

Char  ch2 = 'Y';

Primitive Variables can be of two types

(1) Class level (instance) variable:

It's not mandatory to initialize Class level (instance) variable. If we do not initialize instance variable compiler will assign default value to it. Generally speaking, this default will be zero or null, depending on the data type. Relying on such default values, however, is generally considered bad coding practice.The following chart summarizes the default values for the above data types.

(2) Method local variable:

Method local variables have to be initialized before using it. The compiler never assigns a default value to an un-initialized local variable. If you cannot initialize your local variable where it is declared, make sure to assign it a value before you attempt to use it. Accessing an un-initialized local variable will result in a compile-time error.

Let’s See simple java program which declares, initialize and print all of primitive types.

Java class PrimitiveDemo as below:

Package primitive;

Public class PrimitiveDemo {

Public static void main(String[] args) {

Byte b =100;

Short s =123;

Int v = 123543;

Int calc = -9876345;

Long amountVal = 1234567891;

Float intrestRate = 12.25f;

Double sineVal = 12345.234d;

Boolean flag = true;

Boolean val = false;

Char ch1 = 88; // code for X

Char ch2 = 'Y';

System.out.println("byte Value = "+ b);

System.out.println("short Value = "+ s);

System.out.println("int Value = "+ v);

System.out.println("int second Value = "+ calc);

System.out.println("long Value = "+ amountVal);

System.out.println("float Value = "+ intrestRate);

System.out.println("double Value = "+ sineVal);

System.out.println("boolean Value = "+ flag);

System.out.println("boolean Value = "+ val);

System.out.println("char Value = "+ ch1);

System.out.println("char Value = "+ ch2);

}

}

Copy

Output of above PrimitiveDemo class as below:

Summary of Data Types

Summary

• Java has group of variable types called primitive data type which are not object.
• Primitive types are categorized as Integer, Floating point, characters and boolean.
• Primitive types help for better performance of the application.

6.14 Concatenating and Buffering Files

Concatenate: It is possible to concatenate two or more files and save in a different file.

In java, by using SequenceInputStream class we can concatenate two or more files.

Buffer Files: In java, we can create a buffer to store temporary data that is read from & written to a stream and this process known as i/o buffer operation.

Buffer is  sit between programmer and source/destination file.

Buffer can be created by using following classes:

• BufferedInputClass
• BufferedOutputClass

Example: write a program to concatenate two file A & B and concatenated data print on output screen.

Suppose we have a File “A.txt”

And                         File “B.txt”

Output: Hello students I am aditya.                                                                                           Hello

Example: Write a program to copy the content of one file to another file using buffer/BufferReader.                                                                

Suppose we have a File “A.txt”                               

Output:                                              File “B”

Note: If there is no file “B” it will be create automatically.

Example: Write a program to concatenate two file A & B and save the concatenated data on a file C.

Suppose we have a File “A.txt” and File “B.txt”

Output:               File “C”

Note: Ifthere is no file “C” it will be create automatically.

6.15 Random Access Files

This class is used for reading and writing to random access file. A random access file behaves like a large array of bytes. There is a cursor implied to the array called file pointer, by moving the cursor we do the read write operations. If end-of-file is reached before the desired number of byte has been read than EOFException is thrown. It is a type of IOException.

Constructor

Method

Example

1. Import java.io.IOException;  
2. Import java.io.RandomAccessFile;  
3.  
4. Public class RandomAccessFileExample {  
5.    Static final String FILEPATH ="myFile.TXT";  
6.    Public static void main(String[] args) {  
7.        Try {  
8.            System.out.println(new String(readFromFile(FILEPATH, 0, 18)));  
9.            WriteToFile(FILEPATH, "I love my country and my people", 31);  
10.        } catch (IOException e) {  
11.            e.printStackTrace();  
12.        }  
13.    }  
14.    Private static byte[] readFromFile(String filePath, int position, int size)  
15.            Throws IOException {  
16.        RandomAccessFile file = new RandomAccessFile(filePath, "r");  
17.        File.seek(position);  
18.        Byte[] bytes = new byte[size];  
19.        File.read(bytes);  
20.        File.close();  
21.        Return bytes;  
22.    }  
23.    Private static void writeToFile(String filePath, String data, int position)  
24.            Throws IOException {  
25.        RandomAccessFile file = new RandomAccessFile(filePath, "rw");  
26.        File.seek(position);  
27.        File.write(data.getBytes());  
28.        File.close();  
29.    }  
30. }  

The myFile.TXT contains text "This class is used for reading and writing to random access file."

After running the program it will contains

This class is used for reading I love my country and my peoplele.

6.16 Design Patterns: Introduction, Types of Design Patterns

A design patterns are well-proved solution for solving the specific problem/task.

Now, a question will be arising in your mind what kind of specific problem? Let me explain by taking an example.

Problem Given:
Suppose you want to create a class for which only a single instance (or object) should be created and that single object can be used by all other classes.

Solution:
Singleton design pattern is the best solution of above specific problem. So, every design pattern has some specification or set of rules for solving the problems. What are those specifications, you will see later in the types of design patterns.

But remember one-thing, design patterns are programming language independent strategies for solving the common object-oriented design problems. That means, a design pattern represents an idea, not a particular implementation.

By using the design patterns you can make your code more flexible, reusable and maintainable. It is the most important part because java internally follows design patterns.

To become a professional software developer, you must know at least some popular solutions (i.e. design patterns) to the coding problems.

Advantage of design pattern:

1. They are reusable in multiple projects.
2. They provide the solutions that help to define the system architecture.
3. They capture the software engineering experiences.
4. They provide transparency to the design of an application.
5. They are well-proved and testified solutions since they have been built upon the knowledge and experience of expert software developers.
6. Design patterns don?t guarantee an absolute solution to a problem. They provide clarity to the system architecture and the possibility of building a better system.

When should we use the design patterns?

We must use the design patterns during the analysis and requirement phase of SDLC(Software Development Life Cycle).

Design patterns ease the analysis and requirement phase of SDLC by providing information based on prior hands-on experiences.

Categorization of design patterns:

Basically, design patterns are categorized into two parts:

1. Core Java (or JSE) Design Patterns.
2. JEE Design Patterns.

Core Java Design Patterns

In core java, there are mainly three types of design patterns, which are further divided into their sub-parts:

1. Creational Design Pattern

1. Factory Pattern
2. Abstract Factory Pattern
3. Singleton Pattern
4. Prototype Pattern
5. Builder Pattern.

2. Structural Design Pattern

1. Adapter Pattern
2. Bridge Pattern
3. Composite Pattern
4. Decorator Pattern
5. Facade Pattern
6. Flyweight Pattern
7. Proxy Pattern

3. Behavioural Design Pattern

1. Chain Of Responsibility Pattern
2. Command Pattern
3. Interpreter Pattern
4. Iterator Pattern
5. Mediator Pattern
6. Memento Pattern
7. Observer Pattern
8. State Pattern
9. Strategy Pattern
10. Template Pattern
11. Visitor Pattern

6.17 Adapter Patterns

An Adapter Pattern says that just "converts the interface of a class into another interface that a client wants".

In other words, to provide the interface according to client requirement while using the services of a class with a different interface.

The Adapter Pattern is also known as Wrapper.

Advantage of Adapter Pattern

• It allows two or more previously incompatible objects to interact.
• It allows reusability of existing functionality.

Usage of Adapter pattern:

It is used:

• When an object needs to utilize an existing class with an incompatible interface.
• When you want to create a reusable class that cooperates with classes which don't have compatible interfaces.
• When you want to create a reusable class that cooperates with classes which don't have compatible interfaces.

Example of Adapter Pattern

Let's understand the example of adapter design pattern by the above UML diagram.

UML for Adapter Pattern:

There are the following specifications for the adapter pattern:

• Target Interface: This is the desired interface class which will be used by the clients.
• Adapter class: This class is a wrapper class which implements the desired target interface and modifies the specific request available from the Adaptee class.
• Adaptee class: This is the class which is used by the Adapter class to reuse the existing functionality and modify them for desired use.
• Client: This class will interact with the Adapter class.

Implementation of above UML:

Step 1

Create a CreditCard interface (Target interface).

1. Public interface CreditCard {  
2.    Public void giveBankDetails();  
3.    Public String getCreditCard();  
4. }// End of the CreditCard interface.  

Step 2

Create a BankDetails class (Adaptee class).

File: BankDetails.java

1. // This is the adapter class.  
2. Public class BankDetails{  
3.    Private String bankName;  
4.    Private String accHolderName;  
5.    Private long accNumber;  
6.      
7.    Public String getBankName() {  
8.        Return bankName;  
9.    }  
10.    Public void setBankName(String bankName) {  
11.        This.bankName = bankName;  
12.    }  
13.    Public String getAccHolderName() {  
14.        Return accHolderName;  
15.    }  
16.    Public void setAccHolderName(String accHolderName) {  
17.        This.accHolderName = accHolderName;  
18.    }  
19.    Public long getAccNumber() {  
20.        Return accNumber;  
21.    }  
22.    Public void setAccNumber(long accNumber) {  
23.        This.accNumber = accNumber;  
24.    }  
25. }// End of the BankDetails class.  

Step 3

Create a BankCustomer class (Adapter class).

File: BankCustomer.java

1. // This is the adapter class  
2.  
3. Import java.io.BufferedReader;  
4. Import java.io.InputStreamReader;  
5. Public class BankCustomer extends BankDetails implements CreditCard {  
6. Public void giveBankDetails(){  
7.  Try{  
8.   BufferedReader br=new BufferedReader(new InputStreamReader(System.in));  
9.      
10.   System.out.print("Enter the account holder name :");  
11.   String customername=br.readLine();  
12.   System.out.print("\n");  
13.      
14.   System.out.print("Enter the account number:");  
15.   Long accno=Long.parseLong(br.readLine());  
16.   System.out.print("\n");  
17.      
18.   System.out.print("Enter the bank name :");  
19.   String bankname=br.readLine();  
20.      
21.   SetAccHolderName(customername);  
22.   SetAccNumber(accno);  
23.   SetBankName(bankname);  
24.   }catch(Exception e){  
25.        e.printStackTrace();  
26.   }  
27.  }  
28.  @Override  
29.  Public String getCreditCard() {  
30.   Long accno=getAccNumber();  
31.   String accholdername=getAccHolderName();  
32.   String bname=getBankName();  
33.          
34.   Return ("The Account number "+accno+" of "+accholdername+" in "+bname+ "  
35.                        Bank is valid and authenticated for issuing the credit card. ");  
36.  }  
37. }//End of the BankCustomer class.  

Step 4

Create a AdapterPatternDemo class (client class).

File: AdapterPatternDemo.java

1. //This is the client class.  
2. Public class AdapterPatternDemo {  
3. Public static void main(String args[]){  
4.  CreditCard targetInterface=new BankCustomer();  
5.  TargetInterface.giveBankDetails();  
6.  System.out.print(targetInterface.getCreditCard());  
7. }   
8. }//End of the BankCustomer class.  

Output

1. Enter the account holder name :Sonoo Jaiswal  
2.  
3. Enter the account number:10001  
4.  
5. Enter the bank name :State Bank of India  
6.  
7. The Account number 10001 of Sonoo Jaiswal in State Bank of India bank is valid   
8. And authenticated for issuing the credit card.  

6.18 Singleton pattern

Singleton Pattern says that just" define a class that has only one instance and provides a global point of access to it".

In other words, a class must ensure that only single instance should be created and single object can be used by all other classes.

There are two forms of singleton design pattern

• Early Instantiation: creation of instance at load time.
• Lazy Instantiation: creation of instance when required.

Advantage of Singleton design pattern

• Saves memory because object is not created at each request. Only single instance is reused again and again.

Usage of Singleton design pattern

• Singleton pattern is mostly used in multi-threaded and database applications. It is used in logging, caching, thread pools, configuration settings etc.

Uml of Singleton design pattern

How to create Singleton design pattern?

To create the singleton class, we need to have static member of class, private constructor and static factory method.

• Static member: It gets memory only once because of static, itcontains the instance of the Singleton class.
• Private constructor: It will prevent to instantiate the Singleton class from outside the class.
• Static factory method: This provides the global point of access to the Singleton object and returns the instance to the caller.

Understanding early Instantiation of Singleton Pattern

In such case, we create the instance of the class at the time of declaring the static data member, so instance of the class is created at the time of classloading.

Let's see the example of singleton design pattern using early instantiation.

File: A.java

1. Class A{  
2. Private static A obj=new A();//Early, instance will be created at load time  
3. Private A(){}  
4.   
5. Public static A getA(){  
6.  Return obj;  
7. }  
8.  
9. Public void doSomething(){  
10. //write your code  
11. }  
12. }  

Understanding lazy Instantiation of Singleton Pattern

In such case, we create the instance of the class in synchronized method or synchronized block, so instance of the class is created when required.

Let's see the simple example of singleton design pattern using lazy instantiation.

File: A.java

1. Class A{  
2. Private static A obj;  
3. Private A(){}  
4.   
5. Public static A getA(){  
6.   If (obj == null){  
7.      Synchronized(Singleton.class){  
8.        If (obj == null){  
9.            Obj = new Singleton();//instance will be created at request time  
10.        }  
11.    }              
12.    }  
13.  Return obj;  
14. }  
15.  
16. Public void doSomething(){  
17. //write your code  
18. }  
19. }  

Significance of Classloader in Singleton Pattern

If singleton class is loaded by two classloaders, two instance of singleton class will be created, one for each classloader.

Significance of Serialization in Singleton Pattern

If singleton class is Serializable, you can serialize the singleton instance. Once it is serialized, you can deserialize it but it will not return the singleton object.

To resolve this issue, you need to override the readResolve() method that enforces the singleton. It is called just after the object is deserialized. It returns the singleton object.

1. Public class A implements Serializable {  
2.        //your code of singleton  
3.        Protected Object readResolve() {  
4.            Return getA();  
5.        }  
6.  
7.    }  

Understanding Real Example of Singleton Pattern

• We are going to create a JDBCSingleton class. This JDBCSingleton class contains its constructor as private and a private static instance jdbc of itself.
• JDBCSingleton class provides a static method to get its static instance to the outside world. Now, JDBCSingletonDemo class will use JDBCSingleton class to get the JDBCSingleton object.

Assumption: you have created a table userdata that has three fields uid, uname and upassword in mysql database. Database name is ashwinirajput, username is root, password is ashwini.

File: JDBCSingleton.java

1. Import java.io.BufferedReader;  
2. Import java.io.IOException;  
3. Import java.io.InputStreamReader;  
4. Import java.sql.Connection;  
5. Import java.sql.DriverManager;  
6. Import java.sql.PreparedStatement;  
7. Import java.sql.ResultSet;  
8. Import java.sql.SQLException;  
9.  
10. Class JDBCSingleton {  
11.     //Step 1  
12.      // create a JDBCSingleton class.  
13.     //static member holds only one instance of the JDBCSingleton class.  
14.             
15.         Private static JDBCSingleton jdbc;  
16.           
17.     //JDBCSingleton prevents the instantiation from any other class.  
18.       Private JDBCSingleton() {  }  
19.        
20.    //Now we are providing gloabal point of access.  
21.         Public static JDBCSingleton getInstance() {    
22.                                     If (jdbc==null)  
23.                                   {  
24.                                            Jdbc=new  JDBCSingleton();  
25.                                   }  
26.                         Return jdbc;  
27.             }  
28.            
29.   // to get the connection from methods like insert, view etc.   
30.          Private static Connection getConnection()throws ClassNotFoundException, SQLException  
31.          {  
32.                
33.              Connection con=null;  
34.              Class.forName("com.mysql.jdbc.Driver");  
35.              Con= DriverManager.getConnection("jdbc:mysql://localhost:3306/ashwanirajput", "root", "ashwani");  
36.              Return con;  
37.                
38.          }  
39.            
40. //to insert the record into the database   
41.          Public int insert(String name, String pass) throws SQLException  
42.          {  
43.              Connection c=null;  
44.                
45.              PreparedStatement ps=null;  
46.                
47.              Int recordCounter=0;  
48.                
49.              Try {  
50.                    
51.                      c=this.getConnection();  
52.                      Ps=c.prepareStatement("insert into userdata(uname,upassword)values(?,?)");  
53.                      Ps.setString(1, name);  
54.                      Ps.setString(2, pass);  
55.                      RecordCounter=ps.executeUpdate();  
56.                        
57.              } catch (Exception e) { e.printStackTrace(); } finally{  
58.                    If (ps!=null){  
59.                      Ps.close();  
60.                  }if(c!=null){  
61.                      c.close();  
62.                  }   
63.              }  
64.             Return recordCounter;  
65.          }  
66.  
67. //to view the data from the database        
68.      Public  void view(String name) throws SQLException  
69.      {  
70.                Connection con = null;  
71.        PreparedStatement ps = null;  
72.        ResultSet rs = null;  
73.                  
74.                Try {  
75.                      
76.                        Con=this.getConnection();  
77.                        Ps=con.prepareStatement("select * from userdata where uname=?");  
78.                        Ps.setString(1, name);  
79.                        Rs=ps.executeQuery();  
80.                        While (rs.next()) {  
81.                                  System.out.println("Name= "+rs.getString(2)+"\t"+"Paasword= "+rs.getString(3));      
82.                         
83.                        }  
84.                
85.          } catch (Exception e) { System.out.println(e);}  
86.          Finally{  
87.                    If(rs!=null){  
88.                        Rs.close();  
89.                    }if (ps!=null){  
90.                      Ps.close();  
91.                  }if(con!=null){  
92.                      Con.close();  
93.                  }   
94.                }  
95.      }  
96.        
97.     // to update the password for the given username  
98.      Public int update(String name, String password) throws SQLException  {  
99.              Connection c=null;  
100.               PreparedStatement ps=null;  
101.                 
102.               Int recordCounter=0;  
103.               Try {  
104.                       c=this.getConnection();  
105.                       Ps=c.prepareStatement(" update userdata set upassword=? where uname='"+name+"' ");  
106.                       Ps.setString(1, password);  
107.                       RecordCounter=ps.executeUpdate();  
108.               } catch (Exception e) {  e.printStackTrace(); } finally{  
109.                       
110.                   If (ps!=null){  
111.                       Ps.close();  
112.                   }if(c!=null){  
113.                       c.close();  
114.                   }   
115.                }  
116.              Return recordCounter;  
117.           }  
118.             
119. // to delete the data from the database   
120.          Public int delete(int userid) throws SQLException{  
121.               Connection c=null;  
122.               PreparedStatement ps=null;  
123.               Int recordCounter=0;  
124.               Try {  
125.                        c=this.getConnection();  
126.                       Ps=c.prepareStatement(" delete from userdata where uid='"+userid+"' ");  
127.                       RecordCounter=ps.executeUpdate();  
128.               } catch (Exception e) { e.printStackTrace(); }   
129.               Finally{  
130.               If (ps!=null){  
131.                       Ps.close();  
132.              }if(c!=null){  
133.                       c.close();  
134.               }   
135.            }  
136.              Return recordCounter;  
137.           }  
138.  }// End of JDBCSingleton class