Problem:

Unable to use <spring:message> tag with the JSTL  <c:set> tag like below:

<c:set var=”someVar” value=”<spring:message code=’some.value’/>” />

Solution:
Nest the <spring:message> tag in the JSTL tag.

<c:set var=”someVar”>
<spring:message code=”some.value”/>
</c:set>

Enjoy Learning,
Kamlesh

This article explains how java detects concurrent modifications to a List with the help of an example. The comments provided along with the code are self explanatory so let us go through the example first:

ConcurrentModificationTest.java

package com.technicalmusings.examples.collection;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

/**
* The class explains how concurrent modification is detected in List.
*/

public class ConcurrentModificationTest {

public static void main(String[] args) {

// Instantiating the list sets the modCount field of list to 0
// modCount is a protected integer variable defined in the AbstractList class.

List<Object> myList = new LinkedList<Object>();

myList.add(new Object()); // modCount incremented to 1
myList.add(new Object()); // modCount incremented to 2
myList.add(new Object()); // modCount incremented to 3

// Getting an iterator sets the value of expectedModCount field
// equal to that of the modCount field of list.

Iterator<Object> itr1 = myList.iterator(); //itr1: expectedModCount = 3
Iterator<Object> itr2 = myList.iterator(); //itr2: expectedModCount = 3

// The first Iterator traverses the list once
itr1.next();

// The second iterator traverses and removes the first element
itr2.next();
itr2.remove();
// In the previous step Itr2 modifies the list and sets the
// expectedModCount field to 4. The modCount field of the list
// has also been now incremented to 4

// The first iterator again tries to traverse the list
itr1.next();

// java.util.ConcurrentModificationException is thrown at this stage
// because itr1 finds its expectedModCount (which is still 3) to be not
// matching with the modCount field of the list
}
}

The ConcurrentModificationTest.java class shown above explains how java works behind the scenes to detect concurrent modification and throw the ConcurrentModificationException in case of a List. List has an integer field modCount, which is incremented each time a structural modification is done in the list. Structural modification includes methods like add, remove, clear etc. The Iterator on the other hand uses another integer field, expectedModCount, to take care of concurrent modifications in the list. Iterator expects both the variables modCount and expectedModCount to be the same. In case the list is modified by any other means the modCount and expectedModCount differs and the exception is thrown.

Such custom exception handling can be achieved using the UncaughtExceptionHandler interface of the Thread class. The ThreadGroup class also implements the Thread.UncaughtExceptionHandler interface. The interface has only one method defined, which is:

void uncaughtException(Thread t, Throwable e);

This handler interface is invoked when a thread abruptly terminates due to an uncaught exception. The below excerpt from Java documentation explains the UncaughtExceptionHandler interface:

When a thread is about to terminate due to an uncaught exception the Java Virtual Machine will query the thread for its UncaughtExceptionHandler using Thread.getUncaughtExceptionHandler() and will invoke the handler’s uncaughtException method, passing the thread and the exception as arguments. If a thread has not had its UncaughtExceptionHandler explicitly set, then its ThreadGroup object acts as its UncaughtExceptionHandler. If the ThreadGroup object has no special requirements for dealing with the exception, it can forward the invocation to the default uncaught exception handler.

Thread class has two methods viz. setDefaultUncaughtExceptionHandler() and setUncaughtExceptionHandler(). The setDefaultUncaughtExceptionHandler() which is a static method of Thread class can be used to provide a common exception handler for all the threads. On the other hand setUncaughtExceptionHandler() is a non static method of Thread class which is used to provide handler to a given thread.

The below example shows how to handle the uncaught exception thrown from a Thread:

MyThreadTest.java

package com.technicalmusings.examples.thread;

/**
* The below class creates a thread which is supposed to throw an exception.
* A handler is added to the thread before calling the start method of thread.
* When the thread executes the exception is handled by the handler
* and the custom exception message is displayed on the console.
*/

public class MyThreadTest {

public static void main(String[] args) {

Thread newThread = new Thread(new ThreadWithException());

// Add the handler to the thread object
newThread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler(){

@Override
public void uncaughtException(Thread t, Throwable e) {

System.out.println("ERROR! An exception occurred in " + t.getName() + ". Cause: " + e.getMessage());
}
});

newThread.start();
}
}

/**
* This thread throws a custom exception in its run method.
*/

class ThreadWithException implements Runnable {

@Override
public void run() {
throw new RuntimeException("Application Specific Exception!!");
}
}

Output:

ERROR! An exception occurred in Thread-0. Cause: Application Specific Exception!!

Enjoy Learning,
Kamlesh

How many times you have heard this punch line and how many times implemented the same in your work or life? Sounds like a Déjà vu, isn’t it?

In the book Code Complete 2, Steve McConnell has referred to a very nice story to emphasis that we should not always adhere to the above line. The story goes as below:

Beth wanted to cook a pot roast according to an award-winning pot roast recipe handed down in her husband’s family. Her husband, Abdul, said that his mother had taught him to sprinkle it with salt and pepper, cut both ends off, put it in the pan, cover it, and cook it. Beth asked, “Why do you cut both ends off?” Abdul said, “I don’t know. I’ve always done it that way. Let me ask my mother.” He called her, and she said, “I don’t know. I’ve always done it that way. Let me ask your grandmother.” She called his grandmother, who said, “I don’t know why you do it that way. I did it that way because it was too big to fit in my pan.

Cheers,

Kamlesh

The Blog-Health-o-Meter™ reads Wow.

Crunchy numbers

A Boeing 747-400 passenger jet can hold 416 passengers. This blog was viewed about 7,300 times in 2010. That’s about 18 full 747s.

In 2010, there were 7 new posts, growing the total archive of this blog to 24 posts. There were 11 pictures uploaded, taking up a total of 490kb. That’s about a picture per month.

The busiest day of the year was May 17th with 1,076 views. The most popular post that day was Inside Java: Arrays.asList(T… a).

Where did they come from?

The top referring sites in 2010 were dzone.com, stumbleupon.com, google.co.in, google.com, and shiman.wordpress.com.

Some visitors came searching, mostly for java arrays.aslist, arrays.aslist, java callable, java aslist, and kamlesh java.

Attractions in 2010

These are the posts and pages that got the most views in 2010.

Inside Java: Arrays.asList(T… a) February 2010
8 comments

What is Time Complexity of An algorithm? : (O-notation) July 2007
4 comments

Java Threads : Callable and Future October 2009
3 comments

Axis2: Creating and consuming a web service February 2010
1 comment

Java Interview: Checklist April 2010
5 comments

With the help of a Scripting Engine, the Scripting API can invoke scripts in the Java code. Java 6 comes with an implementation of JavaScript interpreter by Mozilla, Rhino. Scripting engines for other scripting languages can be found at http://scripting.dev.java.net.

Let us see an example of how to invoke JavaScript from a Java class.

package com.technicalmusings.sample.js;
import java.util.List;
import javax.script.Invocable;
import javax.script.ScriptEngine;
import javax.script.ScriptEngineFactory;
import javax.script.ScriptEngineManager;
import javax.script.ScriptException;

public class ScriptRunner {

public static void main(String[] args) throws Exception{

    //the script manager
    ScriptEngineManager scriptManager = new ScriptEngineManager();

    //Check the available script engines
    List<ScriptEngineFactory> scriptFactories = scriptManager.getEngineFactories();

    System.out.println("Available Engines in Java 1.6.0_17:");
    for (ScriptEngineFactory factory : scriptFactories){
        System.out.println(factory.getEngineName());
    }
    System.out.println("-----------------------------------");

    System.out.println("Java Script Variables");
    System.out.println("-----------------------------------");

    //Get the java script engine
    ScriptEngine engine = scriptManager.getEngineByName("JavaScript");

    /*
    * USING A JAVASCRIPT VARIABLE:
    * Variables evaluated in JavaScript engine defaults to engine scope.
    * In the below example I am using the method engine.eval(String
    * script) to invoke JavaScript. In case you wish to store JavaScript
    * in a file like abc.js, you can use the overloaded version of the
    * same method which takes a Reader object; engine.eval(Reader
    * reader);
    */

    engine.put("i", 10);
    System.out.println("i * 10 : " + engine.eval("i * 10"));//100
    System.out.println("i : " + engine.eval("i"));//10
    System.out.println("i = i * 10 : " + engine.eval("i = i * 10"));//100
    System.out.println("i : " + engine.eval("i"));//100

    //using javascript variable in java
    int i = ((Double)engine.eval("i")).intValue();
    System.out.println("JavaScript variable in Java; i : " + i);
    System.out.println("-----------------------------------");

    /*
    * USING JAVASCRIPT FUNCTION:
    * Script engines provide the feature of invoking a function. In order
    * to be able to invoke a function the script engine must implement
    * the Invocable interface. Following example shows how to use a
    * simple function in JavaScript.
    */

    System.out.println("Java Script Function");
    System.out.println("-----------------------------------");
    //Check whether engine implements Invocable as it depends on the engine’s implementation.
    if(engine instanceof Invocable){
    //Declare the function
        String functionScript = "function display(message){ return message }";
        engine.eval(functionScript);

        //Invoke the function with a String parameter
        String message = "Hey JS! Greetings from Java";
        Object result = ((Invocable)engine).invokeFunction("display", message);
        System.out.println(result);

        //Invoke the function using a pre defined variable
        result = ((Invocable)engine).invokeFunction("display", "i is " + engine.eval("i"));
        System.out.println(result);
    }
    System.out.println("-----------------------------------");
 }
}

The output of the above example is given as below:

Available Engines in Java 1.6.0_17:
Mozilla Rhino
-----------------------------------
Java Script Variables
-----------------------------------

i * 10 : 100.0
i : 10
i = i * 10 : 100.0
i : 100.0
-----------------------------------
Java Script Function
-----------------------------------
Hey JS! Greetings from Java
i is 100.0
-----------------------------------

I have shown very basic use of the scripting APIs in this post. There are many other features which a scripting engine provides. For example if we require executing a script multiple times we can compile the script once and use that as required. The engine in that case must implement the Compilable interface.

The Scripting API also solved the problem of using a JavaScript variable in java and vice-versa. Most of the times we face this problem in a JSP where we have to use workarounds. Though I still need to test this but this should work. Let me know if you have tested the same.

Enjoy Learning,

Kamlesh

Following are the topics/keywords/concepts which require a crisp knowledge and understanding. These are basisc only.

• JVM – About JVM, JIT compiler, Bytecode, Classloader
• Garbage Colection – Conditions when JVM invokes garbage collection, System.gc()
• Static and Instance initializer block
• Datatypes – character especially
• enum – where to declare, defining constructor, methods and variables in enum
• OOP concepts – inheritance, polymorphism, aggregation vs Composition, abstraction
• Multiple Inheritance in java
• Difference/Similarities between interface and abstract class
• Software Engineering Concepts – Coupling and Cohesion
• String, StringBuffer and StringBuilder
• Exception Handling – Checked vs Unchecked Exceptions, Assertion, Error, Exception Hierarchy, throw vs throws
• final, finally and finalize
• Method Overriding (Rules for the same)
• Method Overloading – Covariant Return (Java5)
• Autoboxing
• Array – Declaring an anonymous and multidimensional array
• Keywords like super and this
• The Object classs – equals and hashcode methods
• Access Specifiers – default, public , protected and private
• Marker Interface, Wrapper Classe and Adapter Class
• Classes like Math, StrictMath, Scanner, Console
• Java IO: Important classes in IO, NIO.
• Reading and writing XMLs in java. Type of parsers – SAX, DOM and STAX.
• Java UI: AWT vs Swing, Different Layouts, Event handling, Calback methods
• Serialization, Transient keyword
• Multithreading – Runnable vs Thread, How to write a thread, difference between run and start method.
• Java5 Concurrency and advanced threading – Callable, Future, Executors, Thread pooling, Locks and Conditions
• Collection and Generics – Map, Set and List; Conventional Questions like ArrayList vs Vector, HashTable vs HashMap etc; Comparator and Comparable; Important collection classes.
• Methods of java.util.Collections – Synchronizing a collection, Creating views
• JDBC: The JDBC code, Type of JDBC Drivers, Type of Statements, execute, executeUpdate and executeQuery

We can discuss these further in case of queries/suggestions. Feel free to comment and add in case I missed something.

Enjoy learning,

Kamlesh

Whenever this question is asked the most common (and sometimes expected) answers are:

“No” or

“Well! Java does support multiple inheritance but with the interfaces not the classes.”

Both the answers are correct and accepted.

However we can find a better answer of the same question if we go by what the Java Specification has to say:

“Classes support single implementation inheritance, in which the implementation

of each class is derived from that of a single superclass, and ultimately from

the class Object.”

“Multiple interface inheritance is supported.”

The term ‘implementation inheritance’ may be confused with the keyword implements, which is incorrect. Implementation inheritance means a class can inherit (using the keyword extends) only one super class.e.g.

Incorrect: public class Derived extends Base1, Base2

Correct:  public class Derived extends Base

On the other hand Interface Inheritance implies that a class can implement multiple interfaces (using implements keyword) and an interface can extend multiple interfaces (using extends keyword).

Correct: public class Concrete implements A, B

Correct: public interface C extends A, B

Incorrect: public interface C implements A, B

The concept of inheritance differs from that of C++ in order to avoid the classic diamond problem in C++.

Enjoy Learning,
Kamlesh

      public static <T> List<T> asList(T... a)
 

This method is declared and defined in java.util.Arrays class. The method returns an object of ArrayList class. But here is one difference which we have to note and take care while using this.     

The object being returned does not belong to java.util.ArrayList class rather it belongs to java.util.Arrays$ArrayList class. Surprised! Actually the Arrays class defines an private static inner class named ArrayList. Following is the signature of the ArrayList class:     

      private static class ArrayList<E> extends AbstractList<E>implements RandomAccess, 
      java.io.Serializable 

Now let us see what the difference between the two ArrayList classes is.  

The Arrays$ArrayList class is sometimes refered as the view of java.util.ArrayList or a fixed size list. This class does not override all the methods of AbstractList class. To be more precise, following are the methods it overrides or declares:     

      public int size()  

      public Object[] toArray()

      public <T> T[] toArray(T[] a)

      public E get(int index)

      public E set(int index, E element)

      public int indexOf(Object o)

      public boolean contains(Object o)

Other methods if being called refer to the AbstractList class default implementation.  

For example if we try to call the add or remove method of Arrays$ArrayList class, we will get an UnsupportedOperationException . The reason behind this is the implementation of these methods in the AbstractList class which is:  

      public void add(int index, E element) {
                 throw new UnsupportedOperationException();
      }  

      public E remove(int  index) {
                 throw new  UnsupportedOperationException();
      }  

I hope this clears the understanding of how views are being used in java.

Let us conclude this article with the javadoc comments of Arrays.asList method: 

Returns a fixed-size list backed by the specified array.  (Changes to the returned list “write through” to the array.)  This method acts as bridge between array-based and collection-based APIs, in combination with Collection#toArray.  The returned list is serializable and implements RandomAccess.

This method also provides a convenient way to create a fixed-size list initialized to contain several elements:
List<String> stooges = Arrays.asList(“Larry”, “Moe”, “Curly”); 

Enjoy Learning,
Kamlesh

In December 2009, Pivot has been declared a top-level Apache project and Pivot 1.4 is the latest version which is available for download.

About Pivot, this is what Apache has to say:

Apache Pivot is an open-source platform for building rich internet applications in Java. It combines the enhanced productivity and usability features of a modern RIA toolkit with the robustness of the Java platform. Pivot applications are written using a combination of Java and XML and can be run either as an applet or as a standalone, optionally offline, desktop application.

Like other modern development platforms, Pivot provides a comprehensive set of foundation classes that together comprise a “framework”. These classes form the building blocks upon which more complex and sophisticated applications can be built.

Expolre more about Apache Pivot, here.

Enjoy Learning,

Kamlesh