My first article is published

Hi friends,

One of my article about struts and AJAX has been published in the following website .

http://struts.javabeat.net/articles/2007/06/ajax-support-in-struts-2-0/

This is the first article of mine being published.

Find an element in Array ( .NET )

Most of us will often need to find an element in an array. In C or C++, we can do this by using the FOR loops. In .NET 2.0, we have a build-in method, which is very simple and powerful too. It is similar to ArrayList’s Contains method. The following code snippet will show this.

Private Function MyMethod() as string
Dim countryCodes() As String
countryCodes = “IND,CHI,JPN”.Split(”,”.ToCharArray)
If Array.Exists(countryCodes, AddressOf CountryCodeStartsWith) Then
Return “Exists”
Else
Return “Not Exists”
End If
End Function

Private Function CountryCodeStartsWith(ByVal countryCode As String) As Boolean
dim Country as string = “INDIA”
If Country.startsWith(countryCode) Then
Return True
Else
Return False
End If
End Function


The Array.Exists has two parameters. The first one is nothing but an array where the element is to searched. The second part of the code , which will be confusing for beginners, is a delegate for the function. At the time of execution the elements in CountryCodes - Our Array - will be passed as a parameter to this delegate. also we can customize this matching function very easily.Hope this will help you.

- P

Difference between two Dates in C#.NET ?

To find the difference between two dates is very simple in VB — By using DateDiff method. But in C#, there is no direct method to do so. but there is a way to achive this.
For this we need to understand TimeSpan Class.

The following code snippet will show you how to find the difference.

DateTime startTime = DateTime.Now;
DateTime endTime = DateTime.Now.AddSeconds( 75 );
TimeSpan span = endTime.Subtract ( startTime );
Console.WriteLine( “Time Difference (seconds): ” + span.Seconds );
Console.WriteLine( “Time Difference (minutes): ” + span.Minutes );
Console.WriteLine( “Time Difference (hours): ” + span.Hours );
Console.WriteLine( “Time Difference (days): ” + span.Days );

By concatenating all this you will get the difference between two dates. You can also use span.Duration().

There are certain limitations to. The TimeSpan is capable of returning difference interms of Days, Hours, mins and seconds only. It is not having a property to show difference interms of Months and years.

Hope this will help you…

- P

Core Java Programming

      
       Core java seems very difficult now a days....

Check out the following statements

        int i=1;
        i+=i++;
        System.out.println(i);

What do you think is the output of the above statements..
It is just a simple assignment and increment statement.

in i++
            i gets incremented only after the execution of the line,
so i=1+1
            so i =2 in second line
but in the third line the value of i should be incremented but as per the execution of the statement,
Value of i is got as 2
What happened to the increment.....

=+ and ++ cant execute in the same statement and same variable

Why????

Velocity intergration with struts

            Velocity is a Java-based template engine. It permits anyone to use a simple yet powerful template language to reference objects defined in Java code.
            When Velocity is used for web development, Web designers can work in parallel with Java programmers to develop web sites according to the Model-View-Controller (MVC) model, meaning that web page designers can focus solely on creating a site that looks good, and programmers can focus solely on writing top-notch code.
        Velocity separates Java code from the web pages, making the web site more maintainable over its lifespan and providing a viable alternative to Java Server Pages (JSPs) or PHP.


Five steps to Velocity

The recipe for combining Struts and the Velocity Template Engine is simple and straightforward; in fact, you can do it in just five steps:

   1. Place the Velocity JARs in your classpath.
   2. Modify the web.xml file to recognize the Velocity servlet.
   3. Place the Velocity toolbox.xml under your application's WEB-INF directory.
   4. Modify your struts-config to point its views to Velocity templates instead of JSPs.
   5. Create a Velocity template for each page you want to render.

        Let us take up an example to understand better.When we search for an ISBN, it should display the contents of the isbn.. For this example let us execute the five steps..

Step 1. Place the Velocity JARs in WEB-INF/lib

The Step 1 is the easiest.Download velocity jars and place them in WEB-INF/lib

Step 2. Modify web.xml to recognize the Velocity servlet

The next step is to modify the Struts web.xml file to recognize the Velocity servlet and direct all resources

request ending with .vm to the Velocity servlet

<servlet>
  <servlet-name>velocity</servlet-name> //declare the Velocity servlet and give it a handle of velocity.
  <servlet-class>
    org.apache.velocity.tools.view.servlet.VelocityViewServlet
  </servlet-class>                                            

  <init-param>
    <param-name>org.apache.velocity.toolbox</param-name>// toolbox configuration location.
    <param-value>/WEB-INF/toolbox.xml</param-value>      
 </init-param>                                                 

 <load-on-startup>10</load-on-startup>
</servlet>

<!-- Map *.vm files to Velocity -->
<servlet-mapping>
  <servlet-name>velocity</servlet-name>
  <url-pattern>*.vm</url-pattern>      
</servlet-mapping>


The Velocity servlet takes a "toolbox" parameter. The toolbox is the place you declare the tools available to

your application.

Step 3. Place toolbox.xml under WEB-INF

The tool box bascially conntains all the tools. We define each of them with the key,scope and the class..

<?xml version="1.0"?>
<toolbox>
  <tool>
     <key>link</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.StrutsLinkTool
     </class>
  </tool>
  <tool>
     <key>msg</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.MessageTool
     </class>
  </tool>
  <tool>
     <key>errors</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.ErrorsTool
     </class>
  </tool>
  <tool>
     <key>form</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.FormTool
     </class>
  </tool>
  <tool>
     <key>tiles</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.TilesTool
     </class>
  </tool>
  <tool>
     <key>validator</key>
     <scope>request</scope>
     <class>
       org.apache.velocity.tools.struts.ValidatorTool
     </class>
  </tool>
</toolbox>

Step 4. Modify struts-config

    Struts config should be modified to support velocity. There is no much difference if we have a velocity template forward the action to a *.vm pattern

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC
          "-//Apache Software Foundation//DTD
             Struts Configuration 1.0//EN"
          "http://jakarta.apache.org/struts/dtds/
            struts-config_1_0.dtd">

<struts-config>
    <form-beans>
        <form-bean name="searchForm" type="app.SearchForm"/>
    </form-beans>

    <global-forwards>
        <forward name="welcome" path="/welcome.do"/>
    </global-forwards>
 
   <action-mappings>
        <action
            path="/welcome"
            type="org.apache.struts.actions.ForwardAction"
            parameter="/pages/search.vm"/>

        <action
            path="/search"
            type="app.SearchAction"
            name="searchForm"    
            scope="request"
            input="/pages/search.vm">
            <forward name="success"
              path="/pages/results.vm"/>
        </action>
    </action-mappings>
</struts-config>
Note that we can use both *.do and *.vm in the same application depending on the requirement.

Step 5. Create a Velocity template

velocity template for the example application's search page.

HTML>
  <HEAD>
    <TITLE>Search</TITLE>
  </HEAD>
  <BODY>
    $!errors.msgs() //$!errors.msgs() to get any error messages on the error-message queue.
    <FORM method="POST"
      action="$link.setAction('/search')"> //to obtain the URL for the search forward.
      <h2>Book Search</h2>
      ISBN:<INPUT type="text" name="isbn">
      <INPUT type="submit" value="Submit" name="submit">
    </FORM>
  </BODY>
</HTML>
     
Velocity template for the results page

<html>
  <body>

  <h1>Book Details</h1>
  <a href="$link.setForward("searchEntry")">Search
    again</a>

  <h3>$book.title</h3>

    <b>ISBN:</b>$book.isbn<br>
    <b>Title:</b>$book.title<br>
    <b>Author:</b>$book.author<br>
    <b>Price:</b>$book.price<br>
    <b>No Pages:</b>$book.pages<br>
    <b>Description:</b>$book.description<br>
    <b>Publisher:</b>$book.publisher<br>
  </body>
<html>

The action class sets a book object in session, which is retrieved and displayed in the velocity template.

This is a sample application with velocity and struts. Velocity does seems simpler than JSP's

Garbage Collection...

This is one topic which most of you know about. I was once asked by my senior to read about this.. And yes, i did read about that.

The Java Virtual Machine has 2 primary jobs:
# Execute Code
# Manage Memory

Memory Management involves 3 mail goals

# Allocate Memory from OS
# Manage Java Allocations
# Remove Garbage Objects

Garbage Collection involves around Memory management and it is one major advantage of Java over C or C++. One of our professors were very particular about freeing every memory used in C++ and I am happy that in Java, no need to care about it..
This is the second good reason for shifting to JAVA from C++. Not to forget the first reason "no pointers in java".

Memory allocation in Java is done in the heap, I mean there is one heap and objects are all allocated memory from this heap.

An object is created in the heap and is garbage-collected after there are no more references to it. Objects cannot be reclaimed or freed by explicit language directives.

Objects become garbage when there are no more references to the object.So, how do u say an object has no more references.

If no active threads have reference to this object, It is said eligible for GC.(All programs are said to me executed as threads and it starts executing from the main method.)

The garbage collector checks to see if there are any objects in the heap that are no longer being used by the application. If such objects exist, then the memory used by these objects can be reclaimed. (If no more memory is available for the heap, then the new operator throws an OutOfMemoryException.)

There are several GC algorithms in use today. Each algorithm is fine-tuned for a particular environment in order to provide the best performance. Let us see one of them.

Mark, Sweep and compact Algorithm.

Quite simple
# Mark: identify garbage
# Sweep: Find garbage on heap, de-allocate it
# Compact: collect all empty memory together

Every application has a set of roots. Roots identify storage locations, which refer to objects on the managed heap or to objects that are set to null. For example, all the global and static object pointers in an application are considered part of the application's roots. In addition, any local variable/parameter object pointers on a thread's stack are considered part of the application's roots. Finally, any CPU registers containing pointers to objects in the managed heap are also considered part of the application's roots. The list of active roots is maintained and is made accessible to the garbage collector's algorithm.



When the garbage collector starts running, it makes the assumption that all objects in the heap are garbage. In other words, it assumes that none of the application's roots refer to any objects in the heap. Now, the garbage collector starts walking the roots and building a graph of all objects reachable from the roots. For example, the garbage collector may locate a global variable that points to an object in the heap.

The collector continues to walk through all reachable objects recursively.

Once this part of the graph is complete, the garbage collector checks the next root and walks the objects again. As the garbage collector walks from object to object, if it attempts to add an object to the graph that it previously added, then the garbage collector can stop walking down that path. This serves two purposes. First, it helps performance significantly since it doesn't walk through a set of objects more than once. Second, it prevents infinite loops should you have any circular linked lists of objects.

Once all the roots have been checked, the garbage collector's graph contains the set of all objects that are somehow reachable from the application's roots; any objects that are not in the graph are not accessible by the application, and are therefore considered garbage. The garbage collector now walks through the heap linearly, looking for contiguous blocks of garbage objects (now considered free space). The garbage collector then shifts the non-garbage objects down in memory (using the standard memcpy function that you've known for years), removing all of the gaps in the heap.


There are many other Garbage collection algorithms too..

But what we need to know about them is
1) We never know when they get executed.
When the memory goes low, it is executed. We cannot manually start it. We can ask the compiler to do it but we cannot demand it to do it. It means when we ask it execute GC , it may or may not do it.

To ask the compiler.... use ,

System.gc();// call the static function

or

Runtime rt = new Runtime();
rt.gc();

2) We can manually make the object eligible to be Garbage Collected.. by pointing it to null

{
int i=5;
System.out.println(i);
i=null;
}
After the function of the object or variable is over , one can make it to point to null to make it eligible to be Garbage Collected.

3) It doesn't Guarantee to provide enough space for your application.
When you go out of memory u cant rely on GC to remove all garbage and give u enough memory to run your application. It will remove only what it feels as Garbage , even after removing the garbage you might run out of memory.

Overloading and Overridding

For long i thought , this is one of the simplest concept in java..
Both types of polymorphism have same method or function names .
In overriding , the function in the super class is over ridden by the subclasses and both have the same name , same parameters and same return types.

Over ridding example

class Animal
{
public void eat()
{
}
}

class Dog extends Animal
{
public void eat()//overriding eat of animal
{
}
public void befriendly()
{
}
}

public class Test
{
public static void main(String a[])
{
Animal a = new Dog();
a.eat()// dogs eat is called because at runtime a is an object if Dog.
a.befriendly();//Complier error.....
}
}

Remember
Animal a=new Dog (); means that the variable a is a animal reference variable at compile time and Dog's object during run time..
So, even though at runtime a.befriendly(); may run as a is a Dog's object , It will not compile because at compile time "a" is a animal reference.

In Overloading , the function in the same class or super class is overloaded whereby the functions have the same name and should have different number of parameters or different types of parameters and can have different return types.

Overloading Example

class Vehicle
{
public void parts(String part1)
{
}
}

class van extends Vehicle
{
public void parts(String head, String part1)// This is not over ridding the parts of the Vehicle class, it is overloading
{
}

public void parts(String head, String part1,String part2)
{
}
}

public class test2
{
public static void main(String a[])
{
Vehicle van = new van();
van.parts("asdfasd","fads");//compiler error
Van v= new Van();
v.parts("DF","Adsfa","Dfd");//legal
}
}

In here the Parts() of Vehicle is overloaded by parts of Van and not over ridden.
So when the compiler comes across
Vehicle van = new van();
It is Vehicles reference in the compile time , so
van.parts("asdfasd","fads");
results in a compiler error..
Though at run time it may seem perfect..

You should keep in mind that

= > The method to be overloaded is decided at compile time.
= > The method to be overridden is decided at run time.
= > You can run only after you have compiled..