Generics in java

Generics

 

When you take an element out of a Collection, you must cast it to the type of element that is stored in the collection. Besides being inconvenient, this is unsafe. The compiler does not check that your cast is the same as the collection's type, so the cast can fail at run time.

Generics provides a way for you to communicate the type of a collection to the compiler, so that it can be checked. Once the compiler knows the element type of the collection, the compiler can check that you have used the collection consistently and can insert the correct casts on values being taken out of the collection.

Here is a simple example taken from the existing Collections tutorial:

    // Removes 4-letter words from c. Elements must be strings
    static void expurgate(Collection c) {

        for (Iterator i = c.iterator(); i.hasNext(); )

          if (((String) i.next()).length() == 4)

            i.remove();

    }

Here is the same example modified to use generics:

    // Removes the 4-letter words from c
    static void expurgate(Collection c) {
        for (Iterator i = c.iterator(); i.hasNext(); )
          if (i.next().length() == 4)
            i.remove();
    }

When you see the code , read it as “of Type”; the declaration above reads as “Collection of String c.” The code using generics is clearer and safer. We have eliminated an unsafe cast and a number of extra parentheses. More importantly, we have moved part of the specification of the method from a comment to its signature, so the compiler can verify at compile time that the type constraints are not violated at run time. Because the program compiles without warnings, we can state with certainty that it will not throw a ClassCastException at run time. The net effect of using generics, especially in large programs, is improved readability and robustness.

To paraphrase Generics Specification Lead Gilad Bracha, when we declare c to be of type Collection, this tells us something about the variable c that holds true wherever and whenever it is used, and the compiler guarantees it (assuming the program compiles without warnings). A cast, on the other hand, tells us something the programmer thinks is true at a single point in the code, and the VM checks whether the programmer is right only at run time.

While the primary use of generics is collections, there are many other uses. “Holder classes,” such as WeakReference and ThreadLocal, have all been generified, that is, they have been retrofitted to make use of generics. More surprisingly, class Class has been generified. Class literals now function as type tokens, providing both run-time and compile-time type information. This enables a style of static factories exemplified by the getAnnotation method in the new AnnotatedElement interface:

    T getAnnotation(Class annotationType);

This is a generic method. It infers the value of its type parameter T from its argument, and returns an appropriate instance of T, as illustrated by the following snippet:

    Author a = Othello.class.getAnnotation(Author.class);

Prior to generics, you would have had to cast the result to Author. Also you would have had no way to make the compiler check that the actual parameter represented a subclass of Annotation.

Generics are implemented by type erasure: generic type information is present only at compile time, after which it is erased by the compiler. The main advantage of this approach is that it provides total interoperability between generic code and legacy code that uses non-parameterized types (which are technically known as raw types). The main disadvantages are that parameter type information is not available at run time, and that automatically generated casts may fail when interoperating with ill-behaved legacy code. There is, however, a way to achieve guaranteed run-time type safety for generic collections even when interoperating with ill-behaved legacy code.

The java.util.Collections class has been outfitted with wrapper classes that provide guaranteed run-time type safety. They are similar in structure to the synchronized and unmodifiable wrappers. These “checked collection wrappers” are very useful for debugging. Suppose you have a set of strings, s, into which some legacy code is mysteriously inserting an integer. Without the wrapper, you will not find out about the problem until you read the problem element from the set, and an automatically generated cast to String fails. At this point, it is too late to determine the source of the problem. If, however, you replace the declaration:

    Set s = new HashSet();

with this declaration:

    Set s = Collections.checkedSet(new HashSet(), String.class);

the collection will throw a ClassCastException at the point where the legacy code attempts to insert the integer. The resulting stack trace will allow you to diagnose and repair the problem.

You should use generics everywhere you can. The extra effort in generifying code is well worth the gains in clarity and type safety. It is straightforward to use a generic library, but it requires some expertise to write a generic library, or to generify an existing library. There is one caveat: You may not use generics (or any other Tiger features) if you intend to deploy the compiled code on a pre-5.0 virtual machine.

If you are familiar with C++'s template mechanism, you might think that generics are similar, but the similarity is superficial. Generics do not generate a new class for each specialization, nor do they permit “template metaprogramming.”

How many types of action clases are there in stuts |

How many types of action clases are there in stuts |

Apart from Action Class these are the following Action clases which you'ld find in Struts Framework ::::::::::::::

1)Dispatch Action :----- It dispatches to a public method that is named by the request parameter whose name is specified by the parameter property of the corresponding ActionMapping. This Action is useful for developers who prefer to combine many similar actions into a single Action class in order to simplify their application design.

2)Forward Action :----------It forwards to the context-relative URI specified by the parameter property of our associated ActionMapping.

3)IncludeAction :-----------It includes the context-relative URI specified by the parameter property of our associated ActionMapping.

and there are more actions but these are the main actions which you developers mainly use in your daiyl codings...........


Action -- As all know basic action class in which we will implement our bussiness logic

Include Action-- Similar to Include in our jsp

Forward Action-- Instead of directly forwarding from one JSP to Another We user Forward Action (If we do that directly it violates Struts MVC Architechture).

Dispatch Action-- Handling multiple operations in multiple methods. one method per operation instead of merging the entire logic in single execute method of action class.

Look up Dispatch Action-- Purpose is Similar to Dispatch action.Implementation is different Recommended not to use this.

Switch Action-- to switch between different modules in struts application



The important Dispatchers that struts provides includes : DispatchAction ActionDispatcher LookupDispatchAction and MappingDispatchAction.

DispatchAction: In this type of aggregation the action class must extend DispatchAction class as shown.

public final class CRUDDispatchAction extends DispatchAction {

public ActionForward create(ActionMapping mapping
ActionForm form
HttpServletRequest request
HttpServletResponse response) throws Exception {
return (mapping.findForward( success ));
}
...

and the action mapping will be as





in your jsp you can call this action as

Create
...

Observe that the above class extends DispatchAction and so you cannot use this method if your class already extends your (some) super class (eg. the class where the session is validated/invalidated). Here the user has to send a query string variable (methodToCall) to set the action name to call.

ActionDispatcher: This flavor of aggregation is same as DispatchAction except that we need not extend ActionDispatcher so we can use this method even if our class extends a super class. The following code snippet shows this scenario.


public final class CRUDActionDispatcher extends Action {

protected ActionDispatcher dispatcher new ActionDispatcher(this ActionDispatcher.DEFAULT_FLAVOR);

public ActionForward execute(ActionMapping mapping
ActionForm form
HttpServletRequest request
HttpServletResponse response) throws Exception {
return dispatcher.execute(mapping form request response);

The DEFAULT_FLAVOR field suggests that the default parameter is method if none is specified as parameter in struts-config.xml (eg . methodToCall).
ActionDispatcher flavor also needs methodToCall parameter to be set (using hidden variable or a query string) as in case of DispatchAction.

LookupDispatchAction: This type of aggregation is useful in situations where in you have multiple submit buttons in a single form. The class must extend LookupDispatchAction. However the great thing about this type is that its java script free. That means you need not set any hidden variables or pass query string however you must use submit buttons as shown.



...
The example Action class will be as follows

public class CRUDLookUpDispatchAction extends LookupDispatchAction {

protected Map getKeyMethodMap() {
Map map new HashMap();
map.put( button.create create );

return map;
}
public ActionForward create(ActionMapping mapping
ActionForm form
HttpServletRequest request
HttpServletResponse response) throws Exception {
return (mapping.findForward( success ));
}
Observe the getKeyMethodMap() method. The submit button names are specified in a Map and their keys comes from MessageResources file. Struts picks up the name from this file and redirects it to the value specified in the Map. The calling code in jsp however has multiple submit buttons only differing in their names.

MappingDispatchAction: This aggregation extends MappingDispatchAction class. This is the most useful type among the four types available. But as seen in other cases you can use this type only when your action does not extend any other action. The good thing about this type is that the action mappings can differ and so need not be the same as in all other cases. To illustrate this consider the below mappings.








Notice that in the first action mapping there is no form bean while in the second the bean name is specified. This means that the user has the flexibility to change the mapping according to his needs and hence not been contained to use a constant mapping for all the CRUD actions. Note that in all the other types of aggregations we must use the same mapping for all the CRUD actions.

Struts Interview Question

 1.What is MVC?

Model-View-Controller (MVC) is a design pattern put together to help control change. MVC decouples interface from business logic and data.

    * Model : The model contains the core of the application's functionality. The model encapsulates the state of the application. Sometimes the only functionality it contains is state. It knows nothing about the view or controller.

    * View: The view provides the presentation of the model. It is the look of the application. The view can access the model getters, but it has no knowledge of the setters. In addition, it knows nothing about the controller. The view should be notified when changes to the model occur.

    * Controller:The controller reacts to the user input. It creates and sets the model.

 2.What is a framework?

A framework is made up of the set of classes which allow us to use a library in a best possible way for a specific requirement.

3.What is Struts framework?

Struts framework is an open-source framework for developing the web applications in Java EE, based on MVC-2 architecture. It uses and extends the Java Servlet API. 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.

4.What are the components of Struts?

Struts components can be categorize into Model, View and Controller:

    * Model: Components like business logic /business processes and data are the part of model.

    * View: HTML, JSP are the view components.

    * Controller: Action Servlet of Struts is part of Controller components which works as front controller to handle all the requests.

5.What are the core classes of the Struts Framework?

Struts is a set of cooperating classes, servlets, and JSP tags that make up a reusable MVC 2 design.

    * JavaBeans components for managing application state and behavior.

    * Event-driven development (via listeners as in traditional GUI development).

    * Pages that represent MVC-style views; pages reference view roots via the JSF component tree.

6.What is ActionServlet?

ActionServlet is a simple servlet which is the backbone of all Struts applications. It is the main Controller component that handles client requests and determines which Action will process each received request. It serves as an Action factory – creating specific Action classes based on user’s request.

7.What is role of ActionServlet?

ActionServlet performs the role of Controller:

    * Process user requests

    * Determine what the user is trying to achieve according to the request

    * Pull data from the model (if necessary) to be given to the appropriate view,

    * Select the proper view to respond to the user

    * Delegates most of this grunt work to Action classes

    * Is responsible for initialization and clean-up of resources

8.What is the ActionForm?

ActionForm is javabean which represents the form inputs containing the request parameters from the View referencing the Action bean.

9.What are the important methods of ActionForm?

The important methods of ActionForm are : validate() & reset().

10.Describe validate() and reset() methods ?

validate() : Used to validate properties after they have been populated; Called before FormBean is handed to Action. Returns a collection of ActionError as ActionErrors. Following is the method signature for the validate() method.

public ActionErrors validate(ActionMapping mapping,HttpServletRequest request)

reset(): reset() method is called by Struts Framework with each request that uses the defined ActionForm. The purpose of this method is to reset all of the ActionForm's data members prior to the new request values being set.

public void reset() {}

 11.What is ActionMapping?

Action mapping contains all the deployment information for a particular Action bean. This class is to determine where the results of the Action will be sent once its processing is complete.

12.How is the Action Mapping specified ?

We can specify the action mapping in the configuration file called struts-config.xml. Struts framework creates ActionMapping object from configuration element of struts-config.xml file

    type="submit.SubmitAction"
         name="submitForm"
         input="/submit.jsp"
         scope="request"
         validate="true">
  
13.What is role of Action Class?

An Action Class performs a role of an adapter between the contents of an incoming HTTP request and the corresponding business logic that should be executed to process this request.

14.In which method of Action class the business logic is executed ?

In the execute() method of Action class the business logic is executed.

public ActionForward execute(
        ActionMapping mapping,
             ActionForm form,
             HttpServletRequest request,
             HttpServletResponse response)
          throws Exception ;

execute() method of Action class:

    * Perform the processing required to deal with this request
    * Update the server-side objects (Scope variables) that will be used to create the next page of the user interface
    * Return an appropriate ActionForward object


 15.What design patterns are used in Struts?
People who read this, also read:-  


* AJAX Interview Questions
    * Spring Questions
    * webMethods Certification
    * iBatis an alternative to Hibernate
    * Tibco Interview Questions

* AJAX Interview Questions
    * Spring Questions
    * webMethods Certification
    * iBatis an alternative to Hibernate
    * Tibco Interview Questions Struts is based on model 2 MVC (Model-View-Controller) architecture. Struts controller uses the command design pattern and the action classes use the adapter design pattern. The process() method of the RequestProcessor uses the template method design pattern. Struts also implement the following J2EE design patterns.
    * Service to Worker
    * Dispatcher View
    * Composite View (Struts Tiles)
    * Front Controller
    * View Helper
    * Synchronizer Token

 16.Can we have more than one struts-config.xml file for a single Struts application?

Yes, we can have more than one struts-config.xml for a single Struts application. They can be configured as follows:
action      
 
    org.apache.struts.action.ActionServlet
    config
 
     /WEB-INF/struts-config.xml,             
     /WEB-INF/struts-admin.xml,
     /WEB-INF/struts-config-forms.xml         
 
 18.What is the difference between session scope and request scope when saving formbean ?

when the scope is request,the values of formbean would be available for the current request.
when the scope is session,the values of formbean would be available throughout the session.

19.What are the important tags of struts-config.xml ?

The five important sections are:

 20.What are the different kinds of actions in Struts?
The different kinds of actions in Struts are:
    * ForwardAction
    * IncludeAction
    * DispatchAction
    * LookupDispatchAction
    * SwitchAction

21.What is DispatchAction?

The DispatchAction class is used to group related actions into one class. Using this class, you can have a method for each logical action compared than a single execute method. The DispatchAction dispatches to one of the logical actions represented by the methods. It picks a method to invoke based on an incoming request parameter. The value of the incoming parameter is the name of the method that the DispatchAction will invoke.

22.How to use DispatchAction?

To use the DispatchAction, follow these steps :

    * Create a class that extends DispatchAction (instead of Action)
    * In a new class, add a method for every function you need to perform on the service – The method has the same signature as the execute() method of an Action class.
    * Do not override execute() method – Because DispatchAction class itself provides execute() method.
    * Add an entry to struts-config.xml

 23.What is the use of ForwardAction?

The ForwardAction class is useful when you’re trying to integrate Struts into an existing application that uses Servlets to perform business logic functions. You can use this class to take advantage of the Struts controller and its functionality, without having to rewrite the existing Servlets. Use ForwardAction to forward a request to another resource in your application, such as a Servlet that already does business logic processing or even another JSP page. By using this predefined action, you don’t have to write your own Action class. You just have to set up the struts-config file properly to use ForwardAction.

24.What is IncludeAction?

The IncludeAction class is useful when you want to integrate Struts into an application that uses Servlets. Use the IncludeAction class to include another resource in the response to the request being processed.

25.What is the difference between ForwardAction and IncludeAction?

The difference is that you need to use the IncludeAction only if the action is going to be included by another action or jsp. Use ForwardAction to forward a request to another resource in your application, such as a Servlet that already does business logic processing or even another JSP page.

26.What is LookupDispatchAction?

The LookupDispatchAction is a subclass of DispatchAction. It does a reverse lookup on the resource bundle to get the key and then gets the method whose name is associated with the key into the Resource Bundle.

27.What is the use of LookupDispatchAction?

LookupDispatchAction is useful if the method name in the Action is not driven by its name in the front end, but by the Locale independent key into the resource bundle. Since the key is always the same, the LookupDispatchAction shields your application from the side effects of I18N.

 28.What is difference between LookupDispatchAction and DispatchAction?

The difference between LookupDispatchAction and DispatchAction is that the actual method that gets called in LookupDispatchAction is based on a lookup of a key value instead of specifying the method name directly.

29.What is SwitchAction?

The SwitchAction class provides a means to switch from a resource in one module to another resource in a different module. SwitchAction is useful only if you have multiple modules in your Struts application. The SwitchAction class can be used as is, without extending.

30.What if element has declaration with same name as global forward?

In this case the global forward is not used. Instead the element’s takes precendence.

  31.What is DynaActionForm?

A specialized subclass of ActionForm that allows the creation of form beans with dynamic sets of properties (configured in configuration file), without requiring the developer to create a Java class for each type of form bean.

32.What are the steps need to use DynaActionForm?

Using a DynaActionForm instead of a custom subclass of ActionForm is relatively straightforward. You need to make changes in two places:

    * In struts-config.xml: change your to be an org.apache.struts.action.DynaActionForm instead of some subclass of ActionForm

            * In your Action subclass that uses your form bean:
          o import org.apache.struts.action.DynaActionForm
          o downcast the ActionForm parameter in execute() to a DynaActionForm
          o access the form fields with get(field) rather than getField()

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionMessage;
import org.apache.struts.action.ActionMessages;


import org.apache.struts.action.DynaActionForm;

public class DynaActionFormExample extends Action {
 public ActionForward execute(ActionMapping mapping, ActionForm form,
   HttpServletRequest request, HttpServletResponse response)
            throws Exception {            
  DynaActionForm loginForm = (DynaActionForm) form;
                ActionMessages errors = new ActionMessages();       
        if (((String) loginForm.get("userName")).equals("")) {
            errors.add("userName", new ActionMessage(
                            "error.userName.required"));
        }
        if (((String) loginForm.get("password")).equals("")) {
            errors.add("password", new ActionMessage(
                            "error.password.required"));
        }
        ...........


33.How to display validation errors on jsp page?

tag displays all the errors. iterates over ActionErrors request attribute.

34.What are the various Struts tag libraries?

The various Struts tag libraries are:

    * HTML Tags
    * Bean Tags
    * Logic Tags
    * Template Tags
    * Nested Tags
    * Tiles Tags

35.What is the use of ?

repeats the nested body content of this tag over a specified collection.
36.What are differences between and

: is used to retrive keyed values from resource bundle. It also supports the ability to include parameters that can be substituted for defined placeholders in the retrieved string.

: is used to retrieve and print the value of the bean property. has no body.

37.How the exceptions are handled in struts?
Exceptions in Struts are handled in two ways:

    * Programmatic exception handling :
      Explicit try/catch blocks in any code that can throw exception. It works well when custom value (i.e., of variable) needed when error occurs.

    * Declarative exception handling :You can either define handling tags in your struts-config.xml or define the exception handling tags within tag. It works well when custom page needed when error occurs. This approach applies only to exceptions thrown by Actions.
 
            type="java.lang.NullPointerException"
            path="/WEB-INF/errors/null.jsp"/>

or

           type="package.SomeException"
           path="/WEB-INF/somepage.jsp"/>

38.What is difference between ActionForm and DynaActionForm?

    * An ActionForm represents an HTML form that the user interacts with over one or more pages. You will provide properties to hold the state of the form with getters and setters to access them. Whereas, using DynaActionForm there is no need of providing properties to hold the state. Instead these properties and their type are declared in the struts-config.xml
    * The DynaActionForm bloats up the Struts config file with the xml based definition. This gets annoying as the Struts Config file grow larger.
    * The DynaActionForm is not strongly typed as the ActionForm. This means there is no compile time checking for the form fields. Detecting them at runtime is painful and makes you go through redeployment.
    * ActionForm can be cleanly organized in packages as against the flat organization in the Struts Config file.
    * ActionForm were designed to act as a Firewall between HTTP and the Action classes, i.e. isolate and encapsulate the HTTP request parameters from direct use in Actions. With DynaActionForm, the property access is no different than using request.getParameter( .. ).
    * DynaActionForm construction at runtime requires a lot of Java Reflection (Introspection) machinery that can be avoided.
 39.How can we make message resources definitions file available to the Struts framework environment?
We can make message resources definitions file (properties file) available to Struts framework environment by adding this file to struts-config.xml.

Oracle sues Google over use of Java in Android By Eric Bangeman | Last updated about 8 hours ago

Oracle sues Google over use of Java in Android
By Eric Bangeman | Last updated about 8 hours ago

In a tersely worded press release, Oracle announced that it was suing Google for patent and copyright infringement over its use of the Java programming language for Android development. Neither the press release nor the complaint filed in the US District Court for Northern California go into any significant detail.

"In developing Android, Google knowingly, directly, and repeatedly infringed Oracle's Java-related intellectual property" an Oracle spokesperson said in a statement. "This lawsuit seeks appropriate remedies for their infringement."

Google makes heavy use of Java in the Android software development kit (SDK). Third-party developers code Android apps in Java, which is then translated into bytecode that runs in Dalvik, Google's own custom VM. Google subsequently released the Android Native Development Kit, which allows developers to build Android components with C and C++. It is not intended to replace the Java development model, though, which remains the strongly preferred means of Android development.

Aside from its use of Java syntax, Google's Android SDK implementation is largely independent from Oracle's. It uses its own compiler and runtime tailored specifically for Android.

Originally developed by Sun Microsystems as a "write-once, run anywhere" language, Java became the property of Oracle when it purchased Sun in April 2009. Java was a significant part of the deal for Oracle, as it has been a major player in the world of Java middleware.

Prior to its acquisition by Oracle, Sun proved hostile to the Harmony Project, the Apache Software Foundation's attempt to build an Apache-licensed Java SE implementation. In addition to Dalvik, Google also uses Harmony's class libraries in Android, which has apparently aroused the ire of Oracle.

In the complaint, a copy of which was posted on VentureBeat, Oracle claims that Android, the Android SDK, and Dalvik all infringe on seven patents owned by the database giant. Oracle also accuses Google of "knowingly, willingly, and unlawfully" copying, preparing, publishing, and distributed its IP.

The fact that Oracle has chosen to sue Google over its implementation is sure to cause concern in the wider Java community.

Neither Oracle nor Google responded to our requests for comment in time for publication.





larry-ellisonOracle announced today that it has filed suit against Google for alleged patent and copyright infringement.

The business software giant headed by Larry Ellison (pictured) said that the suit concerns intellectual property related to the Java programming language, which Oracle purchased through its acquisition of Sun Microsystems. In a press release, Oracle spokeswoman Karen Tillman said, “In developing Android, Google knowingly, directly and repeatedly infringed Oracle’s Java-related intellectual property.”

I’ve embedded a copy of Oracle’s complaint below, which includes more details about the company’s allegations. From the complaint: “Google’s Android competes with Oracle America’s Java as an operating system software platform for cellular telephones and other mobile devices. … Google has been aware of Sun’s patent portfolio, including the patents at issue, since the middle of this decade, since Google hired certain former Sun Java engineers.”

A Google spokesman told me that the company hasn’t been served with the complaint yet, so it can’t comment. There’s a good chance that Oracle raised the issue with Google before filing suit, so it may be worth quoting the boilerplate language in Google’s latest earnings report about how Google is involved in legal claims “from time to time,” but that the company believes “the resolution of our current pending matters will not have a material adverse effect on our business.”

Reading XLS Content Using Java Code.

Reading XLS Content Using Java Code.

We can read XLS content cell by cell by using java code.For this we need jxl jar file.

The following is the simple example to read .xls file and display its content.

Following is the link to download jxl jar file

http://fisheye1.cenqua.com/viewrep/jptools/jpTools/lib

import java.io.File;

import java.io.*;

import jxl.*;

import java.util.*;

import jxl.Workbook;

import jxl.read.biff.*;

class ReadXls

{

public static void main(String[] args)

{

try

{

String filename = "C:/ExcelFileName.xls";

WorkbookSettings ws = new WorkbookSettings();

ws.setLocale(new Locale("en", "EN"));

Workbook workbook = Workbook.getWorkbook( new File(filename),ws);

Sheet s = workbook.getSheet(0);

System.out.println("Sheet Content::"+s.getName());

readDataSheet(s);

workbook.close();

}

catch (IOException e)

{

e.printStackTrace();

}

catch (BiffException e)

{

e.printStackTrace();

}

private static void readDataSheet(Sheet s)

{

// Find the labeled cell from sheet

System.out.println(lc.getString());

//gets the value of cell at specified column and row

DateCell dc = (DateCell) s.getCell(20,1);

System.out.println(dc);

}

}

Jackie Evancho, 10, amazes on 'America's Got Talent'

You've got to listen to Jackie Evancho, 10, who stole the show last night on America's Got Talent. And, yes, she's being called "the next Susan Boyle."

GCT Coimbatore MBA & MCA Counselling 2010 | TN MBA/MCA Counselling 2010 | GCT Counselling Schedule | www.gct.ac.in

GCT Coimbatore MBA & MCA Counselling 2010 | TN MBA/MCA Counselling 2010 | GCT Counselling Schedule | www.gct.ac.in

The Government College of Technology, Coimbatore formerly known as the Arthur Hope College of Technology, was started in July 1945 in accordance with the general policy of the then Government of Madras to give high priority to technical education under the post-war reconstruction schemes in order to meet the demand for trained engineers for various

Anna University Tirunelveli examination results

Visit Anna University, Tirunelveli website www.annauniv.edu.in for information on Academic programmes & Courses offered by the University, Admission procedures, list of Affiliated colleges and Curriculum Syllabi for U.G./P.G Degree programmes.



Anna University Tirunelveli students can access their semester examination results and latest exam related notifications on the website.