What is Struts ?

What is Struts ?
Apache Struts is a free open-source framework for creating Java web applications.

Difference Between Struts 1 and Struts 2

Struts1 was an action- oriented framework that implemented a Model-View-Controller (MVC) separation of concerns in its architecture.
Struts2 is a brand new implementation of those same MVC principles in an action-oriented framework.

Difference Between Struts 1 and Struts 2.

Why we need MVC framework?

Why we need Struts ?

  To Bind request parameters to Java types
  To Validate data
  To Make calls to business logic
  To Make calls to the data layer
  To Render presentation layer (HTML, and so on)
  To Provide internationalization and localization                                    
 
STRUTS2 FEATURES: 

  Interceptors for layering cross-cutting concerns away from action logic;
  Annotation-based configuration to reduce or eliminate XML configuration;
  Powerful expression language, Object-Graph Navigation Language(OGNL), that transverses the entire framework.
  Mini-MVC–based tag API that supports modifiable and reusable UI components.
  The framework's architecture and tags are buzzword compliant.
  Struts works well with conventional REST applications and with nouveau technologies like SOAP and AJAX.


Resources for Understanding and Using Struts

Sturts developers guide Link http://struts.apache.org/2.x/docs/core-developers-guide.html

Struts examples http://struts.apache.org/2.x/docs/strutsxml-examples.html

Differences Between Struts 1 and Struts 2

Base Action class is  abstract class in Struts1 where as it is Interface in Struts2 and
also provides a base ActionSupport class that implements commonly used interfaces.

Struts 1 Actions are singletons and must be thread-safe where as
Struts 2 doesn't have thread-safety issues as Action objects are instantiated for each request.

Actions are dependent on the servlet API , as HttpServletRequest and HttpServletResponse are passed to execute method in Struts1 but in case of Struts 2, Actions are not container dependent because they are made simple POJOs. In struts 2, the servlet contexts are represented as simple Maps.

Testing Struts2 action is simple as there is no Servlet API usage in execute method .

Struts 1 recieves an input by creating an ActionForm object which extend a ActionForm base class.
            Other JavaBeans classes cannot be used.
Struts 2 requires Action properties as input properties ,these Input properties may be rich object types.

Struts 1 integrates with JSTL, so it uses the JSTL EL(Expression Language http://en.wikipedia.org/wiki/Expression_Language).
Struts 2 can use JSTL, but the framework also supports a more powerful language called "Object Graph Notation Language" (OGNL).

Struts 1 binds objects into the page context by using the standard JSP mechanism.
Struts 2 uses a ValueStack technology to make the values accessible to the taglibs
             without coupling the view to the object to which it is rendering.

Struts 1 ActionForm properties are almost in the form of Strings. Commons-Beanutils are
            used by used by Struts 1 for type conversion.
Struts 2 uses OGNL for type conversion.

Struts 1 uses manual validation that is done via a validate method on the ActionForm, or
            by using an extension to the Commons Validator.
Struts 2 allows manual validation that is done by using the validate method and the XWork Validation framework.

Each module in Struts 1 has a separate Request Processors (lifecycles), while all the Actions in the module must share the same lifecycle.
In Struts 2 different lifecycles are created on a per Action basis via Interceptor Stacks.

For Full comparision Between Struts 1 and Struts 2
http://struts.apache.org/2.0.14/docs/comparing-struts-1-and-2.html

Tags
Struts,Differences,Frame Works,

Java Annotations Introduction

Annotations

Annotations provide data about a program that is not part of the program itself. They have no direct effect on the operation of the code they annotate.

Annotations have a number of uses, among them:

• Information for the compiler — Annotations can be used by the compiler to detect errors or suppress warnings.
• Compiler-time and deployment-time processing — Software tools can process annotation information to generate code, XML files, and so forth.
  
• Runtime processing — Some annotations are available to be examined at runtime.
  

There are two types of annotations available:

• Simple annotations: These are the basic types supplied with Tiger, which you can use to annotate your code only; you cannot use those to create a custom annotation type.
• Meta-annotations: These are the annotation types designed for annotating annotation-type declarations. Simply speaking, these are called the annotations-of-annotations.

An annotation is the meta-tag that you will use in your code to give it some life.
Annotation type is used for defining an annotation.

Annotation Types
An Annotation type definition takes an "at" (@) sign, followed by the interface keyword plus the annotation name.
 On the other hand, an annotation takes the form of an "at" sign (@), followed by the annotation type.
There are three annotation types:

1. Marker: Marker type annotations have no elements, except the annotation name itself.
2. Single-Element: Single-element, or single-value type, annotations provide a single piece of data only. This can be represented with a data=value pair or, simply with the value (a shortcut syntax) only, within parenthesis.
3. Full-value or multi-value: Full-value type annotations have multiple data members. Therefore, you must use a full data=value parameter syntax for each member.

Example to Define an Annotation (Annotation type)

                public @interface MyAnnotation {

                          String doSomething();   
               }

Singel element Usage:

           MyAnnotation (doSomething="What to do") 

               public void mymethod() { .... }

multi-value  Usage

                     @MyAnnotation (doSomething="What to do", count=1,  date="09-09-2005")    

                    public void mymethod() {        ....     }  

Simple Annotations

There are three annotation types that are predefined by the language specification itself:        

1. Deprecated
2. Override
3. Suppresswarnings

         @Deprecated annotation indicates that the marked element is deprecated and should no longer be used. The compiler generates a  warning  whenever a program uses a method, class, or field with the @Deprecated annotation.
        The Javadoc tag starts with a lowercase "d" and the annotation starts with an uppercase "D".    

 // Javadoc comment follows       
 /**        
 * @deprecated        
 * explanation of why it was deprecated        
 */       
 @Deprecated       
        static void deprecatedMethod() { }  

        @Override annotation informs the compiler that the element is meant to override an element declared in a superclass .   

 // mark method as a superclass method   
 // that has been overridden      
 @Override       
 int overriddenMethod() { }   

        @SuppressWarnings annotation tells the compiler to suppress specific warnings that it would otherwise generate.

          // use a deprecated method and tell      
   // compiler not to generate a warning      
   @SuppressWarnings("deprecation")       
   void useDeprecatedMethod() {           
    objectOne.deprecatedMethod(); 
    //deprecation warning - suppressed      
   }   

Meta-Annotations

Meta-annotations, which are actually known as the annotations of annotations, contain four types. These are:

• Target
• Retention
• Documented
• Inherited

The target annotation indicates the targeted elements of a class in which the annotation type will be applicable. It contains the following enumerated types as its value:

• @Target(ElementType.TYPE)—can be applied to any element of a class
• @Target(ElementType.FIELD)—can be applied to a field or property
• @Target(ElementType.METHOD)—can be applied to a method level annotation
• @Target(ElementType.PARAMETER)—can be applied to the parameters of a method
• @Target(ElementType.CONSTRUCTOR)—can be applied to constructors
• @Target(ElementType.LOCAL_VARIABLE)—can be applied to local variables
• @Target(ElementType.ANNOTATION_TYPE)—indicates that the declared type itself is an annotation type

The retention annotation indicates where and how long annotations with this type are to be retained. In simple it indicates the scope of the annotation Type.
There are three values:

• RetentionPolicy.SOURCE—Annotations with this type will be by retained only at the source level and will be ignored by the compiler
• RetentionPolicy.CLASS—Annotations with this type will be by retained by the compiler at compile time, but will be ignored by the VM
• RetentionPolicy.RUNTIME—Annotations with this type will be retained by the VM so they can be read only at run-time

The documented annotation indicates that an annotation with this type should be documented by the javadoc tool. By default, annotations are not included in javadoc. But if @Documented is used, it then will be processed by javadoc-like tools and the annotation type information will also be included in the generated document.

Inherited annotation

It is important to understand the rules relating to inheritance of annotations, as these have a bearing on join point matching based on the presence or absence of annotations.

By default annotations are not inherited.The annotation used on the super class doesn't get inherited to sub class,unless the annotation (@MyAnnotation used in the following example)used on super class has the @Inherited meta-annotation.
Annotation are not be inheritable in case of  extending Interface even if they have @Inherited meta-annotation.

@MyAnnotation    
 class Super {      
  @Oneway public void foo() {}    
 }
 class Sub extends Super {
  public void foo() {}
 }    

Then Sub does not have the MyAnnotation annotation, and Sub.foo() is not an @Oneway method, despite the fact that it overrides Super.foo() which is.
If an annotation type @MyAnnotation has the meta-annotation @Inherited then an annotation of that type on a class will cause the annotation to be inherited by sub-classes. So, in the example above, if the MyAnnotation type had the @Inherited attribute, then Sub would have the MyAnnotation annotation.
@Inherited annotations are not inherited when used to annotate anything other than a type.
 A type that implements one or more interfaces never inherits any annotations from the interfaces it implements(they are inheritable only if subclass extends another super class).

        Every compiler warning belongs to a category. The Java Language Specification lists two categories: "deprecation" and "unchecked." The  "unchecked" warning can occur when interfacing with legacy code written before the advent of generics .

         To suppress more than one category of warnings, use the following syntax:

 @SuppressWarnings({"unchecked", "deprecation"}) 

Annotation Processing:
            The more advanced uses of annotations include writing an annotation processor that can read a Java program and take actions based on its             annotations.

            To make annotation information available at runtime, the annotation type itself must be annotated with @Retention(RetentionPolicy.RUNTIME),
            as follows:

 import java.lang.annotation.*;     
 @Retention(RetentionPolicy.RUNTIME)   
 @interface AnnotationForRuntime {       
  // Elements that give information              
  // for runtime processing       
 }    

Resources

1)Annotations
http://download.oracle.com/javase/tutorial/java/javaOO/annotations.html

2)An Introduction to Java Annotations
http://www.developer.com/java/other/article.php/3556176/An-Introduction-to-Java-Annotations.htm

3)Chapter 2. Annotations
http://www.eclipse.org/aspectj/doc/released/adk15notebook/annotations.html

4)Java Custom Annotations (Has good Example on Inherited meta-annotation)

http://technicalmumbojumbo.wordpress.com/2008/01/13/java-custom-annotations/

**********************************************************************************************************************************************

Java Command-line flags for the JVM

DisableExplicitGC

-XX:+DisableExplicitGC flag automatically turns a System.gc() call into a no-op

HeapDumpOnOutOfMemoryError

 -XX:+HeapDumpOnOutOfMemory

Setting this command tells the JVM to take a "heap dump snapshot" and save it to a file for processing.
You can specify the actual path to which the file is saved using the corresponding -XX:HeapDumpPath flag.

java -X lists all the non-standard (but mostly safe) arguments that the JVM provides — things like:

    * -Xint, which runs the JVM in interpreted mode (which can be useful for testing whether the JIT compiler is actually having an effect on your code or verifying if you have a bug in the JIT compiler).
    * -Xloggc:, which does the same thing as -verbose:gc but logs to a file instead of spe
    
Source
http://www.ibm.com/developerworks/java/library/j-5things11/index.html

Java,Java Command Line Flags

MySQL Joins

Mysql Inner Join returns the set of  only those records which matches in one table with another.
If I do a regular JOIN (with none of the keywords INNER, OUTER, LEFT or RIGHT),
then I get all records that match in the appropriate way in the two tables,
and records in both incoming tables that do not match are not reported:

mysql> select name, phone, selling from demo_people join demo_property
            on demo_people.pid = demo_property.pid;

If I do a LEFT JOIN, I get all records that match in the same way and
IN ADDITION I get an extra record for each unmatched record
in the left table of the join - thus ensuring (in following example) that every
 PERSON gets a mention ie from demo_people table:

mysql> select name, phone, selling from demo_people left join demo_property    
    on demo_people.pid = demo_property.pid;    
   
If I do a RIGHT JOIN, I get all the records that match and
IN ADDITION I get an extra record for each unmatched record in the right table
 of the join - in following example, that means that each property (from demo_property )
gets a mention even if we don't have seller details.

mysql> select name, phone, selling from demo_people right join demo_property
           on demo_people.pid = demo_property.pid;

Mysql Full Join is used to return all the records from both left and right outer join.
The joined table contain all records from both tables and fill nulls values
for those missing matches on either side.
The Full Join in Mysql is the outcome result set of left outer join and right outer join using UNION clause.

mysql>  select * from Roseindia as R left outer join newstrack as N
    -> on  R.empid=n.empid
    -> Union
    -> select * from Roseindia as R right outer join newstrack N
    -> on R.empid=n.empid;

An INNER JOIN does a full join, just like the first example, and
the word OUTER may be added after the word LEFT or RIGHT in the 2nd & 3rd examples -
it's provided for ODBC compatibility and doesn't add an extra capabilities.  

Mysql Natural Join is a specialization of equi-joins. The join compares all columns in
both tables that have the same column-name in both tables that have column name in
the joined table. The resulting set include only one column for each pair of the same named column.
More Info http://www.roseindia.net/sql/sqljoin/mysql-natural-join.shtml

CROSS JOIN:This type of join is the simplest join. The cross join result in cartesian product of all the records from two tables
mysql> select  * from roseindia cross  join newstrack;

INNER JOIN OR EQUI JOIN:This is the type of join where tables are combined based on a common column.
OUTER JOIN: Join is used to combine all rows of one table with  matching rows from the other table and also show unmatchable records from other table. It is used whenever multiple tables must be accessed through a SQL SELECT statement.

http://www.roseindia.net/sql/sqljoin/mysql-join-query.shtml

Sources:
http://www.wellho.net/mouth/158_MySQL-LEFT-JOIN-and-RIGHT-JOIN-INNER-JOIN-and-OUTER-JOIN.html
http://www.roseindia.net/sql/sqljoin/mysql-full-join.shtml
For more info:
http://www.keithjbrown.co.uk/vworks/mysql/mysql_p5.php

Tags:MySQL,SQL Joins,

Spring aware interfaces

For the most part, beans running in the Spring container, They don't know (or
even need to know) their names or even that they are running within a Spring
container. This is usually a good thing because if a bean is aware of the container,
then it becomes coupled with Spring and may not be able to exist outside of the container.

A well designed component should not have direct dependencies on its container,  
But sometimes, beans need to know more. Sometimes they need to know the
truth who they are and where they are running.

This capability comes in the form of the
Bean-NameAware,
BeanFactoryAware,
and ApplicationContextAware interfaces .

By implementing these three interfaces,
beans can be made aware of their name, their BeanFactory, and their ApplicationContext, respectively.

However, by implementing these interfaces, a bean becomes coupled with Spring.

The Spring container tells a bean what its name is through the BeanNameAware
interface.

public interface BeanNameAware {
  void setBeanName(String name);
}

Spring's ApplicationContextAware and BeanFactoryAware interfaces enable a
bean to be aware of its container. These interfaces declare a setApplication-
Context() method and a setBeanFactory() method, respectively.

When to use?

your bean needs access to parameterized text messages in a message source.
Or maybe it needs to be able to publish application
events for application event listeners to respond to. Whatever the case, your bean
should be aware of the container in which it lives.
Spring,Java,Spring FAQ,

UDH in Binary SMS / Multipart SMS messsages

Multipart SMS messaging

By design, SMS is developed to send up to 140 bytes of user data. All user data is send in the 'User Data' part of the SMS packet. Because SMS text messages are encoded using 7-bit characters you can send up to 160 characters in a single SMS message. When sending Unicode text, you can only send 70 characters per single SMS message.
It is however possible to split up text and data messages and send them using multiple SMS messages. The receiving party will be able to combine the messages to the original message. This is called Segmentation and Reassembly (SAR). When sending multipart SMS messages you will be charged for every single SMS message sent.

Sending Multipart Messages through a GSM phone or modem

To send enhanced content, a so called user data header (UDH) is added add the beginning of the user data block of the SMS. When using an UDH, there is less data left for user data in the User Data field (140 - length of UDH).
An UDH can be used to send multipart messages, smart messaging (ringtones, WAP push, pictures etc), voicemail indications and other services. In this article we will only discuss the use of UDH to send multipart text messages.
The UDH for message concatenation will only take 5 bytes, so there are 135 bytes left for the user data. When sending concatenated text messages, you can send 153 characters when using 7-bit text, when using Unicode 67 characters per part.

Byte	Value	Description
01	00	Information Element Identifier: Concatenated short message, 8bit reference number
02	03	Information Element Data Length (always 03 for this UDH)
03	A4	Information Element Data: Concatenated short message reference, should be same for all parts of a message
04	03	Information Element Data: Total number of parts
05	01	Information Element Data: Number of this part (1/3)

Example of a multipart message consisting of 3 parts containing 300 bytes:
SMS 1 User Data: 00 03 A4 03 01 [ 135 bytes of message data ]
SMS 2 User Data: 00 03 A4 03 02 [ 135 bytes of message data ]
SMS 3 User Data: 00 03 A4 03 03 [   30 bytes of message data ]
Source and Full Info

User Data Header (UDH)

The SMS that make up a concatenated SMS are related together by using the User Data Header (UDH) of an SMS. The UDH is a collection of bytes which can be put at the start of the SMS content. It can be used to control what happens to the rest of the content. For instance, it was used to send the older style of Nokia picture messages.
To indicate that the content contains a UDH, a flag on the SMS called the UDH Indicator (UDHI) must be turned on. This tells the phone that it must separate the UDH from the rest of the content.

Figure:Format of an SMS with a UDH

The phone separates the UDH by reading the first byte of the content. The number in this byte is the length of the rest of UDH and is called the User Data Header Length (UDHL). The phone then knows how many bytes make up the UDH and can separate it from the rest of the message.
As already stated, a UDH can control various things and so can contain various commands. These commands are called Information Elements (IE's). These IE's always take the following format: an Identity Element Identifier (IEI) followed by the Length of the IE Data (IEDL) followed by the IE Data (IED). A UDH can contain 1 or more of these IE's.

Source and For full Info

Resources

1)Parameters with Definitions for Sending SMS and MMS

2)Sending Binary Messages using NowSMS

JAVA Composition vs Aggregation

Association - it's a structural relationship between two classifiers i.e. classes or Use cases.
An Association specifies how objects are related to one another.
Aggegation & Composition are associations with following  qualities.

Aggegation is normally understood as a "has-a" relationship.
Here both the entities continue to have their own independent existence.
Aggregations are not allowed to be circular - that is, an object can not be "a part of itself".

Composition is normally understood as a "contains-a" relations.
It depicts a Whole-part relationship and the 'part' entity doesn't have its own independent existence.
Adds a lifetime responsibility to Aggregation.

In case of Aggregation, both the entities will continue to have their independent existence whereas in case of Composition the lifetime of the entity representing 'part' of the "whole-part" is governed by the entity representing 'whole'.

Aggregation represents a loose form of relationship as compared to that represented by Composition which depicts a stronger relationship.

Example:
An Employ can have Cabin(seating arrangement) and Food preferences.
Cabin can exist without employ ie Aggegation
Food Preferences of employ  cannot exist without employ as they are specific to that employ object -- Composition

Sources

Composition vs Aggregation. How is Association related to them?
Association Vs Aggregation Vs Composition   

Lables: JAVA FAQ,Aggregation,Composition,Association

Why we need MVC framework?

Why we need MVC framework?

Web applications differ from conventional websites in that web applications can create a dynamic response. Many websites deliver only static pages. A web application can interact with databases and business logic engines to customize a response.

Web applications based on JavaServer Pages sometimes commingle database code, page design code, and control flow code. In practice, we find that unless these concerns are separated, larger applications become difficult to maintain.

One way to separate concerns in a software application is to use a Model-View-Controller (MVC) architecture. The Model represents the business or database code, the View represents the page design code, and the Controller represents the navigational code.

The Struts framework is designed to help developers create web applications that utilize a MVC architecture.

In Struts 2, MVC are implemented by the action, result, and FilterDispatcher.

Resources for  Struts MVC

Struts 2 Tutorial

Implementing MVC Architecture using Struts

Struts framework and model-view-controller design pattern

Spring's Web MVC framework is designed around a DispatcherServlet  that dispatches requests to handlers, with configurable handler mappings, view resolution, locale and theme resolution as well as support for upload files.

Resources for  Spring MVC

Developing a Spring Framework MVC application step-by-step

Spring MVC Fast Tutorial(Quick n Simple)

Spring Tutorial

Formatting(Precision) Java Double /Float Decimal Digits

Formatting( Precision ) Java Double Decimal Digits

Formatters converts a floating point/double value  to a string  with a specified number  of decimals.

For formatting the decimal part of double/Float we can use NumberFormat or DecimalFormat .

The difference between them is that

        NumberFormat is an abstract class.
        DecimalFormat is a concrete implementation of NumberFormat.

Using NumberFormat:

NumberFormat is the abstract base class for all number formats. This class provides the interface for formatting and parsing numbers. NumberFormat also provides methods for determining which locales have number formats, and what their names are.
Number formats are generally not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally. 

    NumberFormat nfrmtr = NumberFormat.getNumberInstance();
    nfrmtr.setGroupingUsed(false);
    nfrmtr.setMaximumFractionDigits(2);
    nfrmtr.setMinimumFractionDigits(2);
    double dval = 0.0;
    System.out.println(nfrmtr.format(dval));

Using DecimalFormat:

DecimalFormat is a concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features designed to make it possible to parse and format numbers in any locale, including support for Western, Arabic, and Indic digits. It also supports different kinds of numbers, including integers (123), fixed-point numbers (123.4), scientific notation (1.23E4), percentages (12%), and currency amounts ($123). All of these can be localized. 

As DecimalFormat is implementing NumberFormat Class we can use the functions available in NumberFormat.

    DecimalFormat dfrmtr = new DecimalFormat("###.##");
    double dval = 0.0;
    System.out.println(dfrmtr.format(dval));     

Sample Program :

import java.text.DecimalFormat;
import java.text.NumberFormat;

public class DecimalFormatter {
    public static void main(String srgs[]){
   
        DecimalFormat dfrmtr = new DecimalFormat("###.##");

        NumberFormat nfrmtr = NumberFormat.getNumberInstance();
        nfrmtr.setGroupingUsed(false);
        nfrmtr.setMaximumFractionDigits(2);
        dfrmtr.setMinimumFractionDigits(2);
       
        double dval = 0.0;
        for (int i = 0; i < 10; i++)
        {
            dval += 0.111;
            System.out.println(dval+" "+dfrmtr.format(dval)+"  "+nfrmtr.format(dval));           
        }
    }
}

Source NumberFormat
Source DecimalFormat

Parameter retrieval from JSP with multipart/form-data

javax.servlet.HttpServletRequest.getParameter(String) returns null
when the ContentType is multipart/form-data


Solution A:


invoke getParameters() on com.oreilly.servlet.MultipartRequest
You can get files from here

Solution B:

1. download Jar file from here
2. invoke readHeaders() in org.apache.commons.fileupload.MultipartStream
JSP Example program  here

Solution C:


invoke getParameter on com.bigfoot.bugar.servlet.http.MultipartFormData

Solution D:

Use Struts. Struts 1.1 handles this automatically.

Reference: jGuru 

Comparison of Java ==, .equals(), compareTo(), and compare()

Source & Full Article


When you really need to know if two references are identical, use ==. But when you need to know if the objects themselves (not the references) are equal, use the  equals() method.


If you don't override a class's equals() method, you won't be able to use those objects as a key in a hashtable and you probably won't get accurate Sets, such that there are no conceptual duplicates.


Equality comparison: One way for primitives, Four ways for objects

Comparison	Objects
a == b, a != b	Compares references, not values. The use of == with object references is generally limited to the following: Comparing to see if a reference is null. Comparing two enum values. This works because there is only one object for each enum constant. You want to know if two references are to the same object
a.equals(b)	Compares values for equality. Because this method is defined in the Object class, from which all other classes are derived, it's automatically defined for every class. However, it doesn't perform an intelligent comparison for most classes unless the class overrides it. It has been defined in a meaningful way for most Java core classes. If it's not defined for a (user) class, it behaves the same as ==. It turns out that defining equals() isn't trivial; in fact it's moderately hard to get it right, especially in the case of subclasses. The best treatment of the issues is in Horstmann's Core Java Vol 1. [TODO: Add explanation and example]
a.compareTo(b)	Comparable interface. Compares values and returns an int which tells if the values compare less than, equal, or greater than. If your class objects have a natural order, implement the Comparable<T> interface and define this method. All Java classes that have a natural ordering implement this (String, Double, BigInteger, ...).
compare(a, b)	Comparator interface. Compares values of two objects. This is implemented as part of the Comparator<T>sort() or for use by sorting data structures such as TreeMap and TreeSet. You might want to create a Comparator object for the following. interface, and the typical use is to define one or more small utility classes that implement this, to pass to methods such as Multiple comparisons. To provide several different ways to sort something. For example, you might want to sort a Person class by name, ID, age, height, ... You would define a Comparator for each of these to pass to the sort() method. System class. To provide comparison methods for classes that you have no control over. For example, you could define a Comparator for Strings that compared them by length. Strategy pattern. To implement a strategy pattern, which is a situation where you want to represent an algorithm as an object that you can pass as a parameter, save in a data structure, etc. If your class objects have one natural sorting order, you may not need this.

Java 2 Platform, Enterprise Edition (J2EE) FAQ

What is the Java 2 Platform, Enterprise Edition (J2EE)?
The Java 2 Platform, Enterprise Edition (J2EE) is a set of coordinated specifications and practices that together enable solutions for developing, deploying, and managing multi-tier server-centric applications. Building on the Java 2 Platform, Standard Edition (J2SE), the J2EE platform adds the capabilities necessary to provide a complete, stable, secure, and fast Java platform to the enterprise level. It provides value by significantly reducing the cost and complexity of developing and deploying multi-tier solutions, resulting in services that can be rapidly deployed and easily enhanced.
What are the main benefits of the J2EE platform?
The J2EE platform provides the following:

• Complete Web services support. The J2EE platform provides a framework for developing and deploying web services on the Java platform. The Java API for XML-based RPC (JAX-RPC) enables Java technology developers to develop SOAP based interoperable and portable web services. Developers use the standard JAX-RPC programming model to develop SOAP based web service clients and endpoints. A web service endpoint is described using a Web Services Description Language (WSDL) document. JAX-RPC enables JAX-RPC clients to invoke web services developed across heterogeneous platforms. In a similar manner, JAX-RPC web service endpoints can be invoked by heterogeneous clients. For more info, see http://java.sun.com/webservices/.
• Faster solutions delivery time to market. The J2EE platform uses "containers" to simplify development. J2EE containers provide for the separation of business logic from resource and lifecycle management, which means that developers can focus on writing business logic -- their value add -- rather than writing enterprise infrastructure. For example, the Enterprise JavaBeans (EJB) container (implemented by J2EE technology vendors) handles distributed communication, threading, scaling, transaction management, etc. Similarly, Java Servlets simplify web development by providing infrastructure for component, communication, and session management in a web container that is integrated with a web server.
• Freedom of choice. J2EE technology is a set of standards that many vendors can implement. The vendors are free to compete on implementations but not on standards or APIs. Sun supplies a comprehensive J2EE Compatibility Test Suite (CTS) to J2EE licensees. The J2EE CTS helps ensure compatibility among the application vendors which helps ensure portability for the applications and components written for the J2EE platform. The J2EE platform brings Write Once, Run Anywhere (WORA) to the server.
• Simplified connectivity. J2EE technology makes it easier to connect the applications and systems you already have and bring those capabilities to the web, to cell phones, and to devices. J2EE offers Java Message Service for integrating diverse applications in a loosely coupled, asynchronous way. The J2EE platform also offers CORBA support for tightly linking systems through remote method calls. In addition, the J2EE platform has J2EE Connectors for linking to enterprise information systems such as ERP systems, packaged financial applications, and CRM applications.
• By offering one platform with faster solution delivery time to market, freedom of choice, and simplified connectivity, the J2EE platform helps IT by reducing TCO and simultaneously avoiding single-source for their enterprise software needs.

What technologies are included in the J2EE platform?
The primary technologies in the J2EE platform are: Java API for XML-Based RPC (JAX-RPC), JavaServer Pages, Java Servlets, Enterprise JavaBeans components, J2EE Connector Architecture, J2EE Management Model, J2EE Deployment API, Java Management Extensions (JMX), J2EE Authorization Contract for Containers, Java API for XML Registries (JAXR), Java Message Service (JMS), Java Naming and Directory Interface (JNDI), Java Transaction API (JTA), CORBA, and JDBC data access API.


For Source & more FAQs  sun.com

Definitions of JRE JDK JVM J2SE J2EE

Java SE Overview

There are two principal products in the Java SE platform family: Java SE Runtime Environment (JRE) and Java Development Kit (JDK).

Java Runtime Environment (JRE)
The Java Runtime Environment (JRE) provides the libraries, the Java Virtual Machine, and other components to run applets and applications written in the Java programming language. In addition, two key deployment technologies are part of the JRE: Java Plug-in, which enables applets to run in popular browsers; and Java Web Start, which deploys standalone applications over a network. It is also the foundation for the technologies in the Java 2 Platform, Enterprise Edition (J2EE) for enterprise software development and deployment. The JRE does not contain tools and utilities such as compilers or debuggers for developing applets and applications.
Java Development Kit (JDK)
The JDK is a superset of the JRE, and contains everything that is in the JRE, plus tools such as the compilers and debuggers necessary for developing applets and applications. The conceptual diagram above illustrates all the component technologies in Java SE platform and how they fit together.

Java SE API

The Java SE application programming interface (API) defines the manner by which an applet or application can make requests to and use the functionality available in the compiled Java SE class libraries. (The Java SE class libraries are also part of the Java SE platform.)
The Java SE API consists of core technologies, Desktop (or client) technologies, and other technologies.

• Core components provide essential functionality for writing powerful enterprise-worthy programs in key areas such as database access, security, remote method invocation (RMI), and communications.
• Desktop components add a full range of features to help build applications that provide a rich user experience – deployment products such as Java Plug-in, component modeling APIs such as JavaBeans, and a graphical user interface.
• Other components round out the functionality.

Java Virtual Machine
The Java Virtual Machine is responsible for the hardware- and operating system-independence of the Java SE platform, the small size of compiled code (bytecodes), and platform security.
Java Platform Tools
The Java SE platform works with an array of tools, including Integrated Development Environments (IDEs), performance and testing tools, and performance monitoring tools.

Java EE Overview

The Java 2 Platform, Enterprise Edition (J2EE) defines the standard for developing multitier enterprise applications. The J2EE platform simplifies enterprise applications by basing them on standardized, modular components, by providing a complete set of services to those components, and by handling many details of application behavior automatically, without complex programming.

The J2EE platform takes advantage of many features of the Java 2 Platform, Standard Edition (J2SE), such as "Write Once, Run Anywhere" portability, JDBC API for database access, CORBA technology for interaction with existing enterprise resources, and a security model that protects data even in internet applications. Building on this base, the Java 2 Platform, Enterprise Edition adds full support for Enterprise JavaBeans components, Java Servlets API, JavaServer Pages and XML technology. The J2EE standard includes complete specifications and compliance tests to ensure portability of applications across the wide range of existing enterprise systems capable of supporting the J2EE platform. In addition, the J2EE specification now ensures Web services interoperability through support for the WS-I Basic Profile.
The J2EE specification also supports emerging Web Services technologies through inclusion of the WS-I Basic Profile . WS-I Basic Profile compliance means that the developers can build applications on the J2EE platform as Web services that interoperate with Web services from non-J2EE compliant environments.

With simplicity, portability, scalability, and legacy integration, the J2EE platform is the platform for enterprise solutions.

For more info
                    Source(J2SE) sun.com
                    Source(J2EE) sun.com