WHAT'S NEW?
Java IO have lot of high level and low level of readers and writers.

Files can be read using both the input stream as well as output stream.




Let us try to read the content from a file using FileReader.

FileReader
- A low level Reader for reading the data from the file.


Constructor:


FileReader(File f)

- Open a reader on the specified object.

FileReader(String s)

- Open a reader on the specified path.



Methods


public int read()

- Reads the ascii value of the character till the EOF(End of File)  is reached.

Code to read the data from the file



import java.io.*;



public class ReadUsingFR

{

public static void main(String[] args)

{

try

{

File f=new File("xyz.txt"); // Replace xyz.txt with your file path.

FileReader fr=new FileReader(f);

int data=0;



while((data=fr,read())!=-1)

{

char c=(char)data;

System.out.print(c);

}

fr.close();

}

catch(Exception e)

{

e.printStackTrace();

}



}

}


IMPLICIT OBJECTS- JSP simplifier authoring & provides certain objects implicitly to be accessed within a JSP page without any explicit declaration.
- These objects are called as implicit objects .
- These objects are not declared explicitly but they are provided by Container during translation phase.
There are in all 9 implicit objects

TIP FOR STUDENT:It is always recommended to remember the name of this implicit object & their classes in context to interviews.....
There are 9 implicit objects:-
1) request.
2) response
3) out
4) session
5) application


6) config
7) page
8)pageContext
9)exception

1) request:-
- request object represents all the information about HttpRequest.
- Instance of :javax.servlet.http.HttpServletRequest
Scope:request scope.- Using this object we can access headers cookies ,etc.

2) response:-
- response object represents response to the client.
- Instance of : javax.servlet.http.HttpServletResponse.
Scope:page scope- response object is used for adding cookies, redirecting the calls,etc

3) out:-
- out object represents output stream.
- out objects are used for sending arguments to print methods.
- Instance of:javax.servlet.jsp.JSPWriter
-Scope:page scope
4) session:-
- session object is used to track client's information across the session.
- Instance of: javax.servlet.http.HttpSession
Scope:session scope.

5) application:-
- application object represent the context for the JSP page.
- application object is accessible to any object used within JSP page.
- Instance of:javax.servlet.ServletConfig
- Scope:page scope.

6) config:-
- config object provides access to the initialization parameters
- Instance of : javax.servlet.ServletConfig
- Scope : page scope

7) page:-
- page refers to the instance of JSP implementation class, i.e the JSP itself.
- accessed using 'this' reference.
- Instance of : javax.lang.Object
- Scope:page scope.

8) pageContext:-
- pageContext encapsulates other implicit objects.
- If a class is given pageContext reference it get access to all the objects from all the scope
- Instance of : javax.servlet.jsp.PageContext
- Scope:page scope.
9) exception:-
- Refers to runtime exception that resulted in invoking the errorPage.
- Available only in error page.
- errorPage:- a JSP which has is errorPage attribute true in page directive.
- Instance of :java.lang.Throwable
- Scope:page scope.

 Scriplets

-Any piece of code written in scriplet goes into service() method.
-Any complex or simple java code can be written in srciplet.
-Scriplet are meant for embedding java code.


-Scriplet never get translated.
-Hence a very simple but logical point to remember for scriplet is that Scriplet NEVER CAUSE TRANSITION ERRORS.
-Scriplet CAN BE BROKEN by STATIC content.<% Java Code %>
<%------------
------------
------------%>

-Nothing but pure java code goes in the dotted area.
-Any data declared become local to service().

TomJSP.jsp/j3
 
<html>
<body>
<%
      String name=request.getParameter ("name");
     if(name.equalsIgnoreCase("Tom"))
       {
          out.println("Hi Tom!!!");
          out.println("How are You ?");
       }
else
      {
         out.println("Who You ?");
         out.println("I don't know You");
      }
%>
</body>
</html>

URL:http://localhost:8080/learningkattaWebApp/j3 ?name=Tom

ScripletTomJSP.jsp/j4
 
<html>
<head> Scriplet Tom </head>
<body>
<b>
       A JSP to demonstrate that SCRIPLET can be broken by static content
</b>
<% String name=request.getParameter("name");
      if(name.equals("tom"))
          {
%>  
<b> 
Hi Tom! How are you ?  
</b>
<br>
<%
      }      
      else
     {  
%>
<b>
Who you ? I don't know you ?  <%= name %>
<%
       }




%>
</body>
</html>

Data Declaration and Method Definition


 Data Declaration and Method Definition

-There may arise a case when a programmer requires to use his own method.
-But till yet, we have seen that whatever we write goes in servlet method (service ()).
-As JSP Declaration doesn't provide any output they are used in conjuction with JSP Expression and JSP Scriplets.

<%! Data Declaration; %>
<%! Method Definition()
{
}
%>

<%! int count=0; %>
<%! public String m1()
{
return "Hello";
}
%>
-Method returning some values are allowed in JSP Declaration.
http://localhost:8080/learningkattaWebApp/j2?name=Tom

HelloDeclarationJSP.jsp
 
<html>
<body>

Data Declaration and Method Definition

b) Data Declaration and Method Definition
-There may arise a case when a programmer requires to use his own method.
-But till yet, we have seen that whatever we write goes in servlet method (service ()).
-As JSP Declaration doesn't provide any output they are used in conjuction with JSP Expression and JSP Scriplets.




<%! Data Declaration; %>
<%! Method Definition()
{
}
%>
<%! int count=0; %>
<%! public String m1()
{
return "Hello";
}
%>
-Method returning some values are allowed in JSP Declaration.
http://localhost:8080/learningkattaWebApp/j2?name=Tom

HelloDeclarationJSP.jsp
 


<%! 
public String sayHello(String name)
{
return "Hello" + name;
}
%>
Message:<%= sayHello(request.getParameter("name") %?>


<%! 
public String sayHello(String name)
{
return "Hello" + name;
}
%>
Message:<%= sayHello(request.getParameter("name") %?>
</body>
</html>

Expressions-JSP


-JSP expression automatically print out whatever is being sent between the tags.
-Expressions are evaluated and output is sent to the browser.
-Expressions are later resolved and consumed by HTML itself.
<%= expression %>[Anything which comes on right hand side int i=1;
int z=x+y;
Date dt =new Date();



Point To REMEMBER:
NO semi-colon at the end.
Ease of using Expressions.
Without expression:
 
<%@ page import="java.util.* %>
<html>
<body>
Date: <% out.println(new Date());%>
</body>
</html>

With expression:
 
<%@ page import="java.util.*" %>
<html>
<body>
Today's Date:<%=new Date() %>
</body>
</html>

-Whenever container encounters expression, Container takes everything typed between the <%= %> and put it as an argument in out.println() <%= new Date() %>Becomes
out.println(new Date());
Tip for Students:
You people always by mistake put up a semi-colon at the end which result in
<%= new Date(); %>
Becomes
out.println(new Date(););
Which becomes error then.
Hence,No semi-colon(;) at the end of Expression.
FirstJSP.jsp
 
<%@ page import="java.util.*" %>
<html>
<body>
<%@ include file="Header.html" %>
<b>
<Hello User!!!Welcome to the world of  JSP !!
</b>




Current Date : <%= new Date() % > 
<%@ include file="Footer.html"  %>
</body>
</html>

include Directive
-include directive are given after <html> and before </html>.
-It makes the static inclusion of .html/.jsp file.
-These files are include during translation.

Syntax:
<%@ include file="somename.html" %>
-Include .html/.jsp file should not contain <html> and </html>.


Header.html
 
<body>
<h6>Welcome To Asterix Solution</h6><br>
<hr>
</body>

Footer.html
 
<body>
<hr>
<br>
<h6>This website is a copyright</h6>
</body>

IncludeJSP.jsp
 
<%@ page language="Java" %>
<html>
<body>




<%@ include file="Header.html" %>
<p> Please login..........</p>
>%@ include file="Footer.html" %>
</body>
</html>

a)Page Directive
-This tag is always given above tag.
-Controls resultant translated page.
-No output.
Syntax:
<%@ page attribute="value" attribute="value" %>



Attribute of page directive.i) language
-By default java is used.
<%@ page language="Java" %>

|

-It is used for future consideration, where JSP might support language other than java.
ii) import 
-import package required by this JSP page.
-This is the only attribute which can be repeated more than once.
<%@ page language="Java" import="java.util.*" import="java.sql.*" %>
OR
<%@ page language="Java" import="java.util.*, java.sql.*" %>

iii) buffer-JSP does not uses PrintWriter, but uses JSPWriter.
-Buffer can be "none","8 kb","12 kb" as per requirement.
<%@page buffer="15 kb" %>

iv) autoflush-Defines whether the buffered output is flushed automatically.
-Default value is true.
-If false is passed, an IOException is generated.
<%@ page autoflush="true" %>

v)isErrorPage -Defines whether current page represent JSP error page.
-Default value is "false",but if it's change to true,page has access to implicit exception object.
<%@ page isErrorPage="true" %>

vi) errorPage-Defines the URL to which Exception should be sent.
-The target JSP's isErrorPage value should be true.
<%@ page errorPage="MyExceptionPage.jsp" %>

vii) session-Defines whether page will have implicit session object.
-Default value is "true".
<%@ page session="true" %>
equivalent to getSession(true);
<%@ page session="false" %>
equivalent to getSession(false);

viii) isThreadSafe-Defines whether the generated servlet need to implement the SingleThreadModel.
-Default value is "true".

public void jspInit()
- This method is invoked when JspPage is intialised.
- This method is called once in the life-time of JSP Page.
- To put Jsp in service, jspInit() must get completed successfully.

public void _jspService(HttpServletRequest request, HttpServletResponse response) throwsServletException, IOException
- The _jspService() corresponds to the body of JSP page.
- This method is defined automatically by the Container & this should not be defined by JSP page author.
- This method is called many a times in its life cycle .

public void jspDestroy()
- This method is invoked when Jsp Page is about to be destroyed.

JSP Comments
- Comments can be used in JSP.
- Two different types of comments are allowed in JSP.

JSP ARCHITECTURE - Whenever a request arises for .jsp file.


JSP-ENGINE will :
i) Translate .jsp file into a .java file.
ii) Compiles the file into a servlet file.

Container will:
iii) Load the servlet class.
iv) Instantiate it using default constructor.
v) Invokes jspInit()
Required that :
a) jspInit() does not throw any exception.
b) jspInit() returns in stipulated time.
vi) Put the servlet in service.
vii) Creates request & response object.
viii) Starts the thread, invoke _jspService() & passes request & response object as arguments.
ix) Retreive the request parameter, perform processing, send responses to the client using writer object.
x) Close the writer object.
xi) When Container shut downs jspDestroy() is invoked.
SERVLETS V/S JSP

1)Servlet
- Servlet does not have any separation between dynamic & static contents.
JSP
- JSP has a clean separation between dynamic & static content.

2)Servlet
- Servlet does not have support for implicit objects.
JSP
- JSP supports implicit objects.

3)Servlet
- Servlet supports any protocol including Http.
JSP
- JSP supports only Http protocol.

4)Servlet
- Servlets are pure java program stored with extension (.java).
JSP
- JSPs are document-centric stored with extension(.jsp)

5)Servlet
- If any changes are made in .class file. It has to be redeployed
JSP
- Whenever any changes are made to (.jsp) file, JSP ENGINE Retranslates & recompiles, hence no redeployment.

WHY JSP?
Servlet follows Component architecture, follows request response model.



- All the code goes inside service() / doGet () / doPost().
- This makes Servlet monolithic in nature.
- It is a tough job to write all the code in same method.
- Hence there emerged a need for a clear separation between CONTENT GENERATION & CONTENT REPRESENTATION.
- Using JSP Separation found was something like this.

Java Server Pages- JSP stands for Java Server Pages.
- JSP is a text document with any name which can contain 100% HTML tags & additional tags to embed java code.
- It is a java technology which allows software developer to dynamically generate HTML, XML or other types of document in response to Web client request.
- This document is stored in WEB-ROOT of a WEB-APPLICATION.
- Whenever the request comes for any jsp for the first time, JSP ENGINE (which) is part of Container translates .jsp into a .java file.
- Translated .java file is nothing but a 100% HttpServlet.
- Whenever any changes are made in .jsp file. JSP ENGINE retranslates & Recompile it.





ADVANTAGES OF JSP1)WRITE ONCE, RUN ANYWHERE
- JSP technology is platform independent.
- JSP can be written on any platform, it can run from any platform & can
Be accessed from any web-browser on any platform.

2)HIGH QUALITY TOOL SUPPORT
- An explicit goal of Java Server Pages design is to enable the creation of high quality portable tools.

3)REUSE OF COMPONENTS & TAG LIBRARIES
- JSP uses reusable components such as
JAVA BEANS
ENTERPRISE JAVA BEANS
TAG LIBRARIES 

- This save development time as well as gives cross-platform power & flexibility of Java programming.

4)SEPERATION OF DYNAMIC & STATIC CONTENT
- JSP enables separation of dynamic contents from static contents that is inserted in static template.
- This makes work easier & hence diminishes the dependency of WEB-DESIGNER over WEB-DEVELOPER & vice-versa.

5)SUPPORTS SCRIPTING & ACTIONS
- JSP supports scripting elements as well as actions.
- Action permits ENCAPSULATION.
- Scripting provides mechanism to glue-together functionalities.








class Floyd
{
public static void main(String[]args)
{

int i,j;
for(i=1;i<=4;i++)
{
for(j=0;j<i;j++)
{
System.out.print(((i+j)%2)+"\t");
}
System.out.println("\n");
}

}
}

A simple program to find out whether the String is palindrome or not without using StringBuffer class.



Let me break it in simple steps


Step 1: Find the length of the original String using length().

String original="MALAYALAM";
int l=original.length();

Step 2: Declare one more String to hold a reversed value.


String reverse="";

Step 3: Start a for loop in reverse order and make the use of method charAt(); 

In case you don't know the working of charAt() you can check it here. Click Me for charAt() post.

Whatever character you get in the reverse order,store it in reverse String

for(int i=l-1;i>=0;i--)
{
reverse=reverse+ original.charAt(i);
}

Step 4: When the loop ends, you have two String where you can check whether they both match, if they match they are palindrome, else they are not.


if(original.equals(reverse))
{
System.out.println("It is a palindrome");
}
else
{
System.out.println("It is not a palindrome");
}



Now let me put the whole code in one program.

class PalindromeWithoutSB 
{
public static void main(String[] args) 
{
String original="MALAYALAM";
int l=original.length();
String reverse="";

for (int i=l-1;i>=0 ;i-- )
{
reverse=reverse+original.charAt(i);
}
if(original.equals(reverse))
{
System.out.println("It is a palindrome");
}
else
{
System.out.println("It is not a palindrome");
}

}
}

charAt() of String class is a simple method to find out the character at a particular position in the String.


Structure of charAt() looks like

public char charAt(int index)
- Returns the character at a particular index in the String


Lets say for String "Zartab", if i need to find what is the character at index number

So now to get any character at location let say 4, we need to write the code as

String str="Zartab";
char c=str.charAt(4);
System.out.println(c);

c will return 'A'.

The whole will look like

class CharAtDemo 
{
public static void main(String[] args) 
{
String str="ZARTAB";
char c=str.charAt(4);
System.out.println(c);
}
}


While working in projects it is one of the tricky task to convert the date from and to the various formats.


Especially for developers in India where date is majorly used in format DD-MM-YYYY face a difficulty of changing the date to and from the SQL format.

I am going to make the use of method split() of class String. In case you have never used the methods you can check the working here.

The actual code goes as follow

class DateWorker
{
public static String convert(String date)
{
String[] dateArray=date.split("-");
String convertedDate=dateArray[2]+"-"+dateArray[1]+"-"+dateArray[0];
return convertedDate;
}
}


public class ConvertDate
{
public static void main(String[] args)
{
String normalDate="23-05-2015";
String sqlDate=DateWorker.convert(normalDate);
System.out.println(sqlDate);

String normal=DateWorker.convert(sqlDate);
System.out.println(normal);
}
}


One method of DateWorker is enough for both the conversion as both the conversion are nothing but inversions.

Try the code and you will understand the rest. 


Let say you have a string which reads "AX-001-2589". 

If you want to break the String into array based in the separator i.e. in this case is a -.

String have a method by name split().

The structure of the methods looks something like this

public String[] split(String regex)

- The above method splits the String into an array containing all the elements separated by the given regex.

So coming back to example if we need to split the String into the array the program goes like

class SplitTheString 
{
public static void main(String[] args) 
{
String str="AX-001-2526";

String[] array=str.split("-");

for(int i=0;i<array.length;i++)
{
System.out.println(array[i]);
}
}
}


So the array holds data something like this

array[0]="AX";
array[1]="001";
array[2]="2526";