In programming, persistence storage refers to a storage area which may forget the data/information once it looses the electronic energy supply. such as RAM – Random Access Memory. When we run an application having some variables, methods, objects, etc. That data is stored in Computer RAM. Problem with this system is when we want to share some information between two execution cycle that won’t be possible. For Example: We have developed a “Student Management System” for a college and one operator starts entering student records in our software. If we as a developer has written code which stores student information in an Array, in that case a power failure/system crash/software termination/software closing may lead to information lost and operator need to start entering details from the scratch! Here the conclusion is: We cannot not store the important or permanent data in RAM. We must choose either 1) File 2) Database. In this tutorial we gonna learn about reading a file. so that the previously written data can be fetched and processed. By this way our application will also be in a consistent state. Following are the various ways to read a file in any storage device like hard disk, floppy, pen drive, etc. The basic need to use a storage device is to mount the same and you are ready to go!

FileInputStream

FileInputStream is derived from InputStream class.

import java.io.*;

class FileInputStreamDemo
{
	public static void main(String[] s)throws IOException
	{
		byte[] b = new byte[10000];
		File f = new File("data.txt");  // this wil points to the data.txt of the same directory where your program is stored.
		FileInputStream fis = new FileInputStream(f);
		int length = fis.read(b);
		String str = new String(b,0,length);
		
		System.out.println("Data: "+str);
		
		fis.close();
			
	}	
}

Output:

FileReader

import java.io.*;

class FileReaderDemo
{
	public static void main(String[] s)throws IOException
	{
		String str = "";
		char[] c = new char[100];
		File f = new File("data.txt"); 
		FileReader fr = new FileReader(f);
		
		int len = 0;
		len = fr.read(c);
		str = new String(c,0,len);
		System.out.println("Data: "+str);
		
		fr.close();
	}	
}

Output:

BufferedWriter + FileWriter

import java.io.*;

class FileBufferedReaderDemo
{
	public static void main(String[] arg)throws Exception
	{
		BufferedReader br = new BufferedReader(new FileReader(new File("data.txt")));
		System.out.print("Data: ");
		String str = br.readLine();
		System.out.println(str);	
	}
}

Output:

FilterReader

FilterReader is an abstract class which does not have any abstract method. We can override the methods of it and perform our code instead. For more details visit: FilterReader

Aim

Write a program using FilterReader which removes tags from the file content. e.g. <tag> should be removed.

import java.io.*;
class FilterReaderDemo
{
  	public static void main(String[] args) 
	{
		try 
		{
          FilterReader fr = new FilterReader(new FileReader("data.txt")){
			  		  public int read(char[] buf, int from, int len) throws IOException 
					  {
						boolean intag = false;
						int numchars = 0; 
						
						while (numchars == 0) 
						{
						  numchars = in.read(buf, from, len); 
						  if (numchars == -1)
						  {
							return -1;
						  }
						  int last = from; 
						  for (int i = from; i < from + numchars; i++) 
						  {
							if (!intag) 
							{
							  if (buf[i] == '<')
								intag = true; 
							  else
								buf[last++] = buf[i]; 
							} 
							else if (buf[i] == '>')
							{
							  intag = false;
							}
						  }
						  numchars = last - from; 
						}
						return numchars;
					  }
					
					  public int read() throws IOException 
					  {
						char[] buf = new char[1];
						int result = read(buf, 0, 1);
						if (result == -1)
						  return -1;
						else
						  return (int) buf[0];
					  }
			  };
		  BufferedReader in = new BufferedReader(fr);
		  
		  String line;
		  while ((line = in.readLine()) != null)
		  {
			System.out.println(line);
		  }
		  in.close(); // Close the stream.
		} 
		catch (Exception e) 
		{
		  System.err.println(e);
		}
  }
}

Output:
Output:

DataInputStream

import java.io.*;
class DataInputStreamDemo
{
	public static void main(String[] s)throws Exception
	{
		FileInputStream fis = new FileInputStream(new File("db.txt"));
		DataInputStream dis = new DataInputStream(fis);
		int avail =  dis.available();
		byte[] b = new byte[avail];
		dis.readFully(b);
		System.out.println(new String(b)); 
		dis.close();		
	}	
}

Output:

ObjectInputStream

import java.io.*;
import java.util.*;
class ObjectInputStreamDemo
{
	public static void main(String[] s)throws Exception
	{
		FileInputStream fis = new FileInputStream("test.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);

        System.out.println(ois.readInt());
        System.out.println(ois.readObject());
        System.out.println(ois.readObject());
		ois.close();
		System.out.println("All Objects read!");
	}	
}

Output:

The post Various ways to read a file appeared first on Ankit Virparia.

A normal reader/writer class can read/write what we demand for. But lets say we have a special requirement of writing/reading. For Example: We want to read only those lines from the file which has “.” at the end. Rest we want to skip. For this kind of scenario where by some very frequent and static processing is to be done each time then we can create our own FilterReader which will do the job for us. So that manually we will not be doing it again and again. FilterReader is an abstract class which does not have any abstract method. We can override the methods of it and perform our code instead. We are going to discuss another case here.

Aim

Write a program using FilterReader which removes tags from the file content. e.g. <tag> should be removed.

import java.io.*;

class NoTagReader extends FilterReader 
{
  boolean intag = false;
  public NoTagReader(Reader r) 
  {
    super(r);
  }

  public int read(char[] buf, int from, int len) throws IOException 
  {
    int numchars = 0; 
	
    while (numchars == 0) 
	{
      numchars = in.read(buf, from, len); 
      if (numchars == -1)
	  {
        return -1;
	  }
      int last = from; 
      for (int i = from; i < from + numchars; i++) 
	  {
        if (!intag) 
		{
          if (buf[i] == '<')
            intag = true; 
          else
            buf[last++] = buf[i]; 
        } 
		else if (buf[i] == '>')
		{
          intag = false;
		}
      }
      numchars = last - from; 
    }
    return numchars;
  }

  public int read() throws IOException 
  {
    char[] buf = new char[1];
    int result = read(buf, 0, 1);
    if (result == -1)
      return -1;
    else
      return (int) buf[0];
  }

}
class FilterReaderDemo
{
  	public static void main(String[] args) 
	{
		try 
		{
          NoTagReader ntr = new NoTagReader(new FileReader("data.txt"))
		  BufferedReader in = new BufferedReader(ntr);
		  
		  String line;
		  while ((line = in.readLine()) != null)
		  {
			System.out.println(line);
		  }
		  in.close(); // Close the stream.
		} 
		catch (Exception e) 
		{
		  System.err.println(e);
		}
  }
}

Output:

The post FilterReader appeared first on Ankit Virparia.

A normal reader/writer class can read/write what we demand for. But lets say we have a special requirement of writing/reading. For Example: At the end of the file which we write, we want to print(write) Date. Which is a special requirement and this will be needed for each time we write a file. For this kind of scenario where by some very frequent and static processing is to be done each time then we can create our own FilterWriter which will do the job for us. So that manually we will not be doing it again and again. FilterWriter is an abstract class which does not have any abstract method. We can override the methods of it and perform our code instead. We are going to discuss another case here.

Aim

Write a program using FilterWriter which converts larges statements(having more than 15 chars) to a shorter statement and write a file.
e.g. If we tries to write “This is demo by Ankit”. It appends first 5 chars and last 5 chars of string with “…” and generate “This … Ankit” as a output.

import java.io.*;

public class FilterDemo 
{

    public static void main(String[] args)throws Exception
	{
        File f = new File("data.txt");  
		FileWriter fw = new FileWriter(f);
		myFilterWriter mfw = new myFilterWriter(fw);
		mfw.write("This is demo by Ankit");
		mfw.flush();
		mfw.close();
    }
}

class myFilterWriter extends FilterWriter
{
    myFilterWriter(Writer w)
    {
       super(w); 
    }

    @Override
    public void write(String str) throws IOException 
    {
        int len = str.length();
        String output = "";
        if(len>15)
        {
            output = str.substring(0,5);
            output += "... ";
            output += str.substring(len-5,len);
        }
        super.write(output); 
    }
    
}

Output:

The post FilterWriter appeared first on Ankit Virparia.

In programming, persistence storage refers to a storage area which may forget the data/information once it looses the electronic energy supply. such as RAM – Random Access Memory. When we run an application having some variables, methods, objects, etc. That data is stored in Computer RAM. Problem with this system is when we want to share some information between two execution cycle that won’t be possible. For Example: We have developed a “Student Management System” for a college and one operator starts entering student records in our software. If we as a developer has written code which stores student information in an Array, in that case a power failure/system crash/software termination/software closing may lead to information lost and operator need to start entering details from the scratch! Here the conclusion is: We cannot not store the important or permanent data in RAM. We must choose either 1) File 2) Database. In this tutorial we gonna learn about writing a file. so that the same/other application can read the data which we have written in future. By this way our application will also be in a consistent state. Following are the various ways to write a file in any storage device like hard disk, floppy, pen drive, etc. The basic need to use a storage device is to mount the same and you are ready to go!

FileOutputStream

FileOutputStream is derived from OutputStream class.

import java.io.*;

class FileOutputStreamDemo
{
	public static void main(String[] s)throws IOException
	{
		byte[] b;
		String str = "I want to write some text to file.";
		b = str.getBytes();
		
		
		File f = new File("data.txt");  // this will points to the data.txt of the same directory where your program is stored.
		FileOutputStream fos = new FileOutputStream(f);
		fos.write(b);
		fos.flush();
		
		System.out.println("File Created!");
		
		fos.close();
	}	
}

Output:

FileWriter

import java.io.*;

class FileWriterDemo
{
	public static void main(String[] s)throws IOException
	{
		String str = "I want to write some text to file.";
		
		File f = new File("data.txt");  // this wil points to the data.txt of the same directory where your program is stored.
		FileWriter fw = new FileWriter(f);
		
		fw.write(str);
		fw.flush();
		
		System.out.println("File Created!");
		
		fw.close();
	}	
}

Output:

BufferedWriter + FileWriter

import java.io.*;

class FileBufferedWriterDemo
{
	public static void main(String[] s)throws IOException
	{
		String str = "I want to write some text to file.";
		
		
		File f = new File("data.txt");  // this wil points to the data.txt of the same directory where your program is stored.
		FileWriter fw = new FileWriter(f);
		BufferedWriter bw = new BufferedWriter(fw);
		
		bw.write(str);
		bw.flush();
		
		System.out.println("File Created!");
		
		bw.close();
			
	}	
}

Output:

FilterWriter

FilterWriter is an abstract class which does not have any abstract method. We can override the methods of it and perform our code instead. For more details visit: FilterWriter

Aim

Write a program which defines a FilterWriter which converts larges statements(having more than 15 chars) to a shorter statement and write a file.
e.g. If we tries to write “This is demo by Ankit”. It appends first 5 chars and last 5 chars of string with “…” and generate “This … Ankit” as a output.

import java.io.*;
public class FilterDemo
{
    public static void main(String[] args) throws IOException 
    {
        // TODO code application logic here
        File f = new File("data.txt");  
        FileWriter fw = new FileWriter(f);
        FilterWriter mfw = new FilterWriter(fw){
            @Override
            public void write(String str) throws IOException 
            {
                int len = str.length();
                String output = "";
                if(len>15)
                {
                    output = str.substring(0,5);
                    output += "... ";
                    output += str.substring(len-5,len);
                }
                super.write(output); 
             }};
        mfw.write("This is demo by Ankit");
        mfw.flush();
        mfw.close();
        
    }
}

Output:

DataOputputStream

import java.io.*;
class DataOutputStreamDemo
{
	public static void main(String[] s)throws Exception
	{
		FileOutputStream fos = new FileOutputStream(new File("db.txt"));
		DataOutputStream dos = new DataOutputStream(fos);
		dos.writeBytes("This is Test\n\n"); 
		dos.writeDouble(1232.23);
		dos.writeInt(123);
		
		dos.flush();
		dos.close();	
		System.out.println("File Written");	
	}	
}

Output:

ObjectOputputStream

import java.io.*;
import java.util.*;
class ObjectOutputStreamDemo
{
	public static void main(String[] s)throws Exception
	{
		FileOutputStream fos = new FileOutputStream("test.txt");
                ObjectOutputStream oos = new ObjectOutputStream(fos);

                oos.writeInt(12345);
                oos.writeObject("Today");
                oos.writeObject(new Date());
		oos.flush();
                oos.close();
		System.out.println("Objects written!");
	}	
}

Output:

The post Various ways to write a file appeared first on Ankit Virparia.

import java.io.*;
class mkdirDemo
{
	public static void main(String[] s)
	{
		File f = new File("newDir");
		f.mkdir();
		System.out.println("Directory created.");	
	}	
}

Output:

Program to create multiple new Directories using File class:

In case if we would like to create multiple nested directories, A different function is to be invoked. which is: mkdirs()

import java.io.*;
class mkdirsDemo
{
	public static void main(String[] s)
	{
		File f = new File("a/b/newDir/testDir/c");
		f.mkdirs();
		System.out.println("Directories created.");	
	}	
}

Output:

The post Creating directories using Java appeared first on Ankit Virparia.

import java.io.*;
import java.util.*;
class ListDirContent 
{
	public static void main(String args[]) 
	{
		String dirname = "";
		System.out.print("Enter a path:");
		Scanner sc = new Scanner(System.in);
		dirname = sc.nextLine();
		
		File f1 = new File(dirname);
		if (f1.isDirectory()) 
		{
			System.out.println("Directory of " + dirname);
			String s[] = f1.list();
			for (int i=0; i < s.length; i++) 
			{
				File f = new File(dirname + "/" + s[i]);
				if (f.isDirectory()) 
				{
					System.out.println(s[i] + " is a directory");
				} 
				else 
				{
					System.out.println(s[i] + " is a file");
				}
			}
		} 
		else 
		{
			System.out.println(dirname + " is not a directory");
		}
	}
}

Output:

The post Listing content of given Directory appeared first on Ankit Virparia.

How to use File class

• To check the availability of folder or file.
• To check the permission of folder or file.
• To create a blank file.
• To create a stream which points to specific named file which can be used to read/write some data

Program to create a new blank file.

File Name: CreateBlankFile.java

import java.io.*;

class CreateBlankFile 
{
	public static void main(String[] s) throws IOException
	{
		File f = new File("myFile.txt");
		f.createNewFile();
		System.out.println("File created!");	
	}	
}

Output:

Retrieve file information

File Name: FileMethodDemo.java

import java.io.File;
class FileMethodDemo 
{
	public static void main(String args[]) 
	{
		File f1 = new File("myFile.txt");
		System.out.println("File Name: " + f1.getName());
		System.out.println("Path: " + f1.getPath());
		System.out.println("Abs Path: " + f1.getAbsolutePath());
		System.out.println("Parent: " + f1.getParent());
		System.out.println(f1.exists() ? "exists" : "does not exist");
		System.out.println(f1.canWrite() ? "is writeable" : "is not writeable");
		System.out.println(f1.canRead() ? "is readable" : "is not readable");
		System.out.println("is " + (f1.isDirectory() ? "" : "not" + " a directory"));
		System.out.println(f1.isFile() ? "is normal file" : "might be a named pipe");
		System.out.println(f1.isAbsolute() ? "is absolute" : "is not absolute");
		System.out.println("File last modified: " + f1.lastModified());
		System.out.println("File size: " + f1.length() + " Bytes");
	}
}

Output:

The post Introduction to File appeared first on Ankit Virparia.