A document type definition (DTD) describes the permissible tags of an XML document. The DTD serves as a data template. It defines entities, elements, attributes, and notations, as well as the relationships between these. For example, the DTD can state that a memo element consists of To, From, Subject, and Message elements. You need to use a DTD if you want the XML processor to validate your XML documents. DTDs can help you ensure that your XML documents are well-formed. You need to indicate to the XML processor that a DTD should be used. This is done by adding a document type declaration before the document element. The DTD can be internal or external to the document. If the DTD is external, you will need to specify its location or URL.

Is an XML schema an alternative to DTD

Schemas are becoming more popular and DTDs less so. A schema is an XML-based syntax for describing how the XML document is marked up or how it looks – very similar to a DTD, but a DTD has a lot of drawbacks.
A DTD doesn’t use anything like XML syntax to describe the definition. You can’t do data typing in a DTD, and it’s not extensible. An XML schema allows you to specify elements as an integer, a float, a Boolean, or whatever, and has more extensibility to it. Plus, it’s in XML format. Your XML schema, the definition for your XML, is also in XML format.
Microsoft is pushing the XML schema – so you’re likely to see schemas more and more. That’s all we use. In fact, the new BizTalk Server from Microsoft actually uses schemas.

Explain XML Namespaces

An XML namespace is a collection of element names or attribute names to be defined within an XML document.
Let’s say you have an invoice XML document and an order XML document and you want to put them together. You usually have certain names that overlap each other – like the date. You might have an invoice date and an order date – both called “date”. With a namespace, you have an invoice date and an order date, and you can reference them as such – “invoice:date” and then “order:date.” That way you can still use the same two tag names and you won’t get confused about which is which. That’s really what an XML namespace is supposed to do for you.

What are the advantages of XML

XML is free form which means that you can configure it any way you want. It’s also very easy to read – you don’t have to read cryptic code to figure it out.
It was designed specifically for internet protocols, and this makes it simple to transmit an XML document across, for example, a HTTP protocol.
Strong data typing is available for xml, and it is also compatible with the SGML standard. XML is Application independent – you can transfer XML data from a C language program to a Visual Basic program. Or you could, for example, have XML data going from one server out across the internet and being picked up by another application running on a Unix box. XML is also platform independent – it works equally well on Windows, UNIX, or for example, a CICS on a mainframe.
XML is also language independent so it doesn’t matter what type of programming language you’re using – C, Visual Basic, ASP using JavaScript. It doesn’t matter – all have mechanisms to read an XML document. XML is Unicode-based which makes it very flexible and very good for operating across languages like English, Spanish, or French. You can describe all these types of languages since it’s in Unicode.
A huge benefit of XML is that it’s license free –
it doesn’t cost anything to use XML.

Differences between DTD and Schema

What are the disadvantages of DTD

• They are not written in XML syntax, which means you have to learn a new syntax in order to write them
• there is no support for namespaces
• there are no constraints imposed on the kind of character data allowed, so datatyping is not possible
• there is minimal support for code modularity and none for inheritance
• large DTDs are hard to read and maintain
• there are no default values for elements and attribute defaults must be specified when they are declared
• its attribute value models and ID attribute mechanism are simplistic
• there is limited ability to control whitespace
• there is limited documentation support, as you cannot use the structured documentation features available for schema notation

Exception Drill

1. What is an Exception ?
An exception is an abnormal condition that arises in a code sequence at run time. In other words, an exception is a run-time error. 2. What is a Java Exception ?
A Java exception is an object that describes an exceptional condition i.e., an error condition that has occurred in a piece of code. When this type of condition arises, an object representing that exception is created and thrown in the method that caused the error by the Java Runtime. That method may choose to handle the exception itself, or pass it on. Either way, at some point, the exception is caught and processed. 3.Where does Exception stand in the Java tree hierarchy ?
         java.lang.Object
         java.lang.Throwable
         java.lang.Exception
         java.lang.Error 4.What are checked exceptions ?
Checked exception are those which the Java compiler forces you to catch. e.g. IOException are checked Exceptions. 5.What are runtime exceptions ?
Runtime exceptions are those exceptions that are thrown at runtime because of either wrong input data or because of wrong business logic etc. These are not checked by the compiler at compile time. 6.What is the difference between error and an exception ?
An error is an irrecoverable condition occurring at runtime. Such as OutOfMemory error. These JVM errors and you can not repair them at runtime. While exceptions are conditions that occur because of bad input etc. e.g. FileNotFoundException will be thrown if the specified file does not exist. Or a NullPointerException will take place if you try using a null reference. In most of the cases it is possible to recover from an exception (probably by giving user a feedback for entering proper values etc.). 7.How to create custom exceptions ?
Your class should extend class Exception, or some more specific type thereof. 8.If I want an object of my class to be thrown as an exception object, what should I do ?
The class should extend from Exception class. Or you can extend your class from some more precise exception type also. 9.If my class already extends from some other class what should I do if I want an instance of my class to be thrown as an exception object ?
One can not do anytihng in this scenarion. Because Java does not allow multiple inheritance and does not provide any exception interface as well. 10.How does an exception permeate through the code ?
An unhandled exception moves up the method stack in search of a matching When an exception is thrown from a code which is wrapped in a try block followed by one or more catch blocks, a search is made for matching catch block. If a matching type is found then that block will be invoked. If a matching type is not found then the exception moves up the method stack and reaches the caller method. Same procedure is repeated if the caller method is included in a try catch block. This process continues until a catch block handling the appropriate type of exception is found. If it does not find such a block then finally the program terminates. 11.What are the different ways to handle exceptions ?
There are two ways to handle exceptions,
1. By wrapping the desired code in a try block followed by a catch block to catch the exceptions. and
2. List the desired exceptions in the throws clause of the method and let the caller of the method hadle those exceptions. 12.What is the basic difference between the 2 approaches to exception handling.
1 try catch block and
2 specifying the candidate exceptions in the throws clause ?
In the first approach as a programmer of the method, you urself are dealing with the exception. This is fine if you are in a best position to decide should be done in case of an exception. Whereas if it is not the responsibility of the method to deal with it’s own exceptions, then do not use this approach. In this case use the second approach. In the second approach we are forcing the caller of the method to catch the exceptions, that the method is likely to throw. This is often the approach library creators use. They list the exception in the throws clause and we must catch them. You will find the same approach throughout the java libraries we use. 13.Is it compulsory to use the finally block  ?
It is always a good practice to use the finally block. The reason for using the finally block is, any unreleased resources can be released and the memory can be freed. For example while closing a connection object an exception has occurred. In finally block we can close that object. Coming to the question, you can omit the finally block when there is a catch block associated with that try block. A try block should have at least a catch or a finally block. 14.How are try, catch and finally block organized  ?
A try block should associate with at least a catch or a finally block. The sequence of try, catch and finally matters a lot. If you modify the order of these then the code won’t compile. Adding to this there can be multiple catch blocks associated with a try block. The final concept is there should be a single try, multiple catch blocks and a single finally block in a try-catch-finally block. 15.What is a throw in an Exception block ?
“throw” is used to manually throw an exception (object) of type Throwable class or a subclass of Throwable. Simple types, such as int or char, as well as non-Throwable classes, such as String and Object, cannot be used as exceptions. The flow of execution stops immediately after the throw statement; any subsequent statements are not executed. throw ThrowableInstance; ThrowableInstance must be an object of type Throwable or a subclass of Throwable.
throw new NullPointerException(”thrownException”); 16.What is the use of throws keyword ?
If a method is capable of causing an exception that it does not handle, it must specify this behavior so that callers of the method can guard themselves against that exception. You do this by including a throws clause in the method’s declaration. A throws clause lists the types of exceptions that a method might throw. type method-name(parameter-list) throws exception-list {
// body of method
} Here, exception-list is a comma-separated list of the exceptions that a method can throw. static void throwOne() throws IllegalAccessException {
System.out.println(”Inside throwOne.”); 17.Is it necessary that each try block must be followed by a catch block ?
It is not necessary that each try block must be followed by a catch block. It should be followed by either a catch block OR a finally block. And whatever exceptions are likely to be thrown should be declared in the throws clause of the method. 18.If I write return at the end of the try block, will the finally block still execute ?
Yes even if you write return as the last statement in the try block and no exception occurs, the finally block will execute. The finally block will execute and then the control return. 19.If I write System.exit (0); at the end of the try block, will the finally block still execute ?
No in this case the finally block will not execute because when you say System.exit (0); the control immediately goes out of the program, and thus finally never executes. 20.What are Checked and UnChecked Exception ?
A checked exception is some subclass of Exception (or Exception itself), excluding class RuntimeException and its subclasses.
Making an exception checked forces client programmers to deal with the possibility that the exception will be thrown. eg, IOException thrown by java.io.FileInputStream’s read() method·
Unchecked exceptions are RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked. With an unchecked exception, however, the compiler doesn’t force client programmers either to catch the
exception or declare it in a throws clause. In fact, client programmers may not even know that the exception could be thrown. eg, StringIndexOutOfBoundsException thrown by String’s charAt() method· Checked exceptions must be caught at compile time. Runtime exceptions do not need to be. Errors often cannot be. 21.Give me some examples of Checked Exceptions and Unchecked Exceptions ?
Unchecked Exceptions. 
         ArithmeticException 
         ArrayIndexOutOfBoundsException
         ClassCastException
         IndexOutOfBoundsException
         IllegalStateException
         NullPointerException
         SecurityException  Checked Exception
        ClassNotFoundException
        CloneNotSupportedException 
        IllegalAccessException
        InstantiationException
        InterruptedException
        NoSuchFieldException
        NoSuchMethodException 22. What are Chained Exceptions ?
The chained exception feature allows you to associate another exception with an exception. This second exception describes the cause of the first exception. Lets take a simple example. You are trying to read a number from the disk and using it to divide a number. Think the method throws an ArithmeticException because of an attempt to divide by zero (number we got). However, the problem was that an I/O error occurred, which caused the divisor to be set improperly (set to zero). Although the method must certainly throw an ArithmeticException, since that is the error that occurred, you might also want to let the calling code know that the underlying cause was an I/O error. This is the place where chained exceptions come in to picture. Throwable getCause( )
Throwable initCause(Throwable causeExc)      

Collections Drill - II

1.What is meant by compatible equals() and hashCode() methods ?
In order for the Java Collections to work properly (and everything else in Java), the equals() and hashCode() methods must be compatible. Here, compatible means that if equals() reports that two instances are the same, then the hashCode() of both instances must be the same value. 2.Since Properties extends Hashtable, can I use the Hashtable methods to add elements to a Properties list ?
Technically speaking you can. However, you have to make sure you only add key-value pairs where both are strings. If you add something other than a String, the listing, loading, and saving methods won’t work as expected.
Like the Stack/Vector subclass relationship, Properties/Hashtable should be a has-a relationship, not an is-a/subclass relationship. 3.When I wrap a collection to be read-only or synchronized, why can’t I call any of the collection methods via reflection without getting an IllegalAccessException ?
When you wrap a collection through the static methods of the Collections class, this creates an instance of a package-private (default access) class. Because you don’t have access to these classes, you can’t call their methods via reflection (though you can call their methods directly through the appropriate interface). 4.What is a weak reference and what are they used for ?
Normally the Java garbage collector plays safe. It will only free up the memory used by an object when that object can no longer be accessed by the program. Once an object become impossible to reach it is eligible for collection, and eventually its memory will be reclaimed.
This eliminates one of the most common programming errors in some other languages (like C++), where code accidentally tries to access an object that has been freed. Unfortunately it can lead to another problem, where you leave open a potential access route to an object that you don’t need any more. Memory fills up, and the program slows down or reports an “Out of Memory” error. To avoid this, you can be very careful to close off access paths to an object once you have finished using it. Java 2 introduces another alternative, the weak reference. Weak references provide access to an object without preventing it from being freed. When you use a weak reference you have to accept that the object referred to may have disappeared, which results in the reference being automatically set to null. On the other hand, the weak reference will not hold the object in memory once it is inaccessible via normal references (or via “soft” references – see below). Weak references are not appropriate in all circumstances, but sometimes they can make code easier to write and understand. The most common use of weak references is indirect – they are used internally by the WeakHashMap class. Like HashMap, WeakHashMap associates key objects with values. However, once the key object becomes inaccessible via stronger references it becomes eligible for garbage collection. When it is freed, the map entry magically disappears. The assumption here is that if you are not using the key anywhere other than in the map you will have no need to look it up, so it should be freed. Other specialist references are soft references (which inhibit collection until memory runs short), and phantom references (used for cleanup when objects are freed). 5.What is the minimum number of key-value pairs for which it makes sense to use a HashMap, as opposed to using a pair of arrays (one for keys, the other for values) with brute-force key searches ? Many people often need maps for very small numbers (2-5) of key-value pairs. When does it make sense to forgo the convenience of the HashMap to avoid the associated overhead?
Well, is there really that much of a performance loss using a HashMap? There is no synchronization penalty (unless you impose your own). You can tune the sizing by adjusting the initial size and load factor. Plus, do you really want to be responsible for “rolling your own” code to handle the dynamic resizing of the key and value arrays, inserting/removing data from these arrays, optimizing the searching algorithm, etc. Yuck! In general, the performance hit associated with using a general purpose Map (such as the HashMap) is far outweighed by the benefits of using a simple interface backed by a tested algorithm. The only reason I could see wanting to use arrays is to guaruntee the type of your key/values to add type checking and avoid casting. Still, if this is a critical aspect of your application, you can wrap your HashMap in another object to provide type-safety, and the casting overhead should be minimal. Another alternative to creating a custom solution is to explore other collection classes, such as ObjectSpaces’s JGL Libraries. There may be something there that would suit your needs. So, to answer your question, I would say that the fewer the key-value pairs you have, the more reason you have to use a HashMap. Since the fewer the keys, the faster the search, why not use it for 2-5 key-value pairs. I would think that only when you get to many pairs (tens of thousands) and there is a performance problem you should consider an alternative. Basically, exhaust your search of tried-and-true collections before you try a custom solution. Let other people create these collections so you can focus on your application. 6.How does ArrayList increase its capacity ?
Unlike Vector where you can specify a capacity increment, ArrayList doesn’t support this. Instead, ArrayList will increase capacity by about a half when it runs out of space. The refernece implementation uses the forumla:
newCapacity = (oldCapacity * 3)/2 + 1
though, this isn’t part of the class definition so others can implement it differently. 7.What is the default initial size for a Hashtable / HashMap ?
This depends on what version of Java you are using. For JDK 1.2, the size was 101. For JDK 1.3, the size changed to 11. 8.How do you create a multi-dimensional List ?
Since the elements of a List are objects, in order to make the List multi-dimensional, each object in the outer list needs to be a List, too. For instance, … List list = new ArrayList(10);
for (int i=0; i<10; i++) {
list.set(i, new LinkedList());
} Then just fill up each inner list with items. 9.In a TreeMap, can I use a sorting algorithm other than the natural sorting for the keys ?
You can pass a Comparator to the TreeMap constructor to use a sorting order other than the natural order. 10.What are the differences between HashMap and Hashtable ?
Both provide key-value access to data. The Hashtable is one of the original collection classes in Java. HashMap is part of the new Collections Framework, added with Java 2, v1.2.
The key difference between the two is that access to the Hashtable is synchronized on the table while access to the HashMap isn’t. You can add it, but it isn’t there by default. Another difference is that iterator in the HashMap is fail-safe while the enumerator for the Hashtable isn’t. If you change the map while iterating, you’ll know. And, a third difference is that HashMap permits null values in it, while Hashtable doesn’t. For new code, I would tend to always use HashMap. 11.What are the differences between Vector and ArrayList? Which is best to use ?
Vector and ArrayList are very similar. Both of them represent a ‘growable array’, where you access to the elements in it through an index. ArrayList it’s part of the Java Collection Framework, and has been added with version 1.2, while Vector it’s an object that is present since the first version of the JDK. Vector, anyway, has been retrofitted to implement the List interface. The main difference is that Vector it’s a synchronized object, while ArrayList it’s not. While the iterator that are returned by both classes are fail-fast (they cleanly thrown a ConcurrentModificationException when the orignal object has been modified), the Enumeration returned by Vector are not. Unless you have strong reason to use a Vector, the suggestion is to use the ArrayList. 12.How should I implement object comparisons in a flexible manner? For example, I have a Person class and sometimes I will compare based on name and sometimes I will compare based on age.
Instead of having the Person class implement the Comparable interface, you could delegate the comparing to another class. Perhaps you could have a PersonComparator interface that you could implement for the various types of comparisons. For example:
public interface Person {
public String getName();
public int getAge();
} public interface PersonComparator {
public int compare(Person p1, Person p2);
} public class AgeComparator implements PersonComparator {
public int compare(Person p1, Person p2) {
if (p1.getAge() == p2.getAge()) return 0;
return p1.getAge() > p2.getAge() ? 1 : -1;
}
} public class NameComparator implements PersonComparator {
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
} This is a very simple example of the Strategy Pattern. This allows your comparisons and your object to change independent of one another. 13.Does the equals() method of an array do element-level checking ?
If you have two arrays in memory with the same elements, and ask first.equals(second), this does not do an element-by-element comparison. Instead, it behaves just like Object’s equals() method, essentially asking if the variables point to the same place in memory:
int a[] = {1, 2, 3};
int b[] = {1, 2, 3};
// This prints false
System.out.println(a.equals(b)); To check for equality of two arrays, use Arrays.equals().
// This prints true
System.out.println(Arrays.equals(a,b)); 14.How can I retrieve the items in my HashSet / HashMap in the order they were added ?
Prior to Java 1.4, you had to manage a separate insertion order list yourself. Starting with Java 1.4, you can use the new LinkedHashMap / LinkedHashSet classes. The iterators you get back from them return the items in insertion order. 15.How do you sort an ArrayList (or any list) of user-defined objects ?
Create an implementation of the java.lang.Comparable interface that knows how to order your objects and pass it to java.util.Collections.sort(List, Comparator). 16.How can you get the hash code for an instance of a class if the class overrode hashCode() ?
The System class method identityHashCode() allows you to get this information:
int code = System.identityHashCode(anObject); 17.How can I easily shift the elements in a List / Vector such that all the elements rotate n elements ?
The Java 1.4 API adds a rotate() method to the Collections class: rotate(List list, int distance) that will shift the elements for you. 18.What’s the most optimum way of swapping two elements in a List ?
The 1.4 version of Collections has a swap() method to do this for you. However, for earlier version of Java, you can swap two elements w/o an intermediate variable with:
list.set(index1, list.set(index2, list.get(index1)));
This works because the set() method returns the original element. 19.What’s the purpose of the IdentityHashMap ?
The IdentityHashMap uses == for equality checking instead of equals(). This can be used for both performance reasons, if you know that two different elements will never be equals and for preventing spoofing, where an object tries to imitate another. 20.How do I convert an old-style Enumeration to something in the Collections Framework ?
Prior to Java 1.4, any conversion had to be manually done. With the introduction of 1.4, you can call Collections.list(enumeration) to automatically convert the Enumeration to an ArrayList. 21.How do I retrieve the values of a Hashtable/HashMap in sorted order ?
Basically, you can’t directly do this. What you can do is get the Collection of values() back from the map and create a sorted collection, or maintain two maps, one in each direction, and keep the second map sorted by being a TreeMap. Which you use depends on the frequency you must sort the elements. 22.How can I add a Collection to another Collection ?
The java.util.Collection interface includes an addAll(Collection c) method to add one collection to another. 23.How can I use two iterators to go through a collection ?
Just get a separate iterator for each loop:
Collection l = …;
for(Iterator i = l.iterator(); …) {
for(Iterator j = l.iterator();…) {
}
} 24.How do I traverse a map backwards ?
Just keep getting the last key and the head map before it:
if (!map.isEmpty()) {
Object last = map.lastKey();
boolean first = true;
do {
if (!first) {
System.out.print(”, “);
}
System.out.print(last);
last=map.headMap(last).lastKey();
first=false;
} while (last != map.firstKey());
System.out.println();
} 25.How do I traverse a sorted set backwards ?
Just keep getting the last element and the head set before it:
if (!set.isEmpty()) {
Object last = set.last();
boolean first = true;
do {
if (!first) {
System.out.print(”, “);
}
System.out.print(last);
last=set.headSet(last).last();
first=false;
} while (last != set.first());
System.out.println();
} 26.How can I go through an Iterator mulitple times ?
There is no direct support for this. You’ll need to create your own caching mechanism. For instance, as you go through the Iterator the first time, add the elements to a LinkedList. Then, you can just get an Iterator from the LinkedList for the second pass through. 27.What’s new to the Collections Framework in Java 1.4 ?
There are three new implementations:
          LinkedHashSet
          LinkedHashMap
          IdentityHashMap
         One marker interface: 
         RandomAccess
        And six new utility methods for the Collections class:
        rotate(List list, int distance)
        replaceAll(List list, Object oldVal, Object newVal)
        indexOfSubList(List source, List target)
        lastIndexOfSubList(List source, List target) 
       swap(List list, int i, int j) 
       list(Enumeration e) 28.How can I add an array of objects to a collection ?
First you need to convert the array to a Collection. This can be done with Arrays.asList(objectArray). Once you have the array as a List, you can add it to another Collection with theCollection.addAll(theList). 29.Is Vector’s clone method thread-safe ?
Sure it is, since it is a Vector which is thread-safe. 30.How do I load property settings with the Properties class ?
java.util.Properties objects can load values from a file using the method load(InputStream).
Here is the code you need: Properties props = new Properties();
props.load(new FileInputStream(”propertyfile.properties”));
String value = props.getProperty(”propertyname”); //Just a trick: in a web archive (war) you can get the InputStream inside the war archive using
ClassLoader cl = this.getClass().getClassLoader();
InputStream is = cl.getResourceAsStream(”it/package/application.properties”); This is better than using a FileInputStream, because you are loading the file within the archive as it was a resource. You should use this.getClass().getClassLoader() to use the same ClassLoader as the one used the servlet container to load your JSP/Servlet. This code is snipped from a JSP page inside Tomcat. 31.How do I save properties settings with the Properties class ?
Try this:
Properties prop = new Properties();
FileOutputStream output = new FileOutputStream(”Test.properties”);
prop.store(output,”my testproperties”);
output.flush();
output.close(); You’ll need to catch an IOException. 32.What happens if two threads perform a get of one hashmap at the same time ?
Synchronization needs to be done only when there is a chance of changing the data from different threads simultaneously. In your case, it is simply going to be a read, the synchronization is not required. If you need to remove or modify the values in the hashmap, then you [may] need to synchronize that. For synchronizing a HashMap, you can use Collections.synchronizedMap(<your hashmap reference>) which will return a synchronized map for you, which is thread-safe. Remember, synchronization will cause a performance problem. So, it needs to be used carefully, when really required. 33.How can I convert a Collection to an Array then back to a Collection ?
The Collection interface provides a mechanism to turn a Collection into an Array using the methods <T> T[] toArray(T[] a) or Object[] toArray(). The first method will return a Array containing all the elements of the Collection with the array being that of the type provided in the method call. The second method just returns an array being of an Object[] type. The Arrays class provides the opposite. A way to turn an array into a List using the List<T> asList(Array[] a) method. The List returned is of a fixed length with any attempts to add an element throwing an UnsupportedOperationException. import java.util.*; public class G{
public static void main(String[] args){
List<String> sun = new ArrayList<String>();
sun.add(”Feel”);
sun.add(”the”);
sun.add(”power”);
sun.add(”of”);
sun.add(”the”);
sun.add(”Sun”);
String[] s1 = sun.toArray(new String[0]); //Collection to array
for(int i = 0; i < s1.length; ++i){
String contents = s1[i];
System.out.print(contents);
}
System.out.println();
List<String> sun2 = Arrays.asList(s1); //Array back to Collection
for(String s2: sun2){
String s3 = s2; System.out.print(s3);
}
//sun2.add(new String(”Hello”)); // throws UnsupportedOperationException
}
} 34.How can I create a Collection based on another Collection ?
Every concrete implementation provides a constructor, which takes a Collection as an argument. Care must be taken when creating a Collection based another Collection, this is because depending on the target concrete implementation being created, specific rules regarding duplicates may be be enforced. Such as creating a Set based on a List. The following is a short list of the constructors provided by some of the concrete Classes of the JCF (Java Collections Framework), which enable the creation of a Collection based an another implementation. ArrayList(Collection<? extends E> c)
LinkedList(Collection<? extends E> c)
Vector(Collection<? extends E> c)
TreeSet(Collection<? extends E> c) Creating a Collection based on another Collection is quite easy. The hard part is knowing which Collection to use based on performance and other issues. For example the ArrayList created will contain the same elements in the same order as the first ArrayList created. List<String> slist = new ArrayList<String>();
slist.add(”g”);
slist.add(”a”);
slist.add(”d”);
slist.add(”a”);
slist.add(”f”);
slist.add(”e”);
slist.add(”c”);
slist.add(”b”);
for(String s : slist){
System.out.print(s + “\t”);
}
System.out.println();
List<String> s2list = new ArrayList<String>(slist);
for(String s : s2list){
System.out.print(s + “\t”);
} When creating a Set based on an existing List the Set will be void of duplicates.
List<String> slist = new ArrayList<String>();
slist.add(”g”);
slist.add(”a”);
slist.add(”d”);
slist.add(”a”);
slist.add(”f”);
slist.add(”e”);
slist.add(”c”);
slist.add(”b”);
for(String s : slist){
System.out.print(s + “\t”);
}
System.out.println();
Set<String> s2set = new TreeSet<String>(slist);
for(String s : s2set){
System.out.print(s + “\t”);
} 35.How can I define my own Comparable type so that it can be naturally sorted within a List ?
When taking a peek at the Java docs you will notice certain classes implement an interface named Comparable. Take a look at some of the subclasses of Number such as Byte, Integer, Long, Float or some of the classes like String and Date. What the Comparable interface provides is a way for a class to be sorted by it’s natural ordering. So what do we mean by natural ordering? Depending on the type wishing to be sorted the natural ordering can be different things. If we are sorting Strings the ordering is lexicographic or alphabetic if we are sorting Dates the ordering is chronological if we are sorting Integers the ordering is numerical. Comparable only contains one method that needs to be implemented by the class wishing to be sorted naturally. Remember if you try and sort a list that contains elements that do not implement the Comparable interface then Collections.sort() will throw an exception specifically a ClassCastException. public interface Comparable<T>{
public int compareTo(T o);
} The following is a short example on how to implement the Comparable interface and use the compareTo(T o) method.
import java.util.*; public final class Alpha implements Comparable<Alpha>{
public static void main(String[] args){
List<Alpha> alpha = new ArrayList<Alpha>();
alpha.add(new Alpha(”z”));
alpha.add(new Alpha(”g”));
alpha.add(new Alpha(”k”));
alpha.add(new Alpha(”q”));
alpha.add(new Alpha(”a”));
alpha.add(new Alpha(”b”));
alpha.add(new Alpha(”o”));
alpha.add(new Alpha(”v”));
alpha.add(new Alpha(”c”));
Collections.sort(alpha);
System.out.println(alpha);
}
private String letter;
public Alpha(String letter){
if(letter == null){throw new NullPointerException();}
this.letter = letter;
}
public String toString(){return letter;}
public boolean equals(Alpha a){
if(!(a instanceof Alpha))
return false;
return letter.equals(a.letter);
}
public int compareTo(Alpha a){
int i = letter.compareTo(a.letter);
return i;
}
} More complex examples might included sorting on multiple fields. Most things that you would have to sort probably have more then one part like a name for instance (First:Middle:Last) or maybe you have to sort in (Brand:Model) order.
import java.util.*; public final class Car implements Comparable<Car>{
public static void main(String[] args){
Car[] cararry = {new Car(”Toyota”,”Celica”), new Car(”Honda”,”Civic”),
new Car(”Ford”,”Mustang”), new Car(”Lexus”,”ES”), new Car(”Acura”,”Integra”),
new Car(”Honda”,”Accord”), new Car(”Acura”,”RL”), new Car(”Toyota”,”Avalon”)
};
List<Car> car = Arrays.asList(cararry);
Collections.sort(car);
System.out.println(car);
}
private String brand;
private String model;
public Car(String brand, String model){
if(brand == null || model == null){throw new NullPointerException();}
this.brand = brand;
this.model = model;
}
public String toString(){return brand + ” ” + model;}
public boolean equals(Car car){
if(!(car instanceof Car))
return false;
boolean samebrand = brand.equals(car.brand);
return samebrand != true ? samebrand: model.equals(car.model);
}
public int compareTo(Car car){
int i = brand.compareTo(car.brand);
return(i != 0 ? i : model.compareTo(car.model));
}
} 36.What are Generics and how can I use them ?
One of the biggest additions since the creation of the Collections framework is Generics.This long awaited update to the type system is a welcomed feature, which C++ developers have had in their toolbox for years using the STL. A generic type is defined using one or more type variables with it’s contained methods using that type variable as a place holder to mark a parameter or return type. For instance the interface List has now been defined as. public interface List<E>{
public add(E e);
Iterator<E> iterator();
}
public interface Iterator<E>{
E next();
boolean hasNext();
} Type Safe Collections So you might ask. What are Generics and why should I use them? Generics are a way to restrict a data structure to hold only a specific type thus providing compile time type checking. One of the added bonuses is that it is no longer necessary to cast a returned Object to a specific type because the compiler is aware of what type is being held by the Collection and what type is to be returned. Set s = new SortedSet();
s.add(new String(”Java”));
String j = (String) s.get(0); // cast required; // java 5
Set<String> s = new SortedSet<String>();
s.addElement(new String(”String Type”));
String s = s.get(0); // no cast required! Having a type safe system not only obviates the need to cast to a specific type but shields the programmer against miss-casting or casting to an unrelated type at runtime. String s = “Java, write once run anywhere”
List l = new ArrayList();
l.add(new String(”Java”));
Integer i = (Integer)l.get(0); // Runtime exception! ClassCastException! // Using Generics the compiler catches
String s = “Java. Write once run anywhere!”
List<String> l = new ArrayList<String>();
l.add(new String(”Java”));
Integer i = l.get(0); Generics and Subtyping Generics do not share some of the things that are commonly held true in the Java language and one of them is subtyping. One would assume the following perfectly legal since it is true that Object is a supertype of String. But the following is in fact illegal and will cause a compile time error. List<Object> l = new ArrayList<String>(); As a rule. If X is a superclass or superinterface of Y and E is a generic type declaration then it not the case that E<X> is a supertype of E<Y>. So if E<Object> is not a super type of E<String> then what is the super type of E<String>? Read on and find out! Wild Cards Wild Cards represent what is called “the unknown type”. Essentially they can be thought of as the supertype of any Collection. Wildcards allow some flexibility in certain situations where it is needed that a type be abstracted out. For instance what if we define the following method, printSet(Collection<Object> x). We just saw in the previous example that E<Object> is not the super type of E<String> or any other type for that matter. In this case we can change the printSet’s parameter to Collection<?>. This allows us to pass in E<X> where X is any type. public void printElements(Collection<?> c){
for(Object o: c){
System.out.println(o);
}
} When working with wildcards it is always legal to read and assign the contents to an Object type List<String> l = new ArrayList<String>();
l.add(new String(”Java”));
Object o = getElement(l, 0); // legal public Object getElement(List<?> l, int index){
Object o = null;
try{
o = l.get(0);
}catch(IndexOutOfBoundsException e){
//…….
}
return o;
} assigning values is another matter. The add() method takes an argument of type E which is the type that the Collection is to hold. Any type wishing to be added to the Collection would have to be of the same type. Since<?> represents an unknown type it is impossible to determine what the type parameter of the collection represents. Bounded Wildcards A Bounded Wildcard allows as type to be constrained. Bounded Wildcards are useful when there is some type of partial knowledge about the type arguments. While it is still illegal to try and add an element to a unknown Collection with a bounded type they come in handy in other situations. One use is to be able to pass not only types into a method but sub-types also. In doing this we are able to implement polymorphic behavior. import java.util.*; class Printer{
public void print(String s){
for(int i = 0; i < s.length(); i++){
System.out.print(s.charAt(i));
}
}
}
class ReversePrinter extends Printer{
public void print(String s){
for(int i = s.length() – 1 ; i >= 0; i–){
System.out.print(s.charAt(i));
}
}
}
public class G{
public static void main(String[] args){
String s = “Nothing like a good cup of Java in the morning!”
List<Printer> l = new ArrayList<Printer>();
l.add(new Printer());
printElements(l,s);
List<ReversePrinter> rl = new ArrayList<ReversePrinter>();
rl.add(new ReversePrinter());
printElements(rl,s);
}
public static void printElements(List<? extends Printer> l, String s){
Printer printer = l.get(0);
printer.print(s);
System.out.println();
}
} 37.How can I shuffle the elements of a Collection ?
The Collections class which can be found within the java.util namespace provides two methods which suffle the elements of a Collection. static void shuffle(List<?> list)
static void shuffle(List<?> list, Random rnd) The first method shuffles the elements according to a default source of randomness, with the second using a specified source of randomness.
import java.util.*; public class ShuffleTest{
public static void main(String[] args){
List<String> sl = new ArrayList<String>();
sl.add(”One”);
sl.add(”Two”);
sl.add(”Three”);
sl.add(”Four”);
sl.add(”Five”);
sl.add(”Six”);
for(String s: sl){
System.out.println(s);
}
System.out.println();
Collections.shuffle(sl);
for(String s: sl){
System.out.println(s);
}
}
} 38.How can i tell if two Collections contain the same elements or have no elements in common ?
Two methods are needed in this case. boolean containsAll(Collection<?> c)
boolean disjoint(Collection<?>c1 Collection<?>c2) Since containsAll(Collection<?> c) is defined within the Collection interface all concrete implementations will be able to use this method. disjoint(Collection<?>c1 Collection<?>c2) is defined within the Collections class. Using both of these methods is pretty straightforward. containsAll(Collection<?> c) is an instance method so naturally it must be invoked on an object. disjoint(Collection<?>c1 Collection<?>c2) is defined as Static within the Collections class so all that is needed is to invoke it using the class name ie Collections.disjoint(Collection<?>c1 Collection<?>c2) 39.How can I traverse a List backwards ?
In order to traverse a List backwards a ListIterator must be used. The List interface provides a method, which returns a ListIterator. ListIterator<E> listIterator() Using a returned ListIterator, concrete implementations of List can be traverse backwards using the following methods. boolean hasPrevious()
E previous() Since ListIterator extends the Iterator interface forward direction is still possible via Iterators methods.
boolean hasNext()
E next() import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator; public class {
public static void main(String[] args){
List<String> slist = new ArrayList<String>();
slist.add(”1″);
slist.add(”2″);
slist.add(”3″);
slist.add(”4″);
ListIterator i = slist.listIterator();
while(i.hasNext()){
System.out.print(i.next());
}
System.out.println();
while(i.hasPrevious()){
System.out.print(i.previous());
}
}
} 40.How can I get a sorted list of keys that are contained within a Map ?
The Map interface defines a method named keySet() which concrete classes such as HashMap and TreeMap implement. Depending on the implementation on which keySet() is invoked the returned Set might not contain it’s elements (keys) in sorted order. For instance the HashMap class makes no guarantees as to the order of the elements contained within. Whereas the TreeMap class does guarantee element ordering since it implements the SortedMap interface. /* TreeMap used. Keys stored in ascending order */ Map<String,String> book = new TreeMap<String,String>();
book.put(new String(”Java”),new String(”A trademark used for a programming language designed to develop applications, especially ones for the Internet, that can operate on different platforms.”));
book.put(new String(”C#”),new String(”An object-oriented language devised and promoted by Microsoft, intended to replace Java, which it strongly resembles.”));
book.put(new String(”Python”),new String(”A simple, high-level interpreted language by Guido van Rossum”));
book.put(new String(”LISP”),new String(”A programming language designed to process data consisting of lists. It is widely used in artificial intelligence research.”));
Set words = book.keySet();
for(Iterator i = words.iterator();i.hasNext();){
System.out.print(i.next() + “\t”);
} 41.How can I create a read only Collection ?
Unmodifiable Collections can be easily created using various static methods which the Collections class provides. Any attempts to modify the returned Collection, whether direct or via its iterator, result in an UnsupportedOperationException. Collection<T> unmodifiableCollection(Collection<? extends T> c)
List<T> unmodifiableList(List<? extends T> list)
Set<T> unmodifiableSet(Set<? extends T> s)
SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) import java.util.*; public class Unmod{
public static void main(String[] args){
List<String> strlist = new ArrayList<String>();
strlist.add(”C”);
strlist.add(”B”);
strlist.add(”A”);
Collection<String> unmodstrlist = Unmod.makeUnmodifiable(strlist);
// unmodstrlist.add(”G”); throws UnsupportedOperationException
Set<String> strset = new TreeSet<String>();
strset.add(”C”);
strset.add(”B”);
strset.add(”A”);
Collection<String> unmodstrset = Unmod.makeUnmodifiable(strset);
// unmodstrset.add(”G”); throws UnsupportedOperationException
}
public static Collection<String> makeUnmodifiable(Collection<String> c){
return(Collections.unmodifiableCollection(c));
}
} 42.Is there a way determine how many times an Object occurs within a Collection ?
The Collections class provides a method which returns the number of times an Object appears within a given Collection. public static int frequency(Collection<?> c, Object o) If a null Collection is passed in then a NullPointerException is thrown.
import java.util.*; public class Freq {
public static void main(String[] args){
List<Integer> password = new ArrayList<Integer>();
password.add(new Integer(4));
password.add(new Integer(6));
password.add(new Integer(8));
password.add(new Integer(4));
password.add(new Integer(9));
Integer passwordelement = new Integer(4);
System.out.println(passwordelement + ” appears “
+ getFrequency(password,passwordelement) + ” times within password”);
}
private static int getFrequency(Collection c, Object o){
return(Collections.frequency(c,o));
}
} 43.What is the easiest way to obtain a Map Entry ?
The easiest way to obtain a Map Entry or (key-value pair) is by invoking the following method provided by the Map interface. Set<Map.Entry<K,V>> entrySet(); The entrySet() method returns a Set which is populated with Map.Entry objects. The only way to obtain a reference to a Map.Entry is by using an Iterator on the returned Set view. Once a reference to a Map.Entry is obtained the follow methods can be invoked which return the key and value corresponding to the entry. K getKey()
V getValue() import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.Iterator; public class Emps{
public static void main(String[] args){
Map<String,String> empmap = new TreeMap<String,String>();
empmap.put(”956544″,”Bob Jones”);
empmap.put(”132485″,”Phil Harris”);
empmap.put(”102161″,”Kamal Uganda”);
empmap.put(”226545″,”Bill Russel”);
empmap.put(”116423″,”Dorris Smith”);
Set s = empmap.entrySet();
for(Iterator i = s.iterator();i.hasNext();){
Map.Entry me = (Map.Entry)i.next();
System.out.println(me.getKey() + ” : ” + me.getValue());
}
}
} 44.How can I find the maximum element contained within a Collection ?
Finding the maximum element within a Collection is easy. The following method can be used which can be found within the Collections class. public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) This method returns the maximum element of the given Collection according to the natural ordering of it’s elements. This means that all elements must implement the Comparable interface. With the following code below the implementation of the Comparable interface is already taken care of since the class Byte already implements this interface.
import java.util.Set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections; public class Max{
public static void main(String[] args){
Collection<Byte> numl = new ArrayList<Byte>();
numl.add(new Byte(”2″));
numl.add(new Byte(”6″));
numl.add(new Byte(”3″));
numl.add(new Byte(”1″));
numl.add(new Byte(”5″));
numl.add(new Byte(”4″));
System.out.print(”Max element is ” + getMax(numl));
}
public static Byte getMax(Collection<Byte> c){
return Collections.max(c);
}
} If the element type being store within the Collection is user defined, implementation of the Comparable interface must be provided. import java.util.Set;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections; public class Max{
public static void main(String[] args){
Collection<Num> numl = new ArrayList<Num>();
numl.add(new Num(”2″));
numl.add(new Num(”6″));
numl.add(new Num(”3″));
numl.add(new Num(”1″));
numl.add(new Num(”5″));
numl.add(new Num(”4″));
System.out.print(”Max element is ” + getMax(numl).getNum());
}
public static Num getMax(Collection<Num> c){
return Collections.max(c);
}
}
class Num implements Comparable<Num>{
private String i;
public Num(String i){
this.i = i;
}
public int compareTo(Num num){
int x = i.compareTo(num.i);
return x;
}
public String getNum(){
return i;
}
} 45.How can I create an immutable List consisting of n Copies of an Object ?
nCopies(int n, T o) can be used to create an immutable List which contains a specific number of copies of an Object. Care must be taken when trying to add elements to or extract elements from the returned List. Both attempts will throw UnsupportedOperationExceptions. public static <T> List<T> nCopies(int n, T o) import java.util.List;
import java.util.Collections; public class NCopiesTest{
public static void main(String[] args){
List<String> slist = Collections.nCopies(5, “Java Blend”); //immutable list!
slist.add(”Moca Blend”); // throws UnsupportedOperationException!
String selement = slist.remove(0); // throws UnsupportedOperationException!
}
} 46.What is the difference between a Stack and a Queue ?
First things first. Where can Stacks and Queue’s be found? Java provides a Stack class, which can be found within the java.util namespace. Within the same namespace you will find a Queue interface. All concrete Queue implementations can be located within the java.util.concurrent package. What is a Stack? Java’s Stack class extends the Vector class. A Stack represents a Collection of objects that are in LIFO (Last In First Out Order). The Stack class provides operations that allow testing for zero elements, inspection of it’s top most element, removal of it’s top most element, and the addition of elements. boolean empty() Tests if this stack is empty.
E peek() Looks at the object at the top of this stack without removing it from the stack.
E pop() Removes the object at the top of this stack and returns that object as the value of this function.
E push(E item) Pushes an item onto the top of this stack.
int search(Object o) Returns the 1-based position where an object is on this stack. What is a Queue? A Queue is also a Collection of Objects similar to a Stack. Queues typically order the elements contained within in FIFO order but this is not always the case. Elements that are inserted into a Queue are inserted at the tail end as opposed to a Stack where the elements are pushed into it at the head. Looking at the Queue interface the operations are similar to what a Stack provides. E element() Retrieves, but does not remove, the head of this queue.
boolean offer(E o) Inserts the specified element into this queue, if possible.
E peek() Retrieves, but does not remove, the head of this queue, returning null if this queue is empty.
E poll() Retrieves and removes the head of this queue, or null if this queue is empty.
E remove() Retrieves and removes the head of this queue. So what are the differences between Queues and Stacks? Besides how each order their elements there really isn’t much difference. Both provided pretty much the same operations. The big difference is that one is a concrete implementation (Stack) while the other is an interface (Queue) thus implying that additional functionality is provided by the concrete classes that implement the Queue interface such as blocking, and synchronization. 47.How can I insert an element into a List ?
In order to insert an element into a List add(int index, E element) must be used since the List interface does not provide an insert method. If the index is out of rage ie. index < 0 || index > size() an exception will be thrown. import java.util.*; public class Insert{
public static void main(String[] args){
List<String> slist = new ArrayList<String>();
slist.add(new String(”Java”));
slist.add(new String(”Write”));
slist.add(new String(”run”));
slist.add(new String(”anywhere!”));
slist.add(2,new String(”once”));
for(String s:slist){
System.out.println(s);
}
}
} 48.How do I make a copy of an array ?
The clone() in Clonable interface allows to make a copy of the array. In the previous case i.e. arraycopy() we must mention the source array,the source offset(starting position),the destination array,the destination offset(Starting position),and the final one is the number of elements to be copied.This method is useful when you copy a part of the array to a new one. But when we need to copy a whole array to another,then we need not mention all the arguments and have a tough time instead we go for clone() method.In case of the clone() we need to mention the source array and destination array. eg: Array a2=a1.clone(); here the elements of the Array a1 is copied to the Array a2.If we add new elements in Array a1 it will not be reflected in a2.For doing so we need to use the Object refrences. 49.What is the purpose of the CopyOnWriteArrayList and CopyOnWriteArraySet collections ?
Synchronized operations are costly and if you aren’t modifying a collection much, it is best not to synchronize all collection accesses. The CopyOnWriteXXX collections avoid concurrent modification issues during traversal by traversing through the original collection and the modifications happening in a copy of the original store. Think of CopyOnWriteArrayList as a thread-safe version of ArrayList without the syncrhonized access limitations. CopyOnWriteArraySet acts as like a Set, backed by a CopyOnWriteArrayList. 50.What implementations of the Deque interface does Java offer ?
ArrayDeque offers an array backed deque. LinkedList offers a linked list version. LinkedBlockingDeque offers an optionally bounded blocking version. 51.Why do I keep getting an UnsupportedOperationException thrown when I try some collection operations ?
Several methods of the collection interfaces are considered optional. If an unsupported operation is called, that is when you’ll see the UnsupportedOperationException thrown. The javadoc for a collection implementation should document which methods are optional. 53.Is it better to use a for-each loop or an Iterator with a collection ?
It depends on what you need to do. The remove() method of an Iterator is the safe way to remove elements from an underlying collection. You can’t safely remove elements with a for-each loop. For just “visiting” each element, either way works. 54.How can I detect if a duplicate is added to a Set ?
The add() method returns a boolean. If the set did not previously contain the element, true is returned. If the set previoulsy did contain the element, false is returned. Of course, you can also check with the contains() method to see if the element is contained in the Set first. 55.What is a multimap ?
A multimap is a map where a single key can map to multiple values.(And a value can be associated with multiple keys.) 54.How do I create a multimap in Java ?
Typically a Map maps a key to a single value. To have a multimap, the values of a Map should be a List instead. Thus there can be multiple values in the List associated with a single key. 56.What is the natural ordering of a Boolean? Does FALSE come first or second ?
Boolean.FALSE < Boolean.TRUE 57.What does Class<String> mean ?
Class<String> is the generics way of writing String.class. It allows you to improve type safety. 58.What type of data structure would you use to store java objects (Element) with the following requirements ?
I.
Created/loaded only once
Elements are frequently read by multiple threads
No updates (add/remove) to the data structure are required once loaded
Order is not important
Random object access is required by a unique key search. Answer: HashMap II.
Created once
Elements are added / removed in a multi threaded environment
Elements are frequently read in a multi threaded environment
Order is not important
Random object access is required by a unique key search. Answer: HashTable is synchronized
III.
Created/loaded only once
Elements are frequently read in a multi threaded environment
Elements are added / removed in a multi threaded environment
Elements are frequently read in a multi threaded environment
Order is important
Random object access is require based on an index
Duplicate objects allowed Answer: Vector is synchronized IV. Created once
Order is important
Random object access is require based on an index
Elements are frequently read in a multi threaded environment Answer: ArrayList  Add comment May 15th, 2007

Collections Drill - I

1.How to find the maximum size of heap used in the memory in java ?
maxMemory(): Returns the maximum amount of memory that the Java virtual machine will attempt to use
totalMemory(): Returns the total amount of memory in the Java virtual machine.
Also you can use -Xmx parameter to set the max heap size. 2.What is the difference between marshalling and unmarshalling ?
marshling is convert from byte code to network understand able format
unmarshsling is converting from network understand able fromat to byte code convertion. 3.What is the Collections API ?
The Collections API is a set of classes and interfaces that support operations on collections of objects. 4.What is the List interface ?
The List interface provides support for ordered collections of objects. 5.What is the Vector class ?
The Vector class provides the capability to implement a growable array of objects. 6.What is an Iterator interface ?
The Iterator interface is used to step through the elements of a Collection . 7.Which java.util classes and interfaces support event handling?
The EventObject class and the EventListener interface support event processing. 8.What is the GregorianCalendar class ?
The GregorianCalendar provides support for traditional Western calendars 9.What is the Locale class ?
The Locale class is used to tailor program output to the conventions of a particular geographic, political, or cultural region . 10.What is the SimpleTimeZone class ?
The SimpleTimeZone class provides support for a Gregorian calendar . 11.What is the Map interface ?
The Map interface replaces the JDK 1.1 Dictionary class and is used associate keys with values. 12.What is the highest-level event class of the event-delegation model ?
The java.util.EventObject class is the highest-level class in the event-delegation class hierarchy. 13.What is the Collection interface ?
The Collection interface provides support for the implementation of a mathematical bag – an unordered collection of objects that may contain duplicates. 14.What is the Set interface ?
The Set interface provides methods for accessing the elements of a finite mathematical set. Sets do not allow duplicate elements. 15.What is the typical use of Hashtable ?
Whenever a program wants to store a key value pair, one can use Hashtable. 16.I am trying to store an object using a key in a Hashtable. And some other object already exists in that location, then what will happen? The existing object will be overwritten? Or the new object will be stored elsewhere?
The existing object will be overwritten and thus it will be lost. 17.What is the difference between the size and capacity of a Vector?
The size is the number of elements actually stored in the vector, while capacity is the maximum number of elements it can store at a given instance of time. 18.Can a vector contain heterogenous objects ?
Yes a Vector can contain heterogenous objects. Because a Vector stores everything in terms of Object. 19.Can a ArrayList contain heterogenous objects ?
Yes a ArrayList can contain heterogenous objects. Because a ArrayList stores everything in terms of Object. 20.What is an enumeration ?
An enumeration is an interface containing methods for accessing the underlying data structure from which the enumeration is obtained. It is a construct which collection classes return when you request a collection of all the objects stored in the collection. It allows sequential access to all the elements stored in the collection. 21.Considering the basic properties of Vector and ArrayList, where will you use Vector and where will you use ArrayList ?
The basic difference between a Vector and an ArrayList is that, vector is synchronized while ArrayList is not. Thus whenever there is a possibility of multiple threads accessing the same instance, one should use Vector. While if not multiple threads are going to access the same instance then use ArrayList. Non synchronized data structure will give better performance than the synchronized one. 22.Can a vector contain heterogenous objects ?
Yes a Vector can contain heterogenous objects. Because a Vector stores everything in terms of Object 23.How do I use an Iterator to go through a Collection ?
Collection collection = …;
Iterator iterator = collection.iterator();
while (iterator.hasNext()) {
Object element = iterator.next();
// Do something with element
}
} 24.How do I use a ListIterator to go through a List backwards ?
List list = …;
ListIterator iterator = list.listIterator(list.size());
while (iterator.hasPrevious()) {
Object element = iterator.previous();
// Process element
} 25.How do I count the frequency of some word/object ?
The Map interface can be used to count the number of times a word/object appears. The following program demonstrates counting word frequency from the command line: import java.util.*; public class MapExample {
public static void main(String args[]) {
Map map = new HashMap();
Integer ONE = new Integer(1);
for (int i=0, n=args.length; i<n; i++) {
String key = args[i];
Integer frequency = (Integer)map.get(key);
if (frequency == null) {
frequency = ONE;
} else {
int value = frequency.intValue();
frequency = new Integer(value + 1);
}
map.put(key, frequency);
}
System.out.println(map);
Map sortedMap = new TreeMap(map);
System.out.println(sortedMap);
}
} 26. How do I sort objects into their reverse natural ordering ?
The Collections.reverseOrder() method returns a Comparator that sorts objects that implement the Comparable interface in reverse order. 27.How do I use Enumeration to iterate through a collection ?
Enumeration enum = …;
while (enum.hasMoreElements()) {
Object element = iterator.nextElement();
// process element
} 28.How do I make an array larger ?
You cannot directly make an array larger. You must make a new (larger) array and copy the original elements into it, usually with System.arraycopy(). If you find yourself frequently doing this, the Vector class does this automatically for you, as long as your arrays are not of primitive data types. 29.How do you store a primitive data type within a Vector or other collections class ?
You need to wrap the primitive data type into one of the wrapper classes found in the java.lang package, like Integer, Float, or Double, as in: Integer in = new Integer(5); 30.How do I create linked lists if there are no pointers ?
No pointers does not mean no reference variables. You just can’t deference them as you can in C/C++ or perform pointer arithmetic. You can still use abstract data types that require dynamic data structures. See the LinkedList class for an example of a linked list implementation. 31.How do I use an array with the Collections Framework ?
The Arrays.asList() method provides a fixed-length List view of an array, where changes to the List are stored in the original array. The Arrays class also provides additional support methods for sorting and searching an array. 32.Which is faster, synchronizing a HashMap or using a Hashtable for thread-safe access ?
Because a synchronized HashMap requires an extra method call, a Hashtable is faster for synchronized access. 33.Which is the preferred collection class to use for storing database result sets ?
When retrieving database results, the best collection implementation to use is the LinkedList.
The benefits include:
Retains the original retrieval order
Has quick insertion at the head/tail
Doesn’t have an internal size limitation like a Vector where when the size is exceeded a new internal structure is created (or you have to find out size beforehand to size properly)
Permits user-controlled synchronization unlike the pre-Collections Vector which is always synchronized Basically: ResultSet result = stmt.executeQuery(”…”);
List list = new LinkedList();
while(result.next()) {
list.add(result.getString(”col”));
} If there are multiple columns in the result set, you’ll have to combine them into their own data structure for each row. Arrays work well for that as you know the size, though a custom class might be best so you can convert the contents to the proper type when extracting from databse, instead of later. 34.Why doesn’t the Iterator interface extend the Enumeration interface ?
If the Iterator interface extended the Enumeration interface, the Iterator interface would end up with five methods where two methods just called other methods in the interface. The designers of the framework wanted to get rid of the cumbersome Enumeration method names so had the Iterator interface stand on its own with new shorter method names. 35.How do I print a Collection ?
The Collection Framework implementation classes override the toString() method to print out all the elements of the collection. If you create your own custom implementation, as long as your class is a subclass of AbstractMap or AbstractCollection you’ll inherit this behavior. (Keep in mind that AbstractList and AbstractSet subclass AbstractCollection.) 36.How do I synchronize a collection ?
With the Collections Framework, the new implementations are all unsynchronized by default. If you need synchronized access, you must synchronize things yourself. The Collections class offers a wrapper method for each of the six core collection interfaces that add synchronization to an arbitrary collections implementation. To ensure thread-safety, direct access to the original backing collection must be avoided.
For example, the following will synchronize an arbitrary List and lose the original reference so you can’t access it directly: List list = …;
list = Collections.synchronizedList(list); 37.How I do a case-sensitive sort in a language-insensitive manner ?
If you have an array of primitives or an array of equivalent objects that implement the Comparable interface, all you need to do is call the sort() method of the java.util.Arrays class. If the class doesn’t implement Comparable, you need to provide your own Comparator implementation to the sort() method. 38.How do I get the length of an array ?
To avoid getting an ArrayIndexOutOfBoundsException, you can check for the array length from either the length instance variable or using reflection and calling java.lang.reflect.Array.getLength(), passing the array as an argument to the method.
int length = args.length;
// or
int length2 = Array.getLength(args); 39.How can I speed up array accesses and turn off array bounds checking ?
You cannot. It is part of the security architecture of the Java runtime to ensure never accessing invalid memory space. 40.How do I get the list of system properties that tell me things like which version of Java a user is running and their platform-specific line separator ?
The System.getProperties() method will return the standard property set. However, in untrusted applets, you can only ask for specific properties, as in System.getProperty(”java.version”). 41.How do I sort an array ?
The Arrays class in java.util provides a series of sort() methods for sorting arrays. If the array is an array of primitives or an array of a class that implements Comparable then you can just call the method directly: Arrays.sort(theArray); If, however, it is an array of objects that don’t implement the Comparable interface then you need to provide a custom Comparator to help you sort the elements in the array. Arrays.sort(theArray, theComparator); 42.How can I implement a List (ordered collection) that keeps an index (i.e. a Map) of its contents ?
You can’t. Each of the Map and List interfaces define a remove(Object o) method. Each method returns a different type (Map returns an Object while List returns a boolean). Because the compiler doesn’t permit overloaded methods that differ by only return type, you cannot create a class that implements both the List and Map interface. If you need a Map that maintains insertion order, see the LinkedHashMap added in Java 1.4. 43.Is there a way to create a homogenous collection in Java? How do I make a collection where all the elements within it are a specific data type ?
You can wait for Generics to be added to Java or… You’d have to build one yourself. Basically, you’re creating a class that is a Proxy (Gang Of Four design pattern) around the actual Collection. This works similarly to the way the (hidden) Synchronized versions in Collections work. They contain a reference to the original collection object that does the “real” work, but restrict access to it by synchronizing all the access methods. What you’d be doing in this case is restricting access by keeping a reference to the Class object of the class you want to restrict your collection to contain, and throw IllegalArgumentExceptions whenever there’s an attempt to add an object not of that class. There’s no way to enforce compile-time type safety in this manner. The API using “Object” references can’t be changed in Collection. You can also wrap a collection by a Proxy that provides the alternative API that has type-safe method signatures. This is what’s done by the StringTokenizer API (which implements Enumeration, and wraps Enumeration with String versions of the same methods). Otherwise, create your own class with its own signatures, and keep the Collection strictly private. This is best done if you are designing a class for others to use. 44.How does a Hashtable internally maintain the key-value pairs ?
The Hashtable class uses an internal (private) class named Entry to hold the key-value pairs. All entries of the Hashtable are stored in an array of Entry objects with the hash value of the key serving as the index. If two or more different keys have the same hash value these entries are stored as a linked list under the same index. 45.How do I look through each element of a HashMap ?
To go through all the elements of a HashMap, or any class that implements the Map interface, call the entrySet() or keySet() methods than loop through what is returned. The entrySet() returns a group of Map.Entry elements, whereas the keySet() method just returns a Set of key elements. If you then want what the key refers to, you’d have to look them up.
Once you have a Set to work with, you would then use an Iterator to go through all its elements. The following demonstrates: Map map = some hash map
Set set = map.keySet();
Iterator it = set.iterator();
while (it.hasNext()) {
System.out.println(it.next());
} 46.How do I create a read-only collection ?
The Collections class has six methods to help out here:
unmodifiableCollection(Collection c)
unmodifiableList(List list)
unmodifiableMap(Map m)
unmodifiableSet(Set s)
unmodifiableSortedMap(SortedMap m)
unmodifiableSortedSet(SortedSet s) If you then get an Iterator from one of these unmodifiable collections, when you call remove() it will throw an UnsupportedOperationException 47.How can I process through the keys of a Hashtable in sorted order ?
In order to get all the keys for a Hashtable, you use the keys() method to get an Enumeration or the keySet() method to get a Set. If you are using Java 2, and can use the collections framework, what you should do is get the key set of the Hashtable and create a TreeSet from it. You can then get an iterator() from the created TreeSet that will have the keys in order. If you can’t use the collections framework, you’ll have the sort the Enumeration you get back from keys() yourself. 48.Which collections in Java are synchronized and which aren’t ?
The original collection classes in Java are all synchronized: Vector and Hashtable, along with their subclasses Stack and Properties. Those classes introduced with the Java 2 Collections Framework are all NOT synchronized by default, the sets, lists, and maps 49.What are the differences between ArrayList and LinkedList ?
An ArrayList is a List implementation backed by a Java array, similar to the Vector class. As the number of elements in the collection increases, the internal array grows to fit them. If there are lots of growth periods, performance degrades as the old array needs to be copied into the new array. However, random access is very quick as it uses an array index to access.
With a LinkedList, the List implementation is backed by a doubly linked list data structure, allowing easy inserts/deletions anywhere in the structure, but really slow random accesses as the access must start at an end to get to the specific position. Which you use really depends on the type of operations you need to support. 50.How do I read input from a stream “one word at a time” ?           What you need to do is use the java.util.StringTokenizer or java.io.StreamTokenizer to parse your input into words. Each has a default set of delimiters like white space that can be changed. The following demonstrates the using of StringTokenizer to count words in a file. import java.io.*;
import java.util.*; public class Test {
static final Integer ONE = new Integer(1); public static void main (String args[])
throws IOException { Map map = new TreeMap();
FileReader fr = new FileReader(args[0]);
BufferedReader br = new BufferedReader(fr);
String line;
while ((line = br.readLine()) != null) {
processLine(line, map);
}
printMap(map);
}
static void processLine(String line, Map map) {
StringTokenizer st = new StringTokenizer(line);
while (st.hasMoreTokens()) {
addWord(map, st.nextToken());
}
}
static void addWord(Map map, String word) {
Object obj = map.get(word);
if (obj == null) {
map.put(word, ONE);
} else {
int i = ((Integer)obj).intValue() + 1;
map.put(word, new Integer(i));
}
}
static void printMap(Map map) {
Set set = map.entrySet();
Iterator it = set.iterator();
while (it.hasNext()) {
Map.Entry entry = (Map.Entry)it.next();
System.out.println(entry.getKey() +
“: ” + entry.getValue());
}
}
} 51.Do the keys() and elements() methods of a Hashtable enumerate things in the same order ?
There is no requirement that the elements are returned in the same order, only that all of them are returned in the Enumeration. Your best bet for getting the element for a key is to loop through the keys() returned and fetch the element for each. Or, if you can use a HashMap instead of a Hashtable, work with the Map.Entry that is returned by the keySet(). This includes both the key and value together, not requiring a separate lookup. 52.How do I treat an object I get out of a Vector (collection) as the type I put into it  ?
When you get an object out of a Vector (or any collection), the object is returned as being of type Object. You need to cast it back into the object type you put into the data structure if you need to call or treat the object as the original type.
For instance, if you add an array to a vector: String args[] = {”1″, “2″, “3″};
Vector v = new Vector();
v.addElement(args); Then, when you get the object out of the vector, you need to cast it back to the original type:
String args2[] = (String[])v.firstElement();
System.out.println(args2.length); 53.What is the difference between a singly linked list and doubley linked list ?
A singly linked list is one that has only a pointer/reference to the next element in the list. A doubley linked list has both a previous and next pointer/reference. 54.What is meant by natural ordering of objects in the context of the collections framework ?
Java documentation refers to the natural ordering of objects when describing various algorithms and data structures in the collections framework. Object ordering is obviously needed by the sorting algorithms. It is also needed by the specifications of the interfaces such as SortedSet, SortedMap, etc., and the data structures used for container classes such as TreeSet, TreeMap, etc. Unless instructed otherwise via a Comparator object supplied as an argument to the constructor, the default behavior of a class such as TreeSet is to store its objects in an ascending natural order.
The objects of a class exhibit natural ordering if the class has implemented the java.lang.Comparable interface. Such a class must provide an implementation for the compareTo method — referred to as the class’s natural comparison method — that can then be used by the algorithms and the data structures for comparing data objects. The compareTo method must return a negative integer, a zero, or a positive integer if the object on which it is invoked is less than, equal to, or greater than the argument object. It is strongly recommended that a class’s natural ordering as dictated by the implementation of the compareTo method be consistent with equals. This consistency is achieved if and only if e1.compareTo( (Object) e2 ) == 0 has the same boolean value as e1.equals( (Object) e2 ) for every pair of objects e1 and e2 of the class. Lack of this consistency could elicit strange behavior from the data structures that need to compare objects. Many of the system supplied classes possess natural ordering. These include String, Integer, Float, Double, Date, File and many others. For the String class, the natural order is lexicographic; it is chronological for the Date class; lexicographic on the pathname for the File class, etc. 55.What is a fail-fast iterator ?
An iterator is considered fail-fast if it throws a ConcurrentModificationException under either of the following two conditions:
In multithreaded processing: if one thread is trying to modify a Collection while another thread is iterating over it. In single-threaded or in multithreaded processing: if after the creation of the Iterator, the container is modified at any time by any method other than the Iterator’s own remove or add methods.
Note in particular what is implied by the second condition: After we create a container’s iterator, during a loop that iterates over the container we must only use the remove (and when applicable add) methods defined for the iterator and that we must NOT use the same methods defined for the container itself. To illustrate this point, suppose we declare and initialize a List in the following manner
List list = new ArrayList();
list.add(”Peter”);
list.add(”Paul”);
list.add(”Mary”); Let’s say we wish to iterate over this list. We’d need to declare a ListIterator as follows:
ListIterator iter = list.listIterator(); Having created this iterator, we could now set up a loop like:
while(iter1.hasNext()){
String str = iter1.next();
// do something with str
} Because iter is fail-fast, we are not allowed to invoke List’s add or remove methods inside the loop. Inside the loop, we are only allowed to use ListIterator’s add and remove methods. This makes sense because it is the Iterator object that knows where it is in a List as the List is being scanned. The List object itself would have no idea of that.
The Iterators supported by all the work-horse container classes, such as ArrayList, LinkedList, TreeSet, and HashSet, are fail-fast. The Iterator type retrofitted to the older container class Vector is also fail-fast. For associative containers, such as HashMap and the older HashTable, the Iterator type for the Collections corresponding to either the keys or the values or the <key, value> pairs are fail-fast with respect to the container itself. That means that even if you are iterating over, say, just the keys of the container, any illegal concurrent modifications to the underlying container would be detected. One final note regarding iterators versus enumerations: It is also possible to use an Enumeration object returned by the elements() method for iterating over the older container types such as Vector. However, Enumerations do not provide a fail-fast method. On the other hand, the more modern Iterator returned by a Vector’s iterator() and listIterator() methods are fail-fast. Hence, iterators are recommended over enumerations for iterating over the elements of the older container types. 56.How do you sort the elements of a vector ?
Since the Vector class implements the List interface, you can call the Collections.sort() method to sort the elements in place. You can also manually insert elements into a Vector to keep the vector sorted. Of course, if keeping sorted access is such a big deal, you should consider using a different, more appropriate data structure like a TreeSet.
For 1.1 Java users, you’ll need to sort the elements yourself. There is no built-in support for this. A better option might be to sort the elements as you insert each element. 57.What is a WeakHashMap? What is its use and when should you use it ?
A WeakHashMap is a special Map implementation where the keys of the map are stored in a java.lang.ref.WeakReference. By storing the keys in a weak reference, key-value pairs can dynamically be dropped from the map when the only reference to the key is from the weak reference. This makes the WeakHashMap an excellent implementation for a weakly referenced list, where entries that aren’t used elsewhere may be dropped with no side effects. Also, just because a key may be dropped, doesn’t mean it will immediately be dropped. If the system has sufficient resources, the weak key reference that isn’t externally referenced could stay around for a long time. 58.What is the function of a load factor in a Hashtable ?
The load factor determines how full a hashtable may get before it expands its capacity. I think that the comments on the Hashtable API docs explain it very well:
The load factor is a measure of how full the hash table is allowed to get before its capacity is automatically increased. When the number of entries in the hashtable exceeds the product of the load factor and the current capacity, the capacity is increased by calling the rehash method. Generally, the default load factor (.75) offers a good tradeoff between time and space costs. Higher values decrease the space overhead but increase the time cost to look up an entry (which is reflected in most Hashtable operations, including get and put). 59.How do you control growth of vectors when their internal arrays are full ?
The vector constructor can include either an initial capacity or a capacity and growth increment. When not specified, the initial size of the vector is 10 and growth will double when necessary. Otherwise, initialize size and growth will grow when needed as specified by the arguments to the constructor.
If the argument to the constructor is a collection, the initial size of the internal structure is 10% larger than the collection. Since there is no second argument to control growth, the capacity will double when necessary. 60.How to sort the messages in JavaMail ?
Within the JavaMail classes there is no support for this. However, once you get the array of messages back from a folder, you can call the Arrays.sort() method in the collections framework to sort the messges. Since MimeMessage doesn’t implement Comparable, you’ll need to provide your own Comparator specifying how you want the messages to be sorted. 61.When did Strings start caching their hash codes ?
Starting with the 1.3 release of Java, the java.lang.String class will only calculate the hashcode once, when its first needed. Future calls to hashCode() will return the previously calculated value. 62.How can you retrieve the Hashtable’s load factor ?
There is no public interface to access the load factor setting.
Some choices you can do to expose this value… Subclass Hashtable and add a read-only accessor method
Use reflection to access the private field (only possible in trusted environment)
Serialize the Hashtable and get the value from the stream (when reading back the stream, you’ll have to figure out where the appropriate field is) 63.Why can’t I add a collection to itself ?
This will cause a stack overflow exception to be generated on calls to methods like toString() and hashCode(), which recursively call the method on the elements of the collection.     

ANT drill - One

  What is ant? Ant is a small animal who can build magnificent buildings. Ant builds!
ANT is a Java based building tool, which is similar to make, and so much better than make.
ANT, what a smart name for a building tool, even the original author of ANT, James Duncan Davidson, meant “Another Neat Tool”. A win-win ant learning method There is a shortcut.
If you download a small jakarta project, such as Log4J, which is built by ant. It is a good and simple example for you to learn ant. Actually, you hit two birds with one stone.
Ant is easy!
The hard part is how to make a very complicated diversified system work very simple and elegant. Knowledge about ant is not enough, you need an elegant and simple design, you need great naming convention, you need to optimize the code reusability and flexibility, you need a least maintenance system…
Then it is not easy now .. How do I get started to use ant? Can you give me a “Hello World” ant script? Simple.
    * Download the most recent version of ant from Apache; unzip it some where on your machine.
    * Install j2sdk 1.4 or above.
    * Set JAVA_HOME and ANT_HOME to the directory your installed them respectively.
    * Put %JAVA_HOME%/bin;%ANT_HOME%/bin on your Path. Use ${JAVA_HOME}/bin:${ANT_HOME}/bin on UNIX. Yes, you can use forward slash on windows.
    * Write a “Hello world” build.xml
                  <project name=”hello” default=”say.hello” basedir=”.” >
                    <property name=”hello.msg” value=”Hello, World!” />
                    <target name=”say.hello” >
                      <echo>${hello.msg}</echo>
                    </target>
                  </project>
    * Type ant in the directory your build.xml located.
    * You are ready to go!!!! How to delete files from a directory if it exists? The following code fails when directory does not exist!
<delete quiet=”true” dir=”${classes.dir}” includes=”*.class”/> Your code has many problems.
   1. You should not use implicit fileset, which is deprecated. You should use nested fileset.
   2. If dir does not exist, the build will fail, period!
   3. If you are not sure, use a upper level dir, which exists for sure. See the following fileset.
  <delete>
    <fileset dir=”${upperdir.which.exists}”>
      <include name=”${classes.dir}/*.class” />
    </fileset>
  </delete> How do I set classpath in ant? Here is some snippet of code
  <path id=”build.classpath”>
    <fileset dir=”${build.lib}” includes=”**/*.jar”/>
    <fileset dir=”${build.classes}” />
  </path>
  <target….>
    <javac ….>
      <classpath refid=”build.classpath” />
    </java>
  </target>
  <target….>
    <java ….>
      <classpath refid=”build.classpath” />
    </java>
  </target> How does ant read properties? How to set my property system? Ant sets properties by order, when something is set, the later same properties cannot overwrite the previous ones. This is opposite to your Java setters.
This give us a good leverage of preset all properties in one place, and overwrite only the needed. Give you an example here. You need password for a task, but don’t want to share it with your team members, or not the developers outside your team.
Store your password in your ${user.home}/prj.properties
pswd=yourrealpassword
In your include directory master prj.properties
pswd=password
In your build-common.xml read properties files in this order
   1. The commandline will prevail, if you use it: ant -Dpswd=newpassword
   2. ${user.home}/prj.properties (personal)
   3. yourprojectdir/prj.properties (project team wise)
   4. your_master_include_directory/prj.properties (universal)
<cvsnttask password=”${pswd} … />
Problem solved! How to modify properties in ant? No, you can’t!
Properties in Ant are immutable. There is a good reason behind this, see this FAQ item for more details.
Q. How to use ant-contrib tasks?
A: Simple, just copy ant-contrib.jar to your ant*/lib directory
And add this line into your ant script, all ant-contrib tasks are now available to you!
    <taskdef resource=”net/sf/antcontrib/antcontrib.properties” /> How to loop on a list or fileset? Use ant-contrib <for> <foreach> tasks
General to say, use <for> is better than use <foreach> since for each is actually open another ant property space, use more memory too. Why do I get en exception when I use location=”D:\\Code\\include” as attribute of includepath? See here.
You need to escape the string to “D:\\\\Code\\\\include” or use “D:/Code/include” instead!
Believe me or not? Forward slash works on windows in all ant or java code. It also works in windows environment variables. It does not work in cmd (dos) window before XP. It also works in XP dos window now! Can I put the contents of a classpath or fileset into a property? Yes, you can.
This is very similar to the call of Java class toString() method and actually it is calling the toString() method inside ant. For example
<fileset id=”fs1″ dir=”t1″ includes=”**/*.java”/>
<property name=”f1.contents” refid=”fs1″/>
<echo>f1.contents=${f1.contents}</echo> Where can I find the javadoc for ant API? Download apache ant src version. Use ant javadocs command to see generated javadoc for ant in build/docs directory.   How can I use ant to run a Java application? Here is a real world example.
  <target name=”run” depends=”some.target,some.other.target”>
    <java classname=”${run.class}” fork=”yes”>
      <classpath>
        <path refid=”classpath” />
      </classpath>
      <jvmarg line=”${debug.jvmargs}” />
      <jvmarg line=”${my.jvmargs}” />
      <jvmarg value=”-Dname=${name}” />
      <jvmarg line=”${run.jvmargs}” />
      <arg line=”${run.args}” />
    </java>
  </target> How to use ant to run commandline command? How to get perl script running result? Use exec ant task.
Don’t forget ant is pure Java. That is why ant is so useful, powerful and versatile. If you want ant receive unix command and result, you must think Unix. So does in MS-Windows. Ant just helps you to automate the process. How do I debug my ant script? Many ways
    * Do an echo on where you have doubt. You will find out what is the problem easily. Just like the old c printf() or Java System.println()
    * Use project.log(”msg”) in your javascript or custom ant task
    * Run Ant with -verbose, or even -debug, to get more information on what it is doing, and where. However, you might be tired with that pretty soon, since it give you too much information. How to exclude multi directories in copy or delete task? Here is an example.
  <copy todir=”${to.dir}” >
    <fileset dir=”${from.dir}” >
      <exclude name=”dirname1″ />
      <exclude name=”dirname2″ />
      <exclude name=”abc/whatever/dirname3″ />
      <exclude name=”**/dirname4″ />
    </fileset>
  </copy> How to use Runtime in ant? You don’t need to use Runtime etc. Ant have exec task.
The class name is org.apache.tools.ant.taskdefs.ExecTask. You can create the task by using the code in your customized ant Task.
ExecTask compile = (ExecTask)project.createTask(”exec”); How to rearrange my directory structure in my jar/war/ear/zip file? Do I need to unarchive them first? No, you don’t need to unarchive them first.
    * You don’t need to unzip the files from archive to put into your destination jar/ear/war files.
    * You can use zipfileset in your jar/war/ear task to extract files from old archive to different directory in your new archive.
    * You also can use zipfileset in your jar/war/ear task to send files from local directory to different directory in your new archive.
See the follow example:
  <jar destfile=”${dest}/my.jar”>
    <zipfileset src=”old_archive.zip” includes=”**/*.properties” prefix=”dir_in_new_archive/prop”/>
    <zipfileset dir=”curr_dir/abc” prefix=”new_dir_in_archive/xyz”/>
  </jar> Why did I get such warning in ant?
compile:
[javac] Warning: commons-logging.properties modified in the future.
[javac] Warning: dao\\DAO.java modified in the future.
[javac] Warning: dao\\DBDao2.java modified in the future.
[javac] Warning: dao\\HibernateBase.java modified in the future. System time problem, possible reasons:
    * You changed the system time
    * I had the same problem before, I checked out files from cvs to windows, and transfer them to a unix machine, somehow, I got huge amount of such warnings because the system timing issue.
    * If you transfer files from Australia/China/India to the United States, you will get the problem too. True enough, I did and met the problem once. How can I write my own ant task? Easy!
Writing Your Own Task How-To from ant.
In your own $ANT_HOME/docs/manual directory, there also is tutorial-writing-tasks-src.zip
Use them! Use taskdef to define it in your script, define it before using it. How to copy files without extention? If files are in the directory:
<include name=”a,b,c”/>
If files are in the directory or subdirectories:
<include name=”**/a,**/b,**/c”/>
If you want all files without extension are in the directory or subdirectories:
<exclude name=”**/*.*”/> How do I use two different versions of jdk in ant script? The followings are what I’m doing.
   1. Don’t define java.home by yourself. Ant uses an internal one derived from your environment var JAVA_HOME. It is immutable.
   2. I do the followings:
          * In my build.properties (read first)
            jdk13.bin=${tools.home}/jdk1.3.1_13/bin
            jdk14.bin=${tools.home}/j2sdk1.4.2_08/bin/
          * In my master properties file (read last), set default
            javac.location=${jdk13.bin}
          * In my prj.properties, if I need to use 1.4
            javac.location=${jdk14.bin}
          * in my javac task
            executable=”${javac.location}/javac.exe” How to pass -Xlint or -Xlint:unchecked to 1.5 javac task? pass it as compilerarg nested <compilerarg> to specify.
  <compilerarg value=”-Xlint”/>
  <!– or –>
  <compilerarg value=”-Xlint:unchecked”/> Can you give me a simple ant xslt task example? Here is a working one!
    <xslt style=”${xslfile}” in=”${infile}” out=”${outfile}” >
      <classpath>
        <fileset dir=”${xml.home}/bin”
          includes=”*.jar” />
      </classpath>
    </xslt> How to hide password input? Override ant Input task.
Response every user input with a backspace. Not the best, but it works How do I add elements to an existing path dynamically? Yes, it is possible. However, you need to write a custom ant task, get the path, and add/modify it, and put it in use. What I am doing is that I define a path reference lib.classpath, then add/modify the lib.classpath use my own task. How to do conditional statement in ant? There are many ways to solve the problem.
    * Since target if/unless all depend on some property is defined or not, you can use condition to define different NEW properties, which in turn depends on your ant property values. This makes your ant script very flexible, but a little hard to read.
    * Ant-contrib has <if> <switch> tasks for you to use.
    * Ant-contrib also has <propertyregex> which can make very complicate decisions. Can I change/override ant properties when I use ant-contrib foreach task? <foreach> is actually using a different property space, you can pass any property name/value pair to it. Just use <param> nested tag inside foreach How to let auto-detect platform and use platform specific properties? Tell you a great trick, it works excellent.
In your major build-include.xml, put in this line
  <property file=”${antutil.includes}/${os.name}-${os.arch}.properties” />
This will auto-detect your platform, and you write one file for each environment specific variables. For example: HP-UX-PA_RISC2.0.properties SunOS-sparc.properties Windows XP-x86.properties … They work great!!! How to make ant user interactive? I tried to use BufferedReader to get user input, it hangs. See here.
Use this class TimedBufferedReader instead of your BufferedReader will work. This is a working one in our installation process. The original author is credited in the code. I’ve made some improvement.
TimedBufferedReader.java
package setup;
import java.io.Reader;
import java.io.BufferedReader;
import java.io.IOException;
/**
 * Provides a BufferedReader with a readLine method that
 * blocks for only a specified number of seconds. If no
 * input is read in that time, a specified default
 * string is returned. Otherwise, the input read is returned.
 * Thanks to Stefan Reich
 * for suggesting this implementation.
 * @author: Anthony J. Young-Garner
 * @author: Roseanne Zhang made improvement.
 */
public class TimedBufferedReader extends BufferedReader
{
  private int    timeout    = 60; // 1 minute
  private String defaultStr = “”;
  /**
   * TimedBufferedReader constructor.
   * @param in Reader
   */
  TimedBufferedReader(Reader in)
  {
    super(in);
  }
  /**
   * TimedBufferedReader constructor.
   * @param in Reader
   * @param sz int Size of the input buffer.
   */
  TimedBufferedReader(Reader in, int sz)
  {
    super(in, sz);
  }
  /**
   * Sets number of seconds to block for input.
   * @param seconds int
   */
  public void setTimeout(int timeout)
  {
    this.timeout=timeout;
  }
  /**
   * Sets defaultStr to use if no input is read.
   * @param str String
   */
  public void setDefaultStr(String str)
  {
    defaultStr = str;
  }
  /**
   * We use ms internally
   * @return String
   */
  public String readLine() throws IOException
  {
    int waitms = timeout*1000;
    int ms     = 0;
    while (!this.ready())
    {
      try
      {
        Thread.currentThread().sleep(10);
        ms += 10;
      }
      catch (InterruptedException e)
      {
        break;
      }
      if (ms >= waitms)
      {
          return defaultStr;
      }
    }
    return super.readLine();
  }
} What is a good directory structure for main code and junit test code? Dev
    |_src
    |  |_com
    |     |_mycom
    |        |_mypkg
    |           |_A.java
    |_test
       |_src
         |_com
            |_mycom
               |_mypkg
                  |_ATest.java           

Design Patterns : Drill

What is a design pattern.
————————————–
“Design patterns are recurring solutions to design problems you see over
Alpert, et. al., 1998).
“Design patterns constitute a set of rules describing how to accomplish
certain tasks in the realm of software development.” (Pree, 1994)How many catogeries are there in Java patterns.
————————————————–
Creational patterns are ones that create objects for you, rather than
having you instantiate objects directly. This gives your program more
flexibility in deciding which objects need to be created for a given case.
Structural patterns help you compose groups of objects into larger
structures, such as complex user interfaces or accounting data.
Behavioral patterns help you define the communication between objects
in your system and how the flow is controlled in a complex program. Design Patterns is a catalog of 23 generally useful patterns for writing objectoriented software.Give me an example of Creational Patterns.
——————————————————
All of the creational patterns deal with the best way to create instances of objects. This is important because your program should not depend on how objects are created and arranged. In Java, of course, the simplest way to create an instance of an object is by using the new operator. Sharat = new Sharat(); //instance of Fred class However, this really amounts to hard coding how you create the object within your program. In many cases, the exact nature of the object that is created could vary with the needs of the program from time to time and abstracting the creation process into a special “creator” class can make your program more flexible and general. The Factory Pattern is used to choose and return an instance of a class from a number of similar classes based on data you provide to the factory.
The Abstract Factory Pattern is used to return one of several groups of classes. In some cases it actually returns a Factory for that group of classes.
The Builder Pattern assembles a number of objects to make a new object, based on the data with which it is presented. Frequently, the choice of which way the objects are assembled is achieved using a Factory.
The Prototype Pattern copies or clones an existing class rather than creating a new instance when creating new instances is more expensive.
The Singleton Pattern is a pattern that insures there is one and only one instance of an object, and that it is possible to obtain global access to that one instance. What is Singleton pattern. Where did you use it.
——————————————————
Definition: Singleton pattern is used whenever we require a class to have only one instance throughout the application. Sometimes it’s appropriate to have exactly one instance of a class: If we need some data to be stored , used and manipulated the same instance by the whole application, we will use singleton pattern. 

• Ensure that only one instance of a class is created
• Provide a global point of access to the object
• Allow multiple instances in the future without affecting a singleton class’s clients

Examples:

• window managers, print spoolers, and filesystems are prototypical examples.
• Search window in Microsoft word, even if multiple documents are open, only one search window will be opened.  
• One important usage of singleton pattern is when you need to instantiate a subclass and check which class to be instantiated during run time. For example there are two subclasses one for production and one for development and we need to instantiate one during run time depending on the environment.

Syntax:public class ClassicSingleton {
private static ClassicSingleton instance = null;
protected ClassicSingleton() {
// Exists only to defeat instantiation.
}
public static ClassicSingleton getInstance() {
if(instance == null) {
instance = new ClassicSingleton();
}
return instance;
}
The ClassicSingleton class maintains a static reference to the lone singleton instance and returns that reference from the static getInstance() method.public class SingletonInstantiator {
  public SingletonInstantiator() {
   ClassicSingleton instance = ClassicSingleton.getInstance();
ClassicSingleton anotherInstance =
new ClassicSingleton();
       …
  }
}
Explanation: In the first line we have created an instance of this class as null. We have declared a private constructor for the class to make sure that no object of class can be created outside the class.getInstance() method is the entry point for the class which will return the only instance present for the class. This method is marked as static as it will be called directly from other classes. In this method we check if the instance of singletonExample is already present, if yes, return that instance else create the instance and return it. This makes sure that only one instance of the class is present at any point. In the user class, that is calling our singleton class, we just need to call our singletonExample.getinstance() method which will return us the instance of singletonExample. Types:

• we create an instance of singleton class only when it is called for the first time is called lazy instantiation.
• Another variation can be creating the instance before it is called, this kind of instantiation is called eager instantiation.

Problems:

• A side effect of using singleton class: as the constructor of the singleton class is private, you cannot create a subclass of a singleton class, but in most of the cases that is desirable.
• Additionally you can declare the class as final to explicitly show that the class can’t be subclassed. But in case if it is required to create a subclass of singleton class one can define the constructor of singleton class as protective instead of private.
• Another point to note is that the singleton classes are not thread-safe.

Making your singleton class thread-safe is easy, you just have to make your getinstance method synchronized. Public synchronized static singletonExample getInstance()
{
//if instance is null create else return old instance
} What is Factory pattern. Explain it.
——————————————————

• if we have a super class and n sub-classes, and based on data provided, we have to return the object of one of the sub-classes, we use a factory pattern.
• provides a simple decision making class which returns one of several possible subclasses of an abstract base class depending on data it is provided.
• Usually all of the classes it returns have a common parent class and common methods,but each of them performs a task differently and is optimized for differentkinds of data.

You should consider using a Factory pattern when
· A class can’t anticipate which kind of class of objects it must create.
· A class uses its subclasses to specify which objects it creates.
· You want to localize the knowledge of which class gets created.Needs to isolate concrete classes from their super classes. ·  A system needs independent of how its products are created, composed, and represented.

Java Design Pattern

1.What is a design pattern.
2.How many catogeries are there in Java patterns.
3. How many patterns did you use in your project.
4.Give me an example of Creational Patterns.
5.What is Singleton pattern. Where did you use it.
6.How do you use Factory pattern.
7.Can explaing examples of Structural Patterns.
8.What is difference between adapter pattern and decorator pattern.
9.What is Facade Pattern. Give an example.
10.Did you use proxy pattern.
11.Give me some examples of Behavioral Patterns.
12.What is Observer Pattern.
13.Do you know the difference between Command pattern and interpreter pattern.
14.What is Visitor Pattern.

Java Drill - 2

1.Can a private method of a superclass be declared within a subclass?
2.Why Java does not support multiple inheritence ?
3.What is the difference between final, finally and finalize?
4.Where and how can you use a private constructor.
5.In System.out.println(),what is System,out and println,pls explain?
6.What is meant by “Abstract Interface”?
7.Can you make an instance of an abstract class? For example – java.util.Calender is an abstract class with a method getInstance() which returns an instance of the Calender class.
8.What is the output of x<y? a:b = p*q when x=1,y=2,p=3,q=4?
9.Why Java does not support pointers?
10.Parsers? DOM vs SAX parser
11.What is the main difference between Java platform and other platforms?
12.What is the Java Virtual Machine?
13.What is the Java API?
14.What is the package?
15.What is native code?
16.Is Java code slower than native code?
17.What is the serialization?
18.How to make a class or a bean serializable?
19.How many methods in the Serializable interface?
20.How many methods in the Externalizable interface?
21.What is the difference between Serializalble and Externalizable interface?
22.What is a transient variable?
23.What is synchronization and why is it important?
24.What are synchronized methods and synchronized statements?
25.What are three ways in which a thread can enter the waiting state?
26.Can a lock be acquired on a class?
27.What is thread?
28.What is multithreading?
29.How does multithreading take place on a computer with a single CPU?
30.What is the purpose of the wait(), notify(), and notifyAll() methods?
31.What are the high-level thread states?
32.What is the Collections API?
33.How does Java handle integer overflows and underflows?
34.What is the Vector class?
35.If a method is declared as protected, where may the method be accessed?
36.What is an Iterator interface?
37.What is the difference between yielding and sleeping?
38. Is sizeof a keyword?
39.What are wrapped classes?
40.What is the difference between preemptive scheduling and time slicing?
41.How can you write a loop indefinitely?
42.Can an anonymous class be declared as implementing an interface and extending a class?
43.Which class is the superclass for every class.
44. What is the difference between the Boolean & operator and the && operator?
45.What is the GregorianCalendar class?
46.What is the SimpleTimeZone class?
47.What is the Properties class?
48.What is the purpose of the Runtime class?
49.What is the purpose of the System class?
50.What is the purpose of the finally clause of a try-catch-finally statement?
51.What must a class do to implement an interface?
52.What is a static method?
53.What is the difference between a static and a non-static inner class?
54.What is an object’s lock and which object’s have locks?
55.When can an object reference be cast to an interface reference?
56.What’s the difference between J2SDK 1.5 and J2SDK 5.0?
57.Does it matter in what order catch statements for FileNotFoundException and IOExceptipon are written?
58.Can an inner class declared inside of a method access local variables of this method?
59.What can go wrong if you replace && with & in the following code:
String a=null; if (a!=null && a.length()>10) {…}
60.What’s the main difference between a Vector and an ArrayList
61.When should the method invokeLater()be used?
62.How can a subclass call a method or a constructor defined in a superclass?
63.What’s the difference between a queue and a stack?
64.You can create an abstract class that contains only abstract methods. On the other hand, you can create an interface that declares the same methods. So can you use abstract classes instead of interfaces?
65.What comes to mind when someone mentions a shallow copy in Java?
66.What comes to mind when you hear about a young generation in Java?
67.You are planning to do an indexed search in a list of objects. Which of the two Java collections should you use:
ArrayList or LinkedList?
68.How would you make a copy of an entire Java object with its state?
69.There are two classes: A and B. The class B need to inform a class A when some important event has happened. What Java technique would you use to implement it?
70.How can you minimize the need of garbage collection and make the memory use more effective?
71.What access level do you need to specify in the class declaration to ensure that only classes from the same directory can access it?
72.How do I deserilaize an Object?
73.What are different types of inner classes ?
74.Difference Between String and String Buffer?
75.difference between verses (==) and .equals().

Java Drill - 1

1.What is the difference between an Interface and an Abstract class?
2.What is the purpose of garbage collection in Java, and when is it used?
3.Describe synchronization in respect to multithreading.
4.Explain different way of using thread?
5.What are pass by reference and passby value?
6.What is HashMap and Map?
7.Difference between HashMap and HashTable?
8.Difference between Vector and ArrayList?
9.Difference between Swing and Awt?
10.What is the difference between a constructor and a method?
11.What is an Iterator?
12.State the significance of public, private, protected, default modifiers both singly and in combination and state the effect of package relationships on declared items qualified by these modifiers.
13.What is an abstract class?
14.What is static in java?
15.What is final?
16.What if the main method is declared as private?
17.What if the static modifier is removed from the signature of the main method?
18.What if I write static public void instead of public static void?
19.What if I do not provide the String array as the argument to the method?
20.What is the first argument of the String array in main method?
21.If I do not provide any arguments on the command line, then the String array of Main method will be empty or null?
22.How can one prove that the array is not null but empty using one line of code?
23.What environment variables do I need to set on my machine in order to be able to run Java programs?
24.Can an application have multiple classes having main method?
25.Can I have multiple main methods in the same class?
26.Do I need to import java.lang package any time? Why ?
27.Can I import same package/class twice? Will the JVM load the package twice at runtime?
29.What are Checked and UnChecked Exception?
30.What is Overriding?
31.What are different types of inner classes?
32.Are the imports checked for validity at compile time? e.g. will the code containing an import such as java.lang.ABCD compile?
33.Does importing a package imports the subpackages as well? e.g. Does importing com.MyTest.* also import com.MyTest.UnitTests.*?
34.What is the difference between declaring a variable and defining a variable?
35.What is the default value of an object reference declared as an instance variable?
36.Can a top level class be private or protected?
37.What type of parameter passing does Java support?
38.Primitive data types are passed by reference or pass by value?
39.Objects are passed by value or by reference?
40.What is serialization?
41.How do I serialize an object to a file?
42.Which methods of Serializable interface should I implement?
43.How can I customize the seralization process? i.e. how can one have a control over the serialization process?
44.What is the common usage of serialization?
45.What is Externalizable interface?
46.When you serialize an object, what happens to the object references included in the object?
47.What one should take care of while serializing the object?
48.What happens to the static fields of a class during serialization?
49.Does Java provide any construct to find out the size of an object?
50.Give a simplest way to find out the time a method takes for execution without using any profiling tool?
51.What are wrapper classes?
52.Why do we need wrapper classes?
53.What are checked exceptions?
54.What are runtime exceptions?
55.What is the difference between error and an exception??
56.How to create custom exceptions?
57.If I want an object of my class to be thrown as an exception object, what should I do?
58.If my class already extends from some other class what should I do if I want an instance of my class to be thrown as an exception object?
59.How does an exception permeate through the code?
60.What are the different ways to handle exceptions?
61.What is the basic difference between the 2 approaches to exception handling…1> try catch block and 2> specifying the candidate exceptions in the throws clause?
62.When should you use which approach?
63.Is it necessary that each try block must be followed by a catch block?
64.If I write return at the end of the try block, will the finally block still execute?
65.If I write System.exit (0); at the end of the try block, will the finally block still execute?
66.How are Observer and Observable used?
67.What is synchronization and why is it important?
68.How does Java handle integer overflows and underflows?
69.Does garbage collection guarantee that a program will not run out of memory?
70.What is the difference between preemptive scheduling and time slicing?
71.When a thread is created and started, what is its initial state?
72.What is the purpose of finalization?
73.What is the Locale class?
74.What is the difference between a while statement and a do statement?
75.What is the difference between static and non-static variables?
76.How are this() and super() used with constructors?
77.What are synchronized methods and synchronized statements?
78.What is daemon thread and which method is used to create the daemon thread?
79.Can applets communicate with each other?
80.What are the steps in the JDBC connection?
81.How does a try statement determine which catch clause should be used to handle an exception?
82.Can an unreachable object become reachable again?
83.What method must be implemented by all threads?
84.What are synchronized methods and synchronized statements?
85.What is Externalizable?
86.What modifiers are allowed for methods in an Interface?
87.What are some alternatives to inheritance?
88.What does it mean that a method or field is “static”? ?
89.What is the difference between preemptive scheduling and time slicing?
90.What is the catch or declare rule for method declarations? 91.Is Empty .java file a valid source file?
92.Can a .java file contain more than one java classes?
93.Is String a primitive data type in Java?
94.Is main a keyword in Java?
95.Is next a keyword in Java?
96.Is delete a keyword in Java?
97.Is exit a keyword in Java?
98.What happens if you dont initialize an instance variable of any of the primitive types in Java?
99.What will be the initial value of an object reference which is defined as an instance variable?
100.What are the different scopes for Java variables?
101.What is the default value of the local variables? 102.How many objects are created in the following piece of code?
MyClass c1, c2, c3;
c1 = new MyClass ();
c3 = new MyClass (); 104.Can a public class MyClass be defined in a source file named YourClass.java?
105.Can main method be declared final? 106.What will be the output of the following statement?
System.out.println (”1″ + 3); 107.What will be the default values of all the elements of an array defined as an instance variable?               

Database Drill

1.What is DDL and DML ? DDL :-  Data defination Language its having four commands  Create , Alter , Drop , Truncate DML :- Data manuplation language  Insert , Update , Delete , select 2.How can you compare a part of the name rather than the entire name ? SELECT * FROM people WHERE empname LIKE ‘%ab%’
Would return a recordset with records consisting empname the sequence ‘ab‘ in empname . 3.How could I get distinct entries from a table ? The SELECT statement in conjunction with DISTINCT lets you select a set of distinct values from a table in a database. The values selected from the database table would of course depend on the various conditions that are specified in the SQL query.    SELECT DISTINCT empname FROM emptable 4.How to get the results of a Query sorted in any order ?You can sort the results and return the sorted results to your program by using ORDER BY keyword thus saving you the pain of carrying out the sorting yourself. The ORDER BY keyword is used for sorting.

   SELECT empname, age, city FROM emptable ORDER BY empname5.How can I find the total number of records in a table ?   You could use the COUNT keyword , example
       SELECT COUNT(*) FROM emp WHERE age>40 6.What is GROUP BY ?The GROUP BY keywords have been added to SQL because aggregate functions (like SUM) return the aggregate of all column values every time they are called. Without the GROUP BY functionality, finding the sum for each individual group of column values was not possible 7.What is the difference among “dropping a table”, “truncating a table” and “deleting all records” from a table ? Dropping :  (Table structure  + Data are deleted), Invalidates the dependent objects ,Drops the indexes Truncating:  (Data alone deleted), Performs an automatic commit, Faster than delete Delete : (Data alone deleted), Doesn’t perform automatic commit 8.What are the Large object types suported by Oracle ? Blob and Clob 9.Difference between a “where” clause and a “having” clause ? Having clause is used only with group functions whereas Where is not used with. 10.What’s the difference between a primary key and a unique key ? Both primary key and unique enforce uniqueness of the column on which they are defined. But by default primary key creates a clustered index on the column, where are unique creates a nonclustered index by default. Another major difference is that, primary key doesn’t allow NULLs, but unique key allows one NULL only. 11.What are triggers? How to invoke a trigger on demand ? Triggers are special kind of stored procedures that get executed automatically when an INSERT, UPDATE or DELETE operation takes place on a table. Triggers can’t be invoked on demand. They get triggered only when an associated action (INSERT, UPDATE, DELETE) happens on the table on which they are defined. Triggers are generally used to implement business rules, auditing. Triggers can also be used to extend the referential integrity checks, but wherever possible, use constraints for this purpose, instead of triggers, as constraints are much faster. 12. What is a join and explain different types of joins ? Joins are used in queries to explain how different tables are related. Joins also let you select data from a table depending upon data from another table. Types of  Joins INNER JOINS: It will pull all the rows from both tables where there is a match. SELECT postid, posts.title, commentid, comments.title FROM posts INNER JOIN comments ON posts.postid = comments.postid LEFT OUTER JOIN: It will pull all the rows from left side of a join regardless of whether there is a match on the right side of join. Anything missing on the right side will be replaced by NULL. SELECT postid, posts.title, commentid, comments.title FROM posts LEFT OUTER JOIN comments ON posts.postid = comments.postid RIGHT OUTER JOIN: It will pull all the rows from the right side of a join regardless of whether there is a match on the left side of join. Anything missing on the left side will be replaced by NULL. SELECT postid, posts.title, commentid, comments.title FROM posts
RIGHT OUTER JOIN comments ON posts.postid = comments.postid CROSS JOIN: It returns a row of each combination of rows between the two tables. If you had 5 rows in each table, you’ed end up with 25 rows in the result set. SELECT Products.ProductName, Products.UnitPrice, Temporary.Amount FROM Products CROSS JOIN Temporary ORDER BY Products.ProductName, Temporary.Amount 13.What is a Self Join ? Self join is just like any other join, except that two instances of the same table will be joined in the query. SELECT DISTINCT c1.ContactName, c1.Address, c1.City, c1.Region
FROM Customers AS c1, Customers AS c2
WHERE c1.Region = c2.Region
AND c1.ContactName <> c2.ContactName
ORDER BY c1.Region, c1.ContactName; 14.What is Cursor  ? It is private SQL area to execute the sql quries and store the information. There are two types of cursors implicit cursors and explicit cursors. Implicit cursors are system defined and returns one row. Explicit cursors are user defined and returns multiple rows 15.How do you get Column names only for a table (SQL Server)  ? select name from syscolumns
where id=(select id from sysobjects where name=’user_hdr’)
order by colid –user_hdr is the table name16.How to find stored procedures  ?select procedure_name from all_procedures 17.What are Extended stored procedures  ?Extended stored procedures let you create your own external routines in a programming language such as C. Extended stored procedures are DLLs that an instance of Microsoft SQL Server can dynamically load and run. Extended stored procedures run directly in the address space of an instance of SQL Server and are programmed by using the SQL Server Extended Stored Procedure API.18. Explain about Cursors ?Cursors are database objects used to traverse the results of an SQL query. They point to a certain location within a recordset and allow the operator to move forward (and sometimes backward, depending upon the cursor type) through the results one record at a time. There are different types of  cursors: Static, Dynamic, Forward-only, Keyset-driven. Cursors extend result processing by:

• Allowing positioning at specific rows of the result set.
• Retrieving one row or block of rows from the current position in the result set.
• Supporting data modifications to the rows at the current position in the result set.
• Supporting different levels of visibility to changes made by other users to the database data that is presented in the result set.
• Providing Transact-SQL statements in scripts, stored procedures, and triggers access to the data in a result set.

Disadvantages of cursors: Each time you fetch a row from the cursor, it results in a network roundtrip, where as a normal SELECT query makes only one rowundtrip, however large the resultset is. Cursors are also costly because they require more resources and temporary storage (results in more IO operations). Furthere, there are restrictions on the SELECT statements that can be used with some types of cursors.Example:CREATE OR REPLACE Function FindCourse
( name_in IN varchar2 )
RETURN number
IS
cnumber number; CURSOR c1
IS
SELECT course_number
from courses_tbl
where course_name = name_in; BEGIN open c1;
fetch c1 into cnumber; if c1%notfound then
cnumber := 9999;
end if; close c1; RETURN cnumber; END;19.Explain about Stored Procedures ?A stored procedure is a group of SQL statements that form a logical unit and perform a particular task. Stored procedures are used to encapsulate a set of operations or queries to execute on a database server.For example, operations on an employee database (hire, fire, promote, lookup) could be coded as stored procedures executed by application code. Stored procedures can be compiled and executed with different parameters and results, and they may have any combination of input, output, and input/output parameters.No Param
CREATE OR REPLACE PROCEDURE myproc IS
BEGIN
INSERT INTO oracle_table VALUES(’string 1′);
END;
IN Param
CREATE OR REPLACE PROCEDURE myprocin(x VARCHAR) IS
BEGIN
INSERT INTO oracle_table VALUES(x);
END;
OUT Param
CREATE OR REPLACE PROCEDURE myprocout(x OUT VARCHAR) IS
BEGIN
INSERT INTO oracle_table VALUES(’string 2′);
x := ‘outvalue’; // Assign a value to x
END;
IN/OUT Param
CREATE OR REPLACE PROCEDURE myprocinout(x IN OUT VARCHAR) IS
BEGIN
INSERT INTO oracle_table VALUES(x); // Use x as IN parameter
x := ‘outvalue’; // Use x as OUT parameter
END;20.Explain about Views ? View is a virtual or logical table composed of the result set of a query. Unlike orginary tables in a relational database, a view is not part of the physical schema. It is a dynamic virtual table computed or collated from data in the database. Chainging the data in a table alters the data shown in the view.Views can provide advantages over tables

• They can subset the data contained in a table
• They can join and simplify multiple tables into a single virtual table
• Views can act as aggregated tables, where aggregated data (sum,average etc.) are calculated and presented as part of the data
• Views can hide the complexity of data,
• Views do not incur any extra storage overhead
• Depending on the SQL engine used, views can provide extra security.
• Limit the exposure to which a table or tables are exposed to outer world
• Rows in a view are not sorted. So we cannot use ORDER BY clause in the view definition.

          CREATE VIEW V_Customer
          AS SELECT First_Name, Last_Name, Country
         FROM Customer 21.Stored Function Vs Stored Procedure Function : 1. Should return atleast one output parameter.Can return more than one parameter using OUT argument. 2. Parsed and compiled at runtime. 3.Cannot affect the state of database. 4.Can be invoked from SQL statement e.g. SELECT. 5. Functions are mainly used to compute values. Procedure: 1. Doesn’t need to return values, but can return value. 2.Stored as a pseudo-code in database i.e. compiled form. 3.Can affect the state of database using commit etc. 4.Cannnot be invoked from SQL statements e.g. SELECT. 5.Procedures are mainly used to process the tasks.Java based DB Questions 1.How do you call a Stored Procedure from JDBC ?  The first step is to create a CallableStatement object. As with Statement and PreparedStatement objects, this is done with an open Connection object. A CallableStatement object contains a call to a stored procedure.

        CallableStatement cs =

               con.prepareCall("{call SHOW_SUPPLIERS}");

        ResultSet rs = cs.executeQuery();

2.What is cold backup, hot backup ?  Cold backup means all these files must be backed up at the same time, before the databaseis restarted. Hot backup or online backup is a backup taken of each tablespace while the database is running and is being accessed by the users. 3.What is a “dirty read” ?  Quite often in database processing, we come across the situation wherein one transaction can change a value, and a second transaction can read this value before the original change has been committed or rolled back. This is known as a dirty read scenario because there is always the possibility that the first transaction may rollback the change, resulting in the second transaction having read an invalid value. While you can easily command a database to disallow dirty reads, this usually degrades the performance of your application due to the increased locking overhead. Disallowing dirty reads also leads to decreased system concurrency. 4.What is Metadata and why should I use it   Metadata (’data about data’) is information about one of two things: Database information (java.sql.DatabaseMetaData), or Information about a specific ResultSet (java.sql.ResultSetMetaData). Use DatabaseMetaData to find information about your database, such as its capabilities and structure. Use ResultSetMetaData to find information about the results of an SQL query, such as size and types of columns 5.Different types of Transaction Isolation Levels The isolation level describes the degree to which the data being updated is visible to other transactions. This is important when two transactions are trying to read the same row of a table. Imagine two transactions: A and B. Here three types of inconsistencies can occur:

• Dirty-read: A has changed a row, but has not committed the changes. B reads the uncommitted data but his view of the data may be wrong if A rolls back his changes and updates his own changes to the database.
• Non-repeatable read: B performs a read, but A modifies or deletes that data later. If B reads the same row again, he will get different data.
• Phantoms: A does a query on a set of rows to perform an operation. B modifies the table such that a query of A would have given a different result. The table may be inconsistent.

1.TRANSACTION_READ_UNCOMMITTED : Dirty-read, Non-repeatable read and Phantoms can occur2.TRANSACTION_READ_COMMITTED : Dirty-reads are prevented. Non-repeatable read and Phantoms can occur.3.TRANSACTION_REPEATABLE_READ : Dirty-reads and Non-repeatable read are prevented and Phantoms can occur.4.TRANSACTION_SERIALIZABLE : Dirty-reads,Non-repeatable read and Phantoms are prevented.6.How do you handle your own transaction ?Connection Object has a method called setAutocommit(Boolean istrue)
Default is true. Set the Parameter to false , and begin your transaction     

Explain about validator-rules.xml and validation.xml files ?

Validator framework is used to validate the form data and you no need to write any code in your form bean for validations and storing the error messages.Your Form Bean, extending one of the Validator’s Action Form subclasses, does the required validations.If you do not use Validator, you need to handle the data validations in the validate() method of Form Bean objects, and also handle storing of error messages if validationis fails.Two configuration files used by Validator are validation.xml and validator-rules.xml. In order to enable and use the Validator, plug-in should be added in sturts-config.xml <plug-in className=”org.apache.struts.validator.ValidatorPlugin”>
      <set-property property=”pathnames”
                            value=”/WEB-INF/validator-rules.xml,
                                       /WEB-INF/validation.xml”/>
</plug-in> validator-rules.xml: This declares the validation routines and logical names are provided for the validations.It is also contains the client side javascript code for each validation routine. This validation routines are java methods plugged into the system to perform the specific validations. <validator name=”required”
                  classname=”org.apache.struts.validator.FieldChecks”
                  method=”validateRequired”
                  methodParams=”java.lang.Object,
                                            org.apache.commons.validator.ValidatorAction,
                                            org.apache.commons.validator.Field,
                                            org.apache.struts.action.ActionErrors,
                                            javax.servlet.http.HttpServletRequest”
                  msg=”errors.required”>            <javascript>
                    <![CDATA[// place the scripts here]]>
         </javascript>
</validator>If the validation fails when it run, the message(i.e..in ApplicationResources.properties) corresponding to the key specified by the msg attribute will be returned.validation.xml: This configuration files defines which validation routines must be applied for which form beans. Each form bean you want to validate has its own defination in this file. Inside that definations, you want to apply to the Form Beans’s fields. The definition in the file use the logical names of Form Beans from struts-config.xml file along with logical names of the validation routines from validation-rules.xml to tie together <form-validation>
     <formset>
             <form name=”logonForm”>
                    <field property=”username” depends=”required”>
                                <arg0 key=”prompt.username”/>
                   </field>
                   <field property=”username” depends=”required”>
                                <arg0 key=”prompt.password”/>
                   </field>
            </form>
    </formset>
</form-validation> The depends attribute specifies the logical names of validation routines from the validator-rules.xml that should be applied to the field. Add comment March 29th, 2007

What is difference between ActionForm and DynaActionForm

If the ActionForm is used, then user himself has to write the setters and getters when ever he adds a control. The same process is repeated again and again when user creates a view. DynaActionForm eliminates this burden and creates the form bean itself. This way user dont have to write setters and getters. No bean class is required for the DynaActionForm and we will declare the form beans as DynaActionForm type in struts-confing.xml. We will declare the properties and their type in the struts-config.xml<form-beans>
<form-bean name=”employeeForm”   type=”org.apache.struts.action.DynaActionForm”>
<form-property name=”name” type=”java.lang.String”/>
<form-property name=”age” type=”java.lang.String”/>
</form-bean>
</form-beans> 1 comment March 29th, 2007

Describe validate() and reset() methods ?

validate() : ActionForm class provides a validate() method hook that can be overridden by subclasses to perform validations on incoming form data.The validate() method hook gets called after a Form Bean has been populated with incoming form data. Following is the method signature for the validate() methodpublic ActionErrors validate(ActionMapping mapping,HttpServletRequest request)validate() method has return type ActionErrorsreset(): ActionForm class has a reset() method that subclasses can override. The method is a hook that gets called before FormBean is populated with request data from an HTML form. Using this reset() method, all the form fields will be reset.i.e..Unchecking the check boxes, making the text fileds empty..etc public void reset() {} Add comment March 29th, 2007

Explain deployment descriptor(web.xml) configuration for struts application ?

Action Servlet and strtus-config.xml files and configured as below<servlet>
      <servlet-name>action</servlet-name>
      <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
      <init-param>
         <param-name>config</param-name>
         <param-value>/WEB-INF/struts-config.xml</param-value>
       </init-param>
</servlet>This config parameter tells the Strut’s Action Servlet where to find its central configuration file struts-config.xml<servlet-mapping>
             <servlet-name>action</servlet-name>
             <url-pattern>*.do</url-pattern>
<servlet-mapping>In servlet mapping <url-pattern> tag is sayinng that ActionServlet should process any requests for pages thats end in .doTag Library descriptors will be configured as below<taglib>
<taglib-uri> /WEB-INF/tlds/struts-bean.tld</taglib-uri>
<taglib-location> /WEB-INF/tlds/struts-bean.tld</taglib-location>
</taglib> Simillarly struts-html.tld,struts-logic.tld will be configured Add comment March 29th, 2007

Is Struts Thread Safe ?

Struts is not only thread-safe but thread-depenedent. The response to a requeast is handled by light weight Action object, rather than an individual servlet.Struts instanciate each Action class once and allows other request to threaded through the orginal object. This core strategy conserves resources and provides the best posible throughput. A properyly-designed application will exploit this further by routing realated operations through a single action. Add comment March 29th, 2007

95. Hibernate Drill One

1. What is Hibernate
2. What are ORM tools
3. What is Object/relation paradigm mismatch
4. What role does the session interface play in Hibernate
5. What is sessionFactory interface
6. What is Configuration interface
7. What is the naming convention of Hibernate XML mapping file extensions
8. What are the most common methods of configurating hibernate
9. How can the mapping files be configured in Hibernate
10. What happens when both hibernate.properties and hibernate.cfg.xml are in the classpath
11. Sinsce sessionFactory instances arenot lightweight, where is the single created instance planced in j2ee environment.
12. How to set Hibernate to log all generated SQL to the console.
13. In hibernate, what inerfaces/classes must the persistent classes
14. Does hibernate require persistent classes to implementn Serializable.
15. What methods must be the persistent classes implement in Hibernate
16. How can Hibernate be configured to access a instance variable directly and not through a setter method.
17. What is dirty checking in Hibernate.
18. What is the root level element in a hibernate mapping file?
19. Is it possible to declare mappings for multiple classes in one mapping file?
20. How are the individual properties mapped to different table columns?
21. What are derived properties?
22. How can you make a property be read from the database but not modified in anyway (make it immutable)?
23. How can a whole class be mapped as immutable?
24. What is the use of dynamic-insert and dynamic-update attributes in a class mapping?
25. Name types of inheritence models and describe how they work? (such as vertical inheritence, horizontal, etc)
26. Study some hibernate files and write a query based on some set of information.
27. How would you go about creating hibernate classes and XML on a new set of tables? (hint: think code generation).
28. How hibernate is related to J2EE
29. What is component mapping in hibernate?
30. what is lazy fetching in hibernate
31. What are the types of inheritence models and describe how they work like vertical inheritence and horizontal
32. what is the difference between beans and hibernate(which one is good)?
33. what is the advantage of Hibernate over jdbc?
34. how to create primary key using hibernate?
35. What is the difference between sorted and orderd collection in hibernate?
36. Why do you need ORM tools like hibernate? (Aboved questions are not yet edited for format. Answers are on its way.. till then test your self with the above questions.)   

93. EJB Drill 3

Can you control when passivation occurs? The developer, according to the specification, cannot directly control when passivation occurs. Although for Stateful Session Beans, the container cannot passivate an instance that is inside a transaction. So using transactions can be a a strategy to control passivation. The ejbPassivate() method is called during passivation, so the developer has control over what to do during this exercise and can implement the require optimized logic. Some EJB containers, such as BEA WebLogic, provide the ability to tune the container to minimize passivation calls. Taken from the WebLogic 6.0 DTD -The passivation-strategy can be either default or transaction. With the default setting the container will attempt to keep a working set of beans in the cache. With the transaction setting, the container will passivate the bean after every transaction (or method call for a non-transactional invocation). What is the advantage of using Entity bean for database operations, over directly using JDBC API to do database operations? When would I use one over the other? Entity Beans actually represents the data in a database. It is not that Entity Beans replaces JDBC API. There are two types of Entity Beans Container Managed and Bean Mananged. In Container Managed Entity Bean – Whenever the instance of the bean is created the container automatically retrieves the data from the DB/Persistance storage and assigns to the object variables in bean for user to manipulate or use them. For this the developer needs to map the fields in the database to the variables in deployment descriptor files (which varies for each vendor). In the Bean Managed Entity Bean – The developer has to specifically make connection, retrive values, assign them to the objects in the ejbLoad() which will be called by the container when it instatiates a bean object. Similarly in the ejbStore() the container saves the object values back the the persistance storage. ejbLoad and ejbStore are callback methods and can be only invoked by the container. Apart from this, when you use Entity beans you dont need to worry about database transaction handling, database connection pooling etc. which are taken care by the ejb container. The EJB container implements the EJBHome and EJBObject classes. For every request from a unique client, does the container create a separate instance of the generated EJBHome and EJBObject classes? The EJB container maintains an instance pool. The container uses these instances for the EJB Home reference irrespective of the client request. while refering the EJB Object classes the container creates a separate instance for each client request. The instance pool maintenance is up to the implementation of the container. If the container provides one, it is available otherwise it is not mandatory for the provider to implement it. Having said that, yes most of the container providers implement the pooling functionality to increase the performance of the application server. The way it is implemented is, again, up to the implementer. What are the special design care that must be taken when you work with local interfaces? It is important to understand that the calling semantics of local interfaces are different from those of remote interfaces. For example, remote interfaces pass parameters using call-by-value semantics, while local interfaces use call-by-reference. This means that in order to use local interfaces safely, application developers need to carefully consider potential deployment scenarios up front, then decide which interfaces can be local and which remote, and finally, develop the application code with these choices in mind. While EJB 2.0 local interfaces are extremely useful in some situations, the long-term costs of these choices, especially when changing requirements and component reuse are taken into account, need to be factored into the design decision. What is session Facade? Session Facade is a design pattern to access the Entity bean through local interface than accessing directly. It increases the performance over the network. In this case we call session bean which on turn call entity bean. Is is possible for an EJB client to marshal an object of class java.lang.Class to an EJB? Technically yes, spec. compliant NO! – The enterprise bean must not attempt to query a class to obtain information about the declared members that are not otherwise accessible to the enterprise bean because of the security rules of the Java language. Is there any default cache management system with Entity beans ? In other words whether a cache of the data in database will be maintained in EJB ? – Caching data from a database inside the AAApplication Server are what Entity EJB’s are used for.The ejbLoad() and ejbStore() methods are used to synchronize the Entity Bean state with the persistent storage(database). Transactions also play an important role in this scenario. If data is removed from the database, via an external application – your Entity Bean can still be alive the EJB container. When the transaction commits, ejbStore() is called and the row will not be found, and the transaction rolled back. Why is ejbFindByPrimaryKey mandatory? An Entity Bean represents persistent data that is stored outside of the EJB Container/Server. The ejbFindByPrimaryKey is a method used to locate and load an Entity Bean into the container, similar to a SELECT statement in SQL. By making this method mandatory, the client programmer can be assured that if they have the primary key of the Entity Bean, then they can retrieve the bean without having to create a new bean each time – which would mean creating duplications of persistent data and break the integrity of EJB. Is method overloading allowed in EJB? Yes you can overload methods Should synchronization primitives be used on bean methods? – No. The EJB specification specifically states that the enterprise bean is not allowed to use thread primitives. The container is responsible for managing concurrent access to beans at runtime. What is the difference between a Server, a Container, and a Connector? An EJB server is an application, usually a product such as BEA WebLogic, that provides (or should provide) for concurrent client connections and manages system resources such as threads, processes, memory, database connections, network connections, etc. An EJB container runs inside (or within) an EJB server, and provides deployed EJB beans with transaction and security management, etc. The EJB container insulates an EJB bean from the specifics of an underlying EJB server by providing a simple, standard API between the EJB bean and its container. A Connector provides the ability for any Enterprise Information System (EIS) to plug into any EJB server which supports the Connector architecture. See Sun’s J2EE Connectors for more in-depth information on Connectors. For Entity Beans, What happens to an instance field not mapped to any persistent storage, when the bean is passivated? The specification infers that the container never serializes an instance of an Entity bean (unlike stateful session beans). Thus passivation simply involves moving the bean from the ready to the pooled bin. So what happens to the contents of an instance variable is controlled by the programmer. Remember that when an entity bean is passivated the instance gets logically disassociated from it’s remote object. Be careful here, as the functionality of passivation/activation for Stateless Session, Stateful Session and Entity beans is completely different. For entity beans the ejbPassivate method notifies the entity bean that it is being disassociated with a particular entity prior to reuse or for dereference. Does the container create a separate instance of the generated EJBHome and EJBObject classes? The EJB container maintains an instance pool. The container uses these instances for the EJB Home reference irrespective of the client request. while refering the EJB Object classes the container creates a separate instance for each client request. The instance pool maintainence is up to the implementation of the container. If the container provides one, it is available otherwise it is not mandatory for the provider to implement it. Having said that, yes most of the container providers implement the pooling functionality to increase the performance of the application server. The way it is implemented is again up to the implementer. What is the advantage of putting an Entity Bean instance from the Ready State to Pooled state The idea of the Pooled State is to allow a container to maintain a pool of entity beans that has been created, but has not been yet synchronized or assigned to an EJBObject. This mean that the instances do represent entity beans, but they can be used only for serving Home methods (create or findBy), since those methods do not relay on the specific values of the bean. All these instances are, in fact, exactly the same, so, they do not have meaningful state. Jon Thorarinsson has also added: It can be looked at it this way: If no client is using an entity bean of a particular type there is no need for cachig it (the data is persisted in the database). Therefore, in such cases, the container will, after some time, move the entity bean from the Ready State to the Pooled state to save memory. Then, to save additional memory, the container may begin moving entity beans from the Pooled State to the Does Not Exist State, because even though the bean’s cache has been cleared, the bean still takes up some memory just being in the Pooled State.  1 comment March 22nd, 2007

92. EJB Drill Two

What is the differnece between EJB and Java Beans
Explain Local Interfaces
What is EJB Container
What is in-memory replication
What is ripple effect
What’s new in the EJB 2.0 Specification
What is the difference between a Coarse Grained Entiry bean and Fine Grained Entity Bean.
What are transaction isolation levels in EJB
What is the software architectury of EJBs.
Waht is the need of Remote and Home interface. Why can’t it be in one.
What is an EJB Context
How can you call one EJB from inside of another EJB.
What happens if remove() is never inoved on a session bean.
What is EJB QL
Can the primary key in the entity bean be a Java Primitive Type such as int
How EJB Invocation Happens.
What are the transaction attributes.
What is the difference between find and select methods in EJB
What is abstract schema
What are the services provided by container
What is a deployment descriptor
How many EJB objects are created for a bean
What is re-entrant. Is session beans reentrant. Is entity beans reentrant.
What is the difference between EAT,JAT,WAR files
What is lazy loading
Can i amp more than one table in a CMP
Is decorator an EJB design pattern
What is the difference between session context and entity context
Does stateless session bean create() method contain any parameters.
What is the difference between ejbCreate and ejbPostCreate
What are the optional clauses in EJB QL
Can i invoke runtime.gc() in an EJB
What is a remote client view
What is local client view
What is EJB client JAR File.
What are the call back methods in Entity bean?
If session has thrown ApplicaitonException would you use
EJBContext.setRollBackOnly method?
How do you create a entity bean in sun one application server.
How do you map table in CMP.
How do you deploy a EJB
What EAR file. How it will be created.
What is clustering.Explain the packaging structure of an EJB application?more questions: http://groups.google.com/group/lookhere/browse_thread/thread/47716d3565424726/25123fc4710e1839?lnk=st&q=EJB+Interview+questions&rnum=23&hl=en#25123fc4710e1839 Add comment March 22nd, 2007

91. EJB Short Drill - One

What are the differnt kids of EJBsStateless session bean- An instance of these non-persistent EJBs provides a service without storing an interaction or conversation state between methods. Any instance can be used for any client.
Stateful session bean- An instance of these non-persistent EJBs maintains state across methods and transactions. Each instance is associated with a particular client.
Entity bean- An instance of these persistent EJBs represents an object view of the data, usually rows in a database. They have a primary key as a unique identifier. Entity bean persistence can be either container-managed or bean-managed.
Message-driven bean- An instance of these EJBs is integrated with the Java Message Service (JMS) to provide the ability for message-driven beans to act as a standard JMS message consumer and perform asynchronous processing between the server and the JMS message producer. Explain Session BeansA session bean is a non-persistent object that implements some business logic running on the server. One way to think of a session object is as a logical extension of the client program that runs on the server.
Session beans are used to manage the interactions of entity and other session beans,access resources, and generally perform tasks on behalf of the client.
There are two basic kinds of session bean: stateless and stateful.
Stateless session beans are made up of business methods that behave like procedures; they operate only on the arguments passed to them when they are invoked. Stateless beans are called stateless because they are transient; they do not maintain business state between method invocations.Each invocation of a stateless business method is independent from previous invocations. Because stateless session beans are stateless, they are easier for the EJB container to manage, so they tend to process requests faster and use less resources.
Stateful session beans encapsulate business logic and state specific to a client. Stateful beans are called “stateful” because they do maintain business state between method invocations, held in memory and not persistent. Unlike stateless session beans, clients do not share stateful beans. When a client creates a stateful bean, that bean instance is dedicated to service only that client. This makes it possible to maintain conversational state, which is business state that can be shared by methods in the same stateful bean.What is Entity BeanThe entity bean is used to represent data in the database. It provides an object-oriented interface to data that would normally be accessed by the JDBC or some other back-end API. More than that, entity beans provide a component model that allows bean developers to focus their attention on the business logic of the bean, while the container takes care of managing persistence,transactions, and access control. There are two basic kinds of entity beans: container-managed ersistence (CMP) andbean-managed persistence (BMP). Container-managed persistence beans are the simplest for the bean developer to create and the most difficult for the EJB server to support. This is because all the logic for synchronizing the bean’s state with the database is handled automatically by the container. This means that the bean developer doesn’t need to write any data access logic, while the EJB server is supposed to take care of all the persistence needs automatically. With CMP, the container manages the persistence of the entity bean. Vendor tools are used to map the entity fields to the database and absolutely no database access code is written in the bean class. The bean-managed persistence (BMP) enterprise bean manages synchronizing its state with the database as directed by the container. The bean uses a database API to read and write its fields to the database, but the container tells it when to do each synchronization operation and manages the transactions for the bean automatically. Bean-managed persistence gives the bean developer the flexibility to perform persistence operations that are too complicated for the container or to use a data source that is not supported by the container.What are the methods of Entity Bean?An entity bean consists of 4 groups of methods: 1. create methods: To create a new instance of a CMP entity bean, and therefore insert data into the database, the create() method on the bean’s home interface must be invoked. They look like this: EntityBeanClass ejbCreateXXX(parameters), where EntityBeanClass is an Entity Bean you are trying to instantiate, ejbCreateXXX(parameters) methods are used for creating Entity Bean instances according to the parameters specified and to some programmer-defined conditions. A bean’s home interface may declare zero or more create() methods, each of which must have corresponding ejbCreate() and ejbPostCreate() methods in the bean class. These creation methods are linked at run time, so that when a create() method is invoked on the home interface, the container delegates the invocation to the corresponding ejbCreate() and ejbPostCreate() methods on the bean class. 2. finder methods: The methods in the home interface that begin with “find” are called the find methods. These are used to query the EJB server for specific entity beans, based on the name of the method and arguments passed. Unfortunately, there is no standard query language defined for find methods, so each vendor will implement the find method differently. In CMP entity beans, the find methods are not implemented with matching methods in the bean class; containers implement them when the bean is deployed in a vendor specific manner. The deployer will use vendor specific tools to tell the container how a particular find method should behave. Some vendors will use object-relational mapping tools to define the behavior of a find method while others will simply require the deployer to enter the appropriate SQL command.There are two basic kinds of find methods: single-entity and multi-entity. Single-entity find methods return a remote reference to the one specific entity bean that matches the find request. If no entity beans are found, the method throws an ObjectNotFoundException . Every entity bean must define the single-entity find method with the method name findByPrimaryKey(), which takes the bean’s primary key type as an argument.The multi-entity find methods return a collection ( Enumeration or Collection type) of entities that match the find request. If no entities are found, the multi-entity find returns an empty collection. 3. remove methods: These methods (you may have up to 2 remove methods, or don’t have them at all) allow the client to physically remove Entity beans by specifying either Handle or a Primary Key for the Entity Bean. 4. home methods: These methods are designed and implemented by a developer, and EJB specification doesn’t have any requirements for them except the need to throw a RemoteException is each home method. 1 comment March 20th, 2007

90. What is JNDI

The Java Naming and Directory Interface (JNDI) is an application programming interface (API) for accessing different kinds of naming and directory services. JNDI is not specific to a particular naming or directory service, it can be used to access many different kinds of systems including file systems; distributed objects systems like CORBA, Java RMI, and EJB; and directory services like LDAP, Novell NetWare, and NIS+. JNDI is similar to JDBC in that they are both Object-Oriented Java APIs that provide a common abstraction for accessing services from different vendors. While JDBC can be used to access a variety of relational databases, JNDI can be used to access a variety of of naming and directory services. Using one API to access many different brands of a service is possible because both JDBC and JNDI subscribe to the same architectural tenet: Define a common abstraction that most vendors can implement. The common abstraction is the API. It provides an objectified view of a service while hiding the details specific to any brand of service. The implementation is provided by the vendor, it plugs into the API and implements code specific to accessing that vendor’s product. JNDI provides two APIs and one SPI. JNDI has a naming API that allows Java applications to access naming systems like CORBA’s Naming services and a directory API that extends the naming service to provide access to directory services like LDAP. JNDI also has a SPI (Service-Provider Interface) which is a programming model that vendors use to write JNDI plug-ins or implementations for their specific product. Each vendor’s plug-in is called a service-provider. A service-provider implements the JNDI APIs so that a Java application can access that vendor’s product. For the most part, JNDI hides the implementation details of the a service-provider so that Java developer that uses JNDI can use the same objects and method regardless of the brand of naming or directory service accessed. This is the real power behind APIs like JDBC and JNDI: They provide one programming model for accessing many different products; there is no need to learn a different programming model every time a different product is used. Add comment March 20th, 2007

89. What’s the difference between servlet/JSP session and EJB Session

A session in a Servlet, is maintained by the Servlet Container through the HttpSession object, that is acquired through the request object. You cannot really instantiate a new HttpSession object, and it doesn’t contains any business logic, but is more of a place where to store objects. A session in EJB is maintained using the SessionBeans. You design beans that can contain business logic, and that can be used by the clients. You have two different session beans: Stateful and Stateless. The first one is somehow connected with a single client. It maintains the state for that client, can be used only by that client and when the client “dies” then the session bean is “lost”. A Stateless Session Bean doesn’t maintain any state and there is no guarantee that the same client will use the same stateless bean, even for two calls one after the other. The lifecycle of a Stateless Session EJB is slightly different from the one of a Stateful Session EJB. Is EJB Container’s responsability to take care of knowing exactly how to track each session and redirect the request from a client to the correct instance of a Session Bean. The way this is done is vendor dependant, and is part of the contract.  2 comments March 20th, 2007

88. Compare stateless and statefull session bean

 1 comment March 20th, 2007

87. How to choose between stateless and statefull beans

Stateless session beans are a good choice if your application does not need to maintain state for a particular client between business method calls. WebLogic Server is multi-threaded, servicing multiple clients simultaneously. With stateless session beans, the EJB container is free to use any available, pooled bean instance to service a client request, rather than reserving an instance for each client for the duration of a session. This results in greater resource utilization, scalability and throughput. Stateless session beans are preferred for their light-weight implementation. They are a good choice if your application’s beans perform autonomous, distinct tasks without bean-to-bean interaction. Stateful session beans are a good choice if you need to preserve the bean’s state for the duration of the session.  Add comment March 20th, 2007

What is the difference between CMP and BMP

Short answer: with bean-managed persistence, you can optimize your queries and improve performance over the generalized container-managed heuristics. But container-managed persistence is very convenient, and vendors will be working to improve its performance as time goes on.] There is of course a difference as many CMPs use O-R mapping using metadata, which is slower than hardcoded queries (except vendors like GemStone that use a OODB which is slow anyway!) As always, a lot depends on the database schema. Given that CMP is still evolving, complex relationships (e.g.inheritance) and distributed transactions are not even supported by most EJB server vendors, leave alone performance. Having said that however, it does not seem right to compare BMP and CMP on performance because the motivation of CMP is precisely to relieve bean providers from thinking about this! In (J2EE) theory, a good CMP implementation should perform well in a production environment; in practice, except for a couple of vendors who have traditionally been strong in persistent storage space (e.g. Persistence Software, GemStone) you will not find great CMP support at this very moment. BMP offers a tactical approach while CMP is more strategic. Which implies that if you can work-around some (perhaps severe) limitations for near-term, there may be much to gain with CMP as the vendor offering matures. 1 comment March 20th, 2007

85. Explain about XML attributes

Attributes are simple name/value pairs associated with an element. They are attached to the start-tag, as shown below, but not to the end-tag: <name nickname=”sharat”>
<first>sharat</first>
<middle></middle>
<last>lastname</last>
</name> Attributes must have values–even if that value is just an empty string (like “”)–and those values must be in quotes. Attributes Can Provide Meta Data that May Not be Relevant to Most Applications Dealing with Our XML Attributes are Un-Ordered Elements Can Be More Complex Than Attributes. Add comment October 9th, 2006

84. What do you mean by well-formed XML

XML documents must adhere to following rules to be well-formed.

1. Every start-tag must have a matching end-tag, or be a self-closing tag
2. Tags can’t overlap
3. XML documents can have only one root element
4. Element names must obey XML naming conventions
5. XML is case-sensitive
6. XML will keep whitespace in your text

 Add comment October 9th, 2006

83. What are the differences between SAX and DOM parser.

 5 comments September 27th, 2006

82. Describe the differences between XML and HTML

 Add comment September 26th, 2006

81. How you will make available any message resources definations file to the struts famework environment.

Message Resources Definitions file are simple .properties files and these files contains the messages that can be used in the struts project. Message Resources Definitions files can be added to the struts-config.xml file through <message-resources /> tag.
Example:
<message-resources parameter=”MessageResources” /> 1 comment September 9th, 2006

80. What is Jakarta Struts FrameWork

Jakarta Struts is open source implementation of MVC (Model-View-Controller) pattern for the development of web based applications. Jakarta Struts is robust architecture and can be used for the development of application of any size. Struts framework makes it much easier to design scalable, reliable Web applications with Java. Add comment September 9th, 2006

79. What are the core classes of the Struts Frame Work

Core classes of Struts Framework are ActionForm, Action, ActionMapping, ActionForward, ActionServlet etc. Add comment September 9th, 2006

78. What are the components of Struts

Struts is based on the MVC design pattern. Struts components can be categories into Model, View and Controller.Model: Components like business logic / business processes and data are the part of Model.View: JSP, HTML etc. are part of ViewController: Action Servlet of Struts is part of Controller components which works as front controller to handle all the requests. Add comment September 9th, 2006

77. What are differences between <bean:message> and <bean:write>

<bean:message>: This tag is used to output locale-specific text (from the properties files) from a MessageResources bundle. <bean:message key=”label.search.name”/><bean:write>: This tag is used to output property values from a bean. <bean:write> is a commonly used tag which enables the programmers to easily present the data.<bean:write name=”student” property=”age”/> 3 comments September 9th, 2006

76. What is LookupDispatchAction

An abstract Action that dispatches to the subclass mapped execute method. This is useful in cases where an HTML form has multiple submit buttons with the same name. The button name is specified by the parameter property of the corresponding ActionMapping. (Ref. http://struts.apache.org/1.2.7/api/org/apache/struts/actions/LookupDispatchAction.html). Add comment September 9th, 2006

75. What is struts flow

Struts Flow is a port of Cocoon’s Control Flow to Struts to allow complex workflow, like multi-form wizards, to be easily implemented using continuations-capable JavaScript. It provides the ability to describe the order of Web pages that have to be sent to the client, at any given point in time in an application. The code is based on a proof-of-concept Dave Johnson put together to show how the Control Flow could be extracted from Cocoon. (Ref: http://struts.sourceforge.net/struts-flow/index.html ) Add comment September 9th, 2006

74. How to handle exceptions in struts

In Struts you can handle the exceptions in two ways:
a) Declarative Exception Handling: You can either define global exception handling tags in your struts-config.xml or define the exception handling tags within <action>..</action> tag.
Example:<exception   key=”database.error.duplicate”
                    path=”/UserExists.jsp”
                    type=”mybank.account.DuplicateUserException”/> b) Programmatic Exception Handling: Here you can use try{}catch{} block to handle the exception.  2 comments September 9th, 2006

73. What is the Action Errors and Action Message?

ActionMessage: A class that encapsulates messages. Messages can be either global or they are specific to a particular bean property.
Each individual message is described by an ActionMessage object, which contains a message key (to be looked up in an appropriate message resources database), and up to four placeholder arguments used for parametric substitution in the resulting message.data.ok=Data saved successfully ActionMessages messages = new ActionMessages();
ActionMessage msg = new ActionMessage(”data.ok”);
messages.add(”message1″, msg); <html:messages id=”msgId” message=”true” property=”message1″>
       <bean:write name=”msgId”/><br>
</html:messages> msg = new ActionMessage(”data.do”, “stop”);
messages.add(”message2″, msg); In property file data.do configured as below
data.do=Please {0} ActionErrors: A class that encapsulates the error messages being reported by the validate() method of an ActionForm. Validation errors are either global to the entire ActionForm bean they are associated with, or they are specific to a particular bean property (and, therefore, a particular input field on the corresponding form).error.name.required=Please enter the name
ActionErrors errors = new ActionErrors();
errors.add(”name”,new ActionMessage(”error.name.required”)); 2 comments September 9th, 2006

72. How to setup struts to use multiple configuration files.

Struts can use multiple configuration files. Here is the configuration example:
<servlet>
        <servlet-name>banking</servlet-name>
        <servlet-class>org.apache.struts.action.ActionServlet
        </servlet-class>
        <init-param>
        <param-name>config</param-name>
        <param-value>/WEB-INF/struts-config.xml,
                /WEB-INF/struts-authentication.xml,
                /WEB-INF/struts-help.xml
           </param-value>
    </init-param> 1 comment September 9th, 2006

71. What we will define in struts-config.xml file.

The main control file in the Struts framework is the struts-config.xml XML file, where action mappings are specified. This file’s structure is described by the struts-config DTD file, which is defined at http://jakarta.apache.org/struts/. A copy of the DTD can be found on the /docs/dtds subdirectory of the framework’s installation root directory. The top-level element is struts-config. Basically, it consists of the following elements:
data-sources—A set of data-source elements, describing parameters needed to instantiate JDBC 2.0 Standard Extension DataSource objects <data-sources>
      <data-source    autoCommit=”false”
                              description=”Second Database Config”
                              driverClass=”oracle.jdbc.driver.OracleDriver”
                               key=”REFDB”
                               maxCount=”4″ 
                               minCount=”2″
                               password=”admin”
                               url=”jdbc:oracle:thin:@localhost:1521/AUTHORDB”
                               user=”admin”
        />
</data-sources> form-beans—A set of form-bean elements that describe the form beans that this application uses <form-beans>
         <form-bean name=”searchForm”>
                            type=”com.abc.struts.SearchForm”
        </form-bean>
</form-beans> global-forwards—A set of forward elements describing general available forward URIs <global-forwards>
          <forward name=”search” path=”/search.jsp” />
</global-forwards>
action-mappings—A set of action elements describing a request-to-action mapping<action-mapping>
         <action path=”/search”
                     type=”com.abc.struts.SearchAction”
                     name=”searchForm”
                     scope=”request”
                     validate=”true”
                     input=”/search.jsp”>
          <forward name=”results” path=”/results.jsp” />
         </action>
</action-mapping> 1 comment September 9th, 2006

70. What is the request processor in struts and how it works

The RequestProcessor Class is the actual place where the request processing takes place in a Struts controller environment.When the request object first reaches the actionservlet class then it invokes the process method of the underlying RequestProcessor Class.This process method then looks into the struts-config.xml file and tries to locate the name of the action that has come with the request.Once it identifies the action in the xml file it continues the rest of the steps needed for request processing.processor has most of the following responsibilities:

1. Determine path,
2. Handle Locale,
3. Process content and encoding type,
4. Process cache headers
5. Pre Processing hook
6. Pre-processing hook,
7. Determine mapping,
8. Determine roles,
9. Process and validate actionForm,
10. Return a response

It is one instance per application module; it invokes proper Action instance Of course processes all requests for a module. 5 comments September 9th, 2006

69. What is struts actions and action mappings.

A Struts action is an instance of a subclass of an Action class, which implements a portion of a Web application and whose perform or execute method returns a forward.An action can perform tasks such as validating a user name and password.An action mapping is a configuration file entry that, in general, associates an action name with an action. An action mapping can contain a reference to a form bean that the action can use, and can additionally define a list of local forwards that is visible only to this action.An action servlet is a servlet that is started by the servlet container of a Web server to process a request that invokes an action. The servlet receives a forward from the action and asks the servlet container to pass the request to the forward’s URL. An action servlet must be an instance of an org.apache.struts.action.ActionServlet class or of a subclass of that class. An action servlet is the primary component of the controller. 2 comments September 9th, 2006

68. What are the various struts tag libraries.

Struts is very rich framework and it provides very good and user friendly way to develop web application forms. Struts provide many tag libraries to ease the development of web applications. These tag libraries are:

1. Bean tag library – Tags for accessing JavaBeans and their properties.
2. HTML tag library – Tags to output standard HTML, including forms, text boxes, checkboxes, radio buttons etc..
3. Logic tag library – Tags for generating conditional output, iteration capabilities and flow management
4. Tiles or Template tag library - For the application using tiles
5. Nested tag library – For using the nested beans in the application

 Add comment September 9th, 2006

67. What is the difference between perform() and execute()

• Perform method is the method which was deprecated in the Struts Version 1.1. 
• In Struts 1.x, Action.perform() is the method called by the ActionServlet. This is typically where your business logic resides, or at least the flow control to your JavaBeans and EJBs that handle your business logic.
• As we already mentioned, to support declarative exception handling, the method signature changed in perform.
• Now execute just throws Exception. Action.perform() is now deprecated;
• however, the Struts v1.1 ActionServlet is smart enough to know whether or not it should call perform or execute in the Action, depending on which one is available.

 6 comments September 9th, 2006

66.How to enable front-end validation based on the xml in validation.xml

The <html:javascript> tag to allow front-end validation based on the xml in validation.xml. For  example the code: <html:javascript  formName=”logonForm”
                         dynamicJavascript=”true”
                         staticJavascript=”true”  /> generates the client side java script for the form “logonForm” as defined in the  validation.xml file. The <html:javascript> when added in the jsp file generates the client site validation script.Following tag displays all the errors:
<html:errors/> Add comment September 9th, 2006

65. What is the Struts Validator Framework

Struts Framework provides the functionality to validate the form data. It can be use to validate the data on the users browser as well as on the server side. Struts Framework emits the java scripts and it can be used validate the form data on the client browser. Server side validation of form can be accomplished by sub classing your From Bean with DynaValidatorForm class. Following are the core components of this framework:

1. Validators
2. Configuration Files
3. Resource Files/Bundles
4. JSP Custom Tags
5. Validator Form Classes

The Validator Framework uses two XML configuration files validator-rules.xml and validation.xml. The validator-rules.xml defines the standard validation routines, these are reusable and used in validation.xml. to define the form specific validations. The validation.xml defines the validations applied to a form bean.The Validator framework was developed by David Winterfeldt as third-party add-on to Struts. Now the Validator framework is a part of Jakarta Commons project and it can be used with or without Struts. The Validator framework comes integrated with the Struts Framework and can be used without doing any extra settings. Add comment September 9th, 2006

64. What is Action Class

• The Action is part of the controller. The purpose of Action Class is to translate the HttpServletRequest to the business logic.
• To use the Action, we need to  Subclass and overwrite the execute()  method.
• The ActionServlet (commad) passes the parameterized class to Action Form using the execute() method.
• There should be no database interactions in the action.
• The action should receive the request, call business objects (which then handle database, or interface with J2EE, etc) and then determine where to go next.
• Even better, the business objects could be handed to the action at runtime (IoC style) thus removing any dependencies on the model.  
• The return type of the execute method is ActionForward which is used by the Struts
• Framework to forward the request to the file as per the value of the returned ActionForward object.

 Add comment September 9th, 2006

63. Explain ActionFrom Class and its life cycle.

An ActionForm is a java bean that extends org.apache.struts.action.ActionForm, ActionForm maintain the session state of web application.All data submitted by the user are sent corresponding ActionForm  ActionForm class is used to capture user-input data from an HTML form and transfer it to the Action Class. ActionForm plays the role of Transport Vehicle between the presentation Tire & Business Tier.
Life Cycle :
1. Request received by Controller
2. Create or recycle ActionForm
3. Call reset()
4. store ActionForm in proper scope
5. populate ActionForm from Request
6. Validate the ActionForm
7. If errors found then forward back to input attribute page(configured in Action mapping in struts-config.xml) with ActionForm in scope. If no errors found then call execute() with the ActionForm. Add comment September 9th, 2006

62. What are new features of Struts 1.1

The new features added to Struts 1.1 are1. RequestProcessor class
2. Method perform() replaced by execute() in Struts base Action Class
3. Changes to web.xml and struts-config.xml
4.Declarative exception handling
5.Dynamic ActionForms
6.Plug-ins
7.Multiple Application Modules
8.Nested Tags
9.The Struts Validator
10.Change to the ORO package
11.Change to Commons logging
12.Removal of Admin actions
13. Deprecation of the GenericDataSource.

61. What is a Action Servlet

public class ActionServlet extends javax.servlet.http.HttpServlet

1. ActionServlet provides the “controller” in the Model-View-Controller (MVC) design pattern for web applications that is commonly known as “Model 2″.
2. The class org.apache.struts.action.ActionServlet is the called the ActionServlet.
3. In the the Jakarta Struts Framework this class plays the role of controller.
4. All the requests to the server goes through the controller.
5. Controller is responsible for handling all the requests.

60. What is the difference between TYPE_SCROLL_INSENSITIVE and TYPE_SCROLL_SENSITIVE

You will get a scrollable ResultSet object if you specify one of these ResultSet constants.The difference between the two has to do with whether a result set reflects changes that are made to it while it is open and whether certain methods can be called to detect these changes. Generally speaking, a result set that is TYPE_SCROLL_INSENSITIVE does not reflect changes made while it is still open and one that is TYPE_SCROLL_SENSITIVE does. All three types of result sets will make changes visible if they are closed and then reopened:

Statement stmt =
con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
ResultSet srs =
stmt.executeQuery(”SELECT COF_NAME, PRICE FROM COFFEES”);
srs.afterLast();
while (srs.previous())
{
String name = srs.getString(”COF_NAME”);
float price = srs.getFloat(”PRICE”);
System.out.println(name + ” ” + price);
} 2 comments September 9th, 2006

59. How to make updates to updatable result sets.

Another new feature in the JDBC 2.0 API is the ability to update rows in a result set using methods in the Java programming language rather than having to send an SQL command. But before you can take advantage of this capability, you need to create a ResultSet object that is updatable. In order to do this, you supply the ResultSet constant CONCUR_UPDATABLE to the createStatement method.E.g. Connection con = DriverManager.getConnection(”jdbc:mySubprotocol:mySubName”); Statement stmt = con.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_UPDATABLE); ResultSet uprs = (”SELECT COF_NAME, PRICE FROM COFFEES”); Add comment September 9th, 2006

58. How to Retrieve Warnings

SQLWarning objects are a subclass of SQLException that deal with database access warnings. Warnings do not stop the execution of an application, as exceptions do; they simply alert the user that something did not happen as planned. A warning can be reported on a Connection object, a Statement object (including PreparedStatement and CallableStatement objects), or a ResultSet object. Each of these classes has a getWarnings method, which you must invoke in order to see the first warning reported on the calling objectE.g. SQLWarning warning = stmt.getWarnings(); if (warning != null) { while (warning != null) { System.out.println(”Message: ” + warning.getMessage()); System.out.println(”SQLState: ” + warning.getSQLState()); System.out.print(”Vendor error code: “); System.out.println(warning.getErrorCode()); warning = warning.getNextWarning(); } } Add comment September 9th, 2006

57. How can you load the driver.

Driver can be loaded in 2 ways :1. class.forName(”sun.jdbc.odbc.JdbcOdbc”); 2. Driver d=new Driver(”sun.jdbc.odbc.JdbcOdbc”);    DriverManager.registerDriver(d);vendar specific one: Driver d=new oracle.driver.oracleDriver(); Add comment September 9th, 2006

56. How can you retrieve data from the ResultSet

Example:Statement stmt = conn.createStatement(); 
ResultSet rs = stmt.executeQuery(SELECT COF_NAME, PRICE FROM COFFEES”); 
while (rs .next() ) 
{ 
//Iam assuming there are 3 columns in the table. 
System.out.println ( rs.getString(1)); 
System.out.println(rs.getString(2)); 
System.out.println(rs.getString(3)); 
} 
//don’t forget to close the resultset, statement & connection 
rs.close(); //First  
stmt.close(); //Second 
con.close(); //Last  
System.out.println(”You are done”);  Add comment September 9th, 2006

55. How do you implement Connection Pooling

Connection Pooling can be implemented by the following way. 

1.  A javax.sql.ConnectionPoolDataSource interface that serves as a resource manager connection factory for pooled java.sql.Connection objects. Each database vendors provide the implementation for that interface. 
   1. For example, the oracle vendors implementation is as follows: oracle.jdbc.pool.oracleConnectionPoolDataSource Class. 
2. A javax.sql.PooledConnection interface encapsulates the physical connection for the database. Again, the vendor provides the implementation.

Code for connecting the connection poolingInitalContext ic=new InitialContext(); Hashtable ht=new Hashtable(); ht.put(”Context.INITIAL_PROVIDER”,weblogic.jndi.InitialCla) //u have to set weblogic properties first and the jndi name that u r defining in  //weblogic while creating the connectionpool ht.put(”Context.PROVIDER_URL”,t3://localhost:7001); ht.put(”Context.SECURITY_PRINCIPAL”,username); ht.put(”Context.SECURITY_CREDENTIALS”,passwordof weblogic); DataSource ds=(DataSource)ic.lookup(”jndiname”); Connection con=ds.getConnection(); Statement stmt=con.createStatement(); Add comment September 9th, 2006

54. How to call a stored procedure from JDBC

Stored Procedures can be called in java by using the prepareCall() method which returns a CallableStatement object.CallableStatement cs = con.prepareCall(”{call Procedure_name}”); ResultSet rs = cs.executeQuery(); Add comment September 9th, 2006

53. What are the three statements in JDBC & difference between them.

1.Statement which is used to run simple sql statements like select and update 
2. PrepareStatment is used to run Pre compiled sql.  
3. CallableStatement is used to execute the stored procedures. 1 comment September 9th, 2006

52. What is the difference between ResultSet and RowSet

A ResultSet maintains a connection to a database and because of that it can’t be serialized and also we cant pass the Resultset object from one class to other class across the network.RowSet is a disconnected, serializable version of a JDBC ResultSet and also the RowSet extends the ResultSet interface so it has all the methods of ResultSet. The RowSet can be serialized because it doesn’t have a connection to any database and also it can be sent from one class to another across the network. More on RowSet: A RowSet can be * connected * or *disconnected* 
A *disconnected* rowset gets a connection to a data source in order to fill itself with data or to propagate changes in data back to the data source, but most of the time it does not have a connection open. While it is disconnected, it does not need a JDBC driver or the full JDBC API, so its footprint is very small. Thus a rowset is an ideal format for sending data over a network to a thin client.  
A connected RowSet is like a wrapper around the ResultSet. 
Implementation: 
A CachedRowSet class—a disconnected rowset that caches its data in memory; not suitable for very large data sets, but an ideal way to provide thin Java clients, such as a Personal Digital Assistant (PDA) or Network Computer (NC), with tabular data  
A JDBCRowSet class—a connected rowset that serves mainly as a thin wrapper around a ResultSet object to make a JDBC driver look like a JavaBeans component  
A WebRowSet class—a connected rowset that uses the HTTP protocol internally to talk to a Java servlet that provides data access; used to make it possible for thin web clients to retrieve and possibly update a set of rows 2 comments September 9th, 2006

51. What is a transaction.

To emulate a business transaction, a program may need to perform several steps. A financial program, for example, might transfer funds from a checking account to a savings account with the steps listed in the following pseudocode:

begin transaction

   debit checking account

   credit savings account

   update history log

commit transaction

Either all three of these steps must complete, or none of them at all. Otherwise, data integrity is lost. Because the steps within a transaction are a unified whole, a transaction is often defined as an indivisible unit of work.

• A transaction can end in two ways: with a commit or a rollback.
• When a transaction commits, the data modifications made by its statements are saved.
• If a statement within a transaction fails, the transaction rolls back, undoing the effects of all statements in the transaction.
• In the pseudocode, for example, if a disk drive crashed during the credit step, the transaction would roll back and undo the data modifications made by the debit statement. Although the transaction failed, data integrity would be intact because the accounts still balance.
• In the preceding pseudocode, the begin and commit statements mark the boundaries of the transaction.

Transaction mainly consist of ACID. A-Atomicity, C- Consistency, I – Integrity, D- Durability. If a process consist of acid successfully then we can say that the transaction is successful. Add comment September 9th, 2006

50. What is the purpose of setAutoCommit()

Autocommit behavior    The JDBC specification requires that, by default, a COMMIT is performed after each data modification statement. Currently, the server-side JDBC behavior is to commit. You can control this behavior using a statement such as the following:

·  conn.setAutoCommit( false ) ;

where conn is the current connection object.·  Connection defaults    From server-side JDBC, only the first call to getConnection( “jdbc:default:connection” ) creates a new connection with the default values. Subsequent calls return a wrapper of the current connection with all connection properties unchanged. If you set AutoCommit to OFF in your initial connection, any subsequent getConnection calls within the same Java code return a connection with AutoCommit set to OFF. You may wish to ensure that closing a connection resets the connection properties to their default values, so that subsequent connections are obtained with standard JDBC values. The following type of code achieves this:

Connection conn = DriverManager.getConnection("");

boolean oldAutoCommit = conn.getAutoCommit();

try {

     // do code here

}

finally {

    conn.setAutoCommit( oldAutoCommit );

}

 Add comment September 9th, 2006

49. What is the difference between statement and prepared statment?

• Prepared Statement is Pre-compiled class , but Statement is not.
• So in PreparedStatement the execution will be faster.

Actually when u submit a simple statement to the databse, at first the DBMS parses it and sends it back with the result, so again when u send the same statement again the DBMS server parses it and sends back the result so here a lot of time is wasted and because the statement is again parsed though it has been sent twice or thrice it consumes a lot of time and response will be slow.Prepared Statement is used when u want to execute a statement object many times. when u submit a PreparedStatement the DBMS server parses it and creates a execution plan. This e-plan can be used when u again send the same statement to the database.That is the DBMS server zest executes the compiled statement rather that executing it from first, hence we get an precompiled statement.And also the advanatge of using this PreparedStatement is it is used to send dynamic sql statements, which u can give values later than giving the values at the time of creation. 4 comments September 9th, 2006

48. What is a savepoint.

Save point is a feature using which we can save  status of the transaction to a perticular extent.so that if anytime we have lost a transaction we can get it back using save point. Add comment September 9th, 2006

47. What is the difference between ResultSetMetaData and DatabaseMetaData

ResultSetMetaData

• You can interrogate JDBC for detailed information about a query’s result set using a ResultSetMetaData object.
• ResultSetMetaData is a class that is used to find information about the ResultSet returned from a executeQuery call.
• It contains information about the number of columns, the types of data they contain, the names of the columns, and so on.
• Two of the most common methods in the ResultSetMetaData are getColumnName and getColumnTypeName. These retrieve the name of a column, and the name of its associated data type, respectively, each in the form of a String.

DatabaseMetaData

DatabaseMetaData is a class that can be used to fetch information about the database you are using. Use it to answer questions such as: ·         What kind of catalogs are in the database?·         What brand of database am I working with?·         What username am I?ex: username = dbmd.getUserName(); Add comment September 9th, 2006

46. What do you mean by batch update

1. The JDBC drivers that support JDBC 2.0 and above support batch updates.
2. With batch updates, instead of updating rows of a  table one at a time, you can direct JDBC to execute a group of updates at the same time.
3. Statements that can be included in the same batch of updates are known as batchable statements.

Homogeneous batch: If a statement has input parameters or host expressions, you can include that statement only in a batch that has other instances of the same statement. This type of batch is known as a homogeneous batch. Heterogeneous batch: If a statement has no input parameters, you can include that statement in a batch only if the other statements in the batch have no input parameters or host expressions. This type of batch is known as a heterogeneous batch. Two statements that can be included in the same batch are known as batch compatible. Use the following Statement methods for creating, executing, and removing a batch of SQL updates:

• addBatch
• executeBatch
• clearBatch

example: the amendments to the all email ids of the employees. Add comment September 9th, 2006

45. What is the difference between local and global transaction.

A transaction is atomic unit of Work.The tasks which are made into the transaction act as a unit which can be executed successfully all,or if at least one task fails to its promise ,then the effect of all the tasks are to be rollbacked.Thus transaction is committed or rolled backed.Transactions can be divided into two categories. 1.Local Transactions:These transactions are confined to objects which reside inside one particular JVM.Local transactions in java can be implemented using the JTA api. 2.Global Transactions:These transactions may encapsulate objects which are distributed on various JVM’s.Global transactions are implemented throught TWO-PHASE-COMMIT design implementation. Add comment September 9th, 2006

44. What the new features in JDBC 2.0

The following are the JDBC 2.0 features. ·         Resultset enhancementso        JDBC 2.0 supports scrollable resultset capability under three major headings, namely, forward-only, scroll-insensitive, and scroll-sensitive. o        Each of these resultsets can in turn be Read_only or Updatable. Forward_only/Read_only is feature of JDBC 1.0. ·         Batch Updateso        automatic batch update and explicit batch update.·         Advanced Data Typeso        The advanced data types such as objects, object references, arrays, LOBS, SQL Data, and Struct are now supported by JDBC 2.0. ·         JNDIo        The Java Naming and Directory Interface (JNDI) is an interface to obtain network resources in a vendor independent fashion. This is available as part of the JDBC2.0 Optional Package (JDBC 2.0 Standard Extension API) and implemented by means of javax.sql package. ·         Connection Poolingo        Connection pooling is a method where multiple consumers share a limited set of connections instead of each having to create new connections. This also includes connection caching. This is implemented by means of javax.sql package. ·         Distributed Transactionso        A distributed transaction is a combination of two or more related transactions that execute in a coordinated manner. o        All the individual transactions might take place in the same database, but typically, the individual transactions are in different databases and often in different locations. o        Distributed transactions are defined as a JDBC2.0 standard extensions API and are also implemented by means of javax.sql package. ·         Other Featureso        Other features include fetch size/row prefetching. Fetch size is part of JDBC2.0 and includes methods to define the number of rows retrieved by each database fetch.      

43. Explain JDBC Driver Types

JDBC drivers are divided into four types or levels. Each type defines a JDBC driver implementation with increasingly higher levels of platform independence, performance, and deployment administration. The four types are:

• Type 1: JDBC-ODBC Bridge
• Type 2: Native-API/partly Java driver
• Type 3: Net-protocol/all-Java driver
• Type 4: Native-protocol/all-Java driver

Type 1: JDBC-ODBC Bridge 
The type 1 driver, JDBC-ODBC Bridge, translates all JDBC calls into ODBC (Open DataBase Connectivity) calls and sends them to the ODBC driver. As such, the ODBC driver, as well as, in many cases, the client database code, must be present on the client machine. Figure 1 shows a typical JDBC-ODBC Bridge environment. Pros
The JDBC-ODBC Bridge allows access to almost any database, since the database’s ODBC drivers are already available. Type 1 drivers may be useful for those companies that have an ODBC driver already installed on client machines. Cons

• The performance is degraded since the JDBC call goes through the bridge to the ODBC driver, then to the native database connectivity interface. The result comes back through the reverse process. Considering the performance issue, type 1 drivers may not be suitable for large-scale applications.
• The ODBC driver and native connectivity interface must already be installed on the client machine. Thus any advantage of using Java applets in an intranet environment is lost, since the deployment problems of traditional applications remain.

Type 2: Native-API/partly Java driver
JDBC driver type 2 — the native-API/partly Java driver — converts JDBC calls into database-specific calls for databases such as SQL Server, Informix, Oracle, or Sybase. The type 2 driver communicates directly with the database server; therefore it requires that some binary code be present on the client machine. Pros
Type 2 drivers typically offer significantly better performance than the JDBC-ODBC Bridge.
The vendor database library needs to be loaded on each client machine. Consequently, type 2 drivers cannot be used for the Internet. Type 2 drivers show lower performance than type 3 and type 4 drivers. Type 3: Net-protocol/all-Java driver 
JDBC driver type 3 — the net-protocol/all-Java driver — follows a three-tiered approach whereby the JDBC database requests are passed through the network to the middle-tier server. The middle-tier server then translates the request (directly or indirectly) to the database-specific native-connectivity interface to further the request to the database server. If the middle-tier server is written in Java, it can use a type 1 or type 2 JDBC driver to do this.Pros
The net-protocol/all-Java driver is server-based, so there is no need for any vendor database library to be present on client machines. Further, there are many opportunities to optimize portability, performance, and scalability. Moreover, the net protocol can be designed to make the client JDBC driver very small and fast to load. Additionally, a type 3 driver typically provides support for features such as caching (connections, query results, and so on), load balancing, and advanced system administration such as logging and auditing. Cons
Type 3 drivers require database-specific coding to be done in the middle tier. Additionally, traversing the recordset may take longer, since the data comes through the backend server. Type 4: Native-protocol/all-Java driver 
The native-protocol/all-Java driver (JDBC driver type 4) converts JDBC calls into the vendor-specific database management system (DBMS) protocol so that client applications can communicate directly with the database server. Level 4 drivers are completely implemented in Java to achieve platform independence and eliminate deployment administration issues. Pros
Since type 4 JDBC drivers don’t have to translate database requests to ODBC or a native connectivity interface or to pass the request on to another server, performance is typically quite good. Moreover, the native-protocol/all-Java driver boasts better performance than types 1 and 2. Also, there’s no need to install special software on the client or server. Further, these drivers can be downloaded dynamically. Cons
With type 4 drivers, the user needs a different driver for each database.  1 comment September 8th, 2006

42. What is JDBC

• JDBC (Java Database Connectivity) provides a standard interface for accessing a relational database from a Java application regardless of where the application is running and where the database is.
• It provides a way for Java applications to call SQL and PL/SQL.
• In other words it is a way to execute SQL statements and also call stored database procedures.
• One important feature of JDBC is location independence. Java programs with database access can be written and deployed as an application or as a Web-based applet.
• The ease of development, robustness, and security of Java programs makes it a good choice for writing database applications in Java.
• JDBC consists of a high-level “thin” API and multiple low-level drivers for connecting to different databases.

 Add comment September 8th, 2006

41. Explain Basic Steps in writing a Java program using JDBC

Basically a Java program implementing JDBC performs the following functions: ·         Load a JDBC driver.·         Establish a database connection.·         Optionally interrogate the database for capability subset.·         Optionally retrieve schema metadata information.·         Construct a SQL or callable statement object and send queries or database tasks.·         Execute the database tasks or process resultsets.·         Close the statement object and resultset.·         Close the connection. Add comment September 8th, 2006

40. What is the difference between <jsp:include> and <c:import>

1. The <c:import> tag imports a resource specified by a URL and exposes it to the page, variable, or reader.
2. The <jsp:include> standard action is a request-time action that will include the output of another JSP at the location of the tag within the calling JSP.
3. <c:import> is similar to the <jsp:include> directive, but with more features.
4. The body of the import tag can have param tags for adding parameters to the URL.
5. we can overcome jsp:include limitations with the JSTL import tag.
6. The import tag adds functionality to the jsp:include tag and eliminates the need to code these functions yourself.
7. The first additional function allows you to include content directly from other Web sites. So the following is now legal:
   <c:import url=”http://www.example.com/somecontent.html”/>
8. You can even use ftp:
   <c:import url=”ftp://ftp.example.com/somecontent.txt”/>
9. Rather than dump an imported URL straight to the page, you can store it in a variable. This is a common strategy in all the JSTL tags and increases the power of a JSP page:
   <c:import url=”http://www.example.com/example.inc” var=”example”/> Once this included page is stored in the example variable, you can use another taglib, such as the Jakarta String taglib, to replace all references to example.com with done.com.
10. Since you can store <c:import> in a variable I’m wondering if <c:import> might do some type of full read before printing to output, whereas I imagine <jsp:include> uses buffering. This could show a performance difference for very large files, with <c:import> requiring longer and taking more memory to get all the data in the import whereas <jsp:include> did things with buffers.
11. Include Syntax:

<jsp:include page=”…url..” flush=”true or false“/>The tag can optionally contain a body:

<jsp:include page="…url…” flush=”true or false“>

  <jsp:param  …./>

</jsp:include>

          Import Syntax:<c:import url=”resource URL”
          [var=”variable name”]
          [scope=”page|request|session|application”]
          [varReader=”variable name”]
          [context=”context name”]
          [charEncoding=”character encoding”]>
     JSP body content
</c:import> 2 comments September 8th, 2006

39. What is the differences between Http Servlet and generic Servlet

HttpServlet Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A subclass of HttpServlet must override at least one method, usually one of these:

• doGet, if the servlet supports HTTP GET requests
• doPost, for HTTP POST requests
• doPut, for HTTP PUT requests
• doDelete, for HTTP DELETE requests
• init and destroy, to manage resources that are held for the life of the servlet
• getServletInfo, which the servlet uses to provide information about itself

There’s almost no reason to override the service method. service handles standard HTTP requests by dispatching them to the handler methods for each HTTP request type (the doXXX methods listed above). Likewise, there’s almost no reason to override the doOptions and doTrace methods. GenericServlet defines a generic, protocol-independent servlet. To write an HTTP servlet for use on the Web, extend HttpServlet instead. GenericServlet implements the Servlet and ServletConfig interfaces. GenericServlet may be directly extended by a servlet, although it’s more common to extend a protocol-specific subclass such as HttpServlet. GenericServlet makes writing servlets easier. It provides simple versions of the lifecycle methods init and destroy and of the methods in the ServletConfig interface. GenericServlet also implements the log method, declared in the ServletContext interface. To write a generic servlet, you need only override the abstract service method. 5 comments September 7th, 2006

38. Servlets 20 mins drill and Quiz.

What is the servlet? Servlet is a script, which resides and executes on server side, to create dynamic HTML. In servlet programming we will use java language. A servlet can handle multiple requests concurrently What’s the difference between servlets and applets? Servlets executes on Servers. Applets executes on browser. Unlike applets, however, servlets have no graphical user interface. What are the uses of Servlets? A servlet can handle multiple requests concurrently, and can synchronize requests. Servlets can forward requests to other servers and servlets. Thus servlets can be used to balance load among several servers. When doGET() method will going to execute? When we specified method=’GET’ in HTML
Example : < form name=’SSS’ method=’GET’> When doPOST() method will going to execute? When we specified method=’POST’ in HTML
< form name=’SSS’ method=’POST’ > Which code line must be set before any of the lines that use the PrintWriter? setContentType() method must be set. Which protocol will be used by browser and servlet to communicate ? HTTP How Can You invoke other web resources (or other servelt / jsp ) ? Servelt can invoke other Web resources in two ways: indirect and direct.
Indirect Way : Servlet will return the resultant HTML to the browser which will point to another Servlet (Web resource)
Direct Way : We can call another Web resource (Servelt / Jsp) from Servelt program itself, by using RequestDispatcher object.
You can get this object using getRequestDispatcher(”URL”) method. You can get this object from either a request or a Context.
Example :
RequestDispatcher dispatcher = request.getRequestDispatcher(”/jspsample.jsp”);
if (dispatcher != null)
dispatcher.forward(request, response);
} How Can you include other Resources in the Response? Using include method of a RequestDispatcher object.
Included WebComponent (Servlet / Jsp) cannot set headers or call any method (for example, setCookie) that affects the headers of the response.
Example : RequestDispatcher dispatcher = getServletContext().getRequestDispatcher(”/banner”);
            if (dispatcher != null)
            dispatcher.include(request, response);
} Is there any way to generate PDF’S dynamically in servlets? We need to use iText. A open source library for java. Please refer sourceforge site for sample servlet examples. What is the difference between using getSession(true) and getSession(false) methods? getSession(true) – This method will check whether already a session is existing for the user. If a session is existing, it will return that session object, Otherwise it will create new session object and return taht object.
getSession(false) – This method will check existence of session. If session exists, then it returns the reference of that session object, if not, this methods will return null. Can I invoke a JSP error page from a servlet? Yes, you can invoke the JSP error page and pass the exception object to it from within a servlet. The trick is to create a request dispatcher for the JSP error page, and pass the exception object as a javax.servlet.jsp.jspException request attribute. However, note that you can do this from only within controller servlets. If your servlet opens an OutputStream or PrintWriter, the JSP engine will throw the following translation error: java.lang.IllegalStateException: Cannot forward as OutputStream or Writer has already been obtained The following code snippet demonstrates the invocation of a JSP error page from within a controller servlet: protected void sendErrorRedirect(HttpServletRequest request,
HttpServletResponse response, String errorPageURL, Throwable e) throws
ServletException, IOException {
request.setAttribute (”javax.servlet.jsp.jspException”, e);
getServletConfig().getServletContext().
getRequestDispatcher(errorPageURL).forward(request, response);
} public void doPost(HttpServletRequest request, HttpServletResponse response)
{
try {
// do something
} catch (Exception ex) {
try {
sendErrorRedirect(request,response,”/jsp/MyErrorPage.jsp”,ex);
} catch (Exception e) {
e.printStackTrace();
}
}
} What is the Servlet Interface? The central abstraction in the Servlet API is the Servlet interface. All servlets implement this interface, either directly or, more commonly, by extending a class that implements it such as HttpServlet.
Servlets–>Generic Servlet–>HttpServlet–>MyServlet.
The Servlet interface declares, but does not implement, methods that manage the servlet and its communications with clients. Servlet writers provide some or all of these methods when developing a servlet. If you want a servlet to take the same action for both GET and POST request, what should you do? Simply have doGet call doPost, or vice versa. When a servlet accepts a call from a client, it receives two objects. What are they? ServeltRequest: which encapsulates the communication from the client to the server.
ServletResponse: which encapsulates the communication from the servlet back to the client.
ServletRequest and ServletResponse are interfaces defined by the javax.servlet package. What information that the ServletResponse interface gives the servlet methods for replying to the client? It Allows the servlet to set the content length and MIME type of the reply. Provides an output stream, ServletOutputStream and a Writer through which the servlet can send the reply data. What information that the ServletRequest interface allows the servlet access to? Information such as the names of the parameters passed in by the client, the protocol (scheme) being used by the client, and the names of the remote host that made the request and the server that received it. The input stream, ServletInputStream.Servlets use the input stream to get data from clients that use application protocols such as the HTTP POST and PUT methods. What do you understand by servlet mapping?
Servlet mapping defines an association between a URL pattern and a servlet. You can use one servlet to process a number of url pattern (request pattern). For example in case of Struts *.do url patterns are processed by Struts Controller Servlet. What must be implemented by all Servlets?
The Servlet Interface must be implemented by all servlets. What are the uses of Servlets?

• Servlets are used to process the client request.
• A Servlet can handle multiple request concurrently and be used to develop high performance system
• A Servlet can be used to load balance among serveral servers, as Servlet can easily forward request.

What is Session ID?
A session ID is an unique identification string usually a long, random and alpha-numeric string, that is transmitted between the client and the server. Session IDs are usually stored in the cookies, URLs (in case url rewriting) and hidden fields of Web pages. What are the advantage of Cookies over URL rewriting?
Sessions tracking using Cookies are more secure and fast. Session tracking using Cookies can also be used with other mechanism of Session Tracking like url rewriting.Cookies are stored at client side so some clients may disable cookies so we may not sure that the cookies may work or not. 
In url  rewriting requites large data transfer from and to the server. So, it leads to network traffic and access may be become slow. What is session hijacking?
If you application is not very secure then it is possible to get the access of system after acquiring or generating the authentication information. Session hijacking refers to the act of taking control of a user session after successfully obtaining or generating an authentication session ID. It involves an attacker using captured, brute forced or reverse-engineered session IDs to get a control of a legitimate user’s Web application session while that session is still in progress. What is Session Migration?
Session Migration is a mechanism of moving the session from one server to another in case of server failure. Session Migration can be implemented by:
a) Persisting the session into database
b) Storing the session in-memory on multiple servers. How to track a user session in Servlets?
The interface HttpSession can be used to track the session in the Servlet. Following code can be used to create session object in the Servlet: HttpSession session = req.getSession(true);How you can destroy the session in Servlet?
You can call invalidate() method on the session object to destroy the session. e.g. session.invalidate(); 3 comments September 7th, 2006

37. What is servlet lazy loading.

• A container doesnot initialize the servlets ass soon as it starts up, it initializes a servlet when it receives a request for that servlet first time. This is called lazy loading.
• The servlet specification defines the <load-on-startup> element, which can be specified in the deployment descriptor to make the servlet container load and initialize the servlet as soon as it starts up.
•  The process of loading a servlet before any request comes in is called preloading or preinitializing a servlet.

 Add comment September 7th, 2006

36. Sir, do you know about jsp application object

• This implicit object represents the application to which the JSP belongs.
•  JSPs are grouped into applications according to their URLs where the first directory name in a URL defines the application.
• The application object contains methods that provide information about the JSP Container, support for logging plus utility methods for example translating a relative URL to an absolute path.

Servlet Class

javax.servlet.ServletContext The following table summarises the most useful methods available to the application object.

 Add comment September 7th, 2006

35. Tell me something about jsp session object

• The session implicit object is used to provide an association between the client and the server.
• This association, or session, persists over multiple connections and/or requests during a given time period.
• Sessions are used to maintain state and user identity across multiple page requests.
• A session can be maintained either by using cookies or by URL rewriting. To expose whether the client supports cookies, session defines an isCookieSupportDetermined() method and an isUsingCookies() method.

Servlet Class

HttpSession The following table summarises the most useful methods available to the session object.

 Add comment September 7th, 2006

34. What do you know about jsp response object

• The response object handles the output to the client.
• This object can be used for creating HTTP Headers, creating cookies, setting content type and redirecting workflow.

Servlet Class

javax.servlet.http.HttpServletResponse The following table summarises the most useful methods available to the response object.

 Add comment September 7th, 2006

33. Explain request implicit object

1. The request object retrieves the values that the client browser passed to the server during an HTTP request such as headers, cookies or parameters associated with the request.
2. Among the most common use of the request object is to obtain parammeter or query string values.

Servlet Classjavax.servlet.HttpServletRequest The following table summarises the most useful methods available to the request object.

 Add comment September 7th, 2006

32. What is the difference between ServletContext and ServletConfig

public interface ServletContext

• Defines a set of methods that a servlet uses to communicate with its servlet container, for example, to get the MIME type of a file, dispatch requests, or write to a log file.
• There is one context per “web application” per Java Virtual Machine.
• The ServletContext object is contained within the ServletConfig object, which the Web server provides the servlet when the servlet is initialized.

public interface ServletConfig

• A servlet configuration object used by a servlet container used to pass information to a servlet during initialization.
• This object defines how a servlet is to be configured is passed to a servlet in its init method.
• Most servlet containers provide a way to configure a servlet at run-time (usually through flat file) and set up its initial parameters.
• The container, in turn, passes these parameters to the servlet via the ServetConfig.

 2 comments September 6th, 2006

31. Explain Servlet Life Cycle.

1. Servlets are normal Java classes which are created when needed and destroyed when not needed. Since Servlets run within a Servlet Container, creation and destruction of Servlets is the duty of Servlet Container and not yours.
2. Implementing the init() and destory() methods of Servlet interface allows you to be told by the Servlet Container that when it has created an instance of your Servlet and when it has destroyed that instance.
3. An important point to remember is that your Servlet is not created and destroyed for every request it receives, rather it is created and kept in memory where requests are forwarded to it and your Servlet then generates response.

   Servlet Initialization (init())
So you have created your Servlet class by extending the HttpServlet class and have placed it in /WEB-INF/classes/ directory of your application. Now when will Servlet Container create an instance of your Servlet? there are two situations :

• When you have specifically told the Servlet Container to preload your Servlet when the Servlet Container starts by setting the load-on-startup tag to a non-zero value e.g.

·         <web-app>

·          

·           <servlet>

·             <servlet-name>test</servlet-name>

·             <servlet-class>com.wordpress.sharat.servlets.TestServlet</servlet-class>

·             <load-on-startup>1</load-on-startup>

·           </servlet>

·          

</web-app>

So when the Servlet Container starts it will preload your Servlet in the memory.

• If your Servlet is not already loaded, it’s instance will be created as soon as a request is received for it by the Servlet Container.
• During the loading of the Servlet into the memory, Servlet Container will call your Servlet’s init() method.
• Since init() is going to be called only once you can put Servlet initialization code in it like getting hold of a database connection or whatever.

Responding to Requests(service())

1. Once your Servlet is initialized and it’s init() method called, any request that the Servlet Container receives will be forwarded to your Servlet’s service() method.
2. HttpServlet class breakes this service() method into more useful doGet(), doPost(), doDelete(), doOptions(), doPut() and doTrace() methods depending on the type of HTTP request it receives.
3. So in order to generate respose you should override the doGet() or doPost() method as required.
4. At this moment all the requests will be forwarded to the appropriate doGet() or doPost() or whatever method as required. No new instance will be created for your Servlet.

Servlet Destruction(destory())When your application is stopped or Servlet Container shuts down, your Servlet’s destroy() method will be called. This allows you to free any resources you may have got hold of in your Servlet’s init() method.Always Remember

• init() and destroy() methods will be called only once during the life time of your Servlet
•  while service() and it’s broken down methods ( doGet(), doPost() etc ) will be called as many times as requests are received for them by the Servlet Container.

 3 comments September 6th, 2006

30. Explain the advantages of JSTL

1. The Java Standard Tag Library (JSTL) is a standardized collection of custom tags.
2. It has a number of tags for common tasks such as iterating through lists, interacting with databases, handling XML data, formatting data, and much more.
3. The latest version of JSTL is 1.1. An implementation of JSTL can be downloaded from the Apache Jakarta Web site (http://jakarta.apache.org/).
4. JSTL consist of four sets of tags and a library of functions, grouped according to their functionality:

• The JSTL core tag library contains tags that deal with flow control in JSP pages, iterating over collections, evaluating expressions, and importing resources.
• Before using the core tag library, the following directive needs to be added to the JSP page:
• <%@ taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core” %>
• The equivalent XML syntax for this directive is as follows:
• <jsp:directive.taglib prefix=”c” uri=”http://java.sun.com/jsp/jstl/core” />

The following table summarizes the JSTL core tags.

 8 comments September 6th, 2006

29. What are the advantages of JSP

• Separation of static from dynamic content.
• Write Once Run Anywhere.
• Dynamic content can be served in a variety of formats.

            example: browsers using HTML/DHTML, to handheld wireless devices like mobile phones and PDAs using WML, to other B2B applications using XML

• Recommended Web access layer for n-tier architecture.
• Completely leverages the Servlet API.

 Add comment September 6th, 2006

28. Explain JSP Basic Structure Items.

JSP Expression

• <%= expression %>
• Expression is evaluated and placed in output.
• XML equivalent is
  <jsp:expression>
expression
</jsp:expression>.
• Predefined variables are request,response,out,session,application,config, andpageContext (available in scriptlets also).

JSP Scriptlet

• <% code %>
• Code is inserted in service method.
• XML equivalent is
  <jsp:scriptlet>
code
</jsp:scriptlet>.

JSP Declaration

• <%! code %>
• Code is inserted in body of servlet class, outside of service method.
• XML equivalent is
  <jsp:declaration>
code
</jsp:declaration>.

JSP page Directive

• <%@ page att=”val” %>
• Directions to the servlet engine about general setup.
• XML equivalent is
  <jsp:directive.page att="val"\>.
• Legal attributes, with default values in bold, are:
  • import=”package.class”
  • contentType=”MIME-Type”
  • isThreadSafe=”true|false”
  • session=”true|false”
  • buffer=”sizekb|none”
  • autoflush=”true|false”
  • extends=”package.class”
  • info=”message”
  • errorPage=”url”
  • isErrorPage=”true|false”
  • language=”java”

JSP include Directive

• <%@ include file=”url” %>
• A file on the local system to be included when the JSP page is translated into a servlet.
• XML equivalent is
  <jsp:directive.include
  file=”url”\>.
• The URL must be a relative one. Use the jsp:include action to include a file at request time instead of translation time.

JSP Comment

• <%– comment –%>
• Comment; ignored when JSP page is translated into servlet.
• If you want a comment in the resultant HTML, use regular HTML comment syntax of <-- comment -->.

The jsp:include Action

• <jsp:include page=”relative URL” flush=”true”/>
• Includes a file at the time the page is requested.
• If you want to include the file at the time the page is translated, use the page directive with theinclude attribute instead. Warning: on some servers, the included file must be an HTML file or JSP file, as determined by the server (usually based on the file extension).

The jsp:forward Action

• <jsp:forward page=”relative URL“/>
• Forwards request to another page.

The jsp:plugin Action

• <jsp:plugin attribute=”value“*> … </jsp:plugin>
• Generates OBJECT orEMBED tags, as appropriate to the browser type, asking that an applet be run using the Java Plugin.

 Add comment September 6th, 2006

27. How to handle cookies in JSP

• The getCookies() method of the request object returns an array of Cookie objects.
• Cookies are used to allow web browsers to hold small amounts of information or state data associated with a user’s web browsing.
• Cookies are named and have a single value. They may have optional attributes, including a comment presented to the user, path and domain qualifiers for which hosts see the cookie, a maximum age, and a version.

Cookie(java.lang.String name, java.lang.String value)

Cookie objects have the following methods.getComment()
Returns the comment describing the purpose of this cookie, or null if no such comment has been defined.getMaxAge()
Returns the maximum specified age of the cookie.getName()
Returns the name of the cookie.getPath()
Returns the prefix of all URLs for which this cookie is targetted.getValue()
Returns the value of the cookie.setComment(String)
If a web browser presents this cookie to a user, the cookie’s purpose will be described using this comment.setMaxAge(int)
Sets the maximum age of the cookie. The cookie will expire after that many seconds have passed. Negative values indicate the default behaviour: the cookie is not stored persistently, and will be deleted when the user web browser exits. A zero value causes the cookie to be deletedsetPath(String)
This cookie should be presented only with requests beginning with this URL.setValue(String)
Sets the value of the cookie. Values with various special characters (white space, brackets and parentheses, the equals sign, comma, double quote, slashes, question marks, the “at” sign, colon, and semicolon) should be avoided. Empty values may not behave the same way on all browsers. Add comment September 6th, 2006