MindsMapped offers highly advanced job oriented Java J2ee Training Online, java j2ee Classes, Online Java J2ee Course,Java J2ee Certification, Online Java J2ee Training and Placement,java interview questions, Java J2ee Skillset, Java J2ee Interview questions and answers. Java Training, Online Java Training, java training and Placement.

java interview questions, Java J2ee Training Online, java j2ee Classes, Online Java J2ee Course,Java J2ee Certification, Online Java J2ee Training and Placement, Java J2ee Skillset, Java J2ee Interview questions and answers. Java Training, Online Java Training, java training and Placement.

 

CONTACT  US

 
ENROLL NOW
Call Us
(+1) 385 743 0999
(+1) 385 237 9777
Email Us
info@mindsmapped.com
Receive Call Back

Java / J2EE Course Contents

MindsMapped online Java / J2EE Course Contents

MindsMapped Online IT Training Reviews Control System Training,

    	
Part I: Core Java
    Chapter 1: The History and Evolution of Java 
        1.Java's Lineage
            1.	The Birth of Modern Programming: C
            2.	C++: The Next Step
            3.	The Stage Is Set for Java
        2.The Creation of Java
            1.  The C# Connection
        3.How Java Changed the Internet
            1.  Java Applets
            2.	Security
            3.	Portability
            4.	Java's Magic: The Bytecode
            5.	Servlets: Java on the Server Side
            6.	The Java Buzzwords
                1.  Simple
                2.  Object-Oriented
                3.  Robust
                4.  Multithreaded
                5.  Architecture-Neutral
                6.  Interpreted and High Performance
                7.  Distributed
                8.  Dynamic
                7.  The Evolution of Java
                8.  Java SE 8
                9.  A Culture of Innovation    
    Chapter 2: An Overview of Java
        1.  Object-Oriented Programming
            1.	Two Paradigms
            2.	Abstraction
            3.	The Three OOP Principles
        2.  A First Simple Program
            1.	Entering the Program
            2.	Compiling the Program
            3.	A Closer Look at the First Sample Program
        3.  A Second Short Program
        4.  Two Control Statements
            1.	The if Statement
            2.	The for Loop
        5.  Using Blocks of Code
        6.  Lexical Issues
            1.	Whitespace
            2.	Identifiers
            3.	Literals
            4.	Comments
            5.	Separators
            6.	The Java Keywords
            7.	The Java Class Libraries
    Chapter 3: Data Types, Variables, and Arrays   
        1.  Java Is a Strongly Typed Language
        2.  The Primitive Types
        3.  Integers
             1.  byte
             2.  short
             3.  int
             4.  long
        4.  Floating-Point Types
            1.  float
            2.  double
        5.  Characters
        6.  Booleans
        7.  A Closer Look at Literals
            1.  Integer Literals
            2.  Floating-Point Literals
            3.  Boolean Literals
            4.  Character Literals
            5.  String Literals
        8.  Variables
            1.  Declaring a Variable
            2.  Dynamic Initialization
            3.  The Scope and Lifetime of Variables
        9.  Type Conversion and Casting
            1.  Java's Automatic Conversions
            2.  Casting Incompatible Types
        10. Automatic Type Promotion in Expressions
            1.  The Type Promotion Rules
        11. Arrays
            1.  One-Dimensional Arrays
            2.	Multidimensional Arrays
            3.	Alternative Array Declaration Syntax
        12. A Few Words About Strings
        13. A Note to C/C++ Programmers About Pointers
    Chapter 4: Operators
        1.  Arithmetic Operators
            1.  The Basic Arithmetic Operators
            2.  The Modulus Operator
            3.  Arithmetic Compound Assignment Operators
            4.  Increment and Decrement
        2.  The Bitwise Operators
            1.  The Bitwise Logical Operators
            2.  The Left Shift
            3.  The Right Shift
            4.  The Unsigned Right Shift
            5.  Bitwise Operator Compound Assignments
        3.  Relational Operators
        4.  Boolean Logical Operators
			1.  Short-Circuit Logical Operators
        5.  The Assignment Operator
        6.  The ? Operator
        7.  Operator Precedence
        8.  Using Parentheses
    Chapter 5: Control Statement
        1.  Java's Selection Statements
            1.  if
            2.  switch  
        2.  Iteration Statements
            1.  while
            2.  do-while
            3.  for
            4.  The For-Each Version of the for Loop
            5.  Nested Loops
        3.  Jump Statements
            1.  Using break
            2.  Using continue 
    Chapter 6: Introducing Classes
        1.  Class Fundamentals
            1. The General Form of a Class
            2. A Simple Class
        2.  Declaring Objects
            1. A Closer Look at new
        3.  Assigning Object Reference Variables
        4.  Introducing Methods
            1.  Adding a Method to the Box Class
            2.  Returning a Value
            3.  Adding a Method That Takes Parameters
        5.  Constructors
            1.  Parameterized Constructors
        6.  The this Keyword
            1.  Instance Variable Hiding        
        7.  Garbage Collection
        8.  The finalize( ) Method
        9.  A Stack Class
    Chapter 7: A Closer Look at Methods and Classes
		1.  Overloading Methods
            1.  Overloading Constructors
        2.  Using Objects as Parameters
        3.  A Closer Look at Argument Passing
        4.  Returning Objects
        5.  Recursion
        6.  Introducing Access Control
        7.  Understanding static
        8.  Introducing final
        9.  Arrays Revisited
        10. Introducing Nested and Inner Classes
        11. Exploring the String Class
        12. Using Command-Line Arguments
        13. Varargs: Variable-Length Arguments
            1.  Overloading Vararg Methods
            2.  Varargs and Ambiguity
    Chapter 8: Inheritance
        1.  Inheritance Basics
            1.  Member Access and Inheritance
            2.  A More Practical Example
            3.  A Superclass Variable Can Reference a Subclass Object
        2.  Using super
            1.  Using super to Call Superclass Constructors
            2.  A Second Use for super
            3.  Creating a Multilevel Hierarchy
            4.  When Constructors Are Executed
            5.  Method Overriding
            6.  Dynamic Method Dispatch
        	    1.  Why Overridden Methods?
                2.  Applying Method Overriding
            7.  Using Abstract Classes
            8.  Using final with Inheritance
                1.  Using final to Prevent Overriding
                2.  Using final to Prevent Inheritance
            9.  The Object Class
    Chapter 9: Packages and Interfaces
        1.  Packages
            1.  Defining a Package
            2.  Finding Packages and CLASSPATH
            3.  A Short Package Example
        2.  Access Protection
            1.  An Access Example
        3.  Importing Packages
        4.  Interfaces
            1.  Defining an Interface
            2.  Implementing Interfaces
            3.  Nested Interfaces
            4.  Applying Interfaces
            5.  Variables in Interfaces
            6.  Interfaces Can Be Extended
		5.  Default Interface Methods
            1.  Default Method Fundamentals
            2.  A More Practical Example
            3.  Multiple Inheritance Issues
        6.  Use static Methods in an Interface
        7.  Final Thoughts on Packages and Interfaces
    Chapter 10: Exception Handling
        1.  Exception-Handling Fundamentals
        2.  Exception Types
        3.  Uncaught Exceptions
        4.  Using try and catch
            1.  Displaying a Description of an Exception
        5.  Multiple catch Clauses
        6.  Nested try Statements
        7.  throw
        8.  throws
        9.  finally
        10. Java's Built-in Exceptions
        11. Creating Your Own Exception Subclasses
        12. Chained Exceptions
        13. Three Recently Added Exception Features
        14. Using Exceptions
    Chapter 11: Multithreaded Programming  
        1.  The Java Thread Model
            1.  Thread Priorities
            2.  Synchronization
            3.  Messaging
            4.  The Thread Class and the Runnable Interface
        2.  The Main Thread
        3.  Creating a Thread
            1.  Implementing Runnable
            2.  Extending Thread
            3.  Choosing an Approach
            4.  Creating Multiple Threads
            5.  Using isAlive( ) and join( )
            6.  Thread Priorities
            7.  Synchronization
                1.  Using Synchronized Methods
                2.  The synchronized Statement
            8.  Interthread Communication
                1.  Deadlock
            9.  Suspending, Resuming, and Stopping Threads
           10.  Obtaining A Thread's State
           11.  Using Multithreading
    Chapter 12: Enumerations, Autoboxing, and Annotations (Metadata)
        1.  Enumerations 
            1.  Enumeration Fundamentals
            2.  The values( ) and valueOf( ) Methods
            3.  Java Enumerations Are Class Types
            4.  Enumerations Inherit Enum
            5.  Another Enumeration Example
        2.  Type Wrappers
            1.  Character
            2.  Boolean
            3.  The Numeric Type Wrappers
        3.  Autoboxing
            1.  Autoboxing and Methods
            2.  Autoboxing/Unboxing Occurs in Expressions
            3.  Autoboxing/Unboxing Boolean and Character Values
            4.  Autoboxing/Unboxing Helps Prevent Errors
            5.  A Word of Warning
        4.  Annotations (Metadata)
            1.  Annotation Basics
            2.  Specifying a Retention Policy
            3.  Obtaining Annotations at Run Time by Use of Reflection
            4.  The AnnotatedElement Interface
            5.  Using Default Values
            6.  Marker Annotations
            7.  Single-Member Annotations
            8.  The Built-In Annotations
        5.  Type Annotations
        6.  Repeating Annotations
            1.  Some Restrictions 
    Chapter 13: I/O and Other Topics
        1.  I/O Basics
            1.  Streams
            2.  Byte Streams and Character Streams
            3.  The Predefined Streams
        2.  Reading Console Input
            1.  Reading Characters
            2.  Reading Strings
            3.  Writing Console Output
            4.  The PrintWriter Class
            5.  Reading and Writing Files
            6.  Automatically Closing a File
            7.  Applet Fundamentals
            8.  The transient and volatile Modifiers
            9.  Using instanceof
           10.  strictfp
           11.  Native Methods
           12.  Problems with Native Methods
           13.  Using assert
				1.  Assertion Enabling and Disabling Options
           14.  Static Import
           15.  Invoking Overloaded Constructors Through this( )
           16.  Compact API Profiles       
    Chapter 14: Generics
        1.  What Are Generics?
        2.  A Simple Generics Example
            1.  Generics Work Only with Reference Types
            2.  Generic Types Differ Based on Their Type Arguments
            3.  How Generics Improve Type Safety
        3.  A Generic Class with Two Type Parameters
        4.  The General Form of a Generic Class
        5.  Bounded Types
        6.  Using Wildcard Arguments
            1.  Bounded Wildcards
        7.  Creating a Generic Method
            1.  Generic Constructors
        8.  Generic Interfaces
        9.  Raw Types and Legacy Code
        10. Generic Class Hierarchies
            1.  Using a Generic Superclass
            2.  A Generic Subclass
            3.  Run-Time Type Comparisons Within a Generic Hierarchy
            4.  Casting
            5.  Overriding Methods in a Generic Class
        11. Type Inference with Generics
        12. Erasure
            1. Bridge Methods
        13. Ambiguity Errors
        14. Some Generic Restrictions
            1. Type Parameters Can't Be Instantiated
            2. Restrictions on Static Members
            3. Generic Array Restrictions
            4.	Generic Exception Restriction  
    Chapter 15: Lambda Expressions
            1.  Introducing Lambda Expressions
	            1.  Lambda Expression Fundamentals
                2.  Functional Interfaces
                3.  Some Lambda Expression Examples
            2.  Block Lambda Expressions
            3.  Generic Functional Interfaces
            4.  Passing Lambda Expressions as Arguments
            5.  Lambda Expressions and Exceptions
            6.  Lambda Expressions and Variable Capture
            7.  Method References
                1.  Method References to static Methods
                2.  Method References to Instance Methods
                3.  Method References with Generics
            8.  Constructor References
            9.  Predefined Functional Interfaces
Part II: Core Java Library
    Chapter 1: String Handling   
        1. The String Constructors
        2.  String Length
        3.  Special String Operations
            1.  String Literals
            2.  String Concatenation
            3.  String Concatenation with Other Data Types
            4.  String Conversion and toString( )
        4.  Character Extraction
            1.  charAt( )
            2.  getChars( )
            3.  getBytes( )
            4.  toCharArray( )
            5.  String Comparison
                1.  equals( ) and equalsIgnoreCase( )
                2.  regionMatches( )
                3.  startsWith( ) and endsWith( )
                4.  equals( ) Versus ==
                5.  compareTo( )
                6.  Searching Strings
                7.  Modifying a String
                    1.  substring( )
                    2.  concat( )
                    3.  replace( )
                    4.  trim( )
                8.  Data Conversion Using valueOf( )
                9.  Changing the Case of Characters Within a String
                10. Joining Strings
                11. Additional String Methods
                12. StringBuffer
                    1.  StringBuffer Constructors
                    2.  length( ) and capacity( )
                    3.  ensureCapacity( )
                    4.  setLength( )
                    5.  charAt( ) and setCharAt( )
                    6.  getChars( )
                    7.  append( )
                    8.  insert( )
                    9.  reverse( )
                    10. delete( ) and deleteCharAt( )
                    11. replace( )
                    12. substring( )
                    13. Additional StringBuffer Methods
                13. StringBuilder 
    Chapter 2: Exploring java.lang
        1.  Primitive Type Wrappers
            1.  Number
            2.  Double and Float
            3.  Understanding isInfinite( ) and isNaN( )
            4.  Byte, Short, Integer, and Long
            5.  Character
            6.  Additions to Character for Unicode Code Point Support
            7.  Boolean
        2.  Void
        3.  Process
        4.  Runtime
            1.  Memory Management
            2.  Executing Other Programs
        5.  ProcessBuilder
        6.  System
            1.  Using currentTimeMillis( ) to Time Program Execution.
            2.  Using arraycopy( )
            3.  Environment Properties
        7.  Object
        8.  Using clone( ) and the Cloneable Interface
        9.  Class
        10. ClassLoader
        11. Math
            1.  Trigonometric Functions
            2.  Exponential Functions
            3.  Rounding Functions
            4.  Miscellaneous Math Methods
        12. StrctMath
        13. Compiler
        14. Thread, ThreadGroup, and Runnable
            1.  The Runnable Interface
            2.  Thread
            3.  ThreadGroup
        15. ThreadLocal and InheritableThreadLocal
        16. Package
        17. RuntimePermission
        18. Throwable
        19. SecurityManager
        20. StackTraceElement
        21. Enum
        22. ClassValue
        23. The CharSequence Interface
        24. The Comparable Interface
        25. The Appendable Interface
        26. The Iterable Interface
        27. The Readable Interface
        28. The AutoCloseable Interface
        29. The Thread.UncaughtExceptionHandler Interface
        30. The java.langSubpackages
            1.  java.lang.annotation
            2.  java.lang.instrument
            3.  java.lang.invoke
            4.  java.lang.management
            5.  java.lang.ref
            6.  java.lang.reflect
    Chapter 3: java.util Part 1: The Collections Framework 
        1.  Collections Overview
        2.  JDK 5 Changed the Collections Framework
            1.  Generics Fundamentally Changed the Collections Framework
            2.  Autoboxing Facilitates the Use of Primitive Types
            3.  The For-Each Style for Loop
        3.  The Collection Interfaces
            1.  The Collection Interface
            2.  The List Interface
            3.  The Set Interface
            4.  The SortedSet Interface
            5.  The NavigableSet Interface
            6.  The Queue Interface
            7.  The Deque Interface
        4.  The Collection Classes
            1.  The ArrayList Class
            2.  The LinkedList Class
            3.  The HashSet Class
            4.  The LinkedHashSet Class
            5.  The TreeSet Class
            6.  The PriorityQueue Class
            7.  The ArrayDeque Class
            8.  The EnumSet Class
        5.  Accessing a Collection via an Iterator
            1.  Using an Iterator
            2.  The For-Each Alternative to Iterators
        6.  Spliterators
        7.  Storing User-Defined Classes in Collections
        8.  The RandomAccess Interface
        9.  Working with Maps
            1.  The Map Interfaces
            2.  The Map Classes
        10. Comparators
            1.  Using a Comparator
        11. The Collection Algorithms
        12. Arrays
        13. The Legacy Classes and Interfaces
            1.  The Enumeration Interface
            2.  Vector
            3.  Stack
            4.  Dictionary
            5.  Hashtable
            6.  Properties
            7.  Using store( ) and load( )
        14. Parting Thoughts on Collections
    Chapter 4: java.util Part 2: More Utility Classes
        1.  StringTokenizer
        2.  BitSet
        3.  Optional, OptionalDouble, OptionalInt, and OptionalLong
        4.  Date
        5.  Calendar
        6.  GregorianCalendar
        7.  TimeZone
        8.  SimpleTimeZone
        9.  Locale
        10. Random
        11. Observable
            1.  The Observer Interface
            2.  An Observer Example
        12. Timer and TimerTask
        13. Currency
        14. Formatter
            1.  The Formatter Constructors
            2.  The Formatter Methods
            3.  Formatting Basics
            4.  Formatting Strings and Characters
            5.  Formatting Numbers
            6.  Formatting Time and Date
            7.  The %n and %% Specifiers
            8.  Specifying a Minimum Field Width
            9.  Specifying Precision
            10. Using the Format Flags
            11. Justifying Output
            12. The Space, +, 0, and ( Flags
            13. The Comma Flag
            14. The # Flag
            15. The Uppercase Option
            16. Using an Argument Index
            17. Closing a Formatter
            18. The Java printf( ) Connection
        15. Scanner
            1.  The Scanner Constructors
            2.  Scanning Basics
            3.  Some Scanner Examples
            4.  Setting Delimiters
            5.  Other Scanner Features
        16. The ResourceBundle, ListResourceBundle, and PropertyResourceBundle Classes
        17. Miscellaneous Utility Classes and Interfaces
        18. The java.utilSubpackages
            1.  java.util.concurrent, java.util.concurrent.atomic, and java.util.concurrent.locks
            2.  java.util.function
            3.  java.util.jar
            4.  java.util.logging
            5.  java.util.prefs
            6.  java.util.regex
            7.  java.util.spi
            8.  java.util.stream
            9.  java.util.zip
    Chapter 5: Input/Output: Exploring java.io
        1.  The I/O Classes and Interfaces
        2.  File
            1.  Directories
            2.  Using FilenameFilter
            3.  The listFiles( ) Alternative
            4.  Creating Directories
        3.  The AutoCloseable, Closeable, and Flushable Interfaces
        4.  I/O Exceptions
        5.  Two Ways to Close a Stream
        6.  The Stream Classes
        7.  The Byte Streams
            1.  InputStream
            2.  OutputStream
            3.  FileInputStream
            4.  FileOutputStream
            5.  ByteArrayInputStream
            6.  ByteArrayOutputStream
            7.  Filtered Byte Streams
            8.  Buffered Byte Streams
            9.  SequenceInputStream
            10. PrintStream
            11. DataOutputStream and DataInputStream
            12. RandomAccessFile
        8.  The Character Streams
            1.  Reader
            2.  Writer
            3.  FileReader
            4.  FileWriter
            5.  CharArrayReader
            6.  CharArrayWriter
            7.  BufferedReader
            8.  BufferedWriter
            9.  PushbackReader
            10. PrintWriter
        9.  The Console Class
        10. Serialization
            1.  Serializable
            2.  Externalizable
            3.  ObjectOutput
            4.  ObjectOutputStream
            5.  ObjectInput
            6.  ObjectInputStream
            7.  A Serialization Example
        11. Stream Benefits
    Chapter 6: Exploring NIO
        1.  The NIO Classes
        2.  NIO Fundamentals
            1.  Buffers
            2.  Channels
            3.  Charsets and Selectors
        3.  Enhancements Added to NIO by JDK 7
            1.  The Path Interface
            2.  The Files Class
            3.  The Paths Class
            4.  The File Attribute Interfaces
            5.  The FileSystem, FileSystems, and FileStore Classes
        4.  Using the NIO System
            1.  Use NIO for Channel-Based I/O
            2.  Use NIO for Stream-Based I/O
            3.  Use NIO for Path and File System Operations
        5.  Pre-JDK 7 Channel-Based Examples
            1.  Read a File, Pre-JDK 7
            2.  Write to a File, Pre-JDK 7
    Chapter 7: Networking
        1.  Networking Basics
        2.  The Networking Classes and Interfaces
        3.  InetAddress
            1.  Factory Methods
            2.  Instance Methods
        4.  Inet4Address and Inet6Address
        5.  TCP/IP Client Sockets
        6.  URL
        7.  URLConnection
        8.  HttpURLConnection
        9.  The URI Class
        10. Cookies
        11. TCP/IP Server Sockets
        12. Datagrams
             1.  DatagramSocket
             2.  DatagramPacket
             3.  A Datagram Example 
    Chapter 8: The Concurrency Utilities
		1.  The Concurrent API Packages
            1.  java.util.concurrent
            2.  java.util.concurrent.atomic
            3.  java.util.concurrent.locks
        2.  Using Synchronization Objects
            1.  Semaphore
            2.  CountDownLatch
            3.  CyclicBarrier
            4.  Exchanger
        3.  Phaser
        4.  Using an Executor
            1.  A Simple Executor Example
            2.  Using Callable and Future
        5.  The TimeUnit Enumeration
        6.  The Concurrent Collections
        7.  Locks
        8.  Atomic Operations
        9.  Parallel Programming via the Fork/Join Framework
            1.  The Main Fork/Join Classes
            2.  The Divide-and-Conquer Strategy
            3.  A Simple First Fork/Join Example
            4.  Understanding the Impact of the Level of Parallelism
            5.  An Example that Uses RecursiveTask
            6.  Executing a Task Asynchronously
            7.  Cancelling a Task
            8.  Determining a Task's Completion Status
            9.  Restarting a Task
            10. Things to Explore
            11. Some Fork/Join Tips
        10. The Concurrency Utilities Versus Java's Traditional Approach
    Chapter 9: The Stream API
        1.  Stream Basics
            1.  Stream Interfaces
            2.  How to Obtain a Stream
            3.  A Simple Stream Example
        2.  Reduction Operations
        3.  Using Parallel Streams
        4.  Mapping
        5.  Collecting
        6.  Iterators and Streams
            1.  Use an Iterator with a Stream
            2.  Use Spliterator
        7.  More to Explore in the Stream API
    Chapter 10: Regular Expressions and Other Packages
        1.  The Core Java API Packages
        2.  Regular Expression Processing
            1.  Pattern
            2.  Matcher
            3.  Regular Expression Syntax
            4.  Demonstrating Pattern Matching
            5.  Two Pattern-Matching Options
            6.  Exploring Regular Expressions
        3.  Reflection
        4.  Remote Method Invocation (RMI)
			1.  A Simple Client/Server Application Using RMI
        5.  Formatting Date and Time with java.text
            1.  DateFormat Class
            2.  SimpleDateFormat Class
        6.  The Time and Date API Added by JDK 8
            1.  Time and Date Fundamentals
            2.  Formatting Date and Time
            3.  Parsing Date and Time Strings
            4.  Other Things to Explore in java.time
   Chapter 11:  JDBC
        1.  JDBC Drivers
        2.  Steps to connect to the database 
        3.  Connectivity with Oracle 
        4.  Connectivity with MySQL 
        5.  Connectivity with Access without DSN 
        6.  DriverManager 
        7.  Connection interface 
        8.  Statement interface 
        9.  ResultSet interface 
        10. PreparedStatement 
        11. ResultSetMetaData 
        12. DatabaseMetaData 
        13. Storing image 
        14. Retrieving image 
        15. Storing file 
        16. Retrieving file 
        17. Stored procedures and functions 
        18. Transaction Management 
        19. Batch Processing 
        20. JDBC New Features
        21. Mini Project 
    Chapter 12: Java New Features
        1.  Assertion 
        2.  For-each loop 
        3.  Varargs 
        4.  Static Import 
        5.  Autoboxing and Unboxing 
        6.  Enum Type 
        7.  Annotation 
    Chapter 13: Internationalization
        1.  Internationalization 
        2.  ResourceBundle class 
        3.  I18N with Date 
        4.  I18N with Time 
        5.  I18N with Number 
        6.  I18N with Currency 
PART 3 Advanced Java Programming 
    Chapter 1: Servlet  
        1.  Basics of Servlet
            1.  Servlet: What and Why? 
            2.  Basics of Web 
            3.  Servlet API 
            4.  Servlet Interface 
            5.  GenericServlet
            6.  HttpServlet
            7.  Servlet Life Cycle   
            8.  Working with Apache Tomcat Server 
            9.  Steps to create a servlet in Tomcat 
            10. How servlet works? 
            11. servlet in Myeclipse
            12. servlet in Eclipse 
            13. servlet in Netbeans
        2.  ServletRequest
            1.  ServletRequest methods 
            2.  Registration example with DB 
        3.  Servlet Collaboration
            1.  RequestDispatcher 
            2.  sendRedirect
        4.  ServletConfig
            1.  ServletConfig methods 
            2.  ServletConfig example 
        5.  ServletContext
            1.  ServletContext methods 
            2.  ServletContext example 
        6.  Attribute
			1.  How to set, get and remove example? 
        7.  Session Tracking  
            1.  Cookies 
            2.  Hidden Form Field 
            3.  URL Rewriting 
            4.  HttpSession
        8.  Event and Listener
        9.  Filter   
            1.  Filter 
            2.  Authentication Filter 
            3.  FilterConfig
            4.  Useful examples 
        10. ServletInputStream and ServletOutputStream
        11. Annotation Servlet
        12. Project Development        
    Chapter 2:JSP
        1.  Basics of JSP
            1.  Life cycle of JSP 
            2.  JSP API 
            3.  JSP in Eclipse and other IDE's
        2.  Scripting elements
            1.  scriptlet tag 
            2.  expression tag 
            3.  declaration tag 
        3.  9 Implicit Objects
            1.  out 
            2.  request 
            3.  response 
            4.  config
            5.  application 
               6.  session  
            7.  pageContext
            8.  page 
            9.  exception 
        4.  Directive Elements
            1.  page directive 
            2.  include directive 
            3.  taglib directive 
        5.  Exception Handling
        6.  Action Elements
            1.  jsp:forward
            2.  jsp:include
            3.  Bean class 
            4.  jsp:useBean
            5.  jsp:setProperty&jsp:getProperty
            6.  Displaying applet in JSP 
        7.  Expression Language
        8.  MVC in JSP
        9.  JSTL
        10. Custom tags
            1.  Custom Tag : What and Why? 
            2.  Custom Tag API? 
            3.  Custom Tag Example 
            4.  Attributes 
            5.  Iteration 
            6.  Custom URI 
        11. Project Development in JSP
    Chapter 3 :JavaMail API
        1.  Sending Email 
        2.  Sending email through Gmail server
        3.  Receiving Email 
        4.  Sending HTML content       
    Chapter 4: EJB 3
        1.  Introduction to JavaEE
            1.  The Need for JavaEE. - Overview on the JavaEE Architecture  1 tier ,2 tier, 3 tier , N tier 
            2.  Introduction to EJB3
                1.  The EJB Model 
                2.  Key Services of the Application Server
                3.  Developing Session Beans
                4.  Stateless Session Beans 
                5.  Stateful Session Beans 
                6.  Packaging 
                7.  Writing Clients 
                8.  Using Dependency Injection
                9.  No More JNDI 
                10. Injection of EJBContext
            3.  JMS
                1.  JMS Overview 
                2.  JMS Messaging Domains 
                3.  Example of JMS using Queue 
                4.  Example of JMS using Topic 
                5.  Message Driven Beans
            4.  Persistence Introduction to JPA
                1.  Object Relational Mapping 
                2.  Mapping configurations 
                3.  Embedded Objects 
                4.  EJBQL 
PART 4 Maven and J-Unit
    1.  JUnit
        1.  JUnit: What and Why? 
        2.  Types of Testing 
        3.  Annotations used in JUnit 
        4.  Assert class 
        5.  Test Cases
        6.  Maven
    2.  Maven
        1.  Maven: What and Why? 
        2.  Ant Vs Maven 
        3.  How to install Maven? 
        4.  Maven Repository 
        5.  Understanding pom.xml 
        6.  Maven Example 
        7.  Maven Web App Example 
        8.  Maven using Eclipse
PART 5 Spring Framework  
    1.  Basics of Spring
        1.  What is Spring 
        2.  Spring Modules 
        3.  Spring Application 
    2.  Spring with IDE
        1.  Spring in Myeclipse
        2.  Spring in Eclipse 
        3.  IOC container
        4.  Dependency Injection
            1.  Constructor Injection 
            2.  CI Dependent Object 
            3.  CI with collection 
            4.  CI with Map 
            5.  CI Inheriting Bean 
            6.  Setter Injection 
            7.  SI Dependent Object 
            8.  SI with Collection 
            9.  SI with Map 
            10. CI vs SI 
            11. Autowiring
            12. Factory Method 
        5.  Spring AOP
            1.  AOP Terminology 
            2.  AOP Implementations 
            3.  Pointcut
            4.  Advices 
        6.  Spring JDBC
            1.  JdbcTemplate Example 
            2.  PreparedStatement
            3.  ResultSetExtractor
            4.  RowMapper
            5.  NamedParameter
            6.  SimpleJdbcTemplate
            7.  Spring with ORM
                1.  Spring with Hibernate 
                2.  Spring with JPA 
            8.  SpEL
                1.  SpEL Examples 
                2.  Operators in SpEL
                3.  variable in SpEL
            9.  Spring 3 MVC 
            10. Remoting with Spring
                1.  Spring with RMI 
                2.  Http Invoker 
                3.  Hessian 
                4.  Burlap 
                5.  Spring with JMS 
            11. OXM Frameworks
                1.  Spring with JAXB 
                2.  Spring with Xstream
                3.  Spring with Castor 
            12. Spring Java Mail
            13. Web Integration
                1.  Login and Logout Application             
Part 6 Hibernate 
     1. Basics of Hibernate
        1.  Hibernate Introduction 
        2.  Hibernate Architecture 
        3.  Understanding First Hibernate application 
    2.  Hibernate with IDE
        1.  Hibernate in Eclipse 
    3.  Hibernate Application
        1.  Hibernate with annotation 
        2.  Hibernate Web application 
    4.  Hibernate Generator classes 
    5.  Hibernate Dialects 
    6.  Hibernate Logging
        1.  Hibernate with Log4j 1 
        2.  Hibernate with Log4j 2 
    7.  Inheritance Mapping
        1.  Table Per Hierarchy 
        2.  Table Per Hierarchy using Annotation 
        3.  Table Per Concrete 
        4.  Table Per Concreteusing Annotation 
        5.  Table Per Subclass 
        6.  Table Per Subclass using Annotation 
    8.  Collection Mapping 
        1.  Mapping List 
        2.  One-to-many by List using XML 
        3.  Many to Many by List using XML 
        4.  One To Many by List using Annotation 
        5.  Mapping Bag 
        6.  One-to-many by Bag 
        7.  Mapping Set 
        8.  One-to-many by Set 
        9.  Mapping Map 
        10. Many-to-many by Map 
        11. Bidirectional 
        12. Lazy Collection 
    9.  Component Mapping
    10. Association Mapping
        1.  One-to-one using Primary Key 
        2.  One-to-one using Foreign Key 
    11. Transaction Management
    12. HQL
    13. HCQL
    14. Named Query
    15. Hibernate Caching
        1.  First Level Cache 
        2.	Second Level Cache 
    16. Integration
        1.  Hibernate and Spring       
Part 7 Web services :
    1.  Introduction to Web Services	
         1.  Web Service Architecture
        2.  Web Services VS other Technologies
        3.  Web Services Benefits
    2.  XML Theory
        1.  Introduction to XML
        2.  DTD VS XSD
        3.  What is XML Parsing?
        4.  Various other XML Binding API's 
        5.  JAX-P API based XML parsing using (SAX, DOM)
        6.  Validating XML Documents 
            1.  • XML Binding using JAX-B (Marshalling, Un-Marshalling and In-Memory Validation)
    3.  JAX – RPC	Theory
        1.  What is JAX-RPC API
        2.  Different Implementations of JAX-RPC API
        3.  Typical request processing in JAX-RPC
            1.  • Building Web Service using JAX –RPC SUN RI 	Implementation (Contract Last approach)
            2.  • Building Web Service clients using JAX – RPC API 	(Stub based client, DP and DII based clients)
            3.  • Building Web Service using JAX-RPC API Apache Axis 	implementation (Contract First approach)
    4.  WSDL	Theory
        1.  Purpose of WSDL
        2.  Types of WSDL
        3.  Message Exchange Patterns
        4.  Message Exchange Formats
        5.  Various elements of a WSDL document
        6.  Writing a WSDL document
    5.  SOAP	Theory
        1.  Purpose of SOAP
        2.  Various elements of SOAP and its significance
    6.  JAX – WS	
        1.  What is JAX-WS API
        2.  JAX RPC VS JAX-WS
            1.  • Building Web Service using JAX – WS SUN RI 	implementation (Contract Last approach)
            2.  • Building Web Service using JAX – WS Apache Axis 2 	implementation (Contract First approach)
            3.  • Building Asynchronous Web Service using JAX – WS 	dynamic API
    7.  JAX – RS (Restful Service)	 
        1.  What is JAX – RS?
        2.  Need for JAX – RS
        3.  Web Services VS Web Resource
            1.  • Building Web Resource using JAX – RS SUN Jersey 	implementation
            2.  • Building a Web Resource client using Apache Commons 	HTTP Client API
    8.  WS - * (Advanced Concepts in Web Services) 
        1.  What is WS - * stack
            1.  • What is ws – address, ws – security, ws – atomic 	transactions
            2.  Synchronous VS Asynchronous service
                1.  • Building Asynchronous Web Service using JAX –WS Metro 	Implementation using WS – Addressing (Real Asynchronous)