Prasanna

Using compareto in java: using compareto in java In this tutorial, we will learn how we can compare two strings lexicographically in Java. Also, know what is the method we use to compare two strings in java ie., Java String compareTo() Method. However, you may also do compare two strings by using the equals() methods in java.

• Compare two Strings lexicographically in Java
• How to compare two strings without using library function?
• Java String compareTo() Method
• Java program to compare two strings lexicographically using compareTo() Method

Compare two Strings lexicographically in Java

Compareto string java example: Firstly, you should have some idea of what ‘lexicographically’ means? ‘lexicographically’ means ‘alphabetically ordered’ in simple words. Now, we can check the lexicographical order by comparing two strings.

The Java String Class provides many ways to compare the content of the two Strings. One way to compare the content of the two strings by using the equals() method. But today in this tutorial, we will learn how to compare two strings lexicographically in Java using the compareTo() method.

How to compare two strings without using library function?

Algorithm: 

1. Input two strings string 1 and string 2.
2. for (int i = 0; i < str1.length() && i < str2.length(); i ++)
   (Loop through each character of both strings comparing them until one of the string terminates):
   • If unicode value of both the characters is same then continue;
   • If unicode value of character of string 1 and unicode value of string 2 is different then return (str1[i]-str2[i])
3. if length of string 1 is less than string2
   • return str2[str1.length()]
     else
     return str1[str2.length()]

Source Code: 

String compareto example: Let’s see the implementation of the above program here:

// Java program to Compare two strings
// lexicographically
class Compare {
  
    // This method compares two strings
    // lexicographically without using
    // library functions
    public static int stringCompare(String str1,
                                    String str2)
    {
        for (int i = 0; i < str1.length() && 
                    i < str2.length(); i++) {
            if ((int)str1.charAt(i) == 
                (int)str2.charAt(i)) {
                continue;
            } 
            else {
                return (int)str1.charAt(i) - 
                    (int)str2.charAt(i);
            }
        }
  
        // Edge case for strings like
        // String 1="Geeky" and String 2="Geekyguy"
        if (str1.length() < str2.length()) {
            return (str1.length()-str2.length());
        } 
        else if (str1.length() > str2.length()) {
            return (str1.length()-str2.length());
        }
          
        // If none of the above conditions is true,
        // it implies both the strings are equal
        else {
            return 0;
        }
    }

 // Driver function to test the above program
public static void main(String args[])
{
String string1 = new String("Geeks");
String string2 = new String("Practice");
String string3 = new String("Geeks");
String string4 = new String("BtechGeeks");

System.out.println(stringCompare(string1, string2));
System.out.println(stringCompare(string1, string3));
System.out.println(stringCompare(string2, string1));

// To show for edge case
// In these cases, the output is the difference of 
// length of the string
System.out.println(stringCompare(string1, string4));
System.out.println(stringCompare(string4, string1));
}
}

Output: 

-9
0
9
-8
8

Java String compareTo() Method

Java compareto function: Java String compareTo() method is used to compare the two strings lexicographically in Java. The comparison is based on the Unicode value of each character in the string. The String compareTo() method returns the positive number, negative number, or 0.

If the first string is greater than the second string lexicographically, then it returns a positive number. If the first string is smaller than the second string lexicographically, then it returns a negative number. If both the strings are equal lexicographically, then it returns 0.

The following are the two ways to use compareTo() method in the java string class:

int compareTo(String str)

Above the comparison is between string literals. For instance,string1.compareTo(string2) where string1 and string2 are String literals.

int compareTo(Object obj)

Here the comparison is between a string and an object. For instance, string1.compareTo("Just a String object")where string1 is literal and its value is compared with the string defined in the method argument.

Do Read: 

• How to Convert a String to UpperCase in Java?
• How to Concatenate two Strings using concat() method in Java?

Java program to compare two strings lexicographically using compareTo() Method

class Lexicographically
{
public static void main(String args[])
{
String str1 = "Hello";
String str2 = "Hi";
String str3 = "Ram";
String str4 = "Javastudypoint";
String str5 = "Tutorial";
String str6 = "Tutorial";

//-4 because "e" is 4 times less than "i".
System.out.println(str1.compareTo(str2));

//2 because "T" is 2 times greater than "R".
System.out.println(str5.compareTo(str3));

//-2 because "H" is 2 times less than "J".
System.out.println(str1.compareTo(str4));

//-12 because "H" is 12 times less than "T".
System.out.println(str1.compareTo(str5));

//0 because both the strings are equal.
System.out.println(str5.compareTo(str6));
}
}

Output:

-4
2
-2
-12
0

Break statement java: A programming language uses control statements to control the flow of execution of a program. In Java programming, we can control the flow of execution of a program based on some conditions. Java control statements can be put into the following three categories: selection, iteration, and jump. In this tutorial, we will learn about the Java jump statement. The jump statement can be used to transfer the control to other parts of the program. Java break statement is one of the jump statements.

• Java Break Statement
• Flowchart of Break Statement
• How does Break Statement Work?
• Use of Break in a While Loop
• Use of Break in a For Loop
• Use of Break Statement in Switch Case
• Java Break Nested Loop
• Using the Break to Exit a loop
• Java Labeled Break Statement

Java Break Statement

Java break statement: Java break statements can be used to terminate the loop. It can be used inside a loop. We can use a break statement in all types of loops such as: while loop, do-while loop, and for a loop. When a break statement is encountered inside a loop, the loop is terminated and the program control goes to the next statement following the loop. In java, the break statement has three uses.

1. It terminates a statement sequence in a switch statement.
2. It can be used to exit a loop.
3. It can be used as a “civilized” form of goto (labeled break).

Syntax:

break;

Flowchart of Break Statement

Also, Check:

• NavigableSet in Java with Example
• Java Continue Statement with Example

How does Break Statement Work?

Use of Break in a While Loop

Java label break: In the below example we are having a while loop that runs from 0 to 100 and as we have a break statement that only reaches when the loop reaches 2, the loop gets terminated and control passes to the next statement after the loop body.

public class BreakExample1 {
public static void main(String args[]){
int num =0;
while(num<=100)
{
System.out.println("Value of variable is: "+num);
if (num==2)
{
break;
}
num++;
}
System.out.println("Out of while-loop");
}
}

Output:

Value of variable is: 0
Value of variable is: 1
Value of variable is: 2
Out of while-loop

Use of Break in a For Loop

What does a break do in java: Soon after the var hits the var value 99 loop gets terminated.

public class BreakExample2 {

public static void main(String args[]){
int var;
for (var =100; var>=10; var --)
{
System.out.println("var: "+var);
if (var==99)
{
break;
}
}
System.out.println("Out of for-loop");
}
}

Output:

var: 100
var: 99
Out of for-loop

Use of Break Statement in Switch Case

Java break label: In the below program we are having a break statement after every case this is because if we don’t have it the subsequent case blocks would also execute. The same Program without break statement after each case would be Case 2 Case 3 Default.

public class BreakExample3 {

public static void main(String args[]){
int num=2;

switch (num)
{
case 1:
System.out.println("Case 1 ");
break;
case 2:
System.out.println("Case 2 ");
break;
case 3:
System.out.println("Case 3 ");
break;
default:
System.out.println("Default ");
}
}
}

Output:

Case 2

Java Break Nested Loop

Using the Break to Exit a loop

When a break statement is encountered inside a loop, the loop is terminated and the program control goes to the next statement following the loop. See the example below:

Java Break Statement to Exit a Loop with Example

class BreakLoop{
public static void main(String args[]){
for(int i = 1; i<=10; i++){
if(i==6)
break;
System.out.println("i is: " +i);
}
System.out.println("Loop Complete !");
}
}

Output:

Java Labeled Break Statement

The break statement can also be used by itself to provide a “civilized” form of the goto statement. Java doesn’t provide a goto statement, because it provides a way to branch in any arbitrary and unstructured manner. Java uses the label. A label is a block of code that must enclose the break statement, but it doesn’t need to be immediately enclosing block. This means that you can use a labeled break statement to exit from a set of nested blocks.

Java Labeled Break Statement with Example

class LabeledBreakLoop{
public static void main(String args[]){
boolean b = true;

// first lable.
first:{
//second lable.
second:{
//third label.
third:{
System.out.println("Before the break statement.");
if(b)
break second;
System.out.println("This would not execute! ");
}
System.out.println("This would not execute! ");
}
System.out.println("This is after the second block.");
}
}
}

Output:

Before the break statement.
This is after the second block.

JSP scriptlets example: In the previous tutorials, we have learned so many concepts related to JSP. In this tutorial, we will be going to learn about JSP Scripting Elements with Example. Primarily, there are 3 types of Scripting Elements in JSP. Get proper knowledge on JSP Comment, JSP Declaration, JSP Scriptlet, and JSP Expression from here and understand completely what is JSP Scripting Elements?

• What are JSP Scripting Elements?
• Syntax of Scripting Elements in JSP
• JSP Comment Tag
• Example of Comment Tag in JSP
• JSP Declarations Tag
• Example of Declaration Tag in JSP
• JSP Scriptlet Tag
• Example of Scriptlet Tag in JSP
• JSP Expression Tag
• Example of Expression Tag in JSP

What are JSP Scripting Elements?

JSP comments syntax: JSP Scripting elements are utilized to enter java codes into JSP pages. To manages the objects, and do some computation on an object or runtime value, scripting elements are usually used. There are three scripting element types. These are the declaration, scriptlets, and expressions.

Syntax of Scripting Elements in JSP

The syntax starts with <% as follows:
<%! this is a declaration %>
<% this is a scriptlet %>
<%= this is an expression %>

Also Read: 

• Custom Tags in JSP with Example
• What are JavaBeans?

JSP Comment Tag

Comments are listed as text or statements that are overlooked by the JSP container. Moreover, JSP comment is utilized to note some parts of the JSP page to make it clearer and easier to manage. These comments in JSP are not involved in servlet source code while translation phase, nor they seem in the HTTP response.

The syntax of the JSP Comment is as follows:

<%-- JSP comment --%>

Example of Comment Tag in JSP

<%@ page import="java.util.Date"%>
<!DOCTYPE html>
<html>
<head>
<title>Comments in JSP Page</title>
</head>
<body>
<%-- A JSP comment --%>
<!-- An HTML comment -->
<!—The current date is <%= new Date() %>
-->
</body>
</html>

JSP Declarations Tag

Declaration tag in JSP Page is used to declare variables and methods. To define variables and methods of instance scope, it is used. Variable defined in declarations may be accessed from multiple threads, so they must be thread-safe. When JSP Page is initialized, then the declaration is initialized and is made available to other declarations, scriptlets, and expressions.

The syntax of Declaration Tag in JSP is as follows:

<%! declaration; [ declaration; ]+ ... %>

Example of JSP Declaration Tag:

JSP Scriptlet Tag

Scriptlet tag is used to write java code into JSP Page. It is typical that scriptlets are intermingled with template text. Because the variable and the code are local to the _jspService() method, therefore scriptlets don’t have the same thread-safety issue as declarations.

The syntax of Scriptlet Tag in JSP

<% java source code %>

Example of JSP Scriptlet Tag:

JSP Expression Tag

JSP Expression tag is used to print the value of variables and methods. At request processing time, the expression is evaluated, and then the result is converted into a String. If the result of the expression is an object, the toString() method is called. A ClassCastException will be raised if the value can’t be coerced into a String at translation time.

If you don’t know about Exceptions, we will be recommended you first learn the basics of Exceptions in Java.

<%=expression/statement %>

Example of JSP Expression Tag:

Java remove leading whitespace: In this tutorial, we will learn how to remove leading and trailing whitespaces from String. There are various methods to remove the leading and trailing spaces in Java. Java String trim() method is used to remove leading and trailing whitespaces from String. In this tutorial, we will learn the trim() method with a small case study. So that, you can understand Java String trim() method with much clarity. Here, we will discuss first what is the need for that method. We will explain its need with an example.

• String.replaceAll() Method
• String.replaceFirst() Method
• Java String trim() Method
• How does Java trim() Method Work?
• Example Program to Remove Leading and Trailing Spaces in Java
• Removing Leading and Trailing WhiteSpaces from a String in Java Example Program

String.replaceAll() Method

Java remove leading whitespace: replaceAll() Method finds all the leading whitespace. Once you find all the leading spaces you can replace them with an empty string.

String.replaceFirst() Method

Java remove trailing whitespace: As an alternative method, you can also go with the replaceFirst() also. It considers a regular expression and searches for the first occurrence at the beginning of the string. Then the method matches the replaced string part with the string value passed as the second argument.

Java String trim() Method

Trim whitespace java: Java String trim() method is used to remove whitespaces either from the beginning and the end of a string. It returns a copy of the string, with leading and trailing whitespace omitted.

Also, Refer:

• How to compare two Strings in Java using equals() Method?
• Java Continue Statement with Example
• Inheritance in Java with Example

How does Java trim() Method Work?

C++ trim leading whitespace: The Unicode Value for Space Character is ‘\u0020’. This method checks for the Unicode value before and after the string and if it is present then eliminates the space and returns without any spaces.

Output:

  Hello World  
Hello World
      Hey  there    Joey!!!  
Hey  there    Joey!!!

Example Program to Remove Leading and Trailing Spaces in Java

import java.util.Scanner;
class TrimExample{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
System.out.println("Enter Country Name: ");
String country = sc.nextLine();

if(country.equals("india")){
System.out.println("Capital of india is delhi");
}
else if(country.equals("australia")){
System.out.println("Capital of australia is canberra");
}
else if(country.equals("england")){
System.out.println("Capital of england is london");
}
else{
System.out.println("Please enter a valid country name.");
}
}
}

Here, I wrote a simple program where the user entered a country name, and corresponding to the entered country name user will see a message where the country capital is printed. Let’s run this program. The code compiled and runs fine there is no problem at all.

But there are two biggest problems in this code from the programmer’s point of view.

1. In this program, the end-user is responsible to enter the country name. The end-user entered the country name either lower case or upper case or mixture. But our program always considered lower case only. If the end-user entered country name only in lower case then only our program works. By mistake, if the end-user entered the country name in the upper case letter then our program will not wok. Let’s see the example.

There are two solutions to the above problem. First, We can replace equals() method with equalIgnoreCase(). But if in your program there are 1000 lines or 10000 lines then you need to replace the equals() method with an equalIgnoreCase() method with 1000 or 10000 times, which is not a good practice.

The second solution is, as we know our program accepts only lower case letters. So, what we will do is, If the end-user entered the country name we will convert it into a lower case letter. Then our problem will be solved. So the second solution is very easy because we need to write only one line. See the example below.

import java.util.Scanner;
class TrimExample{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
System.out.println("Enter Country Name: ");
String country = sc.nextLine().toLowerCase();

if(country.equals("india")){
System.out.println("Capital of india is delhi");
}
else if(country.equals("australia")){
System.out.println("Capital of australia is canberra");
}
else if(country.equals("england")){
System.out.println("Capital of england is london");
}
else{
System.out.println("Please enter a valid country name.");
}
}
}

Output:

Enter Country Name: INdia
Capital of india is delhi
Enter Country Name: ENGLand
Capital of england is london
Enter Country Name: AUSTRALIA
Capital of australia is canberra

2. But still, there is one more problem with this code. As we know, the end-user is responsible to enter the country name. If the end-user entered the country name with some spaces at the starting or ending then our program check is there some spaces followed by a country name is available or not. In our code, this case is not available, then our code will not works and show a message to the end-user please enter a valid country name. Let’s see the example.

To resolve this problem, What we can do, before comparing the country name if any spaces entered by the end-user either at the beginning or at the end, If we remove those spaces then our problem will be solved. We can remove spaces either at the beginning or end of the string by using the trim() method.

Removing Leading and Trailing WhiteSpaces from a String in Java Example Program

import java.util.Scanner;
class TrimExample{
public static void main(String args[]){
Scanner sc = new Scanner(System.in);
System.out.print("Enter Country Name: ");
String country = sc.nextLine().toLowerCase().trim();

if(country.equals("india")){
System.out.println("Capital of india is delhi");
}
else if(country.equals("australia")){
System.out.println("Capital of australia is canberra");
}
else if(country.equals("england")){
System.out.println("Capital of england is london");
}
else{
System.out.println("Please enter a valid country name.");
}
}
}

Output:

Enter Country Name: INdia
Capital of india is delhi
Enter Country Name: ENGLand
Capital of england is london
Enter Country Name: AUSTRALIA
Capital of australia is canberra

Java bitwise operators examples: In this tutorial, we will discuss the Bitwise Operators in Java with Examples. Bitwise Operators are used in general to manipulate the individual bits of a number. You can use these Java BitWise Operators with any kind of Integral Types such as Char, int, Short, etc., and can’t be applied to double and float. Learn all the Java Bitwise Operators in detail and how each of them works.

Read More: Java Map Interface with Example

Bitwise Operators

Explain bitwise operators in java with example: Bitwise Operators usually work on the binary digits of input values. You can apply these to several integer types such as long, short, char, int, and byte. Bitwise Operators work on the binary equivalent of decimal numbers and then perform the given operation on them bit by bit.

Now that you are aware of the Bitwise Operators let us understand how they work by looking at an example.

• Types of Bitwise Operators in Java
• Bitwise AND Operator (&)
• Bitwise OR Operator (|)
• Bitwise Complement Operator(~)
• Bitwise Exclusive OR Operator (^)
• Bitwise Shift Operators in Java
• Bitwise Shift Left Operator (<<)
• Bitwise Shift Right Operator(>>)
• Shift Right Zero Fill Operator(>>>)
• Bitwise Operators in Java Example Program

Types of Bitwise Operators in Java

Below is the table listing all the 7 BitWise Operators along with symbols, descriptions. Learn how to use these Java Bitwise operators as well.

Bitwise AND Operator (&)

This operator returns 1 if both the operands are 1 or else it returns 0.

Check out the below truth table for understanding the Bitwise AND Operator. Let us consider two operands A and B that can only take the Binary Values 1 or 0.

A	B	A & B
0	0	0
0	1	0
1	0	0
1	1	1

Bitwise AND Operator Example

Output:

x & y = 8

Bitwise OR Operator (|)

This operator returns 1 if either of the bits in the operand is 1, else it returns 0.

Below is the Truth Table for Bitwise OR Operator and you can learn the demonstration of the Bitwise OR Operator. Here A, B are Two Operands on which Bitwise OR Operation is performed.

A	B	A | B
0	0	0
0	1	1
1	0	1
1	1	1

Bitwise OR Operator with Example

Bitwise Complement Operator(~)

This operator inverts all of the bits of its operands. It is denoted by the symbol ~. However, this Bitwise Complement Operator in Java works with a single operand only unlike others.

Bitwise Complement Operator Example

public class BitwiseComplimentExample
{
public static void main(String[] args)
{
int x = 2;
// bitwise compliment // ~0010= 1101 = -3
System.out.println("~x = " + (~x));
}
}

Output:

~x = -3

Have a look at the below example to understand the same.

0 1 0 1

↓ ↓ ↓ ↓

1 0 1 0

Note: Remember that the Bitwise Complement of an Integer N is the same as -(N+1).

1’s Complement can be simply obtained by doing the negation of inputs i.e. if we have 1 the 1’s complement of it is 0 and if 1 is the input 1’s complement would be 0.

2’s Complement:

2’s Complement of a Number can be found by simply adding 1 to the result of 1’s complement.

24 in Binary  = 00011000

1’s Complement of 24 = 11100111

2’s Complement of 24 = 11100111

+1

——–––––

11101000

——–––––

Bitwise Exclusive OR Operator (^)

This operator returns 1 if the corresponding bits are different, else it returns 0. If both the operators are 0 or if both of them are 1 then the result is 0.

Check out the below truth table to understand the Bitwise Exclusive OR Operator clearly. Let A and B be two operands that take the binary values i.e. 0 or 1.

A	B	A ^ B
0	0	0
0	1	1
1	0	1
1	1	0

Bitwise XOR Operator Example

Output:

x ^ y = 1

Do Check: Vector in Java with Example

Bitwise Shift Operators in Java

There are three different types of Shift Operators in Java and they are in the below fashion. Each of them is explained clearly with their respective truth tables. They are as such

• Bitwise Shift Left Operator (<<)
• Bitwise Shift Right Operator(>>)
• Shift Right Zero Fill Operator(>>>)

The syntax for the Shift Right Operators is as such

value <operator> <number_of_times>

Bitwise Shift Left Operator (<<)

This operator shifts the bits of the number to the left and fills 0 in the void spaces that are left as a result. Left Shift Operator shifts all the bits towards the left by a certain number of bits specified and is denoted using the symbol <<.

Example:

If we Perform 1 Bit Left Shift Operation each individual bit is shifted by 1 bit. The Leftmost bit is discarded and the rightmost bit remains vacant and filled with 0s.

1    1    0   0
↙ ↙ ↙ ↙
Discarded 1 ←   1000←0(Replacement Bit)

Bitwise Left Shift Operator Example

Bitwise Shift Right Operator(>>)

This operator shifts the bits of the number to the right and fills 0 in the void spaces that are left as a result. It is denoted using the symbol >>. If we shift any number to the right least significant bit or rightmost digit is discarded and the most significant position(leftmost bit) is filled with the respective sign bit.
In Shift Right Operators there are two types namely

• Signed Right Shift Operator
• Unsigned Right Shift Operator

Signed Right Shift Operator: In this case, bits of the number are filled to the right and the void spaces are filled with the sign bit i.e. 1 for a negative number and 0 for a positive number. The leftmost bit depends on the initial number sign. Signed Right Shift is denoted using the symbol >>.

Example 1:
a = 10
a>>1 = 5 

Example 2:
a = -10 
a>>1 = -5
We store the sign bit.

Unsigned Right Shift Operator: Shifts the numbers of the bits to the right and fills 0 on the voids left as a result. The leftmost bit is set to 0. Unsigned Shift is represented using the symbol >>>.

Example 1:
a = 10
a>>>1 = 5

Example 2:
a = -10 
a>>>1 = 2147483643
Doesn't  preserve the sign bit.

Shift Right Zero Fill Operator(>>>)

This operator shifts the bits of the number to the right and fills 0 in the void spaces that are left as a result. The leftmost bit is set to be 0.

Bitwise Operators in Java Example Program

The following is a sample program that demonstrates all the Bitwise Operators. You can simply copy-paste the following program in your Java Compilers and run the same as it is.

public class BitwiseOperator {
public static void main(String[] args)
{
//Initial values
int a = 6;
int b = 7;

// bitwise and
// 0110 & 0111=0110 = 6
System.out.println("a&b = " + (a & b));

// bitwise or
// 0110 | 0111=0111 = 7
System.out.println("a|b = " + (a | b));

// bitwise xor
// 0110 ^ 0111=0001 = 1
System.out.println("a^b = " + (a ^ b));

// bitwise and
// ~0110=1001
// will give 2's complement of 1001 = -7
System.out.println("~a = " + ~a);

// bitwise left shift
System.out.println("a << 2 = " +(a << 2)); // bitwise right shift System.out.println("a >> 2 = " +(a >> 2));

// bitwise shift right zero fill
System.out.println("b >>> 2 = " +(b >>> 2));
}

}

Output:

The following Output is obtained for the above program.

jsp:forward: In this tutorial, we will discuss JSP Action Tags – JSP useBean, JSP include, JSP forward, and JSP param in detail with an example. First and foremost, let’s understand what is JSP Action Tags. In JSP, to use the bean, we need Action Tags. Also, know what is the difference between Directives & Actions along with the ultimate list of Action Tags in JSP.

This JSP Action Tags – JSP useBean, JSP include, JSP forward, and JSP param Tutorial Includes:  

• What are JSP Action Tags?
• Directives vs Actions
• List of some Action Tags in JSP
  1. jsp:include Action
  2. jsp:forward Action
  3. jsp:param Action
  4. jsp:useBean Action
  5. jsp:setProperty Action
  6. jsp:getProperty Action

What is JSP Action?

jsp include vs include: The tags which are used to implement the bean in a JSP are called JSP Action tags. JSP action tags are a set of predefined tags given by the JSP container to do some common tasks thus reducing the Java code in JSP.

A few of the common tasks are listed below:

1. Instantiate java bean object.
2. Setting values to beans.
3. Reading values from beans.
4. Forwarding the requests to another resource.
5. Including another resource.

Directives vs Actions

• Directives are applied while the translation phase whereas Actions are utilized at the time of the request processing phase.
• Unlike Directives, Actions are re-evaluated each time the page is accessed.

List of some Action Tags in JSP

The following are some of the Action Elements used in JSP:

JSP Action Tags	Description
jsp:forward	forwards the request and response to another resource.
jsp:include	includes another resource.
jsp:useBean	creates or locates bean object.
jsp:setProperty	sets the value of property in bean objects.
jsp:getProperty	prints the value of the property of the bean.
jsp:plugin	embeds another component such as applet.
jsp:param	sets the parameter value. It is used in forward and includes mostly.
jsp:fallback	can be used to print the message if a plugin is working. It is used in jsp:plugin.

Do Refer:

• JSP Directives: Page, Include & Taglib Directive
• Custom Tags in JSP with Example

1. <jsp:include> Action

It is used for both static and dynamic resources on a JSP page. The resources must be in the same context as the current page. It includes the output of the included page during runtime. It doesn’t include the content of the page, it includes only response.

Attributes:

S.No.	Attribute & Description
1. page	The relative URL of the page to be included.
2. flush	The boolean attribute determines whether the included resource has its buffer flushed before it is included.

Syntax:

 <jsp:include page="page name" />

Example:

2. <jsp:forward> Action

The JSP forward action tag is used to forward the content of one JSP page to another JSP page. The forward action terminates the action of the current page and forwards the request to another resource such as a static page, another JSP page, or a java servlet.

The static or dynamic resource to which control has to be transferred is represented as a URL. The user can have the target file as an HTML file, another JSP file, or a servlet. It implements the same functionality as the forward() method in the RequestDispatcher interface. It is used for forwarding the request from one JSP page to another JSP page.

Syntax:

<jsp:forward page ="URL"/>

Example:

3. <jsp:param> Action

The JSP param action is used to add the specific parameter to the current request. Using a name/value pair this is done.The JSP:param action tag can be used inside a jsp:include, jsp:forward and jsp:plugin. A translation error will occur if is used within any other action besides the ones just mentioned.

Syntax:

 <jsp:paramname="parametername" value = "parametervalue" />

Example:

JavaBeans class:

4. <jsp:useBean> Action

It is the standard action, which can make a java object available for use. Then it is possible to get and set the properties on the object(JavaBean). Within a given scope, the bean is determined and with a newly declared scripting variable, It is given an Id. When an element is used then no java scripting variables are created, instead, an EL variable is created. It is possible to use a variety of attributes with

• id: It is used to identify the object instance in the specified scope.
• scope: The scope in which the reference to the bean is available.
• class: a fully qualified class name.
• bean name: The name of the bean, as provided to the instantiate() method of the java.beans.Bean class.
• type: It is an optional attribute that defines the type of the scripting variable defined.

Syntax:

<jsp:useBean id="name" class= "package.class" scope="page/request/session/application"/>

Example: 

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Action JSP1</title>
</head>
<body>
<jsp:useBean id="name" class="demotest.DemoClass">
</body>
</html>

5. <jsp:setProperty> Action

A bean property is set by this property. Using the standard action, the bean must have been previously defined. you can set a bean property by using it in the following ways:

• using a parameter in the request object.
• using a String constant value.
• using a value from a request-time attribute

Syntax:

<jsp:setProperty name= "propertyname" property="some property" value ="some value" />

6. <jsp:getProperty> Action

The getProperty action tag is used to retrieve the value of a given property and convert it to a string and finally insert it into the output. The property value is converted into a String within the action in one of the two ways: The toString() method is called if the property is an object. The valueOf() method of the wrapper class is called if the property is primitive.

Syntax:

 <jsp:getProperty name="name" property="propertyname" />

Example using JSP useBean, JSP setProperty, and JSP getProperty:

JavaBean class: