Multithreading is used to divide a program in to several parts which can be executed in parallel. Java supports multithreading which is absolutely true but Java as a programming language cannot execute the instruction in microprocessor in parallel(by switching). Java relies on operating system for that. So, what we are going to prove here is: Execution/Switching of the threads are done by Operation System at run time. So there will be random execution sequence for us every time we run the program. You can see the output displayed below:

class RandomExecution implements Runnable
{
	Thread t;
	RandomExecution()
	{
		t = new Thread(this);
		t.start();
		for(int i=0;i<10;i++)
		{
			System.out.println("Parent:"+i);	
		}	
			
	}
	public static void main(String[] s)
	{
		RandomExecution obj = new RandomExecution();	
	}	
	public void run()
	{
		for(int i=0;i<10;i++)
		{
			System.out.println("Run:"+i);	
		}	
	}
}

Output:

The post Testing Random Execution – Java Multithreading appeared first on Ankit Virparia.

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.

What is Garbage Collector?

• It is a utility of Java Virtual Machine which is used to reclaim the space/memory allocated previously.
• Compared to C++, in Java the developer need not to worry about freeing the memory.
• Garbage Collection is done by a Thread named as: Garbage Collector
• Developer can not invoke Garbage collector. It is controlled by JVM. When JVM thinks that there is a need of removing memory, It starts the Garbage Collector Thread.
• But we can of course send a request to JVM that: “Please invoke Garbage Collector!”. But it is just a request to JVM. It’s not a call. Garbage Collector may or may not be invoked. Commands to send such request are: 1) System.gc() 2) Runtime.gc().
• One most important part of Garbage Collector is: When garbage collector is invoked by JVM, finalize() method of our program will be invoked by JVM. So that developer can write/execute some code at that time.

Which objects will be removed by Garbage Collector?

• Objects which are no where used further.
• In case object has multiple referenced, All the references of that object are not used further.
• Objects which are created inside a block and execution of that block is over
• When parent object is not gonna used further, All the child objects are also unused.

Above listed kind of objects will be removed by Garbage Collector.

void finalize()

As discussed above, a method named finalize() will be invoked when Garbage Collector is gonna remove the memory(object) of that class. So, that developer can write his end moment code. You can refer the below code to learn: How to write finalize() method.

import java.io.*;

class OpenAFile 
{
    FileInputStream aFile = null;
	String filename  = "";
    OpenAFile(String filename) 
	{
		this.filename = filename;
        try 
		{
            aFile = new FileInputStream(filename);
        }catch (java.io.FileNotFoundException e) 
		{
            System.err.println("Could not open file " + filename);
    	}
    }
	public  void finalize ()
	{
		try 
		{
            if (aFile != null) 
			{
				aFile.close();
				aFile = null;
			}
        }catch (Exception e) 
		{
            System.err.println("Could not close" + filename);
    	}
		
	}
}

Let me know in case you have any question.

The post Garbage Collector / Destructor in java 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.