Important Points:

• RandomAccessFile manages a file pointer
• On creating the object, It points to the 1st byte of the file
• On trying to skip bytes which are even more than the file size, it will reach to end of the file.

Constructor Summary

public RandomAccessFile (File file, String mode) throws FileNotFoundException
public RandomAccessFile (String filePath, String mode) throws FileNotFoundException

RandomAccessFile Modes

"r"	  Open for reading only. Invoking any of the write methods of the resulting object will cause an IOException to be thrown.
"rw"  Open for reading and writing. If the file does not already exist then an attempt will be made to create it.
"rws" Open for reading and writing, as with "rw", and also require that every update to the file's content or metadata be written synchronously to the underlying storage device.
"rwd" Open for reading and writing, as with "rw", and also require that every update to the file's content be written synchronously to the underlying storage device.

Program:

Aim: Write a program using RandomAccessFile class to write 4 int values in a file. Access the 3rd int from the file and change its value by another.

import java.io.IOException;
import java.io.RandomAccessFile;

public class RandomAccessDemo 
{
  public static void main(String[] args) 
  {
    try 
	{		
      RandomAccessFile raf = new RandomAccessFile("test.txt", "rw");
      raf.writeInt(10);
      raf.writeInt(20);
      raf.writeInt(30);
      raf.writeInt(400);

      raf.seek((3 - 1) * 4);  // For 3rd integer, We are doing 2 * size of Int(4).

      raf.writeInt(99);

      raf.seek(0);   // Going back to start point
      
      int i = 0;
      while(raf.length()>raf.getFilePointer()) 
      {
		i = raf.readInt();
        System.out.println(i);
      }
      raf.close();
    } 
	catch (Exception e) 
	{
		System.out.println(e);
    }
  }
}

Output:

Aim: Write a program using RandomAccessFile class to append an existing file (Generated by above program).

import java.io.File;
import java.io.RandomAccessFile;

public class RAFAppendDemo 
{
  public static void main(String[] args) throws Exception 
  {
    File f = new File("test.txt");
    long fileLength = f.length();
    RandomAccessFile raf = new RandomAccessFile(f, "rw");
    raf.seek(fileLength);
    raf.writeBytes("Appended text\n");
  
    raf.seek(0);
	
	System.out.println(raf.readInt());  
	System.out.println(raf.readInt());  
	System.out.println(raf.readInt());  
	System.out.println(raf.readInt());  
	System.out.println(raf.readLine());  
  
    raf.close();
  
  }
  
}

Output:

The post Random Access File – Java 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 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.

System.out is the object of java.io.PrintStream class. And it’s capable enough to send any kind of data to console or File. So in most of the case we don’t go for any other option. But still as a part of “Various ways to write on console”, we gonna discuss several method of writing data on console/command prompt. You can see the list of methods here.

PrintStream – System.out

import java.util.*;
class SODemo
{
	public static void main(String[] s)
	{
		System.out.println(1);  // println(int)
		System.out.println(1.2f);  // println(float)
		System.out.println(1.2);  // println(double)
		System.out.println("Ankit");  // println(String)
		System.out.println('c');  // println(char)
		System.out.println(new Date());  // println(Object)
		System.out.println(new myOPClass(9));  // println(Object)	
	}
}

class myOPClass
{
	int x = 0;
	myOPClass(int x)
	{
		this.x = x;	
	}
	public String toString()
	{
		return "Value of X: "+x;	
	}	
}

Output:

Note: PrintStream is derived from OutputStream class of java.io package. PrintStream is a Filtered Output Stream.

OutputStream + System.out

As discussed, OutputStream is the parent class of PrintStream. So a object of PrintStream class can be referenced by OutputStream.

import java.io.*;
class OSDemo
{
	public static void main(String[] s)throws Exception
	{
		String str = "I wanna print this!";
		byte[] b = str.getBytes();
		
		OutputStream os = System.out;
		os.write(b);
	}
}

Output:

OutputStreamWriter + System.out

import java.io.*;
class OSWDemo
{
	public static void main(String[] s)throws Exception
	{
		String str = "I wanna print this!";
		
		OutputStream os = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(os);
		
		osw.write("Ankit Virparia\n\n");
		osw.flush();
		
		osw.write(str, 2,11);
		osw.flush();
		
		
	}
}

Output:

BufferedWriter + OutputStreamWriter + System.out

import java.io.*;
class BufferedWriterDemo
{
	public static void main(String[] s)throws Exception
	{
		String str = "I wanna print this!";
		
		OutputStream os = System.out;
		OutputStreamWriter osw = new OutputStreamWriter(os);
		BufferedWriter bw = new BufferedWriter(osw);
		
		bw.write("Ankit Virparia\n\n");
		bw.flush();
		
		bw.write(str, 2,11);
		bw.flush();		
	}
}

Output:

Console

import java.io.*;
class ConsoleWriteDemo
{
	public static void main(String[] s)
	{
		Console con = System.console();
		PrintWriter ps = con.writer();
		ps.print("Good Morning!");
		ps.println();
		
		con.writer().println("Hi"); 
	}
}

Output:

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

InputStream – System.in

class ISDemo
{
	public static void main(String[] s)throws Exception
	{
		byte[] b = new byte[1024];
		System.out.print("Enter Text:");
		int cnt = System.in.read(b);	
		String userString = new String(b,0,cnt);
		System.out.println("No. of chars: "+cnt);
		System.out.println("String: "+userString);
	}	
}

Output:

InputStreamReader + Systen.in

import java.io.*;
class ISRDemo
{
	public static void main(String[] s)throws Exception
	{
		InputStreamReader isr = new InputStreamReader(System.in);
		int data;
		String str = "";
		char c ;
		while(true)
		{
			data = isr.read();
			c = (char)data;
			if(c=='\n')break;
			str += c;
		}
		
		System.out.println("String: "+str);
	}	
}

Output:

BufferedReader + InputStreamReader + Systen.in

import java.io.*;

class BufferedReaderDemo
{
	public static void main(String[] arg)throws Exception
	{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		System.out.print("Enter text:");
		String str = br.readLine();
		System.out.println("String: "+str);	
	}
}

Output:

Console

import java.io.*;
class ConsoleDemo
{
	public static void main(String[] s)
	{
		Console con = System.console();
		System.out.print("Enter String:");
		String str = con.readLine();
		System.out.println("String: "+str); 
	}
}

Output:

Scanner

import java.util.*;

class ScannerDemo
{
	public static void main(String[] arg)
	{
		Scanner sc = new Scanner(System.in);
		System.out.print("Enter text:");
		String str = sc.nextLine();
		System.out.println("String: "+str);	
	}
}

Output:

The post Various ways to read from Console 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.

Before we come to the actual definition of stream let us first consider an example in terms of operating system. We can have multiple applications running on our system. In order to identify each application an OS makes use of port numbers. When we send some data from one port to another then we are forming a stream between the two. So stream here is the direction or we can also say a combination of source port and destination port.

Consider an example: suppose we want to execute a java application. To do that we first start command prompt. So the OS assigns some port number P1 to it. Now to compile our java application we use javac.exe which is the compiler for java and OS assigns port number say P2 to it. But compiling is a small process so it will finish early. Once the application is compiled we launch our application using java interpreter i.e. java.exe. OS assigns it a port number say P3. According to the feature of JRE, it creates two static objects: in and out, identifying the direction from P1 to P3 and from P3 to P1 respectively. Both these objects have been declared in java.lang.System class.

Therefore whenever we want to take some input into our application we have to specify the direction using System.in and when we want to send some output from our application we have to specify its direction using System.out. There are mainly two streams in java: byte stream and character stream. Detailed discussion on both the streams would be done in next tutorial.

The post Introduction to Stream appeared first on Ankit Virparia.