The Age Of Java

How to Stop A Thread in Java

2014-10-10T09:19:00.001-07:00

Here is one of the most asked question interviewer asks very often.
How can we stop a thread..??

As we know Thread is one of important Class in Java and multi-threading is most widely used feature, but there is no clear way to stop Thread in Java. Earlier there was a stop method exists in Thread Class but Java deprecated that method citing some safety reason. By default a Thread stops when execution of run() method finish either normally or due to any Exception. In this article we will How to Stop Thread in Java by using a boolean State variable or flag. Using flag to stop Thread is very popular way of stopping thread and its also safe, because it doesn't do anything special rather than helping run() method to finish it self.
Another important point is that you can not restart a Thread which run() method has finished already , you will get an IllegalStateExceptio, following is a Sample Code for stopping a Thread in Java:

private class Runner extends Thread{

boolean bExit = false;

public void exit(boolean bExit){

this.bExit = bExit;

}

@Override

public void run(){

while(!bExit){

System.out.println("Thread is running");

try {

Thread.sleep(500);

} catch (InterruptedException ex) {

Logger.getLogger(ThreadTester.class.getName()).log(Level.SEVERE, null, ex);

}

Should we make bExit Volatile ?

Since every Thread has its own local memory in Java its good practice to make bExit volatile because we may alter value of bExit from any thread and making it volatile guarantees that Runner will also see any update done before making bExit.

That’s all on how to stop thread in Java , let me know if you find any other way of stopping threads in Java without using deprecated stop() method.

How Can We restrict someone to create a limited objects of a class

2012-04-27T00:05:00.000-07:00

Here is example how we can restrict someone to create a limited objects of a class :-

class Example{
    private static int count;
    private static int MAX_COUNT = 5;
    private Example(){
    }

    public static Example getObject(){
        if(count < MAX_COUNT){
              count ++;
              return new Example();
        }
        else{
            System.out.println("You exceded the limit");
            //TO DO
        }
    }

Important Java Collection Interview Questions & Answers

2012-02-08T08:36:00.000-08:00

What is difference between Set and List in Java?

Most of Java programmer knows that Set doesn't allowed duplicate while List does and List maintains insertion order while Set doesn't. What is key here is to show interviewer that you can decide which collection is more suited based on requirements.

Difference between HashMap and Hashtable?

HashMap is not synchronized while hashtalbe is not or hashmap is faster than hashtable etc. What could go wrong is that if he placed another followup question like how hashMap works in Java or can you replace Hashtable with ConcurrenthashMap etc. See HashTable vs HashMap in Java for detailed answer of this interview question.

What is difference between Synchronized Collection and ConcurrentCollection?

Java5 has added several new ConcurrentCollection classes e.g. ConcurrentHashMap, CopyOnWriteArrayList, BlockingQueue etc, which has made Interview questions on Java Collection even trickier. Java Also provided way to get Synchronized copy of collection e.g. ArrayList, HashMap by using Collections.synchronizedMap() Utility function.One Significant difference is that ConccurentCollections has better performance than synchronized Collection because they lock only a portion of Map to achieve concurrency and Synchronization.

What is difference between fail-fast and fail-safe Iterators?

Fail-fast Iterators throws ConcurrentModificationException when one Thread is iterating over collection object and other thread structurally modify Collection either by adding, removing or modifying objects on underlying collection. They are called fail-fast because they try to immediately throw Exception when they encounter failure. On the other hand fail-safe Iterators works on copy of collection instead of original collection

What is difference between Iterator and Enumeration?

Iterator duplicate functionality of Enumeration with one addition of remove() method and both provide navigation functionally on objects of Collection.Another difference is that Iterator is more safe than Enumeration and doesn't allow another thread to modify collection object during iteration except remove() method and throws ConcurrentModificaitonException.

When do you use ConcurrentHashMap in Java?

ConcurrentHashMap is better suited for situation where you have multiple readers and one Writer or fewer writers since Map gets locked only during write operation. If you have equaled number of reader and writer than ConcurrentHashMap will perform in line of hashtable or synchronized hashMap.

How do you Sort objects on collection?

Sorting is implemented using Comparable and Comparator in Java and when you call Collections.sort() it gets sorted based on natural order specified in CompareTo method while Collections.sort(Comparator) will sort objects based on compare() method of Comparator.

Types of Garbage Collector in Java

2012-02-08T08:13:00.000-08:00

Java Runtime(J2SE 5) provides various types of Garbage collection in Java which we can choose based upon our application's performance requirement. J2SE 5 adds three additional garbage collectors except serial garbage collector. Each is generational garbage collector which has been implemented to increase throughput of the application or to reduce garbage collection pause times.

1) Throughput Garbage Collector: This garbage collector in Java uses a parallel version of the young generation collector. It is used if the -XX:+UseParallelGC option is passed to the JVM via command line options . The tenured generation collector is same as the serial collector.

2) Concurrent low pause Collector: This Collector is used if the -Xingc or -XX:+UseConcMarkSweepGC is passed on the command line. This is also referred as Concurrent Mark Sweep Garbage collector. The concurrent collector is used to collect the tenured generation and does most of the collection concurrently with the execution of the application. The application is paused for short periods during the collection. A parallel version of the young generation copying collector is sued with the concurrent collector. Concurrent Mark Sweep Garbage collector is most widely used garbage collector in java and it uses algorithm to first mark object which needs to collected when garbage collection triggers.

3) The Incremental (Sometimes called train) low pause collector: This collector is used only if -XX:+UseTrainGC is passed on the command line. This garbage collector has not changed since the java 1.4.2 and is currently not under active development. It will not be supported in future releases so avoid using this and please see 1.4.2 GC Tuning document for information on this collector.

Important point to not is that -XX:+UseParallelGC should not be used with -XX:+UseConcMarkSweepGC. The argument passing in the J2SE platform starting with version 1.4.2 should only allow legal combination of command line options for garbage collector but earlier releases may not find or detect all illegal combination and the results for illegal combination are unpredictable. It’s not recommended to use this garbage collector in java.

Deque and ArrayDeque

2011-11-21T10:55:00.001-08:00

Deque is the abbreviation of “Double Ended Queue”. A Collection that allows us to add (or) remove elements at both ends. Deque supports total size of collection for both fixed and unspecified size limits.

Deque implementation can be used as Stack(Last in first out ) or Queue(First in First Out). For each insertion, retrieval and removal of elements from deque there exists methods in 2 flavours. One will throw exception if it fails in an operation and another one returns status or special value for each operation.

Operation	Special value method	Exception throwing method
Insertion at head	offerFirst(e)	addFirst(e)
Removal at head	pollFirst()	removeFirst()
Retrieval at Head	peekFirst()	getFirst()
Insertion at Tail	offerLast(e)	addLast(e)
Removal at Tail	pollLast()	removeLast()
Retrieval at Tail	peekLast()	getLast()

Implementation of Deque doesn’t require preventing the insertion of null, but when we are using special value method null is return to indicate that collection is empty. So it is recommendable not to allow insertion of null.

ArrayDeque is a class that implements Deque. It has no capacity restrictions. It will perform faster than stack when used as stack and faster than linked list when used as queue. ArrayDeque is not thread Safe. The following example explains how to write program using ArrayDeque.

Example:
import java.util.ArrayDeque;
import java.util.Iterator;

public class DequeExample
{
public static void main(String as[])
{
ArrayDeque adObj = new ArrayDeque();

//Insertion by using various methods
adObj.add("Oracle");
adObj.addFirst("DB2");
adObj.offerFirst("MySQL"); //returns boolean - true R false
adObj.offerLast("Postgres"); //returns boolean - true R false

//Retrievals
System.out.println("Retrieving First Element :" + adObj.peekFirst());
System.out.println("Retrieving Last Element :"+ adObj.peekLast());

//Removals
System.out.println("Removing First Element :"+ adObj.pollFirst());
System.out.println("Removing Last Element :"+ adObj.pollLast());

//Reverse traversal
System.out.println("Remaining Elements :");
Iterator it = adObj.descendingIterator();
while(it.hasNext())
{
System.out.println(it.next());
}
}
}

Output:
Retrieving First Element :MySQL
Retrieving Last Element :Postgres
Removing First Element :MySQL
Removing Last Element :Postgres
Remaining Elements :
Oracle
DB2

For more please visit- http://download.oracle.com/javase/6/docs/api/java/util/ArrayDeque.html

What's New in Java 6.0 Collection API

2011-11-21T10:35:00.001-08:00

Here we have the new Collections APIs introduced in Java 6.0. There are few interesting changes in the Collections APIs, one amoung them is the Deque. Deque is used for the Bi-Directional traversal. It has different implementations including BlockingDeque,ArrayDeque,etc. Let's talk about the Deque and its various implementation, also few more changes in the Collectiona API in Java 6.0

Following are the new collection APIs introduced in Java 6.0. And the list of Interfaces and classes are given below.

New Interfaces:

Deque
BlockingDeque
NavigableSet
NavigableMap

New Classes:

ArrayDeque
LinkedBlockingDeque
ConcurrentSkipListSet
ConcurrentSkipListMap
AbstractMap.SimpleEntry
AbstractMap.SimpleImmutableEntry

And following are the updated Classes in Java 6.0

LinkedList
TreeSet
TreeMap
Collections

For more please visit- http://download.oracle.com/javase/6/docs/technotes/guides/collections/index.html

Simple Word Replacement From A String Using Regular Expression

2011-09-23T01:37:00.000-07:00

Here is a class which replace some words from a given string using Regular Expression.

/*
 * This code writes "One dog, two dogs in the yard."
 * to the standard-output stream:
 */
import java.util.regex.*;

public class Replacement {
    public static void main(String[] args) 
                         throws Exception {
        // Create a pattern to match cat
        Pattern p = Pattern.compile("cat");
        // Create a matcher with an input string
        Matcher m = p.matcher("one cat," +
                       " two cats in the yard");
        StringBuffer sb = new StringBuffer();
        boolean result = m.find();
        // Loop through and create a new String 
        // with the replacements
        while(result) {
            m.appendReplacement(sb, "dog");
            result = m.find();
        }
        // Add the last segment of input to 
        // the new String
        m.appendTail(sb);
        System.out.println(sb.toString());
    }
}

Search For Any Comment Line in a .java File Using Regular Expression

2011-09-23T00:24:00.000-07:00

The following class searches for the line which are being commented in a file called "Test.java".

 /*
 * Prints out the comments found in a .java file.
 */
import java.util.regex.*;
import java.io.*;
import java.nio.*;
import java.nio.charset.*;
import java.nio.channels.*;

public class CharBufferExample {
    public static void main(String[] args) throws Exception {
        // Create a pattern to match comments
        Pattern p = 
            Pattern.compile("//.*$", Pattern.MULTILINE);
        
        // Get a Channel for the source file
        File f = new File("Test.java");
        FileInputStream fis = new FileInputStream(f);
        FileChannel fc = fis.getChannel();
        
        // Get a CharBuffer from the source file
        ByteBuffer bb = 
            fc.map(FileChannel.MAP_RO, 0, (int)fc.size());
        Charset cs = Charset.forName("8859_1");
        CharsetDecoder cd = cs.newDecoder();
        CharBuffer cb = cd.decode(bb);
        
        // Run some matches
        Matcher m = p.matcher(cb);
        while (m.find())
            System.out.println("Found comment: "+m.group());
    }
}

Removing Control Characters from a File Using Regular Expression

2011-09-23T00:17:00.000-07:00

Here we have a sample class which will remove all the control characters from a file.

/* This class removes control characters from a named
*  file.
*/
import java.util.regex.*;
import java.io.*;

public class Control {
    public static void main(String[] args) 
                                 throws Exception {
                                 
        //Create a file object with the file name
        //in the argument:
        File fin = new File("fileName1");
        File fout = new File("fileName2");
        //Open and input and output stream
        FileInputStream fis = 
                          new FileInputStream(fin);
        FileOutputStream fos = 
                        new FileOutputStream(fout);

        BufferedReader in = new BufferedReader(
                       new InputStreamReader(fis));
        BufferedWriter out = new BufferedWriter(
                      new OutputStreamWriter(fos));

	// The pattern matches control characters
        Pattern p = Pattern.compile("{cntrl}");
        Matcher m = p.matcher("");
        String aLine = null;
        while((aLine = in.readLine()) != null) {
            m.reset(aLine);
            //Replaces control characters with an empty
            //string.
            String result = m.replaceAll("");
            out.write(result);
            out.newLine();
        }
        in.close();
        out.close();
    }
}

Usage of "Final" keyword in Java

2011-09-23T00:11:00.000-07:00

No matter how often we use final keyword in our Java program, but we should use the final keyword liberally to communicate our intent.

The final keyword has more than one meaning :

A final class cannot be extended.
A final method cannot be overridden.
A final field, parameter and local variable cannot change their value once set.

In the last case, "value" for primitives is understood in the usual sense, while "value" for objects means the object's identity, not its state. Once the identity of a final object reference is set, it can still change its state, but not its identity.

Declaring primitive fields as final automatically ensures thread-safety for that field.

Some habitually declare parameters as final, since this almost always the desired behaviour. Others find this verbose, and of little real benefit.

Consistently using final with local variables (when appropriate) can be useful as well. It brings attention to the non-final local variables, which usually have more logic associated with them (e.g:- result variables, accumulators, loop variables). Many find this verbose. A reasonable approach is to use final for local variables only if there is at least one non-final local variable in the method ; this serves to quickly distinguish the non-final local variables from the others.

So here have the advantages of using final :

Clearly communicates your intent
Allows the compiler and virtual machine to perform minor optimizations
Clearly flags items which are simpler in behavior - final says, "If you are looking for complexity, you won't find it here."

Simplest Way To Connect To A Shared Folder in Windows With Java

2011-09-18T10:08:00.000-07:00

Sometimes we usually meet a situation like, we want to access a shared folder in windows environment remotely. So this is one of the simplest way to do so :-

    File file = new File("\\\\theRemoteIP\\webapps"); 
    File[] files = file.listFiles();  
    System.out.println("Access granted");  

    for (int i = 0; i < files.length; i++)  
    {  
        String fname = files[i].getName();  
        System.out.println(fname);  
    }

New Features Of JDK 7

2011-09-10T02:53:00.000-07:00

With JDK 7 out the door, many writeups of the release have naturally focused on its larger features like Project Coin, NIO.2, the fork/join framework, and invokedynamic. However, there are a number of small but useful library conveniences in JDK 7 that shouldn't be overlooked.

To allow more informative assertion errors to be constructed, AssertionError now includes a constructor taking a string message and a Throwable cause, which is one of the four conventional constructors for exception types.
The methods which convert strings to numeric values differed in whether or not a leading plus, "+", was regarded as valid input. Float, Double, and BigDecimal accepted a leading plus while Byte, Short, Integer, Long, and BigInteger did not. As of JDK 7, all those types consistently accept a leading plus in their parseFoo, valueOf, and decode methods.
To help write more efficient comparators, Boolean, Byte, Character, Short, Integer, and Long each have a two-argument static compare method that performs the desired comparison operation without boxing overhead.
This six checked exception types that can be thrown by core reflection now have a common supertype, ReflectiveOperationException. This additional type complements the improved exception handling available with multi-catch and more precise re-throw from Project Coin.
The java.util.Objects class contains a number of small, but commonly used methods, many of them for coping with null inputs. For example, Objects contains a two-argument static equals method which does the right thing on null inputs. I've replaced a half-dozen copies of that method's logic in the JDK; I'm sure many more instances can be removed in other code bases as JDK 7 is adopted.
Part of NIO.2, I expect over time the utility methods in java.nio.file.Files to copy, read, and write the contents of file will see heavy usage.

And To recall, these are the list of feature which we discussed :-

Modularity

Multi-Language Support

New Garbage Collector

NIO.2 New File System API

Additional Swing API

Visit For More @ http://www.oracle.com/technetwork/java/javase/downloads/index.html