3:I[39275,[],""] 5:I[61343,[],""] 6:I[23053,["7699","static/chunks/8e1d74a4-5fcc24cf3a9fd8c2.js","7240","static/chunks/53c13509-baa86b522e6ae78c.js","4740","static/chunks/4740-14bdf05e7ce04a11.js","9617","static/chunks/9617-544346a1cd0024b4.js","3185","static/chunks/app/layout-8c4bc5784f5090d9.js"],"StateProvider"] 7:I[19593,["7699","static/chunks/8e1d74a4-5fcc24cf3a9fd8c2.js","7240","static/chunks/53c13509-baa86b522e6ae78c.js","4740","static/chunks/4740-14bdf05e7ce04a11.js","9617","static/chunks/9617-544346a1cd0024b4.js","3185","static/chunks/app/layout-8c4bc5784f5090d9.js"],""] 8:I[18709,["7699","static/chunks/8e1d74a4-5fcc24cf3a9fd8c2.js","5706","static/chunks/9c4e2130-08078aeb5700c43b.js","5505","static/chunks/385cb88d-fd2f37c33b8aa92c.js","5452","static/chunks/5e22fd23-9bf9fa71e7554411.js","9956","static/chunks/ee560e2c-f551c028fd538293.js","4740","static/chunks/4740-14bdf05e7ce04a11.js","6648","static/chunks/6648-3bc9d66179346fb0.js","9160","static/chunks/app/not-found-5850ce7843ba4d5a.js"],"default"] 9:I[45723,["7699","static/chunks/8e1d74a4-5fcc24cf3a9fd8c2.js","7240","static/chunks/53c13509-baa86b522e6ae78c.js","4740","static/chunks/4740-14bdf05e7ce04a11.js","9617","static/chunks/9617-544346a1cd0024b4.js","3185","static/chunks/app/layout-8c4bc5784f5090d9.js"],"default"] 4:["all","core-java","c"] 0:["79z6y6ppLce0GndJRjYzJ",[[["",{"children":[["all","core-java","c"],{"children":["__PAGE__",{}]}]},"$undefined","$undefined",true],["",{"children":[["all","core-java","c"],{"children":["__PAGE__",{},[["$L1","$L2"],null],null]},["$","$L3",null,{"parallelRouterKey":"children","segmentPath":["children","$4","children"],"error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":"$undefined","notFoundStyles":"$undefined","styles":[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/402d889fee29bde2.css","precedence":"next","crossOrigin":"$undefined"}],["$","link","1",{"rel":"stylesheet","href":"/_next/static/css/0ff6cecb1d0e96f8.css","precedence":"next","crossOrigin":"$undefined"}],["$","link","2",{"rel":"stylesheet","href":"/_next/static/css/cb4e98a4c2dc4d80.css","precedence":"next","crossOrigin":"$undefined"}],["$","link","3",{"rel":"stylesheet","href":"/_next/static/css/a246b44e33111fd9.css","precedence":"next","crossOrigin":"$undefined"}],["$","link","4",{"rel":"stylesheet","href":"/_next/static/css/9d9d0f6a85930e46.css","precedence":"next","crossOrigin":"$undefined"}]]}],null]},[["$","html",null,{"lang":"en","children":["$","body",null,{"children":["$","$L6",null,{"children":[["$","$L7",null,{}],["$","$L3",null,{"parallelRouterKey":"children","segmentPath":["children"],"error":"$undefined","errorStyles":"$undefined","errorScripts":"$undefined","template":["$","$L5",null,{}],"templateStyles":"$undefined","templateScripts":"$undefined","notFound":["$","$L8",null,{}],"notFoundStyles":[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/cb4e98a4c2dc4d80.css","precedence":"next","crossOrigin":"$undefined"}]],"styles":null}],["$","$L9",null,{}]]}]}]}],null],null],[[["$","link","0",{"rel":"stylesheet","href":"/_next/static/css/0cc2495744a38244.css","precedence":"next","crossOrigin":"$undefined"}]],"$La"]]]] b:I[30043,["7699","static/chunks/8e1d74a4-5fcc24cf3a9fd8c2.js","5706","static/chunks/9c4e2130-08078aeb5700c43b.js","5505","static/chunks/385cb88d-fd2f37c33b8aa92c.js","5452","static/chunks/5e22fd23-9bf9fa71e7554411.js","9956","static/chunks/ee560e2c-f551c028fd538293.js","7240","static/chunks/53c13509-baa86b522e6ae78c.js","6051","static/chunks/795d4814-d7614a20709c27af.js","614","static/chunks/3d47b92a-f2bb54912083012c.js","9212","static/chunks/59650de3-13cfd2620b7240d2.js","522","static/chunks/94730671-a8ad9eca65504500.js","7675","static/chunks/b563f954-501d993050fd0717.js","1994","static/chunks/e34aaff9-cd556a7ee1a90c03.js","6990","static/chunks/13b76428-5a68792917164904.js","5957","static/chunks/30a37ab2-a5fc2d8864b3152b.js","6844","static/chunks/f25cdb8d-30c837856fb6d42d.js","7259","static/chunks/479ba886-8536ff4966e1aaf8.js","4740","static/chunks/4740-14bdf05e7ce04a11.js","6648","static/chunks/6648-3bc9d66179346fb0.js","4349","static/chunks/4349-c8f0646a83cc4179.js","4791","static/chunks/4791-6c93b9aca8a9f315.js","5225","static/chunks/5225-dc21c87d99338f19.js","9293","static/chunks/9293-d1b040d0324d0d5a.js","5919","static/chunks/5919-545104f05818203e.js","1413","static/chunks/1413-986ad1f4cd2d661e.js","2499","static/chunks/2499-61bd3b514e9c4cb8.js","4175","static/chunks/4175-fb05509a4e1790ec.js","5653","static/chunks/app/%5B...all%5D/page-f1bbbeae9a681a62.js"],"default"] c:T9c6,d:T4a8e,

Swing is the principal GUI toolkit for the Java programming language. It's part of the Java Foundation Classes API, which offers a graphical user interface (GUI) for Java applications.

Building efficient GUI apps get easy with all the components that come with a swing in Java. Java programming language is structured programming, and with the rising demand, it is essential to learn all Java programming fundamentals. This article addresses swing in Java and the Java swing class hierarchy.

Swing is a library in the Java Foundation Classes (JFC) that expands on the abstract window toolkit (AWT) and provides enhanced functionality and additional UI elements. Extended components have top-notch event handling and drag-and-drop capabilities — introducing java swing — introducing the significance of the swing java tutorial.

Swing is included in the standard Java distribution and features about four times as many User Interface (UI) components as AWT. The AWT is a constrained implementation that is not nearly capable of supplying the components necessary for constructing the complex GUIs that are required in today's commercial applications. It is because the needs for today's application GUIs have changed.

When compared to the resources offered by Swing, the AWT component set is plagued with quite a few flaws and uses up a significant amount of the system's available resources. Programmers that create graphical user interfaces for commercial applications began to show much interest in its Classes.

  1. Swing is available for use in creating GUIs.
  2. Swing may use to develop the graphical user interfaces of server-side and client-side programs.
  3. The original code for the Swing framework wrote entirely in Java.
  4. The Abstract Windowing Toolkit includes the Swing library (Abstract Window Toolkit). 
  5. Swing allows for a more customizable and flexible user experience and access to more robust building blocks.
  6. Swing components in Java may run on any supported platform and are very efficient.

Table of Contents

What is Java Swing?

Java Swing is a graphical user interface toolkit part of the Java Foundation Class (JFC). It is used to create Java-based applications that run various platforms, including Windows, MAC OS, and Linux. Swing provides a rich set of widgets, including buttons, labels, trees, and tables.

Benefits of using java swing

How to use Java Swing

It would be best if you had a basic understanding of java before using Java Swing. It includes understanding how to create and compile Java programs using the Java Program Kit (JDK). You should also be familiar with the swing class hierarchy. In addition to the core swing classes, you must import the package to handle events in swing components.

Java Swing is used to developing graphical user interfaces and other applications. Swing is a component-based framework that includes a rich set of widgets, such as buttons, labels, and text fields. It also provides a set of layout managers that allow you to control the size and position of components on a window or panel.

In addition, Swing provides a set of graphics and utility classes that make it easy to create and manipulate images, fonts, colors, and other graphical objects.

Swing applications are event-driven. Event–handling code is generally placed in a separate class, called an event listener, registered with the component that generates the events. When an event occurs, the event listener is notified and can take appropriate action.

Swing is platform-independent. The same code on one platform will run on any other platform that supports java. It makes it possible to write once and run anywhere.

Swing is also extensible. Developers can create their custom components and add them to the Swing toolkit.

Want to acquire industry skills and gain complete knowledge of Java? Enroll in Instructor-Led live Core Java Training to become Job Ready!

Features of Java Swing

Common java swing components

Java Swing is used to develop graphical user interfaces (GUIs) and other applications. Swing is a component-based framework that includes a rich set of widgets, such as buttons, labels, text fields, combo boxes, radio buttons, sliders, scroll panes, toolbars, progress bars, text areas, and tabbed panes.

It also provides a set of layout managers that allow you to control the size and position of components on a window or panel. In addition, Swing provides a set of graphics and utility classes that make it easy to create and manipulate images, fonts, colors, and other graphical objects.

Also read: Java Regular Expressions

Advantages of Java Swing

The advantages are as follows:

Short Way to Create a JFrame in Java

Container Class

A container class is any class that contains other components. At least one container class is required when developing a GUI application.

Generally speaking, there are three distinct categories of container classes:

  1. Panel - A tool for arranging windowed elements.
  2. Frame- A fully operational Window with tabs, icons, and titles is a Frame.
  3. Dialog - A dialogue box appears, similar to a pop-up window but with limited functionality compared to the frame.

Use of JButton classes

It is used to make a button with a label. When the button is pushed, something will happen because of the ActionListener. It comes from the AbstractButton class and works on any platform.

Purpose of a layout manager

To arrange the components inside a container, we use the layout manager. There are several layout managers:

  1. Border layout.
  2. Flow Layout.
  3. Grid Bag layout.

Checkout:[Arraylist in Java]

About MVC connection

1) A visual component is usually made up of three different parts:

  1. The appearance of the component when rendered on the screen.
  2. The process in which the component responds to the user.
  3. The component's related state information.

2) Model-view-controller, or MVC for short, is a component architecture that has stood the test of time and has shown to be incredibly successful.

  1. In MVC technology, the model is the same as the component's state information.
  2. The view controls how the component looks on the screen, including any parts of the idea that depending on the model's current state.
  3. The controller tells the part how to respond to the user.

3) As detailed below, even the most basic swing parts offer advantages over their AWT counterparts.

  1. Swing buttons and labels can either display pictures instead of text or both text and images simultaneously.
  2. The bounds of the majority of swing components are simply modifiable.
  3. It is not required that the components of swings be rectangular.
  4. The most recent iterations of aggressive technology, like screen readers, can effortlessly extract data from swing components.

MVC Architecture

In the following manner, the Swing API architecture adheres to the loosely based MVC architecture.

  1. Model represents component’s data.
  2. View represents a visual representation of the component’s data.
  3. Controller takes the input from the user on the view and reflects the changes in the component’s data.
  4. Swing component has a Model as a separate element, while the view and controller parts are clubbed in the user interface elements.

 

Conclusion:

Java is a popular programming language used to develop desktop and web applications. It is one of the most popular programming languages that is used today. Java programming language is a multi-paradigm programming language. Java is a programming language used to develop applications in different programming paradigms. It supports procedural programming and functional programming paradigms as well.

You can create a desktop-style application with the help of Java Swing. Creating desktop–style applications is quite similar to creating a web application, but in this case, you will have to build a desktop-style application with the help of a swing toolkit.

This article aims to show how to create a simple desktop-style application with the help of the Swing Toolkit. The next step is creating an application with a single JFrame containing an image and text messages. We will use JFrame as a container for our application. 

The only difference between this and a typical web application is that we will build it on the desktop instead of on the web.

e:T4a1e,

In Java, a Stream is a series of data from various sources, including lists, arrays, sets, and other collections. Unlike collections, which must gather all the values before beginning processing, streams can do so asynchronously. The stream can be thought of as a pipeline in which data is processed as it is needed. This article compiles all of the blog posts covering the basics of the Jave Stream API and associated topics.

We all have heard the term java. It is a programming language or, in other terms, an object-oriented programming language and software platform. It is used in billions of devices, consoles, games, and many more. Learning Java is helpful in this century; as we discussed, many software use java as a programming language and even for designing games we all love and enjoy playing.

One of Java 8's most notable additions was support for streams. This in-depth Java stream tutorial serves as an introduction, and it will cover a wide range of features made possible by streams, emphasizing concrete, real-world applications. Data is never stored in a stream, so it cannot be considered a data structure. And it never changes the original data sources, either.

Java Stream Tutorial - Table of Contents

Why Java Stream?

Java streams enable us with functional-style operations on streams of elements. A stream is just an abstraction of a non-mutable collection of functions applied in some order to the data. A stream is not a collection where you can easily store elements.

Functionality is managed via a Java component. It is made feasible by java.util.stream, which allows for functional-style operations on stream items that are analogous to the map-reduce transformations performed on collections. The descriptions will be easier to grasp because of the visuals.

Now, let's look at a few easy and simple examples of how to create and use streams before we get into terms and core ideas.

An example is displayed here. 

private static Employee[] arrayOfEmps = {

    new Employee(1, "Jeff Bezos", 100.0), 

    new Employee(2, "Bill Gates", 200.0), 

    new Employee(3, "Mark Zuckerberg," 300.0)

};

Stream.of(arrayOfEmps);

Note: In Java 8, the Collection interface now contains a new stream() function.

We may also create a stream for any individual object using stream.of():

Or we can use stream.builder():

Example:

Stream.Builder<Employee> empStreamBuilder = Stream.builder();

empStreamBuilder.accept(arrayOfEmps[0]);

empStreamBuilder.accept(arrayOfEmps[1]);

empStreamBuilder.accept(arrayOfEmps[2]);

Stream<Employee> empStream = empStreamBuilder.build();
Want to acquire industry skills and gain complete knowledge of Java? Enroll in Instructor-Led live Core Java Training to become Job Ready!

Java stream operations

Let's look at some popular applications of the new stream language and specific operations we may execute on it and with its help.

forEach

It is one of the most simple and joint operations; it loops over stream elements. The method is so standard that it is introduced directly in Iterable, Map, and many more.

Example:

@Test

public void whenIncrementSalaryForEachEmployee_thenApplyNewSalary() 

{    

    empList.stream().forEach(e -> e.salaryIncrement(10.0));

     assertThat(empList, contains(

      hasProperty("salary", equalTo(110000.0)),

      hasProperty("salary", equalTo(220000.0)),

      hasProperty("salary", equalTo(330000.0))

    ));

}

If you use the forEach() function, the stream pipeline will be considered consumed and unusable once the procedure has finished.

Related article: Exception Handling in java

map

A new stream is created by the map() function when a function is applied to each element of the previous stream, also known as the "original stream." The new stream could branch off into a few different directions.

The following code snippet shows how to transform a sequence of Integers into an equal sequence of Employees.

@Test

public void whenMapIdToEmployees_thenGetEmployeeStream() 

{

    Integer[] empIds = { 1, 2, 3 };

    List<Employee> employees = Stream.of(empIds)

      .map(employeeRepository::findById)

      .collect(Collectors.toList());

    assertEquals(employees.size(), empIds.length);

}

In this section, we convert an array of employee IDs into an integer stream. Because each integer is given to the function employeeRepository::findById(), which returns the object representing the relevant employee, an employee stream is essentially created.

collect

We got a glimpse of how the collection works in the example mentioned earlier; it is one of the most common ways to get stuff or works out of the stream when we have done or completed the processing: 

@Test

public void whenCollectStreamToList_thenGetList() 

{

    List<Employee> employees = empList.stream().collect(Collectors.toList());  

    assertEquals(empList, employees);

}

The collect() method applies mutable fold operations on the data items kept in the Stream instance. These processes include repackaging elements to various data structures and applying further logic, concatenating them, and so on.

The implementation of the Collector interface supplies the strategy that should use for this operation. In the preceding illustration, we gathered all of the Stream items into a List instance with the help of the toList collector.

Related article: Interface in Java

filter

filter() produces a new stream that consists of a component of the original stream which passes a given test

Example:

 

@Test

public void whenFilterEmployees_thenGetFilteredStream() 

{

    Integer[] empIds = { 1, 2, 3, 4,5 };

    List<Employee> employees = Stream.of(empIds)

      .map(employeeRepository::findById)

      .filter(e -> e != null)

      .filter(e -> e.getSalary() > 200000)

      .collect(Collectors.toList());

   assertEquals(Arrays.asList(arrayOfEmps[2]), employees);

}

 

In the above example, null references for invalid employee ids are filtered away before a second filter is used to retain only workers with wages over a specified threshold.

findFirst

It returns an optional entry in the stream, and the options can be empty.

Example:

@Test

public void whenFindFirst_thenGetFirstEmployeeInStream() 

{

    Integer[] empIds = { 1, 2, 3, 4,5 };

    Employee employee = Stream.of(empIds)

      .map(employeeRepository::findById)

      .filter(e -> e != null)

      .filter(e -> e.getSalary() > 100000)

      .findFirst()

      .orElse(null);

    assertEquals(employee.getSalary(), new Double(200000));

}

This section returns the first employee whose annual compensation is higher than 100,000 dollars. If there is no such employee, it will return the value null.

Checkout: [Polymorphism in Java]

toArray

We learned how to collect() works to get out of the stream. If there is a need to get out of the stream, we just need to use Array():

Example:

@Test

public void whenStreamToArray_thenGetArray() 

{

    Employee[] employees = empList.stream().toArray(Employee[]::new);

    assertThat(empList.toArray(), equalTo(employees));

}

flatMap

flatMap holds a bit complex data structures like stream <List<String>>

Example 

@Test

public void whenFlatMapEmployeeNames_thenGetNameStream() 

{

    List<List<String>> namesNested = Arrays.asList( 

      Arrays.asList("Jeff", "Bezos"), 

      Arrays.asList("Bill", "Gates"), 

      Arrays.asList("Mark", "Zuckerberg"));

    List<String> namesFlatStream = namesNested.stream()

      .flatMap(Collection::stream)

      .collect(Collectors.toList());

    assertEquals(namesFlatStream.size(), namesNested.size() * 2);

}

Note: notice how we were able to change or convert Stream<List<String>> to a more straightforward Stream<String> – using the flatMap() API.

peek

ForEach(), a terminal operation, was demonstrated previously in this section. Before applying any terminal action, we might need to run many operations on each stream element.

Also read: Inheritance in Java

Peek ()

In such circumstances, the peek() function could come in handy. To put it more simply, it does the action provided on each stream element and then returns a new stream that may use in subsequent processing. Peek () is an operation that occurs in between:

Example:

@Test

public void whenIncrementSalaryUsingPeek_thenApplyNewSalary()
 {

    Employee[] arrayOfEmps = {

        new Employee(1, "Jeff Bezos", 100000.0), 

        new Employee(2, "Bill Gates", 200000.0), 

        new Employee(3, "Mark Zuckerberg," 300000.0)

    };

    List<Employee> empList = Arrays.asList(arrayOfEmps);  

    empList.stream()

      .peek(e -> e.salaryIncrement(10.0))

      .peek(System.out::println)

      .collect(Collectors.toList());

    assertThat(empList, contains(

      hasProperty("salary", equalTo(110000.0)),

      hasProperty("salary", equalTo(220000.0)),

      hasProperty("salary", equalTo(330000.0))

    ));

}

Method types and pipelines

filter() and other similar intermediate procedures create a new stream that may use for further processing. When a stream is consumed by a terminal operation like forEach(), it can no longer use it.

In a stream pipeline, the first component is the stream source, then there may be one or more actions in between, and finally, there will be an end operation.

Here's a sample stream pipeline where emptiest is the source, filter() is the intermediate operation, and count over here is the terminal operation:

@Test

public void whenStreamCount_thenGetElementCount() 
{

    Long empCount = empList.stream()

      .filter(e -> e.getSalary() > 200000)

      .count();

    assertEquals(empCount, new Long(1));

}

Some of the processes can be categorized as "short-circuiting." Employing "short-circuiting" methods makes it possible to perform calculations on infinite streams in a finite amount of time.

Example:

@Test

public void whenLimitInfiniteStream_thenGetFiniteElements() {

    Stream<Integer> infiniteStream = .Stream.iterate(2, i -> i * 2).;

    List<Integer> collect = infiniteStream

      .skip(3)

      .limit(5)

      .collect(Collectors.toList());

    assertEquals(collect, Arrays.asList(16, 32, 64, 128, 256));

}

 

In the above example, we used short-circuiting operations skip() to skip the first three elements and limit() to limit to 5 elements from the infinite stream generated using iterate().

Lazy evaluation

Lazy evaluation is one of the most critical parts of streams. As such, it is also one of the essential features of streams since it makes considerable improvements possible. As a result, lazy evaluation is one of the most important qualities of streams.

When the terminal action is started, the computation on the source data is carried out, and the source items are only consumed when it is essential to accomplish the task at hand. All activities that occur over the course of processing are referred to as being lazy, which means that they are placed on hold until it is essential to generate the result. It holds true for all the actions that occur during the processing.

Example:

@Test

public void whenFindFirst_thenGetFirstEmployeeInStream() 
{

    Integer[] empIds = { 1, 2, 3, 4,5 };   

    Employee employee = Stream.of(empIds)

      .map(employeeRepository::findById)

      .filter(e -> e != null)

      .filter(e -> e.getSalary() > 100000)

      .findFirst()

      .orElse(null);    

    assertEquals(employee.getSalary(), new Double(200000));

}
Related Article: Java Annotations

Conclusion:

We got the basics of the java stream, and the details mentioned earlier will help you in developing knowledge for the java stream. We already discussed that Java is the essential programming language, and it is used in software and has a bright future. Learning the language in depth will surely help excellent or high-knowledge programmers.

It may seem complex or challenging to first-time users, but it will be easy with time and proper practice, as we know practice makes things easier. Making notes might help better learning instead of just reading it from the web page and trying to understand it. The examples mentioned are for better understanding any problem in understanding the theory portion; the examples might help in understanding the function of the element. 

f:Ta5a,

 

Stack using Linked List

Another way to represent a stack is by using a linked list. A stack can be represented by using nodes of the linked list. Each node contains two fields: data(info) and next(link) The data field of each node contains an item in the stack and the corresponding next field points to the node containing the next item in the stack The top refers to the topmost node (The last item inserted) in the stack. The empty stack is represented by setting top to nut. Because of the way the nodes are pointing, push and pop operations are easy to accomplish.  

Stack using Linked List      

Program:

Program to implement stack using linked list

# include <stdio.h>
# include <conio.h>
# include <stdlib.h>
struct Node
{
int data;
struct node *top=NULL;
void insertion(int x)
{
struct node *temp;
temp=(struct node *) malloc (size of  (structure node));
temp 7 data =x;
temp7 link =top;
top=temp;
}
int deletion ()
{
struct node  *temp;
int x;
if(cop==NULL)
return -1;
else
{
temp=top;
top=top 7 link;
x=temp 7 data;
free(temp);
return x;
}
void display()
{
struct node *temp;
if(top=NULL)
printf(“stack is empty n”);
else
{
printf(“The contents are “ n”);
temp=top;
while(temp!=NULL)
{
printf(“%5d”,temp7data);
temp=temp7 link;
}
}
}
void main()
{
int ch, x;
clrscr();
printf(“1.INSERTION n”);
printf(“2. DELETION n”);
printf(“3. DISPLAY  The stack n”);
printf(“ 4. EXIT n”);
do
{
printf(“Enter ur choice : n”);
scanf(“%d”, &ch);
switch(ch)
{
case 1 :
printf(“Enter Data elements : n”)       ;
scanf(“%d”,&x);
insertion(x);
case 2 :
x=deletion();
if(x==-1)
printf(“STACK is EMPTY n”)                 ;
else
printf(“ The Deleted value is : %d n”,x);
break;
case 3:
display ();
break;
case 4:
Exit(0);
}
} while(ch<=4);
getch();
}

   

10:T1860,

Linear Queue

A queue is an ordered list in which items may be added only at one end called the “rear” and items may be removed only at the other end called “front”.

Examples

  1. A line of passengers waiting to buy tickets at a reservation counter. Each new passenger gets in line at the “rear”; the passenger at the front of the lines is reserved.
  2. A linear queue can be found in a time-sharing computer system where many users share the system simultaneously.
  3. The first element, which is added to the queue will be the first one to be removed. Thus queues are also called First-in First-Out lists (FIFO) or Last-In-Last-Out lists (LILO).

  Linear Queues  

 

Data Structures Interview Questions

Front=-1; Rear=-1;  

Program: Implementation of linear queues using arrays. 

# include <studio.h>
#include <conio.h>
#include <stdlib.h>
#define maxsize 5
intqueue [maxsize];
int Front=-1;
int Rear=-1;
void Insertion ()
{
intele;
if(Rear== maxsize-1)
{
printf(“Queue is overflow n”);
}
else
{
printf(“Enter an element:”);
sacnf(“%d”,&ele);
Rear=Rear+1;
Queue[Rear]=ele;
if(Front==-1)
{
Front=0;
}
}
}
void deletion ()
{
if(Front==-1)
{
printf(“Queue is under flown”);
}
else
{
printf(“ Deleted element is: %d n”, Queue [Front]);
if (Front==Rear)
{
Front=-1;
Rear=-1;
}
else
{
Front=Front+1;
}
}
}
void display ()
{
inti;
if (Front ==-1)
{
printf(“Queue is under flow n”);
}
else
{
for(i= Front; i<= Rear; i++)
{
prinft(“%5d”,Queue[i]);
}
printf(“n”);
}
}
void main()
{
int choice;
clrscr();
int choice;
printf(“1.INSERTION n”);
printf(“2.DELETION  n”);
printf(“3.DISPLAY  n”);
printf(“4.EXIT n”);
do
{
printf(“Enter your choice:”);
scanf(“%d”,&choice);
switch (choice)
{
case1: insertion (); break;
case2: deletion (); break;
case3: Display(); break;
case4: (0);
}
}
while (choice <=4)
}

1). Initial State:

Linear Queues  

 2). After inserting element 10

Linear Queues in Data Structures

  3). After inserting elements 20, 30, 40, 50:

Linear Queues in Data Structures

4). Inserting element 60 Queue is over flow  

5).After deleting elements 10,20,30,40:

Linear Queues in Data Structures

   5). After inserting elements 20, 30, 40, 50:

Linear Queues in Data Structures  

Applications of the queue:

 

11:T120c5,

Are you planning to attend an interview for a Java role but confused on how to crack that interview and also what would be the most probable Advanced Java Interview Questions that the interviewer may ask? Well, you have reached the right place. Tekslate has collected the most frequently asked Java Advanced Interview Questions which are often asked in multiple interviews.

Most frequently asked Advanced Java Interview Questions

Advanced Java Interview Questions

Q1) What are java objects and java applications? 

Ans. Java object is an object that is provided by the execution of an application. When an application is compiled an object of that application is being made. Java application on the other hand is a program that is being written in Java and being read by the Java virtual machine.

Q2) What is the purpose of garbage collection in Java, and when is it used?

Ans. The purpose of garbage collection is to identify and discard objects that are no longer needed by a program so that their resources can be reclaimed and reused. A Java object is subject to garbage collection when it becomes unreachable to the program in which it is used.

Q3) Advantages and disadvantages of Java Sockets.

Ans:

Advantages of Java Sockets: 

Sockets are flexible and easy to implement for general communications. - Sockets cause low network traffic unlike HTML forms and CGI scripts that generate and transfer whole web pages for each new request.

Disadvantages of Java Sockets:

Socket-based communications allow only to send packets of raw data between applications. - Both the client side and server side have to provide mechanisms to make the data useful in any way.

Q4) Describe synchronization with respect to multithreading.

Ans. With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared variable while another thread is in the process of using or updating the same shared variable. This usually leads to significant errors.

Do you want to master Advanced Java? Then enrol in "Advanced Java Training" This course will help you to master Advanced Java.

Q5) Explain the different ways of using thread?

Ans. The thread could be implemented by using a runnable interface or by inheriting from the Thread class. The former is more advantageous, 'cause when you are going for multiple inheritances. the only interface that can help.

Q6) What is an immutable class? How to create an immutable class? 

Ans. An immutable class is a class that once created, contents can not be changed. - Immutable objects are objects whose state can not be changed once constructed. - Since the state of the immutable objects can not be changed once they are created they are automatically synchronized/thread-safe. - Immutable objects are automatically thread-safe since the state of the immutable objects can not be changed once they are created - All wrapper classes in Java. lang are immutable, i.e. String, Integer, Boolean, Character, Byte, Short, Long, Float, Double, BigDecimal, BigInteger

Q7) What is pass by reference and pass by value?

Ans. Pass By Reference means passing the address itself rather than passing the value. Pass by Value means passing a copy of the value to be passed.

Q8) What is the difference between ArrayList and vector? 

Ans. ArrayList is not thread-safe whereas Vector is thread-safe. - In the Vector class each method is surrounded by a synchronized block and thus making Vector class thread-safe. - Both the ArrayList and Vector hold onto their contents using an Array. - When an element is inserted into an ArrayList or a Vector, the object will need to expand its internal array if it runs out of room. - A Vector defaults to doubling the size of its array, while the ArrayList increases its array size by 50 percent.

Q9) What is HashMap and Map?

Ans. The map is Interface and Hashmap is the class that implements that.

Q10) Difference between HashMap and HashTable?

Ans. The HashMap class is roughly equivalent to Hashtable, except that it is unsynchronized and permits nulls. (HashMap allows null values as key and value whereas Hashtable doesn't allow). HashMap does not guarantee that the order of the map will remain constant over time. HashMap is unsynchronized and Hashtable is synchronized.

Q11) What is the difference between a constructor and a method?

Ans. A constructor is a member function of a class that is used to create objects of that class. It has the same name as the class itself, has no return type, and is invoked using the new operator. A method is an ordinary member function of a class. It has its own name, a return type (which may be void), and is invoked using the dot operator.

Q12) What is an Iterator?

Ans. Some of the collection classes provide traversal of their contents via java. util.Iterator interface. This interface allows you to walk through a collection of objects, operating on each object in turn. Remember when using Iterators that they contain a snapshot of the collection at the time the Iterator was obtained; generally, it is not advisable to modify the collection itself while traversing an Iterator.  

Q13) What is the difference between multitasking and multithreading?

Ans.

Multitasking includes two ways of representation:

1. Preemptive multitasking: where the system terminates the idle process without asking the user.

For example Unix/Linux, Windows NT

2. Non-preemptive multitasking: where the system asks the process to give control to other processes for execution.

For example Windows 3.1 and Mac OS 9.

Multithreading:

1. Multithreaded programs are program that extends the functionality of multitasking by dividing the program in the thread and then executing the task as individual threads.

2. Threads run in a different area and each thread utilizes some amount of CPU and memory for execution.

Q14) What is the difference between an Interface and an Abstract class?

Ans. An abstract class can have instance methods that implement a default behaviour. An Interface can only declare constants and instance methods, but cannot implement default behaviour and all methods are implicitly abstract. An interface has all public members and no implementation. An abstract class is a class that may have the usual flavours of class members (private, protected, etc.), but has some abstract methods.

 

Java Advanced Interview Questions

Q15) What is synchronization and why is it important?

Ans. With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared object while another thread is in the process of using or updating that object's value. This often leads to significant errors.

Q16) Difference between Vector and ArrayList?

Ans. Vector is synchronized whereas ArrayList is not.

Go through this Advanced Java Tutorial to learn Advanced Java end-to-end!

Q17) What is the difference between multiple processes and multiple threads?

Ans. Multiple processes are the way to provide a multitasking environment to the user to allow him to switch over to different programs quickly. In these processes, it consists of a complete set of its own variables and data. Multiple threads share the same variable and the same data. Multiple processes are safe to use but multiple threads are riskier in the sense that they share the same data.

Multiple processes have much more overhead but multiple threads have less overhead and individual threads can be stand-alone if other threads are destroyed.

In multiple processes, intercommunication is slower and more restrictive, whereas communication between threads is faster.

Q18) What is an abstract class?

Ans. Abstract class must be extended/subclassed (to be useful). It serves as a template. A class that is abstract may not be instantiated (ie, you may not call its constructor), an abstract class may contain static data. Any class with an abstract method is automatically abstract itself and must be declared as such. A class may be declared abstract even if it has no abstract methods. This prevents it from being instantiated.

Q19) What is static in Java?

Ans. Static means one per class, not one for each object no matter how many instances of a class might exist. This means that you can use them without creating an instance of a class. Static methods are implicitly final, because overriding is done based on the type of the object, and static methods are attached to a class, not an object. A static method in a superclass can be shadowed by another static method in a subclass, as long as the original method was not declared final. However, you can't override a static method with a nonstatic method. In other words, you can't change a static method into an instance method in a subclass.

Q20) What is the final?

Ans.  A final class can't be extended ie., the final class may not be subclassed. A final method can't be overridden when its class is inherited. You can't change the value of a final variable (is a constant).

Q21) What if the main method is declared as private?

Ans. The program compiles properly but at runtime, it will give a "Main method not public." message.

Q22) What if the static modifier is removed from the signature of the main method?

Ans: Program compiles. But at runtime throws an error "NoSuchMethodError".

Q23) What if I write a static public void instead of a public static void?

Ans. The program compiles and runs properly.

Q24) What if I do not provide the String array as the argument to the method?

Ans. The program compiles but throws a runtime error "NoSuchMethodError".

Q25) What is the first argument of the String array in the main method?

Ans. The String array is empty. It does not have any element. This is unlike C/C++ where the first element by default is the program name.

Q26) If I do not provide any arguments on the command line, then the String array of the Main method will be empty or null?

Ans. It is empty. But not null.

Q27) How can one prove that the array is not null but empty using one line of code?

Ans. Print args. length. It will print 0. That means it is empty. But if it would have been null then it would have thrown a NullPointerException on attempting to print args. length.

Q28) Can an application have multiple classes having the main method?

Ans. Yes, it is possible. While starting the application we mention the class name to be run. The JVM will look for the Main method only in the class whose name you have mentioned. Hence there is no conflict amongst the multiple classes having the main method.

Q29) Can I have multiple main methods in the same class?

Ans. No, the program fails to compile. The compiler says that the main method is already defined in the class.

 

Core Java Interview Questions

Q30) Do I need to import Java.lang package any time? Why?

Ans. No. It is by default loaded internally by the JVM.

Q31) Can I import the same package/class twice? Will the JVM load the package twice at runtime?

Ans. One can import the same package or same class multiple times. Neither compiler nor JVM complains abt it. And the JVM will internally load the class only once no matter how many times you import the same class.

Q32) What is Checked and Unchecked Exception?

Ans. A checked exception is some subclass of Exception (or Exception itself), excluding class RuntimeException and its subclasses. Making an exception checked forces client programmers to deal with the possibility that the exception will be thrown. eg, IOException thrown by java.io.FileInputStream's read() method Unchecked exceptions is RuntimeException and any of its subclasses. Class Error and its subclasses also are unchecked. With an unchecked exception, however, the compiler doesn't force client programmers either to catch the exception or declare it in a throws clause. In fact, client programmers may not even know that the exception could be thrown. eg, StringIndexOutOfBoundsException thrown by String's charAt() methodChecked exceptions must be caught at compile time. Runtime exceptions do not need to be. Errors often cannot be.

Q33) What is Overriding?

Ans. When a class defines a method using the same name, return type, and arguments as a method in its superclass, the method in the class overrides the method in the superclass. When the method is invoked for an object of the class, it is the new definition of the method that is called and not the method definition from the superclass. Methods may be overridden to be more public, not more private.

Q34) What are the different types of inner classes?

Ans. Nested top-level classes, Member classes, Local classes, Anonymous classes Nested top-level classes- If you declare a class within a class and specify the static modifier, the compiler treats the class just like any other top-level class. Any class outside the declaring class accesses the nested class with the declaring class name acting similarly to a package. eg, outer. inner.

Top-level inner classes implicitly have access only to static variables. There can also be inner interfaces. All of these are of the nested top-level variety.

Member classes - Member inner classes are just like other member methods and member variables and access to the member class is restricted, just like methods and variables. This means a public member class acts similarly to a nested top-level class. The primary difference between member classes and nested top-level classes is that member classes have access to the specific instance of the enclosing class.

Local classes - Local classes are like local variables, specific to a block of code. Their visibility is only within the block of their declaration. In order for the class to be useful beyond the declaration block, it would need to implement a more publicly available interface. Because local classes are not members, the modifiers public, protected, private, and static are not usable.

Anonymous classes - Anonymous inner classes extend local inner classes one level further. As anonymous classes have no name, you cannot provide a constructor.

Do you want to master Core Java? Then enroll in "Core Java Training" This course will help you to master Advanced Java.
Q35) Are the imports checked for validity at compile time? e.g. will the code contain an import such as java.lang.ABCD compile?

Ans. Yes, the imports are checked for semantic validity at compile time. The code containing the above line of import will not compile. It will throw an error saying, can not resolve symbol: class ABCD location: package io import java.io.ABCD;

Q36) Does importing a package imports the subpackages as well? e.g. Does import com.MyTest.* also import com.MyTest.UnitTests.*?

Ans. No, you will have to import the subpackages explicitly. Importing com.MyTest.* will import classes in the package MyTest only. It will not import any class in any of its subpackage.

Q37) What is the difference between declaring a variable and defining a variable?

Ans. In a declaration, we just mention the type of the variable and its name. We do not initialize it. But defining means declaration + initialization. e.g String s; is just a declaration while String s = new String ("abcd"); Or String s = "abcd"; are both definitions.

Q38) What is the default value of an object reference declared as an instance variable?

Ans. null unless we define it explicitly.

Q39) Can a top-level class be private or protected?

Ans. No. A top-level class can not be private or protected. It can have either a "public" or no modifier. If it does not have a modifier it is supposed to have default access. If a top-level class is declared as private the compiler will complain that the "modifier private is not allowed here". This means that a top-level class can not be private. The same is the case with protected.

Q40) What type of parameter passing does Java support?

Ans. In Java, the arguments are always passed by value.

Q41) Primitive data types are passed by reference or pass by value?

Ans. Primitive data types are passed by value.

Q42) Objects are passed by value or by reference? 

Ans. Java only supports pass-by values. With objects, the object reference itself is passed by value and so both the original reference and parameter copy both refer to the same object.

Q43) What is serialization?

Ans. Serialization is a mechanism by which you can save the state of an object by converting it to a byte stream.

Q44) How do I serialize an object to a file?

Ans. The class whose instances are to be serialized should implement an interface Serializable. Then you pass the instance to the ObjectOutputStream which is connected to a fileoutputstream. This will save the object to a file.

 

Java Technical Interview Questions

Q45) What is the difference between compile-time polymorphism and runtime polymorphism?

Ans. The following table lists the differences between compile-time and runtime polymorphism:

Compile-time polymorphism

Runtime polymorphism

Also known as static polymorphism

Also known as dynamic polymorphism

Achieved through method overloading (Allowing a class to have multiple methods with the same name but different number/type of arguments)

Achieved through method overriding (Allowing a subclass to have a method with the same name and type signature as a superclass)

The call to the overloaded method is resolved at compile-time

The call to the overridden method is resolved at runtime

 

Q46) What is encapsulation? Explain with a code sample

Ans. Encapsulation simply means keeping the data of a class hidden from the outside world. This is achieved by creating a class that has private fields and public getter/setter methods.

The following class is an example of encapsulation:

public class House {
    
        private int numRooms;
        private String location;
    
        public int getNumRooms() {
            return numRooms;
        }
        public void setNumRooms(int numRooms) {
            this.numRooms = numRooms;
        }
        public String getLocation() {
            return location;
        }
        public void setLocation(String location) {
            this.location = location;
        }
}

This code defines a class called House. It has two fields called numRooms and location, both are private and so cannot be accessed directly outside the class. Both fields have getter and setter methods which can be used by code outside the class.

Q47) What makes Java platform independent?

Ans. Other programming languages like C, C++ are compiled into platform specific binary files with .exe extension. So, the binary file for one operating system does not work on other operating systems. Unlike these languages, Java gets compiled into bytecode. Bytecode is executed within a Java Virtual Machine (JVM) and the same bytecode works on all operating systems. So, Java is platform independent. 

Q48) What is a literal? Give some examples of literals

Ans. A literal is nothing but a constant value that can be assigned to a variable. Literals can be classified according to their data type. The following are some examples of literals:
•    10,20 – These are all Integer literals since they correspond to Integer values
•    26.45,31.89 – These are all floating-point literals since they represent floating-point (decimal) values.
•    ‘A’, ‘b’, ‘%’ – These are character literals since they hold an individual character. Character literals need to be enclosed in single quotes
•    “Java”, “Test” – These are String literals since they hold String values. String literals need to be enclosed in double quotes

Q49) Explain why the Java main method is static.

Ans. A static method can be invoked directly via the class name and does not need an object of the class to be created. The Java main method is invoked by the JVM as soon as a Java program is executed. Hence, the JVM should be able to invoke the main method even before creating an object of the class. Hence the main method is static.

Q50) Explain the difference between the abstract and final keywords?

Ans. The following table lists the differences between the abstract and final keywords:

Abstract

final

Can be specified with a class or method. Cannot be specified with a field

Can be specified with a field, method or class.

When specified with a method, indicates that the method is abstract. So, a subclass needs to provide an implementation for the abstract method or be declared as abstract itself

When specified with a method, indicates that the method cannot be overridden. So, if a subclass tries to provide an implementation for the final method a compilation error occurs

When specified with a class, indicates that the class is abstract. So, a subclass needs to provide an implementation for the abstract methods within the class or must be declared as abstract itself

When specified with a class, indicates that the class cannot be extended. So, if some code tries to create a subclass of a final class, a compilation error occurs.

An abstract class cannot be instantiated

A final class can be instantiated

Q51) Is the following code valid? Explain your answer

short s = 10; // 1

s = s + 10; // 2

Ans. The code above is not valid and causes a compilation error at Line 2. This is because Line 2 adds the value 10 to the short variable s. By default, the literal 10 is treated to be of type int and so Line 2 produces a result of type int but tries to assign it to a variable of type short. This code can be fixed either by changing the data type of s to int or by explicitly casting the result of s+10 to int as follows:
s = (short)(s + 10);

Q52) What is a two-dimensional array? Give some examples of two-dimensional arrays.

Ans. A two-dimensional array is nothing but an array having two dimensions. In other words, it is an array of arrays, that is each array within a two-dimensional array is an array itself. The following are some examples of two-dimensional arrays:

     int array1[ ][ ] = new int[3][6];

     double array2[ ][ ] = new double[2][5];

array1 is a two-dimensional integer array having dimensions 3,6. array2 is a two-dimensional double array having dimensions 2,5.

Q54) Explain the difference between the prefix and postfix increment operator with a code sample.

Ans. Both the prefix and postfix form of the increment operator increments its operand by 1. However, when used in a statement, the prefix operator first performs the increment operation and then the assignment while the postfix operator first performs the assignment and then the increment operation.

The following code sample demonstrates this:

int n1=10;
int n2=++n1;

The code above first causes n1 to be incremented and then assigned to n2, so n2 has the value 11. 

Now consider the following code:

int n1=10;
int n2=n1++;

The code above first causes n2 to be assigned with the value of n1 and then n1 is incremented, so n2 has the value 10.

Q55) What will be the output of the following code? Explain your answer

int num1 = 17;
int num2 = 25;
        
int num3 = num1 & num2;
System.out.println(num3);

Ans.  The code above prints the following output:

            17

The code above uses the bitwise AND (&) operator on num1 and num2. The & operator performs a bitwise AND operation on the binary representations of its operands. So, it returns 1 only if both the bits are 1. So, the above operation can be represented in binary form as below:

00010001 (17)
00011001 (25)
--------------
00010001 (17)

Q56) Explain the break and continue statements?

Ans. Both the break and continue statements are control statements that can be used to transfer control to a different part of a program. Both can be used within a loop. When a break statement is encountered within a loop, it causes the loop to be terminated and control is transferred to the first statement outside the loop. When a continue statement is encountered within a loop, it causes the current iteration of the loop to be skipped and control is transferred to the top of the loop. The loop then continues for the next iteration.

Q57)  What will be the output of the following code? Explain your answer

String taskStatus = "IN_PROGRESS";
    switch (taskStatus) {
        case "ASSIGNED":
            System.out.println("Task is assigned");
        case "IN_PROGRESS":
            System.out.println("Task is in progress");
        case "COMPLETED":
            System.out.println("Task is completed");
}

Ans. The code above uses a switch statement which matches the value of the taskStatus variable with the value in each case statement. Since taskStatus matches the second case statement, it executes the code in this case statement and the code in the subsequent case statements. So, the code above prints the following output:

Task is in progress
Task is completed

Q58) What is the use of the new keyword?

Ans. The new keyword is used along with a constructor to create a new Java object. It has the following syntax:

Class1 ob = new Class1();

The line above creates an object called ob of the type Class1. The new keyword is followed by the class name that is Class1. This allocates memory for the object ob, that is the instance fields of ob.

Q59) Is the following code valid? Explain your answer

Integer num = Integer.valueOf("100");

Ans. Yes, the code above is valid. It creates an Integer object corresponding to the value 100. Integer is a wrapper class corresponding to the int data type. Integer class has a static method called valueOf that can accept as parameter a String and return the Integer value corresponding to the String. In case an invalid Integer is specified within the valueOf method, it throws an Exception.

Q60) Explain the different types of Inheritance supported by Java?

Ans. Java supports the following types of inheritance:

Q61) Identify the error in the following code snippet and explain how it can be fixed?

public class House {
 
}
public class RowHouse extends House {
 
public static void main(String[] args) {
 
House h1 = new RowHouse();//1
RowHouse h2 = new House(); //2
}
}

Ans. This code creates a class called House which has a subclass called RowHouse. Line 1 declares a House variable h1 and assigns it a RowHouse object. This is valid since a subclass object can be assigned to a superclass variable. Line 2 declares a RowHouse object h2 and assigns it a House object. This is invalid and causes a compilation error, since a superclass object cannot be assigned to a variable of a subclass type. So, in order to fix this error, Line 2 needs to be removed from the code.

Q62) Explain the differences between static and default interface methods?

Ans. The following table lists the differences between static and default interface methods:

Default

Static

Has the keyword ‘default’ specified in the method declaration

Has the keyword ‘static’ specified in the method declaration

Can be overridden by an implementing class

Cannot be overridden by an implementing class

Can be invoked via an object of the implementing class

Can only be invoked via the interface name

Q63) Identify the error in the code below and explain how you can fix it?

public interface First {
 
public void firstMethod();
 
}
public interface Second {
 
public void secondMethod();
 
}
public class House implements First,Second{
 
public void firstMethod() {
System.out.println("First Method");
}
}

Ans. The code above will cause a compilation error in the class House. Since the House class implements the interfaces First and Second, it needs to provide code for all the methods in both interfaces. However, in this case, the House class only has code for firstMethod from the interface First. In order to fix the code, it needs to include code for secondMethod from the interface Second. So, the House class needs to be fixed as follows:

public class House implements First,Second{
 
public void firstMethod() {
System.out.println("First Method");
 
}
 
public void secondMethod() {
//code here
}
}

Q64) What are access specifiers in Java? List all of Java’s access specifiers

Ans. Java’s access specifiers help to control where an instance field/method of a class is accessible. Java has the following access specifiers:

Q65) Explain the difference between the add and offer methods on the Queue interface?

Ans. Both the add and the offer methods can be used to add an element to a Queue. However, there are some differences between the two as listed in the table below:

add

offer

Method on the java.util.Collection interface

Method on the java.util.Queue interface

Throws an exception if it is not possible to add the specified element into the Queue

Returns false if it is not possible to add the specified element into the Queue

Q66) Explain with a code sample how you can swap two elements in a List?

Ans. The java.util.Collections class has a method called swap. It can be used to swap two elements in a List. The following code demonstrates this:

List<String> animals = Arrays.asList("Lion","Elephant","Tiger","Zebra");
    Collections.swap(animals, 1, 2); //swaps elements at position 1,2

This code causes the elements at position 1,2 to be swapped, so “Tiger” is moved to position 1 and “Elephant” is moved to position 2

Q67) Explain the difference between a checked and unchecked exception?

Ans. The following table lists the differences between a checked an unchecked exception:

Checked Exception

Unchecked Exception

Checked by the compiler. So, if you write code that can throw a checked exception, the compiler causes an error unless the exception is handled or declared in the throws clause

Is not checked by the compiler. So, if you write code that can throw an unchecked exception, the compiler does not cause an error

All subclasses of java.lang.Exception except java.lang.RuntimeException are unchecked exceptions

All subclasses of java.lang.RuntimeException are unchecked exceptions

Q68) Explain the throw and throws keywords in Java?

Ans. The throw keyword can be specified within any block of code. It can be used to explicitly throw an exception (both in-built as well as custom exception). It is followed by an Exception object. The throws keyword is specified in a method declaration. It indicates that the method is capable of throwing an exception but does not handle it and that the code that invokes the method needs to handle the exception. It is followed by the exception class name.

Q69) Explain how you can check if a String contains another String? 

Ans.  The String class has several methods that can be used to check if a String contains another String. These are as follows:

  1. boolean contains(String str) – Accepts as parameter a String and returns a boolean value which indicates whether the String contains the specified String or not
  2. int indexOf(String str) - Accepts as parameter a String and returns the position of its first occurrence if present, otherwise returns -1.
  3. int lastIndexOf(String str) - Accepts as parameter a String and returns the position of its last occurrence if present, otherwise returns -1.

Q70) What is the difference between the capacity and length methods on the StringBuffer class?

Ans. The capacity method on the StringBuffer class returns the capacity of the StringBuffer that is the number of characters that the StringBuffer is capable of holding. The length method on the StringBuffer class returns the actual length of the StringBuffer, that is the actual number of characters in the StringBuffer.

Q71) What will be the output of the following code? Explain

File file = new File("C:/test");
file.mkdir();

Ans. The code above creates a File object corresponding to the C:/test path and then invokes the mkdir() method on this File object. This method creates a directory corresponding to the specified path. So, once the code above executes, a directory called “test” will be created in c:/

Q72) Explain with a code sample how you can delete a file from the file system?

Ans. The file class has a method called delete. This can be used to delete a file from the file system. The following code demonstrates this:

File file1=new File("C:/test.txt");
file1.delete();

This code first creates a file object corresponding to “C:/test.txt” and then invokes the delete method on this file object. This causes the “C:/test.txt” file to be deleted from the file system.

Q73) Explain what modifications need to be made to the code below so that it prints “MyThread”

public class MyThread extends Thread{
    
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    
        public static void main(String[] args) {
            MyThread t = new MyThread();
            t.start();
        }
}

Ans. The code above creates a Thread class called MyThread. The run method invokes the Thread.currentThread().getName()which prints the name of the current thread. So in order for the code to print “MyThread”, the name of the thread should be set to “MyThread”. For this you can do either of the following:

  1. Add currentThread().setName("MyThread")in the run method
  2. Add setName("MyThread")in the main method before invoking t.start();

Q74)  What will be the output of the following code? Explain

Map<Character,String> animals = Map.of('A',"Lion",'B',"Elephant",'C',"Tiger");
String animal = animals.getOrDefault('D', "Giraffe");

Ans. The code above uses the getOrDefault method on the animals map. This returns the value corresponding to the specified key if the key is present in the Map or the specified default value. Since there is no value corresponding to the key ‘D’, it returns the value “Giraffe”. So, the following is the output of the code listed above:

Giraffe

Q75) Explain what is garbage collection?

Ans. Java supports a process known as garbage collection whereby the memory allocated to objects that are no longer used is freed up automatically. When a Java program is executed, the JVM allocates memory to the objects/variables created in the code. For example, the JVM may allocate memory to some objects declared within a method. Once the method terminates, those objects are no longer required. So, the garbage collector frees up the memory allocated to the objects within the method. The JVM periodically runs the garbage collector in the background.

Q76) Which methods of Serializable interface should I implement?

Ans. The serializable interface is an empty interface, it does not contain any methods. So we do not implement any methods.

Q77) How can I customize the serialization process? i.e. how can one have control over the serialization process?

Ans. Yes, it is possible to have control over the serialization process. The class should implement the Externalizable interface. This interface contains two methods namely readExternal and writeExternal. You should implement these methods and write the logic for customizing the serialization process.

Q78) What is the common usage of serialization?

Ans. Whenever an object is to be sent over the network, objects need to be serialized. Moreover, if the state of an object is to be saved, objects need to be serialized.

Q79) What is an Externalizable interface?

Ans. Externalizable is an interface that contains two methods readExternal and writeExternal. These methods give you control over the serialization mechanism. Thus if your class implements this interface, you can customize the serialization process by implementing these methods.

Q80) When you serialize an object, what happens to the object references included in the object?

Ans. The serialization mechanism generates an object graph for serialization. Thus it determines whether the included object references are serializable or not. This is a recursive process. Thus when an object is serialized, all the included objects are also serialized along with the original object.

Checkout: [Exception Handling in java]

Q81) What one should take care of while serializing the object?

Ans. One should make sure that all the included objects are also serializable. If any of the objects is not serializable then it throws a NotSerializableException.

Q82) What happens to the static fields of a class during serialization?

Ans. There are three exceptions in which serialization does not necessarily read and write to the stream. These are 1. Serialization ignores static fields because they are not part of a particular state. 2. Base class fields are only handled if the base class itself is serializable. 3. Transient fields

Q83) How does an exception permeate through the code?

Ans. An unhandled exception moves up the method stack in search of a matching When an exception is thrown from a code that is wrapped in a try block followed by one or more catch blocks, a search is made for a matching catch block. If a matching type is found then that block will be invoked. If a matching type is not found then the exception moves up the method stack and reaches the caller method. The same procedure is repeated if the caller method is included in a try-catch block. This process continues until a catch block handling the appropriate type of exception is found. If it does not find such a block then finally the program terminates.

Q84) What are the different ways to handle exceptions?

Ans. There are two ways to handle exceptions, 1. By wrapping the desired code in a try block followed by a catch block to catch the exceptions. and 2. List the desired exceptions in the throws clause of the method and let the caller of the method handle those exceptions.

Q85) What is the basic difference between the 2 approaches to exception handling.

Ans. 1> try catch block and 2> specifying the candidate exceptions in the throws clause?

Q86) When should you use which approach?

Ans. In the first approach as a programmer of the method, you urself are dealing with the exception. This is fine if you are in the best position to decide what should be done in case of an exception. Whereas if it is not the responsibility of the method to deal with its own exceptions, then do not use this approach. In this case, use the second approach. In the second approach, we are forcing the caller of the method to catch the exceptions, that the method is likely to throw. This is often the approach library creators use. They list the exception in the throws clause and we must catch them. You will find the same approach throughout the java libraries we use.

Q87) Is it necessary that each try block must be followed by a catch block?

Ans. It is not necessary that each try block must be followed by a catch block. It should be followed by either a catch block OR a finally block. And whatever exceptions are likely to be thrown should be declared in the throws clause of the method.

Q88) If I write return at the end of the try block, will the finally block still execute?

Ans. Yes even if you write return as the last statement in the try block and no exception occurs, the finally block will execute. The final block will execute and then the control return.

Q89) If I write System.exit (0); at the end of the try block, will the finally block still execute?

Ans. No in this case the finally block will not execute because when you say System.exit (0); the control immediately goes out of the program, and thus finally never executes.

Q90) How are the Observer and Observable used?

Ans. Objects that subclass the Observable class maintain a list of observers. When an Observable object is updated it invokes the update() method of each of its observers to notify the observers that it has changed state. The Observer interface is implemented by objects that observe Observable objects.

Q91) How does Java handle integer overflows and underflows?

Ans. It uses those low-order bytes of the result that can fit into the size of the type allowed by the operation.    

12:T83b3,

Data Structures Interview Questions

Data Structure and algorithm questions are important for any programming job interview, especially for java based and Data Science roles. Companies around the world invest millions of dollars in integrating their data handling systems. 

Tekslate experts compiled top Data Structure and Algorithm interview questions for freshers and experienced candidates. Our Data Structure Interview Questions will help you to crack the interview and acquire your dream job. 

 Categories of Data Structures Interview Questions

Q1) What is meant by Data Structure?

Ans: The data structure is a way that determines how to arrange and control the data. It describes the characterizes the connection between them. A few instances of Data Structures are Linked List, Stack, array, Queue, etc. Data Structures are the focal pieces of numerous computer science algorithms as they empower the developers to deal with the information effectively.

Q2) Describe different types of Data Structures?

Ans: Data Structures are classified into two types as follows: 

Q3) What is meant by Linear Data Structure?

Ans: A data structure is called linear if all its components are organised in the consecutive order. In linear data structures, the components are stored in a non-hierarchical level where every item has the predecessor and successor aside from the first and last component.

Q4) What is meant by Non-Linear Data Structure?

Ans: The Non-linear data structure doesn't form a sequence; for example, each component is associated with at least two different things in a non-linear arrangement. The data components are not composed in the consecutive structure.

Q5) List out the area of the applications of Data Structure?

Ans: Data Structures are applied in the following areas of Computer Science:

Q6) List out various Data Structures available?

Ans: Data Structures vary by programming languages and commonly available data structures are array, queues, stack, graphs, tree, and list.

Q7) What do you mean by Abstract data type?

Ans: A data type is a collection of a set of operations and values. Abstract data type refers to the mathematical idea that describes the data type. 

It is a valuable tool for indicating the logical properties of a data type. 

ADT comprises of two sections 

1. Values definition 

2. Operation definition 

Instance:- The value definition for the ADT RATIONAL refers that RATIONAL value consists of two integers, where second doesn't mean equivalent to zero. 

The operation definition for ADT RATIONAL incorporates creation (make level headed) multiplication, addition and test for correspondence.

Q8) List out various operations that can perform on different Data Structures?

Ans: Following are the various operations that can perform on different data Structures: 

Q9) Differentiate between storage structure and file structure?

Ans: Following are the key differences between Storage Structure and File Structure:

Data Structure

File Structure

Data is stored in Ram and Disk

Data is stored on Disk

Customized storage policies

Standard File storage policies

High Compatibility with external applications

Low Compatibility with external applications

Q10) What is meant by linked list in Data Structure?

Ans: A linear data structure or a sequence of data objects where components are collected in contiguous memory areas. The components are connected, utilizing pointers to shape a chain. Every component is a different item, called a node. Every node has two things: a data field and a reference to the next node. The entry point in a connected rundown is known as the head. The rundown is vacant, the head is an invalid reference, and the last hub has an invalid reference. 

A linked list is a dynamic information structure, where the number of nodes is not fixed, and the list can develop and shrink on interest. 

It is applied in situations where: 

Algorithms Interview Questions

Q11) Explain various types of search methods that are available in Data Structure?

Ans: There are two types of search methods that are available in Data Structure: They are as follows:

Linear Search: It includes iterating over a data unit to implement the required operations. 

Binary search: is more proficient such that it can split the data units into chunks, and then it performs search operations on the given data elements.  

Q12) Are linked lists considered as linear or non-linear Data Structures?

Ans: Linked lists are considered non-linear and linear data structures relying on the application. To access the strategies, you can utilize a linear data structure. And if you want to store the data, you can use a non-linear data structure. 

Q13) Give detailed information about Binary Search?

Ans: Binary Search a sorted array by partitioning the search interval repeatedly. The key starts checking the interval covering the whole array. If the key value is less than the middle key of the interval, it searches the lower half of the array. In any case, the key value is greater than the middle key of the interval, and then it searches the upper half of the interval. This process is repeated until the key is found in the given data set. 

Q14) How is the array different from the Linked list?

Ans: Following are the key points that differentiate the array from the linked list: 

Insertion and Deletion 

Insertion and deletion of nodes is an easy process, as we update the address of the next pointer of a node. But it is expensive to do in the array to create the room for the new components and move existing components. 

Dynamic Data Structure 

As a Linked list is a dynamic data structure, there is no compelling reason to give an underlying size as it can develop and contract at runtime by allocating and deallocating memory. In any case, the size is restricted in an array as the number of components is statically stored in the primary memory. 

No wastage of memory 

As the size of a linked list can decrease or increase it depends upon the program, and memory is assigned just when needed, there is no memory squandered. On account of an exhibit, there is memory wastage. For example, if we declare the array of the size 10 and store just five components in it, then the space for five components is wasted. 

Implementation

Data structures like stack and queues are more handily executed utilizing a linked list than an array. 

1. A few situations where we utilize a linked list over array are: 

2. A few situations where we use array over the linked list are: 

In outline, we think about the prerequisites of time, space, and simplicity of usage to conclude whether to utilize a linked list or array.

Q15) List out various types of Linked list in the Data Structures?

Ans: Following are the various types of linked list in the Data Structure:

Single Linked List: In this type of linked list, every node store the reference or address of the next node in the given list, and last node stores the next address or null values for instance 1-> 2.>3->4->5->Null 

Doubly Linked List: In this type of linked list, there are two references associated with each node. One reference point to the next node and another point refers to the previous node.  Instance: 1<->2<->3<->4<->Null value.

Circular Linked List: In this type of linked list, all the nodes connect to form a circle. There will be no null value in the circular linked list. Even it is a single circular or double circular linked list.  

Q16) Explain about doubly-linked lists and give an example?

Ans: It is a typical type (double-linked list LL) of a linked list where a node has two connections: interfaces with the following hub in the arrangement and another that associates with the previous node. This permits crossing across the information components in the two ways. 

Following are the instances: 

Q17) Give detailed information about the binary tree in a data structure?

Ans: A binary tree is a tree data structure with two nodes. In the binary tree, one root node and two nodes on the root node's left and right side. A binary tree is considered an extended linked list. 

Example: Binary Tree

Binary Tree

Q18) What is an algorithm?

Ans: An algorithm is a step by step technique for solving an issue or controlling data. It characterizes a set of guidelines to be executed in a specific order to get the desired output.

Q19) Why do you need to do an algorithm analysis?

Ans: A problem can be addressed in more than one way using many algorithms. Algorithm analysis assesses the necessary assets of a calculation to take care of a particular computational issue. The measure of reality assets needed to execute is likewise decided. 

The time intricacy of an algorithm quantifies the measure of time taken for an analysis to run as a component of the information's length. The space complexity evaluates the measure of memory or space taken by an algorithm, to run as an element.

Q20) What is meant by stack in the Data Structure?

Ans: A stack is an abstract data type that indicates a linear data structure, as in an actual stack or heaps where you can take the top items off the stack to eliminate things. Subsequently, insertion(push) and deletion(pop) of items happen just toward one side called the top of the stack, with a specific request: LIFO (Last In First Out) or FILO (First In Last Out).

Q21) Where can you use stacks?

Ans:  Evaluation, Expression, conversion of evaluating infix, postfix, and prefix expressions

Q22) Explain about Postfix Expression in the Data Structure?

Ans: A postfix expression is a collection of operands and operators, where the operators are placed after the operands. The postfix expression will be as follows in the data structure. 

Expression: abc+-

In the above expression, abc are operands, and + & - are the operators. 

Q23) How to evaluate postfix expression using a stack data structure?

Ans: To evaluate postfix expression using a stack data structure using the following steps: 

Example: 5 3+ 8 2 -*

Q24) Explain about infix expression in the data structure?

Ans: A infix expression is a collection of operands and operators, where the operators are placed between the operands. The infix expression will be as follows in the data structure. 

Expression: (a+b) * (c-d)

In the above expression a, b, c, d are operands and +, -, * are operators. 

Q25) Explain about prefix expression in the Data Structure?

Ans: A prefix expression is a collection of operands and operators, where the operators are placed after the operands. The prefix expression will be as follows in the data structure. 

Expression: +ab

In the above expression a, b are the operands and + is the operator. 

Data Structures Interview Questions For Experienced

Q26) Explain about push and pop operation in the Data Structure?

Ans: Both push and pop operations are used to insert and remove or delete the data from the data structure stack. The push operation indicates that users can insert or add the data into the stack. And the pop operation is used by the users to remove or delete the data from the stack. Generally, the top-most data item is considered when users perform push and pop operations on the stack.

Q27) Explain about Queue in the Data Structure?

Ans: A queue is an abstract data type that defines an ordered list and linear data structure, using the First In First Out (FIFO) operation to access data items. Delete operation can be performed only at the other end called FRONT and the Insert operation can be performed only at one end called REAR.

Q28) List out some applications of the queue in the data structure?

Ans: To organize jobs as in the accompanying situations: 

Q29) What is meant by dequeue in the Data Structure?

Ans: dequeue means double-ended queue, where the data items can insert or delete at both ends called Rear or Front. 

Q30) List out the operations that can perform on Queues?

Ans: The following operation can perform on Queue:

dequeue(): it deletes or removes the data items from the queue.

enqueue(): It inserts or adds the data items to the queue. 

Init(): this operation is used for initializing the queue. 

IsEmpty(): this operation is used to check whether the queue is empty or not. 

front(): this operation is used to get the value of the queue's data item. 

rear(): this operation is used to remove the value of the queue's data item. 

Q31) Explain the working of LIFO in the Data Structure?

Ans: LIFO means Last In First Out it is used for Stack in the Data Structure. LIFO is processing data where the last entered data item in the stack will be removed first from the stack—for instance, stacking a deck of cards by placing one card on top of the other card. If we start removing the cards from the stacking, we will first remove the topmost card. This process is called LIFO. 

Q32) Explain the working of FIFO in the Data Structure?

Ans: FIFO means First In First Out, which is used for queues in the data Structure. FIFO is processing the data where the first data item is processed first, then newly entered data item processed later. Consider a ticket counter: The person who entered first into the line(queue) will take the ticket first, and then the second person. 

Q33) What are the advantages of the heap over the Stack in the Data Structure?

Ans: Generally, both stack and heap are essential for memory and utilized in Java for various necessities: 

Q34) What is the sorting algorithm in Data Structure?

Ans: Sorting means arranging the information in a specific organization. Sorting algorithm indicates the best approach to orchestrate information in a specific request. Most basic requests are in numerical or lexicographical requests. 

The significance of sorting lies in how information looking can be advanced to an elevated level if the information is put away in a sorted way. Sorting is likewise used to speak to information in more coherent configurations. Following are a portion of the instances of sorting, in actuality, situations. 

Telephone Directory: The phone registry stores the phone quantities of individuals sorted by their names so that the names can be looked for without any problem. 

Dictionary: The word reference stores words in a sequential request so that looking at any word becomes simple.

Q35) Which sorting algorithm is considered fastest in the Data Structure? Why?

Ans: A single sorting algorithm can't be viewed as best, as every algorithm is intended for a specific information structure and informational index. Be that as it may, the QuickSort algorithm is by and large considered the quickest because it has the best exhibition for most information sources. 

Its points of interest over other sorting algorithms incorporate the accompanying: 

Cache-efficient: It straightly checks and directly parcels the info. This implies we can capitalize on each reserve load. 

Can skip some swaps: As QuickSort is somewhat touchy to include organized appropriately, it can avoid a few trades. 

Proficient even in most pessimistic scenario input sets, as the request is by and mostly arbitrary. 

Simple adaptation to as of now or generally arranged data sources. 

At the point when speed takes need over steadiness.

Q36) List out top sorting algorithms in the data structure?

Ans: Following are the top sorting algorithms in the Data Structure: 

Q37) What is merge sort and how does it work?

Ans: Merge sort is a divide and conquers algorithm for sorting the information. It works by sorting and merging nearby information to make greater arranged records, consolidated recursively to frame considerably greater sorted records until you have one single sort list.

Q38) What is selection sort and how does it work?

Ans: Selection sort works by more than once picking the most modest number in rising requests from the rundown and setting it first. This cycle is continued advancing close to the furthest limit of the rundown or arranged subarray. 

Scan all things and locate the littlest. Switch over the situation as the principal thing. Repeat the selection sort on the excess N-1 things. We generally repeat forward (I from 0 to N-1) and trade with the littlest component (consistently I). 

Time Complexity: best case O(n2); worst O(n2) 

Space complexity: worst O(1)

Q39) Define the graph in the data Structure?

Ans: It is a non-linear data structure consisting of vertices or nodes connected by edges or arcs to enable storage or retrieval of data. Edges may be directed or undirected. 

Q40) What are the applications of graphs in Data Structure?

Ans: Transport frameworks where stations are spoken to as vertices and courses as the edges of the chart 

Utility diagrams of intensity or water, where vertices are association focuses and edge the wires or lines interfacing them. 

Interpersonal organization diagrams to decide the progression of data and hotspots (edges and vertices) 

Neural organizations where vertices speak to neurons and edge the neurotransmitters between them.

Q41) Define the tree data structure?

Ans: The Tree is a recursive information structure containing at least one data node where one node is assigned as the tree's base while the excess nodes are called the root's offspring. The nodes other than the root node are apportioned into the nonempty sets where every last one is called sub-tree.

Q42) List out various types of trees in Data Structure?

Ans: Following are various types of trees in the Data Structure: 

Q43) What is meant by the AVL tree in Data Structure?

Ans: An AVL tree is a kind of binary tree that is consistently in a condition of partially balanced. The balance is estimated as a distinction between the heights of the subtrees from the root. This self-balancing tree was known to be the first information structure to be planned. 

Q44) What are the properties of B Tree in Data Structure?

Ans: A B tree of order n contains all the properties of an N way tree. Furthermore, it includes the accompanying properties. 

Q45) What are the differences between the B tree and B+ tree?

Ans: Following are the key differences between B tree and B+ tree: 

B Tree

B+ Tree

Search keys cannot regularly be stored.

Excessive search keys can be present.

Data can be stored in internal nodes as well as leaf nodes.

Data only stored on the leaf nodes.

Searching the information is a more slow cycle since data can be found on leaf nodes and the internal nodes.

Searching is nearly quicker as information must be found on the leaf nodes.

Deletion of internal nodes is so time-consuming and complicated.

Deletion will never be a complex method since elements will always be deleted from the leaf nodes.

 

13:T35a8,

What is a transient variable?

A transient variable is a variable that may not be serialized.

Which containers use a border Layout as their default layout?

The Window, Frame and Dialog classes use a border layout as their default layout.

Why do threads block on I/O?

Threads block on I/O (that is enters the waiting state) so that other threads may execute while the I/O Operation is performed.

How are Observer and Observable used?

Objects that subclass the Observable class maintain a list of observers. When an Observable object is updated it invokes the update() method of each of its observers to notify the observers that it has changed state. The Observer interface is implemented by objects that observe Observable objects.

What is synchronization and why is it important?

With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared object while another thread is in the process of using or updating that object's value. This often leads to significant errors.

Can a lock be acquired on a class?

Yes, a lock can be acquired on a class. This lock is acquired on the class's Class object..

What's new with the stop(), suspend() and resume() methods in JDK 1.2?

The stop(), suspend() and resume() methods have been deprecated in JDK 1.2.

Is null a keyword?

The null is not a keyword.

What is the preferred size of a component?

The preferred size of a component is the minimum component size that will allow the component to display normally.

What method is used to specify a container's layout?

The setLayout() method is used to specify a container's layout.

Which containers use a FlowLayout as their default layout?

The Panel and Applet classes use the FlowLayout as their default layout.

What state does a thread enter when it terminates its processing?

When a thread terminates its processing, it enters the dead state.

What is the Collections API?

The Collections API is a set of classes and interfaces that support operations on collections of objects.

Which characters may be used as the second character of an identifier, but not as the first character of an identifier?

The digits 0 through 9 may not be used as the first character of an identifier but they may be used after the first character of an identifier.

What is the List interface?

The List interface provides support for ordered collections of objects.

How does Java handle integer overflows and underflows?

It uses those low order bytes of the result that can fit into the size of the type allowed by the operation.

What is the Vector class?

The Vector class provides the capability to implement a growable array of objects

What modifiers may be used with an inner class that is a member of an outer class?

A (non-local) inner class may be declared as public, protected, private, static, final, or abstract.

What is an Iterator interface?

The Iterator interface is used to step through the elements of a Collection.

What is the difference between the >> and >>> operators?

The >> operator carries the sign bit when shifting right. The >>> zero-fills bits that have been shifted out.

Which method of the Component class is used to set the position and size of a component?

setBounds() method is used to set the position and size of a component.

What is the difference between yielding and sleeping?

When a task invokes its yield() method, it returns to the ready state. When a task invokes its sleep() method, it returns to the waiting state.

Which java.util classes and interfaces support event handling?

The EventObject class and the EventListener interface support event processing.

Is sizeof a keyword?

The sizeof operator is not a keyword.

What are wrapped classes?

Wrapped classes are classes that allow primitive types to be accessed as objects.

Does garbage collection guarantee that a program will not run out of memory?

Garbage collection does not guarantee that a program will not run out of memory. It is possible for programs to use up memory resources faster than they are garbage collected. It is also possible for programs to create objects that are not subject to garbage collection.

What restrictions are placed on the location of a package statement within a source code file?

A package statement must appear as the first line in a source code file (excluding blank lines and comments).

Can an object's finalize() method be invoked while it is reachable?

An object's finalize() method cannot be invoked by the garbage collector while the object is still reachable. However, an object's finalize() method may be invoked by other objects.

What is the immediate superclass of the Applet class?

Panel.

What is the difference between preemptive scheduling and time slicing?

Under preemptive scheduling, the highest priority task executes until it enters the waiting or dead states or a higher priority task comes into existence. Under time slicing, a task executes for a predefined slice of time and then reenters the pool of ready tasks. The scheduler then determines which task should execute next, based on priority and other factors.

Name three Component subclasses that support painting.

The Canvas, Frame, Panel, and Applet classes support painting.

What value does readLine() return when it has reached the end of a file?

The readLine() method returns null when it has reached the end of a file.

What is the immediate superclass of the Dialog class?

Window.

What is clipping?

Clipping is the process of confining paint operations to a limited area or shape.

What is a native method?

A native method is a method that is implemented in a language other than Java.

Can a for statement loop indefinitely?

Yes, a for statement can loop indefinitely. For example, consider the following:

for(;;) ;

What are order of precedence and associativity, and how are they used?

Order of precedence determines the order in which operators are evaluated in expressions.

Associatity determines whether an expression is evaluated left-to-right or right-to-left.

When a thread blocks on I/O, what state does it enter?

A thread enters the waiting state when it blocks on I/O.

To what value is a variable of the String type automatically initialized?

The default value of an String type is null.

What is the catch or declare rule for method declarations?

If a checked exception may be thrown within the body of a method, the method must either catch the exception or declare it in its throws clause.

What is the difference between a MenuItem and a CheckboxMenuItem?

The CheckboxMenuItem class extends the MenuItem class to support a menu item that may be checked or unchecked.

What is a task's priority and how is it used in scheduling?

A task's priority is an integer value that identifies the relative order in which it should be executed with respect to other tasks. The scheduler attempts to schedule higher priority tasks before lower priority tasks.

What class is the top of the AWT event hierarchy?

The java.awt.AWTEvent class is the highest-level class in the AWT event-class hierarchy.

When a thread is created and started, what is its initial state?

A thread is in the ready state after it has been created and started.

Can an anonymous class be declared as implementing an interface and extending a class?

An anonymous class may implement an interface or extend a superclass, but may not be declared to do both.

What is the immediate superclass of Menu?

MenuItem.

What is the purpose of finalization?

The purpose of finalization is to give an unreachable object the opportunity to perform any cleanup processing before the object is garbage collected.

Which class is the immediate superclass of the MenuComponent class?

Object.

What invokes a thread's run() method?

After a thread is started, via its start() method or that of the Thread class, the JVM invokes the thread's run()method when the thread is initially executed.

What is the difference between the Boolean & operator and the && operator?

If an expression involving the Boolean & operator is evaluated, both operands are evaluated. Then the & operator is applied to the operand. When an expression involving the && operator is evaluated, the first operand is evaluated.

If the first operand returns a value of true then the second operand is evaluated. The && operator is then applied to the first and second operands. If the first operand evaluates to false, the evaluation of the second operand is skipped.

 

14:T6d22,

Core Java Interview Questions and Answers

Q1) Which two methods you need to implement for key Object in HashMap?

Ans:  To use any object as a Key in HashMap, it must implement equals and hashcode method in Java. Read How HashMap works in Java for a detailed explanation of how the equals and hashcode method is used to put and get an object from HashMap.

Q2) What is an immutable object? Can you write an immutable object?

Ans:  Immutable classes are Java classes whose objects can not be modified once created. Any modification in an Immutable object results in a new object. For example, is String is immutable in Java. Mostly Immutable are also final in Java, to prevent sub class from overriding methods in Java which can compromise Immutability. You can achieve the same functionality by making members nonfinal but private and not modifying them except in the constructor.

Q3) What is the difference between creating String as new() and literal?

Ans:  When we create a string with a new() Operator, it’s created in the heap and not added into the string pool while String created using literal are created in the String pool itself which exists in the PermGen area of the heap.

String s = new String("Test");

does not put the object in the String pool, we need to call String.intern() method which is used to put them into the String pool explicitly. it's only when you create a String object as String literal e.g. String s = "Test" Java automatically put that into the String pool.

Q4) What is the difference between StringBuffer and StringBuilder in Java?

Ans:  Classic Java questions which some people think tricky and some consider very easy. StringBuilder in Java is introduced in Java 5 and the only difference between both of them is that StringBuffer methods are synchronized while StringBuilder is non synchronized. See StringBuilder vs StringBuffer for more differences.

Q5) Write code to find the First non repeated character in the String?

Ans:  Another good Java interview question, This question is mainly asked by Amazon and equivalent companies. See first non repeated character in the string: Amazon interview question

Q6) What is the difference between ArrayList and Vector?

Ans:  This question is mostly used as a start up question in Technical interviews on the topic of Collection framework. The answer is explained in detail here the Difference between ArrayList and Vector.

Q7) How do you handle error conditions while writing a stored procedure or accessing a stored procedure from java?

Ans:  This is one of the tough Java interview questions and it's open for all, my friend didn't know the answer so he didn't mind telling me. my take is that stored procedure should return an error code if some operation fails but if the stored procedure itself fails then catching SQLException is the only choice.

Q8) What is difference between Executor.submit() and Executer.execute() method ?

Ans:  There is a difference when looking at exception handling. If your tasks throw an exception and if it was submitted with executing this exception will go to the uncaught exception handler (when you don't have provided one explicitly, the default one will just print the stack trace to System.err). If you submitted the task with submitting any thrown exception, checked exception or not, is then part of the task's return status. For a task that was submitted with submitting and that terminates with an exception, the Future.get will re-throw this exception, wrapped in an ExecutionException.

Q9) What is the difference between factory and abstract factory pattern?

Ans:

Q10) What is Singleton? is it better to make the whole method synchronized or only the critical section synchronized?

Ans:  Singleton in Java is a class with just one instance in the whole Java application, for example, java.lang.Runtime is a Singleton class. Creating Singleton was tricky before Java 4 but once Java 5 introduced Enum it's very easy. see my article How to create thread-safe Singleton in Java for more details on writing Singleton using enum and double-checked locking which is the purpose of this Java interview question.

Q11) Can you write a critical section code for singleton?

Ans:  This core Java question is a follow-up of the previous question and expecting a candidate to write Java singleton using double-checked locking. Remember to use volatile variables to make Singleton thread-safe.

Q12) Can you write code for iterating over hashmap in Java 4 and Java 5?

Ans:  Tricky one but he managed to write using a while and for a loop.

Q13) When do you override hashcode and equals()?

Ans: Whenever necessary especially if you want to do an equality check or want to use your object as a key in HashMap.

Q14) What will be the problem if you don't override the hashcode() method?

Ans:  You will not be able to recover your object from hash Map if that is used as a key in HashMap. See here  How HashMap works in Java for a detailed explanation.

Q15) Is it better to synchronize critical section of getInstance() method or whole getInstance() method ?

Ans:  The answer is a critical section because if we lock the whole method than every time someone calls this method will have to wait even though we are not creating any object)

Q16) What is the difference when String is gets created using a literal or new() operator?

Ans:  When we create a string with new() its created in the heap and not added into the string pool while String created using literal are created in the String pool itself which exists in the Perm area of the heap.

Q17) Does not override the hashcode() method has any performance implication?

Ans:  This is a good question and opens to all, as per my knowledge, a poor hashcode function will result in frequent collision in HashMap which eventually increases the time for adding an object into Hash Map.

Q18) What’s wrong with using HashMap in a multithreaded environment? When get() method go to an infinite loop?

Ans:  Another good question. His answer was during concurrent access and re-sizing.

Q19) What do you understand by thread-safety? Why is it required? And finally, how to achieve thread-safety in Java Applications?

Ans: 

            1. Read barriers 

            2. Write barriers.

Inclined to build a profession as core java training? Then here is the blog post on, explore core java training

JMM semantics for synchronized

When a thread acquires a monitor of an object, by entering into a synchronized block of code, it performs a read barrier (invalidates the local memory and reads from the heap instead). Similarly exiting from a synchronized block as part of releasing the associated monitor, it performs a write barrier (flushes changes to the main memory) Thus modifications to a shared state using synchronized block by one Thread, are guaranteed to be visible to subsequent synchronized reads by other threads. This guarantee is provided by JMM in presence of a synchronized code block.

JMM semantics for Volatile  fields

Read & write to volatile variables have the same memory semantics as that of acquiring and releasing a monitor using a synchronized code block. So the visibility of the volatile field is guaranteed by the JMM. Moreover afterward Java 1.5, volatile reads and writes are not reorderable with any other memory operations (volatile and non-volatile both). Thus when Thread A writes to a volatile variable V, and afterward Thread B reads from variable V, any variable values that were visible to A at the time V was written are guaranteed now to be visible to B.

Let's try to understand the same using the following code

Data data = null;

volatile boolean flag = false;

Thread A

-------------

data = new Data();

flag = true; <-- writing to volatile will flush data as well as a flag to main memory

Thread B

-------------

if(flag==true){ <-- as="" barrier="" data.="" flag="" font="" for="" from="" perform="" read="" reading="" volatile="" well="" will="">

use data; <!--- data is guaranteed to visible even though it is not declared volatile because of the JMM semantics of volatile flag.

Q20) What will happen if you call return statement or System.exit on the try or catch block? will finally block execute?

Ans:  This is a very popular tricky Java question and it's tricky because many programmers think that finally block always executed. This question challenge that concept by putting a return statement in try or catch block or calling System.exit from try or catch block. The answer to this tricky question in Java is that finally block will execute even if you put a return statement in the try block or catch block but finally block won't run if you call System.exit from trying or catch.

Q21) Can you override private or static methods in Java?

Ans:  Another popular Java tricky question, As I said method overriding is a good topic to ask trick questions in Java.  Anyway, you can not override private or static method in Java, if you create a similar method with the same return type and same method arguments that are called method hiding.

Q22) What will happen if we put a key object in a HashMap which is already there?

Ans:  This tricky Java question is part of How HashMap works in Java, which is also a popular topic to create confusing and tricky questions in Java. well if you put the same key again then it will replace the old mapping because HashMap doesn't allow duplicate keys. 

Q23) If a method throws NullPointerException in the superclass, can we override it with a method that throws RuntimeException?

Ans:  One more tricky Java question from overloading and overriding concept. The answer is you can very well throw superclass of RuntimeException in the overridden method but you can not do the same if it's checked Exception. 

Q24) What is the issue with the following implementation of the compareTo() method in Java

Ans:  public int compareTo(Object o)

         {

         Employee emp = (Employee) emp;

         return this.id - o.id;

          }

Q25) How do you ensure that the N thread can access N resources without deadlock?

Ans:  If you are not well versed in writing multi-threading code then this is a really tricky question for you. This Java question can be tricky even for the experienced and senior programmers, who are not really exposed to deadlock and race conditions. The key point here is order, if you acquire resources in a particular order and release resources in the reverse order you can prevent deadlock. 

Q26) What is the difference between CyclicBarrier and CountDownLatch in Java?

Ans:  Relatively newer Java tricky question, only been introduced from Java 5. The main difference between both of them is that you can reuse CyclicBarrier even if the Barrier is broken but you can not reuse CountDownLatch in Java. See CyclicBarrier vs CountDownLatch in Java for more differences.

Q27) Can you access nonstatic variables in a static context?

Ans:  Another tricky Java question from Java fundamentals. No, you can not access static variables in the nonstatic context in Java. Read why you can not access the non-static variables from a static method to learn more about these tricky Java questions.

Q28) How many types of memory areas are allocated by JVM?

Ans:  Many types:

Q29) What is the JIT compiler?

Ans: Just-In-Time(JIT) compiler: It is used to improve performance. JIT compiles parts of the byte code that have similar functionality at the same time, and hence reduces the amount of time needed for compilation. Here the term “compiler” refers to a translator from the instruction set of a Java virtual machine (JVM) to the instruction set of a specific CPU.

Q30) What is a platform?

Ans:  A platform is basically the hardware or software environment in which a program runs. There are two types of platforms software-based and hardware-based. Java provides a software-based platform.

Q31) What is the main difference between the Java platform and other platforms?

Ans:  The Java platform differs from most other platforms in the sense that it's a software-based platform that runs on top of other hardware-based platforms. It has two components:

Q32) What gives Java its 'write once and run anywhere' nature?

Ans:  The bytecode. Java is compiled to be a byte code which is the intermediate language between source code and machine code. This byte code is not platform specific and hence can be fed to any platform.

Q33) What is a static variable?

Ans:  A static variable is used to refer to the common property of all objects (that is not unique for each object) e.g. company name of employees, college name of students, etc. static variable gets memory only once in the class area at the time of class loading. more details.

Q34) What is a static method?

Ans:  A static method belongs to the class rather than the object of a class. A static method can be invoked without the need for creating an instance of a class. a static method can access static data member and can change the value of it. more details.

Q35) Why the main method is static?

Ans:  Because the object is not required to call a static method if It were a non-static method, JVM creates an object first then calls a main() method that will lead to the problem of extra memory allocation more details.

Q36) What is a static block?

Ans: This is used to initialize the static data member. It is executed before the main method at the time of classloading.

Core Java Tutorials

15:Tccc,

 

Released  History of MVC

Date Version
10-Dec-2007 Asp.net MVC CTP
13-March-2009 Asp.net MVC 1.0
10-March-2010 Asp.net MVC 2.0
13-Jan-2011 Asp.net MVC 3.0
15-Aug-2012 Asp.net MVC 4.0

 

  1

Interested in mastering "ASP.Net Training"? Check out this blog post to learn more ASP.Net Tutorials.

2

In 3.0 we also can support to was with HTML 5 version.

For in-depth understanding click on:

16:Tecc,

 

Core Java Sample Resume

34, Main Street, Seattle, Washington. (856) 589 785. antony@yahoo.com.

Professional Summary:

Technical Strengths:

Inclined to build a profession as Core Java Tutorials? Then here is the blog post on, explore Core Java Tutorials

Educational Qualifications:

Professional Experience:

Duties and Responsibilities:

Accomplishments:

Inclined to build a profession as Core Java Interview Questions? Then here is the blog post on, explore Core Java Interview Questions

Core Java Sample Resume Secrets You Need To Know:

   

17:T5685,

 

Welcome to Core Java  Tutorials. The objective of these tutorials is to provide an in-depth understanding of Core Java.

In addition to free Core Java  Tutorials, we will cover common interview questions, issues, and how to’s of Core Java.

Introduction

The prime reason behind the creation of Java was to bring portability and security features into a computer language. Besides these two major features, there were many other features that played an important role in molding out the final form of this outstanding language.

Those features are

Simple

Java is easy to learn and its syntax is quite simple, clean, and easy to understand. The confusing and ambiguous concepts of C++ are either left out in Java or they have been re-implemented in a cleaner way.

Eg: Pointers and Operator Overloading are not there in java but were an important part of C++.

Object-Oriented

In java, everything is an object which has some data and behavior. Java can be easily extended as it is based on Object Model.

Robust

Java makes an effort to eliminate error-prone codes by emphasizing mainly on compile-time error checking and runtime checking. But the main areas which Java improved were Memory Management and mishandled Exceptions by introducing automatic Garbage Collector and Exception Handling.

Platform Independent

Unlike other programming languages such as C, C++, etc which are compiled into platform-specific machines. Java is guaranteed to be write-once, run-anywhere language.

On compilation, the Java program is compiled into bytecode. This bytecode is platform-independent and can be run on any machine, plus this bytecode format also provides security. Any machine with Java Runtime Environment can run Java Programs.

Secure

When it comes to security, Java is always the first choice. With java secure features it enables us to develop a virus-free, temper free system. Java program always runs in Java runtime environment with almost null interaction with system OS, hence it is more secure.

Multi-Threading

Java multithreading feature makes it possible to write programs that can do many tasks simultaneously. The benefit of multi-threading is that it utilizes the same memory and other resources to execute multiple threads at the same time, like While typing, grammatical errors are checked along.

Architectural Neutral

The compiler generates bytecodes, which have nothing to do with particular computer architecture, hence a Java program is easy to interpret on any machine.

Portable

Java Byte code can be carried to any platform. No implementation-dependent features. Everything related to storage is predefined, for example, the size of primitive data types

High Performance

Java is an interpreted language, so it will never be as fast as a compiled language like C or C++. But, Java enables high performance with the use of a just-in-time compiler.

Java Core Concepts

1. Variables

2. Operations

Inclined to build a profession as core java training? Then here is the blog post on, explore core java training

3. Classes + Objects

4. Interfaces

Variables

Computer programs, regardless of programming language, typically read data from somewhere (file, keyboard, mouse, network, etc.), process the data, and write some data somewhere again (to screen, file, network, etc.).

In Java, program data is kept in variables. Your Java program first declares the variables, then read data into them, execute operations on the variables, and then write the variables (or data based on the variables) somewhere again. Variables are explained in more detail in the text on Java variables.

Each variable has a data type. The data type determines what kind of data the variable can contain, and what operations you can execute on it. For instance, a variable could be a number. Numbers can be added, subtracted, multiplied, divided, etc. Or, a variable could be a string (text). String's can be divided into substrings, searched for characters, concatenated with other strings, etc. Java comes with a set of built-in data types. These data types are described in more detail in the text on Java data types.

Here is a simple Java variable declaration and operation example. Don't worry if you don't understand it now. Later texts in this Java language tutorial explains the details. The purpose of the example is just to give you a feeling for how working with Java variables look.

int myNumber;

myNumber = 0;

myNumber = myNumber + 5;

The first line of this example declares a variable named myNumber of the data type int. An int is a 32-bit integer (number without fractions).

The second line sets the value of the myNumber variable to 0.

The third line adds 5 to the current value of myNumber

Operations

Operations in Java are the instructions you can use to process the data in variables. Some operations read and write the values of variables (as you have already seen examples of), while other operations control the program flow. The most important operations are:

1. Variable operations

2. Program flow

3. Method calls.

All of these operations are explained in detail in their own texts.

Here are a few examples of operations:

int number = 0;
int abs    = 0;
    
//imagine some operations that assign a value to number 
// - but left out of this example.
    
if(number >= 0) {
    abs = number;    
} else {
    abs = -number; 
}

This example first declares two variables named number and abs. The variable abs is supposed to contain the absolute value of number. The absolute value of a number is always positive. For positive numbers, the absolute value is the number itself. For negative numbers, the absolute value is the number without the negative sign. For instance, the absolute value of -10 is 10.

The if operation checks the value of the number variable to see if it is larger than or equal to 0. If it is, the absolute value assigned to the abs variable is the value of the number variable. If the number value is less than 0, then the value assigned to number is equal to -number. Negating a negative number gives a positive number, remember? -(-10) is 10.

Classes + Objects

Classes group variables and operations together in coherent modules. A class can have fields, constructors, and methods (plus more, but that is not important now). I will shortly describe fields, constructors, and methods here, but they are explained in more detail in their own texts too.

Objects are instances of classes. When you create an object, that object is of a certain class. The class is like a template (or blueprint) telling how objects of that class should look. When you create an object, you say "give me an object of this class".

If you think of a factory producing lots and lots of the same items, then the class would be the blueprint/manual of how the finished product should look, and the objects would be each of the finished products. If the factory produced cars, then the blueprint/design manual of the cars to produce corresponds to a Java class, and the physical cars produced corresponds to Java objects.

Here is a simple diagram illustrating the principle of objects being of a certain class. The class determines what fields and methods the objects of that class have.

Core Java

A Java class can contain fields, constructors, and methods

public class Car {Here is an example Java class declaration: }

This example declares a class named Car. The Car class does not contain any fields, constructors, or methods. It is empty. The example primarily serves to show you an example of how a class declaration looks in Java code.

Fields

A field is a variable that belongs to a class or an object. It is a piece of data, in other words. For instance, a Car class could define the field brand which all Car objects would have. Each Car object could then have a different value for the brand field.

Fields are covered in more detail in the text on Java fields.

Here is the Car class declaration from above with a field name brand added:

public class Car {
    private String brand;
}

This example declares a field named brand of data type String which is text.

Constructors

Constructors are a special kind of method that is executed when an object of that class is created. Constructors typically initialize the object's internal fields - if necessary.

Constructors are covered in more detail in the text on Java constructors.

Here is the Car class from before with a constructor that initializes the brand field:

public class Car {
    
    private String brand;

    public Car(String theBrand) {
        this.brand = theBrand;
    }
}

Methods

Methods are groups of operations that carry out a certain function together. For instance, a method may add to numbers, and divide it by a third number. Or, a method could read and write data in a database, etc.

Methods are typically used when you need to group operations together, that you need to be able to execute from several different places. Or, if you just want your code to be easier to read. In other programming languages, methods may be called "procedures" or "functions".

Methods are covered in more detail in the text on Java methods.

Here is the Car class from before with a single, simple method named getBrand added:

public class Car {
    
    private String brand;

    public Car(String theBrand) {
        this.brand = theBrand;
    }
    
    
    public String getBrand() {
        return this.brand;
    }
}
Interfaces

The interface is a central concept in Java. An interface describes what methods a certain object should have available on it. A class can implement an interface. When a class implements an interface, the class has to implement all the methods described in the interface. Interfaces are described more in my text about Java interfaces.

Packages

Packages in Java is another central concept. A package is a directory containing Java classes and interfaces. Packages provide a handy way of grouping related classes and interfaces, thus making modularization of your Java code easier. Packages are described in more detail in my text about Java pack

Data Types in Java

Java language has a rich implementation of data types. Data types specify size and the type of values that can be stored in an identifier.

In java, data types are classified into two categories :

  1. Primitive Data type
  2. Non-Primitive Data type

Primitive Data type

A primitive data type can be of eight types:

Once a primitive data type has been declared its type can never change, although in most cases its value can change. These eight primitive types can be put into four groups.

Integer: This group includes byte, short, int, long

byte: It is an 8-bit integer data type. Value range from -128 to 127. Default value zero. example: byte b=10;

short: It is a 16-bit integer data type. Value range from -32768 to 32767. Default value zero. example:short s=11;

int: It is a 32-bit integer data type. Value range from -2147483648 to 2147483647. Default value zero. example:int i=10;

long: It is a 64-bit integer data type. Value range from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Default value zero. example: long l=100012;

Floating-Point Number

This group includes float, double

float: It is a 32-bit float data type. Default value 0.0f. example: float ff=10.3f

double: It is a 64-bit float data type. Default value 0.0d. example: double db=11.123

Characters: This group represents char, which represent symbols in a character set, like letters and numbers.

char: It is a 16-bit unsigned Unicode character. Range 0 to 65,535. example: char c='a';

Boolean: This group represents boolean, which is a special type for representing true/false values. They have defined as constants of the language. example: boolean b=true;

Non-Primitive(Reference) Data type

A reference data type is used to refer to an object. A reference variable is declared to be specific and that type can never change. We will talk a lot more about reference data type later in the Classes and Object lessons.

For an Indepth knowledge on core java, click on below

18:Tfef1,

 

An MVC(model view controller) web framework which eases the construct of UI(User Interface) for server-based applications by utilizing reusable components of UI within a page. JSF allows connecting with the event handlers on the server-side and to the data sources of UI widgets. JSF gives an API(Application Programming Interface) and also presents a set of conventional UI components for building more components. JSF facilitates the extension of current conventional UI components and also permits reuse.

JSF gives the components like command button, input text and so on. JSF serves to maintain their states. JSF also facilitates data conversion, server-side validation, extensibility, describes page navigation, accessibility and internationalization.

Tag libraries of JSF utilized to connect the components with the server objects and also add the components upon the webpages, JSF has the tag handler which executes the component tag.

Simply JSF is just like AWT and Swing, JSF is also a development framework that gives a group of reusable and standard GUI components.

Advantages of using JSF

Using JSF decreases the energy of developers while designing and managing the applications, these applications operate on Java server also administer the application UI upon to the destination client.

JSF version history

 

Version

Release Date

Description

JSF 1.0

11-03-2004

This is an initial release.  

JSF 1.1

27-05-2004

There are no specific changes in this release; it is just a bug-fix release.

JSF 1.2

11-05-2006

It has several enhancements over core systems and APIs. Matches with Java ee 5. original selection within java ee.

JSF 2.0

01-07-2009

JSF 2.0 is a huge release for ease of utilization, enhanced performance and functionality this version matches with JAVA ee6.

JSF 2.1

22-11-2010

It implied a maintenance announcement 2 of JSF 2.0. simply a pretty lesser amount of stipulation modifications.

JSF 2.2

21-05-2013

It has launched modern theories like page flow, stateless views and the capability to generate portable support arrangements.

JSF LifeCycle:

JSF contains SIX phases in the life cycle of JSF. 

  1. Restore view this is the initial phase of the JSF life cycle, JSF begins this restore view phase as soon as the button snap. In this phase, JSF builds validators ti UI components, JSF builds the view and wires the event handlers and stores the view within the FaceContext instance. This FaceContext instance will now have all the data that is needed to develop a request.
  2. Apply request value this is the second phase in the JSF lifecycle after the component restored every component within the component tree utilizes the decode method to extract its brand new value from the request parameters.
  3. Process Validation in the phase JSF will process all the registered validators of the component tree. It explores the component attribute protocols and also minimizes these protocols to the local value saved within the component.
  4. Update model values after inspecting the data JSF moves to the moves to the component tree and to the components’ local values it fixes the identical server-side object properties. Then to the input component value attributes the JSF will update the bean properties.
  5. Invoke application in this phase JSF handhold any application-level activities such as submitting a form to another page and also linking to another page
  6. Render response this is the last phase of the JSF life cycle. In this phase, JSF asks the application server to interpret the page if the application is utilizing the JSP pages. These components depicted on the page will be combined with the component tree while JSP container executes that page. If that is not an introductory request, then the component tree will be present, so there is no need to add the components again. 

JSF basic tags:

Tag

Description

h:InputText

HTML input_ type=”text”, textbox.

h:InputSecret

HTML input_type=”password”, textbox.

h:InputTextarea

this is the field of HTML Textarea

h:InputHidden

HTML input_type=”hidden”

h:selectBooleanCheckbox 

a individual HTML check box will be rendered

selectManyCheckbox

A set of HTML checkboxes will be rendered

h:selectOneRadio

An individual radio button will be rendered 

h:selectOneListbox

An individual Listbox will be rendered 

h:selectManyListbox

Various Listboxes will be rendered

h:selectOneMenu

An individual combo box will be rendered

h:outputText

A text of HTML will be rendered

h:outputFormat

This accepts parameters and also a text of HTML will be rendered

h:graphicImage

An image will be rendered by using this tag

h:outputStylesheet

By using this tag we will be including a CSS style sheet within the HTML output

h:outputScript

A script is added within the HTML output by using this tag

JSF Converter tags:

Tag

Description

f:convertnumber

By using this tag we can convert the string into the number of the required format

f:convertDateandTime

By using this tag we can convert the string into the desired date format

JSF validator tags:

Tag

Description

f:validateLength

We can validate the length of the string by using this tag

f:validateLongRange

By using this tag we can validate the rage of a numeric value

f:validateDoubleRage 

By using this tag we can validate the range of float value

f:validateRegex

We can validate the regular expression of a JSF component

JSF MVC Design:

MVC is abbreviated as Model View Controller design gives a set of scheme patterns that assists you to divide the areas of interest that are involved in constructing and executing GUI applications 

MVC Implementation:

In JSF MVC implementation within backing, beans act as a mediator among the view and the model. Because of this, it is necessary to restrict the persistence logic and business logic within the backing beans. One similar option is to empower business logic to a facade that serves essentially as the model.  

JSF view implementation is not like JSF technology; JSF view implementation is a component model of statefulness. The JSF view constituted of two sections. They are the JSP pages and view root.

  1. The JSP page fixes UI components over JSP pages and permits us to unite field components to qualities of backing beans.  
  2. The view root is a combination of UI state and UI components that manage the UI state. 

Request processing Lifecycle of JSF:

There are six phases in the request processing life cycle of JSF.

  1. Restore component model: The controller checks the request and concretes the view ID which is detected by JSP page name if the view is not already present then the JSF controller build it, it the view is already present then the JSF controller utilizes it the view will have all the components. 
  2. Apply request values: each component utilizes the apply request value phase to regain the components contemporary(current) state the values of components are regained from request parameters.
  3. Process validation: in this phase, every component holds its values verified against the application validation protocols.
  4. Update model: this phase, the server-side model values are updated; this can happen only by updating the backing beans properties.
  5. Invoke Application: The controller of JSF invokes the application to manage Form resignations. The component values will be switched, validated, and implemented over the model objects. Therefore we can instantly utilize them to administer the business logic of the application.
  6. Render response: this shows the view and all the components of view and their current state, and later execute the page furthermore transfer it back to the customer.

Standard UI components of JSF:

There are 12 JSF UI components.

Characteristics of JSF: 

Navigation Rules:

Navigation rules are the protocols that are given by the JSF framework that defines which view should be displayed whenever a link or a button clicked. These protocols can be described within the configuration file of JSF, which is named as faces-config.xml. These can be described within the managed beans. Navigation rules will have the conditions which are based on the resulted view.

Internationalization:

Internationalization is a technique within which currency, status messages, date and GUI component labels are not impended within the program rather they are saved outside the source code that is present within resource bundles, and they are retrieved dynamically.

There are three steps to internalize the JSF application.

  1. Property files are defined.
  2. Faces-config.xml is updated
  3. Resource-bundle var is utilized.   

Method and value Binding:

Within JSF, we can obtain some values like a managed bean through value binding. As value binding, the universal(EL) Expression Language is practised to obtain bean or/and methods, Meanwhile, in JSF we do not require to define the set() or get() methods but simply the mane of a variable. Method binding can be utilized to wrap a JSF component, for example, a link over a method of the Java class.

Prerequisites to utilize JSF:

To utilize JSF, we just need 

Why JSF is not so popular:

There are a lot of implementations of JSF like richfaces and primefaces which makes JSF difficult to the client to learn, comprehend and adapt to where the Spring MVC possesses hardly one implementation supported by a particular assortment of developers which eludes trouble. 

Spring has prepared comprehensive combination including data management within ORM frameworks or standalone outside the case which is requiring in JSF implementation.

 

JSF is a component-based framework where a Spring is a client-server based framework. Therefore, it is simple to learn and correlates intimately to Struts2, MVC and few another comparable framework.

Index

19:T66f0,

 

Data Structures Interview Questions And Answers

Q1. What is the data structure?

Ans: A data structure is the logical or mathematical arrangement of data in memory. It considers not only the physical layout of the data items in the memory but also the relationships between these data items and the operations that can be performed on these items.

Q2. Define a variable ?

Ans: A variable is defined as a meaningful name given to a data storage location in the computer memory. When using a variable, we actually refer to the address of the memory where the data is stored.

Q3. Which Data Structure Should be used for implementing LRU cache?

Ans: 

Q4. How to implement a stack using a queue?

Ans: A stack can be implemented using two queues. Let stack to be implemented be ‘s’ and queues used to implement be ‘q1’ and ‘q2’. Stack ‘s’ can be implemented in two ways:

Q5. How is an Array different from Linked List?

Ans:

Q6. What are linear and non-linear data structures?

Ans: A linear data structure involves the arrangement of values in a linearly. Some typical examples of a linear data structure are lists, queues, stacks, and arrays.

In a non-linear data structure, the elements are not stored in a sequence. Graphs and tree are some examples of a non-linear data structure.

Q7. What is the difference between a data type and data structure?

Ans: In computing, a data type is a group of data values with characteristics that are already defined. Some data types are floats, characters, integer, and string. These are called primitive data types. A data structure, on the other hand, is a grouping of data for easy organization and accessibility. Tables, Array stacks, structs, queues, classes, files, and lists are some data structure.

Q8. What are data structure operations?

Ans: 

Q9. Can you list out all the operations that can be performed/executed in data structures?

Ans: The following are the operations that can be executed in data structures:

Q10. Explain what is a Stack and it's usage?

Ans: The Stack is nothing but a linear data structure where the data elements can be accessed. They are two ways to access the data elements, 

For Stack, the basic operations are listed below:

Q11. What is a queue and how it is implemented?

Ans: A queue is also a linear form of data structure where all the data elements are available in a systematic format. The data elements are available in First in First out form (FIFO).

The basic operation of the Queue are listed below:

Q12. What is the difference between Queue and Stack?

Ans: Both Queue and Stack are the same and follow a linear data structure model. The main difference between these two is the way a record is deleted/removed.

In a stack, the most recent data element that is added will be removed. Whereas, in Queue, the least recent data element that is added to the list will be deleted. 

Queues and Stacks are created with the use of arrays and linked lists. 

Q13. List out the different types of Linked lists that are available?

Ans: Below is the different types of Linked lists that are available. 

Q14. Explain the difference between file structure and storage structure?

Ans: The key difference between a storage structure and the file structure is the amount of memory that has been acquired.

The data structure that is stored in the main memory of the computer system is classified as a storage structure. This is an inbuilt storage system where the data is available. 

On the other hand, if the data is residing on an extra/backup storage then it is classified as a File structure.

Q15. Explain what is a stack?

Ans: A Stack can be classified as an ordered list where all the operations like insertions/ deletions can be executed only from one end. The mentioned stack is nothing but a pure list of execution tasks, the order follows LIFO structure, i.e. Last-In-First-Out. So according to the LIFO structure, the line item that is entered into the stack will be executed at the end (concerning the priority).

Q16. Can you list out the operations that can be performed on Stack?

Ans: The following are the list of operations that can be performed on Stack.

Q17. Do you know the syntax of stack overflow condition?

Ans: The syntax of stack overflow condition is :

when top=maxsize-1

Q18. Explain the difference between push and pop operations?

Ans: With the help of push and pop operations, the data can be effectively handled/managed within a stack. The main difference between push and pop operations is listed below:

Push operation:

Push operation is used when inserting the data into the Stack.

Pop Operation:

Pop operation is used when deleting the data from the Stack. 

Q19. Describe what is an array?

Ans: An array is nothing but a collection of data elements that are stored together in a memory location. Also, accessing the data elements within an array is very simple and every data element will have their index number. Using the index number the data element can be easily accessed. 

Q20. Explain what do you mean by a multi-dimensional array?

Ans: A multi-dimensional array is nothing but an array of arrays. The data is stored or piled in the form of the tabular structure where it has rows and columns. The use of multi-dimensional arrays will help to store more amount of data in chunks. 

Q21. A node contains two fields, can you tell me what are they?

Ans: A node contains two fields, they are :

Q22. Explain what do you mean by the queue data structure?

Ans: A queue data structure is nothing but an ordered list that is piled up in the form of a stack. They are two ends to the queues where the operations can be taken into consideration:

Rear: All the data insertions are performed in Rear.

Front: All the data deletions are performed in Front.

Q23. Can you list out some practical examples of the queue data structure?

Ans: Below is the few practical examples of data structure:

The daily usage of printers. All the print jobs at the printer follow a queue data structure. The same with all of your computing requests, CPU handles it well by a queuing mechanism

 Data transfer activities via, sockets, pipes follow a queue data structure.

 All the media songs that are piled up one after the other, i.e. playlists.

Q24. What is a dequeue?

Ans: Dequeue is also known as a double-ended queue. It is exactly the opposite of a queue mechanism. In dequeue structure, all the data insertions and data deletion activities can be executed from both the sides, i.e. Front & Rear. 

Q25. Can you let me know the minimum number of queues that are needed to implement a priority queue?

Ans: In general, to implement the priority queue, we need a bare minimum of at least two queues. One queue is essential to store all of the data elements together and another queue is needed to store the priority-based information. 

Q26. Do you know how many types of trees are available? List them out?

Ans: They are 6 types of tree that are available. Below is the list:

Q27. Explain what is Binary tree?

Ans: A binary tree is a type of tree structure where each node has two children, i.e left child, and right child. Using this the tree structure can be progressed. 

Q28. Can you please let me know which data structure is best for tree construction?

Ans: A queue data structure is the best data structure fit for tree construction. 

Q29. Explain what is a Path?

Ans: A path is an orderly sequence of a continuous flow of vertices which are connected via their edges. Usually in this type of sequence, there are no restrictions observed. 

Q30. Explain what is the cycle?

Ans: A cycle is nothing but a closed path where the first vertice is the same as to that of the last/end vertex. Also, we get to see one condition here, the same vertex should not be passed twice. 

Q31. Explain what is a circuit?

Ans: A circuit is very similar to that of a cycle but the only difference is that the vertex can be passed n number of times and don't have any restrictions. Within the circuit, the first vertex is the same as that of the last vertex. 

Q32. For the BFS algorithm which data structure is useful?

Ans: For the BFS algorithm, the queue data structure is useful.

Q33. For the DFS algorithm, which data structure is useful?

Ans: For the DFS algorithm, the stack data structure is useful. 

Q34. What is a linear search?

Ans: Linear search is also known as a sequential search. With this linear search approach, the search element is compared to every element in the list sequentially until a potential match is found. 

Q35. What is a binary search?

Ans: A binary search is also called a half interval search or a binary chop. Within this search algorithm, the target value will be identified by comparing it to the array.

Q36. Can you list out the advantages of selection sort?

Ans: The advantages of selection sort are given below:

Q37. Explain what is NULL?

Ans: A NULL is a value that can be assigned to a data element. It represents that there is no data available for that particular data element. 

Q38. Explain what is VOID?

Ans: VOID is a data type identifier. 

It is used to identify pointers that don't have a size associated.

Q39. Explain the main difference between a binary search and linear search?

Ans: The main difference between a binary search and the linear search is the number of comparisons it does to the target value. In most of the cases, binary search is quick compared to the linear search.

Q40. For sequential representation, which data structure is used?

Ans: An adjacency matrix is a data structure that is used for sequential representation.

Q41. For linked representation, which data structure is used?

Ans: An adjacency list is used for linked representation. 

Q42. Can you let me know where the tree data structure is applied?

Ans: The tree data structure is applied in the following area:

Q43. Can you increase the size of a linked list? 

Ans: Yes, the size of a linked list can be increased. The size is increased at the runtime.

Q44. Can you increase the size of an array?

Ans: No, the size of an array cannot be increased. 

Q45. Is linked list a linear data structure or a non-linear data structure?

Ans: A linked list is considered as a linear data structure and a non-linear data structure. Based on the usage and the situation, the linked list can be aligned. 

Based on data storage criteria, a linked list is considered as a non-linear data structure.

Based on the access strategy, a linked list is considered as a linear data structure.

Q46. Give examples of Multi-linked structures?

Ans: The following are examples of multi-linked structures

1a:T19ee,

Welcome to Advanced Java Tutorial. The intent of these tutorials is to provide good understanding of Advanced Java.

In addition to free Advanced Java Tutorial, we will cover common interview questions, issues and how to’s of Advanced Java.

Introduction

Core java is having the concept of Java Fundamentals, Applet, Swings, JDBC, JavaBeans. Used for developing general java application where as Advanced java is used for developing the web based application and enterprise application. Advance java is specialization such as in web, DCOM, or data base handling.

Java programming language has continued to grow both in popularity and scope since its initial release. Java in its current form is the culmination of several years work, dating back to 1991 when it was conceived as a modular and extensible programming language.

Java is based on the C and C++ programming languages, but differs from these languages is some important ways. The main difference between C/C++ and Java is that in Java all development is done with objects and classes. This main difference provides distinct advantages for programs written in Java, such as multiple threads of control and dynamic loading.

Another advantage to Java is its extensibility. Since the original release of Java, several extensions have been added to the core code, providing greater flexibility and power to applications. These extensions add objects and classes that improve the Java programmer's ability to use such features as:

The Evolution of Imaging in Java

Early versions of the Java AWT provided a simple rendering package suitable for rendering common HTML pages, but without the features necessary for complex imaging. The early AWT allowed the generation of simple images by drawing lines and shapes. A very limited number of image files, such as GIF and JPEG, could be read in through the use of a Toolkit object. Once read in, the image could be displayed, but there were essentially no image processing operators.

The Java 2D API extended the early AWT by adding support for more general graphics and rendering operations. Java 2D added special graphics classes for the definition of geometric primitives, text layout and font definition, color spaces, and image rendering. The new classes supported a limited set of image processing operators for blurring, geometric transformation, sharpening, contrast enhancement, and thresholding. The Java 2D extensions were added to the core Java AWT beginning with the Java Platform 1.2 release.

The Java Advanced Imaging (JAI) API further extends the Java platform (including the Java 2D API) by allowing sophisticated, high-performance image processing to be incorporated into Java applets and applications. JAI is a set of classes providing imaging functionality beyond that of Java 2D and the Java Foundation classes, though it is compatible with those APIs.

JAI implements a set of core image processing capabilities including image tiling, regions of interest, and deferred execution. JAI also offers a set of core image processing operators including many common point, area, and frequency-domain operators.

JAI is intended to meet the needs of all imaging applications. The API is highly extensible, allowing new image processing operations to be added in such a way as to appear to be a native part of it. Thus, JAI benefits virtually all Java developers who want to incorporate imaging into their applets and applications.

Outline

1. Working with Swing: Your first Swing application, Event Handling, Inner Classes, the Graphics2D object, Layout Managers, Action Events, Swing components...

2. Threading: Basic threads, running multiple threads, thread-safe programming, synchronised methods and -locking

3. Basic XML processing in XML: Introduction to XML, generating XML data, introduction to the different ways of processing XML in Java (DOM, SAX, Stax, JAXB), and a more detailed look at annotation-based XML processing with JAXB.

4. Web Services in Java: Introduction to Web Services, writing annotation-based web services with JAX-WS 2.0.

1b:T12ce,

 

Circular Queue

The Regular, static queues  in data structures have a very big drawback, that once the queue is FULL, even though we delete few elements. From the “  front” and relive some occupied space, we are not able to add anymore elements, as the “rear” has already reaches the queues rear most partition. To overcome this drawback we can implement the queue as a circular queue. Here as we go on adding elements to the queue and reach the end of the array, the next element is stored in the first slot of the array (provide it is free). As the name suggests, this queue is not straight but circular; meaning; you go to have a following structure like this   11       Initially when such a circular queue is empty ,the “Front” and the “rear” values are-1 and -1 respectively; and the queue has a null value of all us element. Every time we add on element to the queue the “rear” value increments by 1 till the time it reaches the upper limit of queue; after which it starts all over again from’0’ Similarly, every time we delete an element from queue, the “front” value increments by till the time it reaches the upper limit of queue. After which  it starts all over again from ‘0’.  

Program :

Implementation at circular Queue # include <stdio.h> # include <conio.h> # include <stdlib.h> # define max 5 Int rear = -1; Int front = -1; Int cq [max]; Void insertion() { Int item; If(( front == 0)&& (rear==max-1)||(front==rear +1)) { Print (“Queue is overflow \n”) } Else { Print (“enter the value”) Scanf(“%d”, & item); If(front ==-1); { Font =0; Rear =0; } Else { If(rear == max-1) { Rear=0; } Else { Rear = rear+1 Cq[rear] = item; } } Void deletion() Int item; If(front==-1) { Printf(“Queue is underflow \n”); } Else Item = cq[front]; Printf(“the deleted item is:%d,”item); Cq[front] =0; If(front== rear) { Front=-1; Rear= -1; } Else { If(front== max-1) { Front=0; } Else { Front= front+1; } } } void display () { int i; for(i=0; i<=max;i++) { printf(“%d”,cq[i]);} } } void main() { int op; clrscr(); printf(“1.insertion \n”); printf(“2. Deletion \n”); printf(“3. Display \n”) ; printf(“4. Exit \n”); do { printf(“Enter your option \n”); scanf(“%d”, &op); switch(op) { case 1: insertion (); break; case 2: Deletion (); break; case 3: display (); break; case 4: exit; break; } while(op<=4) } }  

1). Initial State:

12  

2). After inserting element 10

13    

3). After Inserting elements 20,30,40,50...

14  

4). Inserting element 60

Circular Queue is overflow  

5). After deleting elements 10,20

15  

7).After inserting element 60,70

16  

8). After Deleting elements 30,40

17    

9). After deleting 50

17  

10).Ater deleting 60,70

17    

1c:T706,

Linear search

The linear search in data structures  or the sequential searching is most simple searching method. The key which is to be searched, is compared with each element of the list one by one in Linear Search If a match exits, the search is terminated in Linear Search If the end of the list is reached, it means that the search has failed and the key has no matching element in the list.   ex: 20  

Program : 

Linear search # include <stdio.h> # include <conio.h> int linear(int a[20]),int n, int key); void main() { int a[20],n,i,key,p; clrscr(); printf(“Enter the value \n”); for (i=0; i<n; i++) { scanf(“%d”,&key); } printf (“Enter the search element \n”); scanf(“%d”,&key); p=liner(a,n,key); if(p>=0) { printf(“The element found at %d position”,p+1); } else printf(“The element is not found”); getch(); } int linear(int a[20], int n, int key) { int i=0; while(i<n) { if(a[i]==key) { return j; } i++; } return i; }  

Time complexity:

In the worst case(i.e when there)  N  comparisons are required hence the worst case performance represented as o(n); The best case in which the first comparison returns a match, it requires a single comparison and hence it is o(1) The average case roughly requires N/2 comparisons to search the element. That means the average time, as in worst-case is proportional to N and hence is o(n)    

1d:T119d,

Evaluation of a Postfix Expression

Suppose p is an arithmetic expression written in postfix notation. The following algorithm, which user a STACK to held operands, evaluates P.    Algorithm This algorithm finds the value of an arithmetic expression P written in postfix notation

  1. Add a right parenthesis “)” at the end of p [This acts of a sentinel]
  2. Scan p from left to right and repeat steps 3 and 4 for each element of p until the sentinel ”)” is encountered.
  3. if an operand is encountered, put it on STACK
  4. If an operator X is encountered, Then :
  5. Remove the two top elements of STACK, where A is the top element and B is the next to top element
  6. Evaluate BXA
  7. Place the result of (b) back on STACK [End of if structure] [End of step2 loop]
  8. A set value equal to the top element on STACK
  9. Exit

Not that, when step 5 is executed, There should only be one number on STACK.

Example: 

ABC+*DE/- a=5, B=6,c=2,D=12,E=4  

Symbol scanned STACK
  1. A
 5
  1. B
 5  6
  1. C
 5 6 2
  1. +
 5  8
  1. *
 40
  1. D
 40     12
  1. E
 40     12         4
  1. /
 40         3
  1. -
 37

   

Postfix expression Program 

#include <stdio.h>
#include <conio.h>
#include <string.h>

char postfix[20];
int stack[20];
int top = -1;

void get_postfix_expr() {
    printf("Enter the postfix expression: ");
}

switch(postfix[i]) {
    case '-':
        stack[top] = B - A;
        top--;
        break;
    case '*':
        stack[top-1] = B * A;
        top--;
        break;
    case '/':
        stack[top-1] = B / A;
        top--;
        break;
}

void calculate() {
    int i, A, B;
    for (i = 0; postfix[i] != '\0'; i++) {
        if (postfix[i] >= '0' && postfix[i] <= '9') {
            stack[++top] = postfix[i] - '0';
        } else {
            B = stack[top--];
            A = stack[top--];
            switch(postfix[i]) {
                case '+':
                    stack[++top] = A + B;
                    break;
                case '-':
                    stack[++top] = B - A;
                    break;
                case '*':
                    stack[++top] = B * A;
                    break;
                case '/':
                    stack[++top] = B / A;
                    break;
            }
        }
    }
}

void display() {
    printf("Result = %d", stack[top]);
}

int main() {
    clrscr();
    get_postfix_expr();
    calculate();
    display();
    return 0;
}

Output:

Enter the postfix expression: ABC+*DE/-
Enter the value of A: 5
Enter the value of B: 6
Enter the value of C: 2
Enter the value of D: 1
The calculated value is: 33
1e:Ta70,

Selection sort

Suppose an array A with ‘n’ elements A[0],A[1],A[2]….. is in memory. The selection sort algorithm in data structures for sorting ‘A’ works as follows Pass 1:  First find the smallest element in the list and put it into the first position. Then find the second smallest element in the list of ‘N’ elements A[0],A[1],A[2]------ and then interchange A[Loc] and A[0] is sorted. Pass 2: Find the location LOC of the smallest in the sub list of n-1 elements A[1],A[2],A[3] then A[0],A[1] sorted Pass N-1: Find the location LOC of the smaller of the elements A[N-1], A[N] and then interchange A[LOC] and A[N-1] then : A[0],A[1],A[2]-----  is sorted. 24  

 Selection Sort Program

Implementation of selection sort # include<stdio.h> void selection sort(int a[],int n); void main() { int a[20],n,i; clrscr(); printf(“Enter n value \n”); scanf(“%d”,&n); printf(“Enter those numbers \n”); for (i=0;i<n;i++) { scanf(“%d”,&a[i]); } selection sort(a,n); printf(“Following are the elements in sorting orger: \n”); for(i=0;i<n;i++) { printf(“%5d”,a[i]); } } void selection sort(int a[], int n) { int i, min Loc, t,j; for(i=0;i<n-1;i++) { MinLOC=i; for(j=i+1; j<n;j++) { if(a[j]<a[minLoc]) minLoc=j; } t=a[i]; a[i]=a[MinLoc]; a[MinLoc]=t; } }  

Time complexity :

Complexity of the selection sort algorithm f(n)=(n-1)+(n-2)+-------- +2+1=n(n-1)/2=0(n2)  

Algorithm Worst cape Average cape
selection sort n(n-1)/2=o(n2) n(n-1)/2=o(n2)

 

Output:

Enter n value : 7 Enter those numbers : 60     30     20     10     50     70     40   Following are the elements in the sorting order: 10     20     30     40     50     60     70        

1f:Tb72,

Insertion sort

Suppose an array ‘A’ with ‘n’ elements A[0]. A910,A[20],---------A[N-1] is in memory. The insertion sort algorithm in data structures scans ‘A; from A[0] to A[N-1] insert each element A[k] into its proper position in the previously sorted sub array A[0],A[1],A[2]---- A[K]                      That is pass1                   A[0] by itself ip trivially sorted. pass2                   A[1] is inserted either before or after aA[0] So that : A[0],A[1] is sorted pass3: A[2] is inserted into its proper place in A[1] A[2], that is before A[0] between A[0] A[1] or after A[1], so that : A[0],A[1],A[2] is sorted pass4: [3] is inserted into its proper place in A[1],A[2] so that : A[0],A[1],A[2],A[3] is sorted. PassN : A[N] is inserted into its proper place in A[1],A[2],-------A[N-1] so that : A[0],A[1]--- is sorted.   Example :   25  

Insertion Sort Program

Implementation of insertion sort in data structures # include <stdio.h> # include <conio.h> void main() { int n,i,j,a[20],temp; void insertion sort(int  a[10],int n); clrscr(); printf(“Enter n value: ”); scanf(“%d”,&n); printf(“Enter the elements:\n”); for(i=0; i<n;i++) { scanf(“%d”,&a[i]); } Insertion sort(a,n); } insertion sort(a,n); printf(“The sorted elements are:\n”); for(i=0;i<n;i++) { printf(“%5d”,a[i]); } } void insertion sort (int a[20], int n) { int i,j,temp; for(i=1;i<n;i++) { if(a[j]<a[j-1]) { temp=a[j]; a[j]=a[j-1]; a[j-1]=temp; } } } }

output :

Enter ‘n’ value : 5 Enter the elements:     2       4       3       1       5 The elements are :  2   3       4       5     Time complexity :      

Algorithm Worst case Average case
Insertion sort n(n+1)/2=o(n2) n(n-1)/4=o(n2)

   

20:Tcc0,

Quick sort

The following are the steps to set up Quick Sort in Data Structures.

  1. Select first moment of Array A(or sub array) as pivot.
  2. Initiative and J to first and last elements of the array respectively.
  3. Increment     :    until  A[i]>pivot;stop
  4. Decrement :     until A[j]<pivot,stop
  5. if i<j     : change A[i] and A[j]
  6. Repeat statements 3,4 and 5 until i>j, i.e when i and j cross each other.
  7. Exchange the pivot element with the element pointed to by J which is correct place for pivot

Note that in step 7, The swapping keeps the larger element to the right and smaller element to the left, relative to the pivot.     Example: 26 26 27 27 27  

Quick Sort Program

Implementation of Quick sort # include<stdio.h> void Quick sort(int k[], int lb,int vb); void main() { int a[20]; int n,i; clrscr(); printf(“How many numbers:”); scanf(“%d”, &n); printf(“\n Enter the numbers: \n”); for(i=0;i<n;i++) { scanf(“%d”,a[i]); } quicksort(a,o,n-1); printf(“The following are the sorted elements :\n”); for(i=0;i<n;i++) { printf(“%d”,a[i]); } getch(); } void quick sort(int k[], int lb, int vb) { int flag; int i,j,key; flag=1; if(lb<ub) { int temp; i=lb+1; j=ub; key=k[lb];   while(flag) { while(k[i]<key     &&    i<ub) i=i+1; While(k[j]>key    &&    j>lb) j=j-1; if(i<j) { temp=k[j]; k[j]=k[i]; k[i]=temp; } else flag=0; } temp=k[lb]; k[lb]=k[j]; k[j]=temp; quicksort(k,lb,j-1); quicksort(k,j+1,ub); } }

Output:

How many numbers : Enter the numbers:  

Time complexity:

The running time of sorting algorithm is usually measured by the number f(n) of comparison required to sort ‘n’ elements, the quick sort algorithm which has many variations as been studied extensively generally speaking, The algorithm has a worst case running time of order n2/2=o(n2) it’s an average cape running time of order o(nlogn)  

21:Tc56,

Heap Sort

  Building Heap  

  1. start with just one, element one element will always, satisfy heap property.
  2. Insert next elements and make this a heap
  3. Repeat step b until all elements are include in the heap

  Sorting  

  1. Exchange the root name the last element in the heap
  2. Make this a heap agar, but this time do not include the last node.
  3. Repeat step a and b until there is no element left

   

Example

set the following elements in ascending order using heap sort 4,8,9,5.6   A

4 8 3 9 5 6
1 2 3 4 5 6

   

Build Heap

28 28  

Sorting

29     Program : Implementation of Heap Sort # include<stdio.h> void Heapsort(int a[],int n); void Build Heap(int a[],int n); void Reheap(int a[],int k); void main() { in a[20],n,i; printf(“Enter N value \n”); scanf(“%d”,&n); printf(“Enter those numbers: \n”); for(int i=1; i<=n; i++) { scanf(“%d”,&a[i]); } Heap sort(a,n); printf(“ The following are the sorted elements. \n”); for(i=1;i<=n;i++) { printf(“%d”,a[i]); } } void Heap sort(int a[],int n) { int fs,temp; Build Heap(a,n); for(pos=n;pos>=2;pos--) { temp=a[1]; a[1]=a[pos]; a[pos]=temp; Reheap(a,pos-1); } } void Build Heap(int a[],int n) { for(j=2;j<=n;j++) { key=a[i]; i=j/2; while((i>0) && (a[i]<key)) { a[j]=a[i]; j=i; i=j/2; } a[j]=key; } a[j]=key; } } void Reheap(int a[], int k) { int parent, child, key, heap; parent=1; child=2; Key=a[parent]; heap=0; while((child<=k) && (!heap)) { if(child<k) { if(a[child+1]>a[child]) child=child+1; } if(a[child]>key) { a[parent]=a[child]; parent=child; child=parent*2; } else { heap=1; } } a[parent]=key; }  

Time complexity :

Since each phase require time proportional to nlog2n, The running time to sort the n-element array using heap sort is proportional to nlog2n, that is f(n)=0(nlog2n) the average running time of heap sort is o(nlog2n)

22:T29e8,

Linked List

 

The term “list” refers to a linear collection of data items. One way to store such data is by means at “array” . The array implementation of list hap certain draw backs there are

  1. Memory storage space is wasted, very often the list is much stories than the array size declared.
  2. List cannot grow in its size beyond the size at the declared array i.e required during paragraph execution.
  3. Operations like insertion and declaration as a specified location in  a list requires a lot of movement of data, Therefore leading to inefficient and time containing algorithm
  4. Another way of storing a list in memory is by means of linked list. Each element in the list contain a field, called a link fields, Which contains the address of the next elements in the list need not occupy adjacent space in memory. Thus will make it easier to insert and delete element in the list.

   

Advantages of linked list over arrays:

  1. Linked list is a dynamic structure where as array is a static structure. That is the size of the array is fixed, it cannot be increased or decreased during execution of a program.
  2. In portion and deletion of nodes require no data movement
  3. Joining two arrays is very tedious process because these is lot of data movement, where of joining two linked list is very easy.

Types of linked list :

These are 3 types.

  1. Singly linked list
  2. Doubly linked list
  3. Circular linked list

 

Singly linked list:

  30  

  31  

Inserting at an element in list:     

  1. Inserting at the beginning of the list :
  1. Allocate space for a new node.
  2. Copy the item to be inserted into it.
  3. Make the new nodes next pointer point to the current head of the list
  4. Make the HEAD of the list point to the newly allocated node.
  1. cur -> Link = Head
  2. Hand = Cur;

  32    

Insertion After a give node :

To insert a node in the linked list we need to specify the element to be inserted and the element in the list after which the element has to be inserted.

  1. Search for the element after which the insertion is to be done.
  2. Create a memory space for element to be inserted.
  3. Assign the data value its data field.
  4. Assign is a pointer to pointer of the element searched at step 2
  5. Assign pointer of the element searched at step 2to this new element started.

   

  1. cur    - >  Link      = ptr -> Link;
  2. ptr     - > Link       =cur;

  33  

Deletion Operation :

Deleting Beginning Node:

  1. Store the first “link field” in the “HEAD” pointer
  2. Disappear the memory space held by the deleted element

Head=Head - > Link free(otr); 34  

Deleting a specified node:

 

  1. Search for the element with key value same as the element to be deleted.
  2. Its pointer to next element be saved and late assigned to next element of predecessor of the element searched at step.
  3. Dispose the memory space held by the deleted element.

ptr1=ptr àlink; ptr à link= ptr1 àlink; free(ptr1);   35  

Linked List Program

Implementation of singly linked list # include <studio.h> #include <conio.h> #include<stdlib.h> struct Node { int Data; struct Node *link; }; struct Node*Head; void createList() { int else; struct Node*ptr,*cur; Head=NULL; printf(“Enter Data for the Node -1): “); scanf(“%d”,&ele); while(ele!=-1) { cur=(struct Node*)malloc (size of (structNode)); cur 7 Data=ele; cur 7Link=NULL; if (Head==NULL) Head=cur; else ptr 7link =cur; ptr=cur; printf(“Enter Data For The Node -1):”); scanf(“%d”,&ele); } } void Insertion() { int ele,x; char ch; struct Node*ptr,*cur; ptr=Head; cur=(structNode *) malloc (size of (structNode)); printf(“Enter Data for the New Node:”); scanf(“%d”,&x); cur 7 Data=x; cur 7Link=NULL; printf(“Do you want to insert first(y\n:”); fflush(stdin); scanf(“%c”,&ch); if((ch==’y’) || (ch==’n’)) { cur 7 link =Head; Head =cur; } else { printf(“After which element you want to Insert:”); scanf(“%d”,&ele); while(ptr!=NULL) { if(ptr 7 Data ==ele) { cur 7 Link =ptr à Link; ptr 7 Link= cur; break; } else { ptr =ptr 7Link; } } } } void Deletion () { int ele; char ch; struct Node*ptr,*ptr1; ptr=Head; printf(“Do you want to Delete First (Y/n):”); scanf(“%c”,&ch); if(ch==’y’|| ch==’n’) { Head=Head 7Link; free(ptr) } else { printf(“ which element you want to delete:”); scanf(“%d”, &ele); while(ptr!=NULL) { if(ptr7 Link àData==ele) { ptr1=ptr 7Link; } } } } void Display() { struct node*ptr; ptr=Head; if(ptr==NULL) { printf(“List is Empty \n”); } else { while(ptr!=NULL) { printf(“%5d”,ptr Data); ptr=ptr 7Link; } } } void main() { int choice; createlist() printf(“1.INSERTION \n”); printf(“2.DELETION  \n”); printf(“3.DISPLAY  \n”); printf(“4.EXIT \n”); do { printf(“Enter your choice:”); scanf(“%d”,&choice); switch (choice) { { case1: insertion (); break; case2: deletion (); break; case3: Display(); break; case4: exit(0); } } while (choice<=4); getch(); }    

23:Td6d,

Queues using Linked list

It configures storage (using arrays), queues where harder to manipulate then were stacks. It causes difficulties to handle full queues and empty queues. It is for queues that linked storage really comes into its own The linked implementation has two advantages over the array implementation (1) it is faster locations for insertion and deletion are same at the back and at the front and 2) it wastes no space Linked queues are just as easy to handle as are linked stacks.   45   Program: Program to implement queue using linked list : # include<stdio.h> #include<conio.h> #include<stdio.h> struct node { int data; struct node *next; }; struct node *front=NULL ;*rear; void insertion() { int els; struct node *new node; new node=(struct node *)malloc(sizeof(struct node)); printf(“Enter data for new node: ”); scanf(“%d”,&ele); newnode 7data=ele; newnode 7next=NULL; if(front==NULL) { front=new node; rear=front; } else { rear7 next= new code; rear= new node; } } void deletion() { struct node *temp; if(front==NULL) printf(“QUEUE underflow”); else { temp=front; front=front 7 next; printf(“Deleted element is : %d \n”, temp 7 data); free(temp); } } void display() { struct node *ptr; if(front===NULL) printf(“queue is empty”); else { printf(“elements of queue are :”); for(ptr=front; ptr!=NULL;ptr=ptr7next); printf(“%5d”,ptr7 data); } } void main() { int ch; clrscr(); do { printf(“1. INSERTION \n”); printf(“2. DELETION \n”); printf(“3. DISPLAY \n”); printf(“4.EXIT \n”); printf(“Enter U r choice :”); scanf(“%d”,&ch); switch(ch) { case1: insertion(); break; case2: deletion(); break; case3: display(); break; case 4: exit(0); } } while(ch<=4) getch(); }                            

24:T1e08,

Binary Tree

 A binary trees in data structures T is defined as a finite set of elements, called nodes, such that :

  1. T is empty ( called the null tree of empty tree)
  2. T contains a distinguished node R, called the root of T and the remaining nodes of T form an order pair of disjoin binary trees T1 and T2.

If T does contain a root R, Then the two trees T1 and T2 are called, respectively the left and right sub trees of R.     47    

Differences between a binary tree and a tree in data structures

  Algebraic expressions Following figure shows some binary trees that represent arithmetic expressions. Each operator (+,-,*,/) may have one or two operands The left operand (if any) is the left sub trees of the operator. The right operand is its right sub tree. The right operand is its right sub tree . The leaf element in an expression tree are either constants or variables. Note that an expression tree contains parenthesis One application of expression trees is in the generation of optimal computer code to evaluate an expression   Example : (a-b)/(Cc*d)+e)

  48     Example: (a*b) + (c/d)

  1. a*b
  2.  c/d
  3. 1+2

  49   Example : ((a+b)+c)+d) 50    

Properties of binary trees

  1. The drawing of every binary tree with n elements, n>0, has exactly n-1 edges.
  2. A binary tree of height h, h>=0, has at least hand at most 2n-1 elements init.

 

 Full binary tree & complete binary tree

A binary tree of height h that contains exactly 2n-1 elements is called a full binary tree.   51     The tree T is said to be complete if all its levels, except possible the last, have the maximum number of possible nodes, and if all the nodes at the last level appear as far left as possible. 52  

Representation of Binary trees

The following are the two ways of representing binary trees

 

Suppose T is a binary tree that is complete or nearly complete or nearly complete. Then there is an efficient representation of T. This representation uses only a single linear array TREE as follows.

  1. The root R of T is stored in TREE[1]
  2. If a node N occupies TREE[k]. then the left child is , stored in TREE[2*K] and its right child is stored in TREE[2*(k+1)]

Again , Null is used to indicate an empty sub tree in particular, TREE[1]= NULL indicates that the tree is empty. 53   This representation schema is quite waste of space when many elements are mission. The array representation is useful only when the number of missing elements is small.

The most popular way to represent a binary tree is by using links or pointers. Each element is represented by a node. That has exactly two link fields. Let us call these link fields left child and right child. In addition to these two link fields each node has a filed named data. Example: 54 55  

Binary  tree traversal

There are three common ways to traversal a binary tree :

Preorder traversal

   

In order Traverse

Post order Traversal

  56 57   Algorithm                 Preorder traversal void preorder(Binary Tree Node*t) { // preorder traversal if(t) { printf(“%d”,t- >data);         // visit tree root preorder(t-> leftchild);       // do left sub tree preorder(t-> right child);  // do right sub tree } }   Algorithm In order traversal void inorder (Binary TreeNode   *t) { // Inorder traversal if(t) { inorder(c-> leftchild);  // do left subtree printf(“%d”,t-> data);  // visit tree root inorder(t-> right child); // do right sub tree } }   Algorithm Post order traversal void post order(Binary Tree Node *t) { if(t) { past order(t-> left child);       // do left sub tree past order(t-> right child); // do right sub tree printf(“%d”,t-> data); // visit tree root } }

25:T1236,

Binary search tree

  A binary search tree is a binary tree that may be empty A no-empty binary search tree in data structures satisfy the following properties :

58     Searching BST :

  59      

Search for 9:

  1. compare 9: 15(The root), goto left sub tree;
  2. Compare 9: 6,go to right sub tree.
  3. compare 9: 7, go to right sub tee
  4. compare 9: 9, found it

 

Insertion operation

Algorithm:

  1. perform search for value x
  2. search will end at node y(if x not in tree)
  3. if x<y, insert new leaf x as new left sub tree for y
  4. if x>y, insert new leaf x as new right sub tree for y.

  observations :

  47   10<20. right 30>20, left 25>20, left insert 20 on left Example : instruct a binary search tree with the following elements. 12,5,18,2,9,15,19,13,17 And traverse the binary search tree in zn order, preorder, post order   60       Preorder : 12      529   1815131719 In order: 259       12     1315171819 Post order:295             131715191812  

Deletion operation :

For element removal we consider the three possibilities for the node P that contains the element to be removed.  

Case 1:          First cape is handled by discarding the  root, The root is set to null. 61 Case 2: Next consider the case when the element to be removed is in ia node P that has only one non empty sub tree. IF P has no parent (i.e it is root), The root of its single sub tree becomes the new search tree root. IF p has a parent pp, then we change the pointer from PP so that it points to p’s only child. ex : Delete 5 62   Case 3: Finally, to remove an element in a node that has two no empty sub trees, we replace this element with either the largest element in its left sub tree or the smallest element in its right sub tree. Following this replacement, the replacing element is removed from its original node Ex : Deleting 50   63        

26:T1b71,

AVL Trees

One of the more popular balanced trees, known as an AVL tree in Data Structures, was introduced in 1962 by Adelson-Velski and Landis

Definition:

An empty binary search tree is an AVL tree. If T is a non empty binary search tree with T2 and TR as its left and right sub trees, The T is an AVL tree iff.

                                                                Or An Avl trees is a binary search tree in which for every node in the tree, The height of the left and right Sub trees differ by at most1. 64     hL – hR =1 This is AVL Tree   65     hL – hR =2 This is not AVL Tree 66       This is also a AVL tree hL = Height of left sub tree =2 |hl – hR |=|2-3|=|- 1|=1 | hL –hR| <=1     The difference between heights at left sub tree and right sub tree is called balancing Factor of a node.   Importance of Rotations :

This fact is important.   Single Rotations : RR rotation :- [ Right – Right Rotation] 67 68   69    

 Double Rotations :

70  

LR Rotaion  c Left Right Rotation :

  71         Ex : Example of RL Rotation : 72    

Ex: Example of LR Rotation:

  72   Example: Construct an AVL tree with the following elements 3,2,1,4,5,6,716,15,14 72 72 72    

Insertion :

 

Deletion :

 

27:T3084,

Circular linked list

A linked list in which the last node points to the first node instead of containing null pointer will be termed as circularly linked list or simply circular list   36   Circular linked list in data structures have an advantages over singly linked list. It is concerned with the accessibility of a node. Ina circular list every node is accessible from a given node that is, from this given node all nodes can be reached by changing through the list.  

Insertion operation:

  1. Insertion as a first node:

cur7 1= Head; Head=cur; ptr 7 1=Head;   37    

(ii) Insertion after a given node:

cur 7 link = ptr à link; ptr1 7link =cur;   38    

Deletion Operation

Head =ptr1 7 link; ptr 7 link =Head; free(ptr); 39

temp=ptrl 7 link; ptr1 7 link = ptr1 7 link à link free(temp); 40

Circular linked list Program in Data Structures

Implementaton of circular linked list # include <studio.h> #include <conio.h> # define NULL #include<stdlib.h> struct Node { int data; struct Node*link; }; struct node*Head; void create() { int a; struct Node * cur,*ptr; Head=NULL; printf(“Enter Data For The Node(-1):”); scanf(“%d%,&a); while(a!=-1) { cur =(struct Node *) malloc (size of (struct Node)); cur7data =a; cur 7link =NULL; if(Head== NULL) Head==cur; else ptr= cur; printf(“Enter Data For Node (-1):”); scanf (“%d”,&a); } ptr 7 link =Head; } void insert() { int ele; char ch; struct Node*ftr, *ptr,*ptr1,*cur; ptr=Head; ptr1=Head; cur=(struct Node *) malloc (size of (struct Nodes); printf(“Enter data:”); scanf(“%d”,&cur àdata); cur 7 link =NULL; printf(“Do you want to insert first(y\n):”); flush(stdin); scanf(“%c”,&ch); if((ch==’y’) || (ch==’y’)) { while(ptr 7link!=Head) { ptr=ptr 7 link; } cur 7 link =Head; Head= cur; ptr à link =Head; } else { printf(“After which element you want to insert:”); scanf(“%d”,&ele); do { if( ptr1 7data == ele) { cur 7 link =ptr1 7link; ptr1 7link =cur; } ptr1 = ptr1 7link; } while(ptr1!=Head); } } void deletion() { int ele; char ch; struct Node *temp,*ptr,*ptr1; ptr=ptr1=Head; fflush(stdin); printf(“Do you want to delete first(y\n):”); scanf(“%c”,&ch); if((ch==’y’)|| (ch==’y’)) { while(ptr 7 link!=Head) { ptr= ptr 7link; } cur 7link =Head; Head= cur; ptr 7 link =Head; } else { printf(“After which element you want to insert:”); scanf(“%d”,&ele); do { if(ptr1 7 data ==ele) { cur 7link=ptr1 7 link; ptr1 7link =cur; } ptr1 =ptr1 àlink; } while(ptr1!=Head); } } void deletion() { int ele; char ch; struct Node *temp,*ptr,*ptr1; ptr=ptr1=Head; fflush(stdin); printf(“Do you want to delete first (y/n):”); scanf(“%c”,&ch); if((ch==’y’) || (ch==’y’)) { while(ptr 7link!=Head) { ptr = ptr 7 link; } Head =ptr1 7 link; ptr 7 link =Head; free(ptr1); } printf(“Which element you want to delete:”); scanf(“%d”,&ele); do { if(ptr1 7 link 7 data == ele) { temp=ptr1 7link; ptr1 7 link = ptr1 7 link 7link; free(temp); break; } else { } while(ptr1!=Head) } } void display() { struct Node * temp; temp=Head; do { printf(“%d” 7,temp 7 data); temp=temp 7link; } while(temp!= Head); } } void main() { int op; clrscr(); create(); printf(“1.INSERTION \n”); printf(“2.DELETION  \n”); printf(“3.DISPLAY  \n”); printf(“4.EXIT \n”); do { printf(“Enter your option:\n”); scanf(“%d”,&op); switch (op) { { case1: insertion (); break; case2: deletion (); break; case3: Display(); break; case4: exit(0); } } while (op<=4); }

28:T376a,

Doubly Linked List

In a single linked list, it is possible to move only in the direction of links, that is we have been restricted to traversing linked list in only one direction. In the linked lists, each node provides information about where is the next node in the list. It has no knowledge about where the previous node lies in memory. If we are at say the 15th node in the list, then to reach the 14th node we have to traverse the list right from the first node. To avoid this we can store in each node not only the address of next node but also. The address of the previous node in the linked list this arrangement is often known as ‘Doubly linked list’ in data structures. The list can be traverse in either a forward or backward direction. Each node in doubly linked list must contain two link fields instead of one. Here a node has at least three fields say data, left link and right link.     41  

Insertion Operation

ptr 7 bl=cur; cur 7 fl =ptr; rur=cur; 42    

  1.  Insertion after a given node:

cur 7 fl =ptr àfl; cur 7 bl =ptr; ptr 7 fl 7 bl=cur; ptr 7fl =cur; 40  

Deletion Operation

  1. Deleting First Node

ptr 7fl 7bl= ptr 7bl; root =ptr 7fl;   43  

  1. Deleting a specified node:

ptr 7 fl 7bl = ptr 7bl; ptr 7 bl 7fl= ptr 7fl;   43  

Program

Implementation of Doubly linked list #include <stdio.h> #include<conio.h> # include<stdlib.h> struct dlist { int data; struct dlist ,*fl,*bl; }; typedef struct dlist node; node *ptr,*root,*cur,*last; void display() { ptr=root; last=NULL; printf(“The list is \n”); while(ptr!=NULL) { printf(“%d 7”,ptr7data); if(ptr7flNULL); last=ptr; ptr=ptr-fl; } printf(“\n reverse list”); ptr=last; while(ptr!=Null) { printf(“%d 7”,ptr 7 data);               ptr=ptr7 bl; } } void insertion() { int ele; char ch; ptr=root; cur=(node *) malloc*(sizeof(nodes)); printf(“enter data for node” ); scanf(“%d”, &cur 7 data); cur 7 fl=cur 7 bl=NULL; ffush(stdin); printf(“do you want to insert first(Y/N):”); scanf(“%c”,&ch); if(ch==’Y’ || ch==’Y’) { ptr7 bl=cur; cur7  fl=ptr; root=cur; } Else         { printf(“After which element you want to insert:”); scanf(“%d”,&ele); while(ptr!=NULL) { if(ptr7 data== ele) { cur 7 fl=ptr 7 fl; cur 7 bl=ptr; ptr7 fl 7 bl=cur; ptr7 fl=cur; break; } else ptr=ptr7 fl; } void deletion() { int ele; char ch; ptr=root;           fflush(stdin); printf(“Do you want to delete first(y/n)”); scanf(“%c”, &ch); if(ch==’ Y’||ch=’ Y’) { ptr7 fl 7bl=ptr 7 bl; root=ptr 7 fl; } else { printf(“which element you want to delete :”); scanf(“%d”, &ele); while(ptr!=NULL) { if(ptr 7 data==ele) { ptr7 fl 7 bl=ptr -7bl; ptr 7 bl 7 fl=ptr7fl; }                 else ptr=ptr7 fl; } } } void main() { int a,n; root=NULL; printf(“Enter data for node(-1)”); scanf(“%d”,&a); while(a!=-1) { cur=(node*) malloc(sizeof(nodes)); cur-> data =a; cur7 fl=cur 7 bl=NULL; if(root==NULL) root=cur; else             { cur7 bl=ptr; ptr7 fl=cur; } ptr=cur; printf(“enter data for node(-1)”); scanf(“%d”,&a); } printf(“1.display\n”); printf(“2.Insertion\n”); printf(“3. deletion \n”); printf(“4. Exit \n”); do { printf(“Enter four option :”); scanf(“%d”,&n); switch(n) { case 1: display();break; case 2: insertion();break; case 3: deletion(); break; case 4: exit(0); break; } } while(n<=4); getch(); }

29:T2e4f,

B Trees

m-way search trees

Definition

An m-way search tree may be empty if it is not empty it is a tree that satisfies

The following properties

In the corresponding extended search Tree, each inter-node has up to in children and between 1 and m-1 elements (External nodes contain no elements and have no children) Every node with p elements has exactly p+1 children Consider any node with p elements. Let k1----kp be the keys of these elements. The elements are ordered so that k1<k2 - -- -- kp. Let c0,C1…..C be the p+1 children of the node. The elements in the sub tree with root cp have keys larger than kp and those in the sub tree with root C; have keys larger than ki but smaller than ki+1,1<=i<p   Ex : A seven way search Tree G -> External nodes   73  

B trees of order m

Definition A B-tree in Data Structures at sizzler in is an m-way search tree if the B-tree is not empty, The corresponding extended tree satisfies the following properties The root has at least two children Fill internal nodes other than the root have at least [m/2] children. All external nodes are at the same level.  

Example of B-tree in Data Structures

74   Here m =7 m/2 =7/2 =3.5 =4 figure 2

Insertion into a B tree

To insert an element into a B-tree we first search for the presence of an element with the same key. If such an element is found, The insert fails because duplicates are not permitted. When the search is unsuccessful, we attempt to insert the new element into the last internal node encountered on the search path. Ex: Insert 3into above figure(figure2) When inserting an element with key 3 into the B-tree of figure,we examine the root and its left child. We fall of the tree at the second external node of the left child, since the left child currently has three elements and can hold up to six, the new element any inserted into this node, the result is the B-tree of figure (3).   75   E.g.:2 Insert 25 into figure3: This element is to go into the node [20, 30,40, 50, 60,70].However, this node is full when the new element needs to go into a full node, the full node is split. 76    

Deletion from a B tree

Deletion is first divided into two cases:

  1. The element to be deleted is in a node whose children are external nodes (i.e. the element is in a leaf).
  2. The element is to be deleted from a non-leaf case2 is transformed into case(1) by replacing the deleted element with either the largest element in its left neighboring sub tree or the smallest element in its right –neighboring sub tree. The replacing element is guaranteed to be in a leaf.

e.g. Delete 50 from the B tree of figure3   To delete 50 from the  B tree of figure 4, we write out the modified node [20, 30, 40, 60, 70 ]   77   E.g.2: Deleting the element with key 80 from the B tree of figure (3) Since the element is not in a leaf, we find a suitable replacement .The possibilities are the element with key 70 (i.e. the largest element in the left –neighboring sub tree) and 82 (i.e. the smallest element in the right- neighboring sub tree).When we use the 70, the problem of deleting this elements. 78 E.g.3: Deleting element 25 from the B-tree of figure4 When the element is being deleted from a non-root node that has exactly the minimum number of elements, we try to replace the deleted element with an element from its nearest left sibling or right sibling. Notice that every node more other than the root has either a nearest left sibling or a nearest right sibling or both. 79   E.g.: Deleting element 25 from B tree of figure 4. In our example the siblings [20, 30] and [50, 60, 70] and the element with the key 40 are merged into the single node [20, 30, 40, 50, 60, 70].The resulting B-tree is that of figure (8).   80   Example Construct a B tree of order 3 using the following elements: 78, 52, 81, 40, 33, 90, 85, 20, 38 Solution 81  

 Deques

  82  

 

Program: Implementation of deque using arrays

#include<stdio.h> #include<conio.h> static int deque [max]; int front=-1; int rear=-1; // insert an element from void addqatbeg(int item) { int i; if(front ==0 &&rear == max-1) { printf(“\n Deque is full \n”); return; } if( front ==-1) { front =rear=0; Deque [front=item; return; } if (rear!=max-1) { int c= count(); int k=rear+1; for(i=1;i<=c; i++) { Deque[k]=Deque[k-1]; k- -; } Deque[k]=item; front=k; rear++; } else { front- -; Deque[front]=item; } } void addqatend(int item) { inti; if(front ==0 &&rear ==MAX-1) { printf(“\n Deque is full \n”); return; } if(front==-1) { rear=front=0; Deque[rear]=item; return; } if (rear==MAX-1) { int k=front-1; for(i=front-1;i<rear;i++) { k=i; if(k=MAX-1) Deque[k]=0; else Deque[k]=Deque[i+1]; rear - -; front- -; } rear++; Deque[rear]=item; }    

//removes an element from the front end of deque

int delzatbeg() int item; if(front==-1) { printf(“\n Deque is empty \n”); return 0; } item =Deque[front]; Deque[front]=0; if (front==rear) front=rear=-1; else front++; return item; }  

//removes an element from the rear end of the deque

int delqatend() { int item; if(front==-1) { printf(“\n Deque is empty\n”); return 0; } item=Deque[rear]; Deque[rear]=0; rear- -i; if(rear==-1) front=-1; return item; }

//display elements of a deque

void display() { int i; printf(“\n front à”); for(i=0;i<MAX; i++) printf(“%d”,Deque[i]); prinft(“ß rear”); }

//count the total number of elements in deque

int count() { int  c=0; int i; for(i=0;i<MAX;i++) { if(Deque[i]!=0)c++; } return c; } void main() { int n,i; addqatend(17); addqatbeg(10); addqatend(8); addqatbeg(-9); addqatend(13); addqatbeg(28); addqatend(14); addqatbeg(5); addqatend(25); addqatbeg(6); addqatend(21); addqatbeg(11); printf(“\n Elements in a deque:”); display(); n=count(); printf(“\n Total number of elements in deque :%d”,n); i=delqatbeg(); printf(“\n item extracted:%d”,i); i=delqatbeg(); printf(“\n item extracted:%d”,i); i=delqatbeg(); printf (“\ item extracted :%d”,i); i=delqatbeg(); printf(“\n item extracted:%d”,i); printf(“\n Elements in a Deque after addition:”); display(); i=delqatend(); printf(“\n item extracted :%d, i); i=delqatend(); printf(“/n item extracted:%d”,i); printf(“\n Elemens ina deque after deletion :”); display(); n=count(); printf(“\n Total number of elements in deque:%d”,n); } Output Elements is deque: front 7 6 5 29-9 10 17 8 13 14 25 6 rear Total number of elements in deque :10 item extracted :6 item extracted :5 item extracted:28 item extracted :-9     Elements in adeque after deletion: front 70 0 0 0 10 17 13 14 25 6rear Elements in a deque after addition : front 7 o o 10 17 8 13 14 2516 7 6 rear item extracted :7 item extracted :16 Elements in a deque after deletion: front 7 0 0 10 17 8 13 14 25 0 0 6rear Total number of elements in deque: 6  

2a:Tbe3,

Trees

The linear data structures are generally not suitable for the representation of hierarchical data in hierarchal data we have an ancestor ,descendent, superior-subordinate, whole part, or similar relationship among the data elements. Definition : A tree in data structures is a finite set of one or more nodes such that : A distinguish node, called the root. The remaining nodes are partitioned into n>=0 disjoint steps called sub trees of the root Note# that the hierarchical relationship between various data items can be represented by using trees.

  46  

Example

The inheritance relationship between classes in a form a tree. In most operating systems, files are organized hierarchy calls into nested directories which are presented to the use in the form of a tree. A structured document, such as a book, ie hierarchy organized as a tree where internal nodes are chapters, sections and  sub sections, and where external nodes. 

Related Article: Stacks in Data Structures

Basic terminology

A node stands for the item of information plus the branches to other items, Trees has 13 nodes. The number of sub trees of a node is called its degree. The degree of A is 3, of c is 1 and F is nodes that have degree 0 are called leaf or terminal nodes. The other nodes are called non terminal, nodes. E,F,K,H,I,L,M id set of leaf nodes. A node is external it has no children and it is internal if it has one or more children , external nodes are also known as leafes. The roots of the sub trees of  a node are called the children of that node. In the following above figure ‘A’ is called the parent of B,C and D. The children of D are H,I and J. The parent of D is A. An ancestor of a node is either the node itself an ancestor of the parent of the node. Conversely, we say that a node v is a descendent of a node U if U is an ancestor of V.   Children of the same parent are said to be siblings. H,I and J are siblings. The degree of a tree is the maximum degree of the nodes in the tree. The tree of figure has degree 3. Another commonly used tree term is leafs. By definition the tree root is at level 1; its children (if any) are at level2; their children (if any) are at level 3 and so on. The height or depth of tree is defined to the maximum level of any node in the tree.

2b:T2219,

Graphs

A graph in data structures G consists of two things:

  1. A set v of elements called nodes (or points or vertices)
  2. A set E of edges such that each edge e in E is identified with a unique (unordered) pair [u,v] of nodes in v, denoted by e=[u,v]sometimes we indicate the parts of a parts of a graph by writing G=(v,E).

Examples:

83   G=(V,E)                                                       G=(V,E) V={1, 2, 3, 4}                                    V={1, 2, 3, 4, 5} E={(1,2);(2,3);(2,4);(3,4);(1,3)}       E={(1,2) (1,3) (3,2) (3,5) (3,4) (4,2) (5, 4)} Suppose e=[u,v] then the nodes u and v are called the end points of e ,and u and v are said to be adjacent nodes or neighbors. An edge with an orientation is a directed edge while an edge with no orientation is an undirected edge. The undirected edges (i,j) and (j,i) are the same; the directed edge(i,j) is different from the directed edge(j,i). If all the edges in a graph are undirected, then the graph is undirected graph. The graphs of figure(a) and are undirected graphs. If all the edges are directed , then the graph is directed graph. The graph of figure(b) is a directed graph. Often an undirected graph is a simply called a graph and a directed graph is called a digraph.   In some applications of graphs and graphs we shall assign a weight or cost to each edge, when weights have been assigned to edges we use the terms weighted graph and weighted digraph. To refer to the resulting data object the term network refers to a weighted graph or digraph. Example: 84  

 

Representation of graphs and  Digraphs in data structures

The most frequently used representation schemes for graphs and digraphs are adjacently based adjacency matrices and linked adjacency list.    

  1. Adjacency Matrix:

The adjacency matrix of an n-vertex graph G=(V,E) is an nXn matrix A, each element of A is either zero or one .We shall assume that V={1, 2, 3, . . . . . n}.If G is a graph, then the elements of A are defined as follows.   85  

  1. Linked –adjacency list:

In the case of linked adjacency lists, let G be a graph with m nodes.  The array representation of G in memory i.e., the representation of G by its adjacency matrix A has a number of major drawbacks. Consider the graph G in figure (a).The table shows each node in G followed by its adjacency list, which it  its list of adjacent nodes also called its successors or neighbours.Figure represents a schematic diagram of linked representation of G in memory specifically, the linked representation will contain two lists (or files), a node list NODE and edge list EDGE.     86  

Traversing a Graph:

Many graph algorithms require one of systematically examine the nodes and edges of graph G. There are two standard ways that this is done one way is called a breadth first search and the other is called a depth- first search. The breadth – first search will use a queue as an auxiliary structure to hold nodes for future processing and analogously .The depth –first search will use a stack.

  1. Breadth –first traversal : [B F S]

A data structure queue is used to place all waiting nodes. This queue is also convenient to keep the track of nodes that are already.  

Algorithm:

  1. All nodes are initialized as ready states and initialise queue to empty.
  2. Begin with any node, which is in ready state and put into queue. Mark the status of that node to waiting
  3. While queue is not empty do begin.
  4. Delete the first node k from queue and process it mark the status of that node.
  5. Add all the adjacent nodes of k which are in ready state to the rear side of the queue and mark the status of these nodes to waiting.
  6. If this graph still contains nodes which are in ready which are in ready state then go to step(2)
  7.  

 

Dept-First search (DFS):

In the depth –first search traversal, we back track on a path once it reached the end of the path. We consider the data structure stack instead of a queue as in breadth first search.

Algorithm:

  1. All nodes are initialized to ready state and initialize stack to empty.
  2. Begin with any node which is in ready state and path into stack mark the status of that node to waiting.
  3. While stack in not empty do begin.
  4. Pop to node of stack and process it mark the status of that node to be visited.
  1. Push at the adjacent nodes of k which are in ready state into stack and mark the stack of those nodes to waiting.
  2. If the graph still contains nodes which are in ready state then go to step(2).
  3.  

 

Example for BFS:

88

Adjacency nodes lists:

1 1,2,4
2 0,4
3 0,4,5,9,10
   
4 0,1,2
5 2,6,7,8
6 5
7 5,8
8 5,7
9 2,11
10 2,11
11 9,10

   

 After Traversing the BFS graph:

89  

Example for DFS:

  89

0 1,2,4
1 0,4
2 0,4,5,9,10
4 0,1,2
5 2,6,7,8
6 5
7 5,8
8 5,7
9 2,11
10 2,11

 

After traversing the DFS:

  89    

2c:T5ed6,

To design JSF application we have to use the following elements User interface[View] Web.xml file[Deployment Descriptor] Faces servlet Managed Bean[model1] Facesconfig.xml[Faces configuration file]   Screenshot_7   Loginfrom.jsp <%@taglib usre= “http://Java.sun.com/JSF/Core” prefix=”f”%core tag library <%@taglib usre= “http://Java.sun.com/JSF/ http”prefix=”h”%> <f:view id=”loginview”> <html> <body> <h:form> <h:panel Grid columns=”2”> <h:output text value=”user name”/> <h: input text id=”u name” value =”#. property name u name log cal name”/> <h:output text value=”password”/> <h: input secrete id=”upwd” value=#{log in bean. upwd}”/> <h: command button value=”Log in” action=”#{log in bean, check log in}”/> </h:panel Grid> </h:from> </body > </html> </fi view>   1 - When we click on a button in JSF enabled web page, automatically, action event will be raised, to handle this action event, event handler will, send a request to server 2 - Server will take the request and identify the target resource through web.xml file, in JSF for every request the target resource is faces servlet. 3 - From url pattern (dss) it indicate faces servlet 4 - After getting faces servlet is the target resource through web.xml file, container will  execute faces servlet provided service oriented methods. 5 - upon receiving request from client, faces servlet has to identify the name and location of managed bean component in order to instantiate, for this, faces servlet will go to bases- config.xml file. 6 - After getting the respective managed bean component name and location faces servlet will identify it and it will perform managed bean loading, instantiation and data population[getting request parameter values from request object and storing in managed] 7 - After managed bean instantiation, faces servlet will identify business method from action event and faces servlet will execute that business method 8 - By executing B.method in managed bean, faces servlet is able to get the status value in the form at a strong 9 - Faces servlet has to forward request to a particular JSP page after performing an action in managed bean to identify the target JSP page to forward request, faces servlet will go to faces config.xml file 10 - After getting the target JSP page url from faces config .xml file, faces servlet forward request to target JSP page 11 -After executing the target JSP page, container will dispatch the generated dynamic response to client.   User Interface * The main purpose of user interface in web application is, To improve look and feel the web application To set data from user in order to execute web applications To perform data validations with java script functions To specify different types of requests like GET, POST, Head,…. In general web applications, we will use the technologies, like html, JSP, velocity, free market to prepare user inter face. In case of JSF based web applications, it is not suggestible to use html, tags directly, always it is suggestible to use JSF provided tag library JSF has provided the complete tag library implementation in the form of a jar file i.e-“JSF-api.jar”. If we want to use JSP provided tag library in web application then we have to keep JSF-api. Jar file in web app n lib folder If we want to use JSF tags in JSP tags in JSP page than we have use the following tag lib directives %@taglib =”http://Java.sun.com/JSP/html”prefix=”h”%   Loginform.JSP %@TAGLIB url=”http://java.sun.com/jst/core”prefix=”f”% /html ”prefix=”h”%> <f:view> <html> <body> <h:form> <h:panel Grid column=”2”> <h:out put test value=”username”/> <h:in put text id=”u name” value=”#{login bean u name}”/> <h:out put test value=”password”/> <h:in put secrete id=”u pwd” value=”#{login bean, login }”/> <h:panel Grid>   <f:view>2 it will represent a JSF view <h:panel grid> 2it will represent a grid layout to arrange all the JSF Components. <h: form> 2It is same html<form> tag to represent an unit of GUI Components <h:outputtext>2it will represent a label specified along with ”value” attribute. <h: input text> 2it will represent a text field, where “id” attribute will take component identify to manage components states in component tree where ”value” attribute. Will take an expression to represent a particular property in the respective managed bean  to store the value <h:input secrete>2 It will represent a password field to enter secrete data like passwords, in number where id attribute will take compo not identify to represent a particular property declare d in the respective managed bean in order to store its value, <h:command buttons> 2 it will represent a button to rise action event. Where ”value” attribute will take button label. Where ”action” attribute will represent action event and it able to specify the respective b method at managed bean in order to execute upon button click. 2Request url:- http://local host:-/app1/log in form   Web xml  <web-app> <servlet> < servlet  name faces servile</servlet name> < servlet .class>javax.faces. web app. Faces servlet</servlet class> <load-on-startup>1</load-on-start up> </servlet> <servlet-mapping> <servlet-name>faces servlet </servle -name> </servle -mapping> </web-app>   Deployment Description Deployment description is web.xml file, it will provide meta data or description about our web application required by the container in order to identify and execute server side resources In general, in web application web.xml file can be used to provide the following configuration details Welcome files configuration Display name configuration Context parameter configuration Servlet configuration Filters configuration Listeners configuration Load on startup configuration Session timeout configuration Initialization parameters configuration Error pages configuration Tag library configuration Security configuration   In JSF based web application , web.xml file has to include faces servlet configuration. 2Faces servlet is JSF Provided serviette, it is acting as controller in JSF based web application, to activate this controller we must request faces servlet cfg in web.xml file   Example <Web app> <servlet> < servlet -name>faces servlet<1servket bane> < servlet -class>Javax. faces .web app .faces servlet </servlet-class> <load- on-startup>1</load-on-startup> </servlet > </servlet-mapping > </servlet-name >faces servlet</ servlet-name> <url-pattern>*.dss</url-pattern> <\servlet-mapping> <\web-app> In the above faces servlet configuration, the main requirement of<load-on-startup>configuration is to perform faces servlet loading, instantiation and initialization at the time of servers startup As part of faces servlet initialization, the complete JSF Configurations will be loaded, with this, JSF F/W Will ready at the time of server start up. In general, in web.xml file, we are able to define url patterns fore the servlet in the following 3 approaches

Exact match method[/pattern-name]

Directory match method[/prefix-name/*]

Extension match method[*.extension]

For the faces servlet configuration, we are able to define and pattern either by using director match method or by using extension match method *Possible url patterns fore faces servlet are /faces/*,*,JSF,*Faces,*, only- ext[user defied]   Screenshot_9   Faces servlet In general in MVC based web appl? The mole of the controller is Pick of the request from client Identify model component Perform model component loading instantiation data population Access application logic Identify target view page Forward request to target view page JSF is MVC based web application f/w, it has provided javax.feices webapp faces serve let as. Controller JSF frame work has provided faces servlet as an implementation class to javax. Servlet. Servlet inter face In JSF, FACE SERVLET has provided the implementation for the following methods from servlet interface public void init (servlet config config)throws servlet exception public void service(servlet request , servlet response ) throws servlet exception, ID exception public servlet config get servlet config get() public String Get Servlet Into() public void destroy()   When we start the server the main job of the container is to recognize each and every web application and it will prepare a separate servlet context object for each and every web app. While recognizing web app container will identify web.xml file then container perform web.xml file loading. Parsing and reading the content. If any application level data is identified then container will sore that data in servlet context objects while reading web.xml file content, it container identify “load on startup” configuration under any servlet then containers will perform that servlet loading instantiation and initialization at the time at servlet start up only In JSF based web application, containers will identify startup configuration under faces servlet configuration with this will search for javax faces web app. Faces servlet class file under classes folder if it is not available then container will search for it  all this jar files provided in “lib” folder In the above context container will identify faces servlet under JSF- ape.jar file then container perform face servlet loading instantiation and initialization at the time of server stat up In faces servlet initialization faces servlet will recognize faces config xml file under WEB-INF folder then faces servlet will perform faces – config .xml file loading parsing After faces- config.xml file parsing .faces servlet will prepare “lifecycle” object After the server startup we have to access a page at client browser, we have to provide data in respective fields and we have to submit request from client browser. To server or any hyperlink or by selecting check boxes or radio buttons. Etc When request is submitted to server container will identify the requested resource is faces servlet through web.xml file and container will execute service method of faces servlet When container bypass request to faces servlet, faces servlet will remark a separate object with the present request called as “faces context” object to store the data which is associated with current request. After preparing ”faces context” object container will invoke life cycle object where lifecycle object will process the request by following ”JSF Request processing lifecycle”

Restore view

Apply request values

Process validates

Update model

Invoke application

Render response

  Restore view This phase will check whether the current request is fore any resource or action. If the current request is for any resource then faces servlet will identify the requested resource and by pass the flow of execution directly or render response phase If the present request is for any particular action then faces servlet will perform the following actions Faces servlet will check any ”component free” is existed the present request or not, if any component free is existed then faces servlet will retrieve it It  no component tree is existed w.r.to the present request then Faces servlet has to create new component tree. While preparing component tree Faces servlet will perform the following action Faces servlet will create a root node for <f:view> tag in component tree and child nodes for each and every JSF component Which are available in the respective page Faces servlet will store view id value in “UIVIEW ROOT” Object which is compiling along with request. Faces servlet will store all the  incoming ”locate” provided by client browser in “UIVIEW ROOT” node. if any Validator are configured for UI Components in page then faces servlet will register all the Validator to the components in component tree. If any converters are configured for UI Component in page then faces servlet will register all the converters to the components in component tree. It any listeners are configured fore UI Components in page then faces servlet will register all the listeners to component in component tree. Faces servlet will identify respective model component or Bean component w.r.to the present request through Faces- config.xml file and perform bean loading and instantiation at the time of bean instantiation default values or any initial values will be stored in bean properties these initial values will be set to the respective components in component tree. After preparing component tree, Faces servlet will store other component tree in faces context object and Http Session Object   Apply Request values In this phase faces servlet will take request parameter values from request object and it will set request parameter values to the corresponding components in component tree To set request parameter values to component tree the following method from UI view root:- Public void process Decode()   Process Validator In this phase, faces servlet will perform the following actions: Faces servlet will search fore registered Validator at each and every component in component tree If any Validator is identified at component then faces servlet will execute all the Validator It any validation error messages are available then it will add validation error messages to “Faces context” object. faces servlet will search for the registered convectors at each and every component in component tree It any convertor is identified then faces servlet will execute that convertors If any conversion errors are identified then faces servlet will check any error message is available in faces context object, It any error message is identified then faces servlet will bypass request to “Render Response” phase directly It no error message is identified in faces context object then faces servlet will bypass request to the next phase id “update model” To perform process Validator phase, faces servlet will execute the following method from UI view root class Public void process Validator()   Update model In apply request values phase, all the request parameter values we were set to the components which are available in component tree In this process Validator phase, we have checked weather the data is valid or not After the data validations and conversions the data which is available in component tree is true data, which we have to use in application logic. To use this data in application logic, first we have to set this data to the properties of model component Update model phase will set trustable data from component tree to the model properties. To perform this phase, faces servlet will execute the following method. Public void process updates()   Invoke Application In this phase, faces servlet will perform the following actions. a) Faces servlet will get the registered method name from the components like button, hyperlink, check box, radio button,…from component tree. b) Faces servlet will execute the respective method in the respective managed bean component. c) If no return value is identified from managed bean component method then faces servlet will bypass request to “Render Response” phase to maintain the same page at client browser. d) It any return value is identified from the respective managed Bean component method then faces servlet will identify the target view page from faces – config. Xml file and by pass request to “Render Response” phase to generate response To perform this phase, faces servlet will execute the following method Public void process application()   Render Response phase  In this phase, Faces servlet will convert the respective component tree into the equivalent html or xml or wml and etc formations in order to send response to client browser in html or xml or WML,…formats It the request is coming from “Restore View” phase then render response phase will send the requested resource as response to client. If the request is coming from “Process Validator” phase then render response phase will get all the validation and conversion error messages from “Faces context” Object and send the same page as response to client by embedding error messages. It the request is coming from invoke application phase then render response phase will send the result page as response to client. To perform this phase, faces servlet will execute   Model Component In MVC based web applications, the main purpose at model component is, To manage application B. logic To manage users from data in order to perform data validations and conversions, To manage users from data in order to perform the database operations like insert, update, retrieve,…. To transferee the data from controller layer to view later. In JSF web applications, Managed bean component is acting as model To prepare managed bean component in JSF based web applications, we have to use the following guide lines In JSF, Managed bean component should be a POJO class, it should not be extended or implemented from any predefined library. In JSF based applications, Managed bean class must be public, non abstract and no final All the properties in managed bean class must match the properties name which we defined along with UI Components in user forms We must provide set..()methods and getter..() methods for each and every bean property We have to declare business methods which are registered with the GUI Components like buttons, hyperlinks,… If we want to provide any construction in managed Bean class then that construct fore must be “Public” and “O-argument”. Define application logic by declaring business methods   Example Public class Login bean { Private string u name; Private string u pwd; Public void set u name(string u name) { This. U name = u name; } Public void set upwd(String upwd) { This. Upwd= upwd; } Public string get u name() { Return u name; } Public string get u pwd() { Return u pwd; } Public string log in() { --- logx--- Return “Success”; } }   Faces configuration File The main purpose of  faces configuration file is to provide the following con fig  details request red by faces servlet. Bean component configuration Navigation Rules Validators Convertors Listeners Local configuration. The default name and location of faces configuration file is “Faces config.xml” file under WEB.INF folder In JSF based web application, it is possible to change the name and location of faces configuration file but we have to configure that name and location under web. In the form of a context parameter Here context parameter name is fixed is Javax. faces. CONFIG –FILE <Web - app> <Context. parm> <Param.name>Javax. faces. CONFIG.FILE</paran-bane> <Param. Value>/WEB- INF/classes /my config.xml <Context param ---- <\web.app> In basic JSF application, we need only bean configuration and navigation configurations in faces configuration file 2faces-config> ----- <managed- bean> <managed- bean-name> bean logical name</managed-bean- name> <managed- bean-class> bean fully qualified name  </managed-bean- class > <managed- bean-score>session/application </managed-bean- scope > </managed-bean > <navigation mull> <from-view-id>/form page</from-view-id> <navigation – case> <from- out come> return value from bean method</from – out come> <to- view- id>/ to page </to-view. id> <\navigation-case> --- <\navigation-mule> --- </faces-config>   Faces- config.xml ------------------------ <faces-config> <managed-bean> <managed-bean-name>log in bean</managed-bean-name> <managed-bean-class>com. dss. Log in bean</managed-bean- class > <managed-bean-scope>session</managed-bean- scope > <managed-bean> <Navigation. mule> <from-view-id>/login from.jsp</ from-view-id > <Navigation-case> <from-outcome>success</ from- outcome > <to-view-id>/success.jsp</ to-view-id > </navigation-case> <navigation-case> <from-outcome>failure</ from- outcome > <to-view-id>/failure.jsp</ to-view-id > </navigation-case> </navigation-mule> </faces- config>

2d:T1e41,

What is JSF (JavaServer Faces)?

It is a server side segment based UI structure. It is used to create web applications. It gives a very much characterized programming model and comprises of rich API and applications. The latest version JSF 2 uses Facelets as its default templating system.

How does execution phase work in JSF (JavaServer Faces) lifecyle?

In execute phase, when first request is made, application view is built or restored. For other subsequent requests other actions are performed like request parameter values are applied, conversions and validations are performed for component values, managed beans are updated with component values and application logic is invoked.

What is Render Kit in JSF?

Segment classes for the most part exchange the undertaking of producing yield to the renderer. All JSF parts tail it. Render pack is an arrangement of related renderers. javax.faces.render.RenderKit is the class which speaks to the render pack. The default render pack contains renderers for html however it’s up to you to make it for other markup dialects. Render unit can execute a skin (a look and feel). Render unit can focus on a particular gadget like telephone, PC or markup dialect like HTML, WML, SVG. This is extraordinary compared to other advantage of JSF in light of the fact that JSF doesn't utmost to any gadget or markup.

How to make custom tag in JSF?

JSF custom label illustration:

JSF gives the office to make custom tag to render a pre-characterized content. A JSF custom label utilizes "ui:composition" to embed content into the page.

Steps to create the JSF custom tag:

1. In the first place make a predefined content in a XHTML page with ui:compisition tag.

2. Announces and characterize the custom label subtle elements in a label library descriptor.

3. Enlist the label library descriptor in the web.xml document.

What are different JSF validator tags?

JSF validator tags:

JSF provides inbuilt validators to validate the UI component data. JSF validators can validates length, type, format etc.

For using JSF validator tags we have to use the following namespaces of URI in html node.

<html xmlns="http://www.w3.org/1999/xhtml" xmlns:f="http://java.sun.com/jsf/core"

What is supporting bean?

JSF backing bean is an overseen bean which contains a few or all estimations of a web frame. It is ordinarily for business rationale.

What is JavaServer Faces validation model? 

A mechanism for validating the data a user inputs to a JavaServer Faces UI component.

What is JavaServer Faces navigation model?

A mechanism for defining the sequence in which pages in a JavaServer Faces application are displayed.

What is JavaServer Faces conversion model? 

A mechanism for converting between string-based markup generated by JavaServer Faces UI components and server-side Java objects.

What are contrasts amongst swaggers and JSF?

In a nutshell, Faces has the following advantages over Struts:

Disposed of the requirement for a Form Bean

Disposed of the requirement for a DTO Class

Permits the utilization of the same POJO on all Tiers as a result of the Backing Bean

What regular JSF application comprises of?

A regular JSF application comprises of the accompanying parts:

-JavaBeans segments for overseeing application state and conduct.

-Occasion driven improvement (through audience members as in customary GUI advancement).

-Pages that speak to MVC-style sees; pages reference see roots by means of the JSF part tree.

What if no navigation rule matches a given action?

If no navigation rule matches a given action, then the current page is redisplayed.

Explain life-cycle Phases of JSF?

Restore View : A request comes through the FacesServlet controller. The controller examines the request and extracts the view ID, which is determined by the name of the JSP page.

Apply request values: The purpose of the apply request values phase is for each component to retrieve its current state. The components must first be retrieved or created from the FacesContext object, followed by their values.

Process validations: In this phase, each component will have its values validated against the application's validation rules.

Update model values: In this phase JSF updates the actual values of the server-side model ,by updating the properties of your backing beans.

Invoke application: In this phase the JSF controller invokes the application to handle Form submissions.

Render response: In this phase JSF displays the view with all of its components in their current state.

2e:T59fe,

Java Virtual Machine Introduction

The Java Virtual Machine is the cornerstone of the Java platform. It is the component of the technology responsible for its hardware- and operating system-independence, the small size of its compiled code, and its ability to protect users from malicious programs.

The Java Virtual Machine is an abstract computing machine. Like a real computing machine, it has an instruction set and manipulates various memory areas at run time. It is reasonably common to implement a programming language using a virtual machine; the best-known virtual machine may be the P-Code machine of UCSD Pascal.

What is Java Virtual Machine?

A Java virtual machine (JVM), an implementation of the Java Virtual Machine Specification, interprets compiled Java binary code (called bytecode) for a computer's processor (or "hardware platform") so that it can perform a Java program's instructions. Java was designed to allow application programs to be built that could be run on any platform without having to be rewritten or recompiled by the programmer for each separate platform. A Java virtual machine makes this possible because it is aware of the specific instruction lengths and other particularities of the platform.

What do you mean by bytecode in Java?

Programming code that, once compiled, is run through a virtual machine instead of the computer processor. Bytecode is the compiled format for Java programs. Once a Java program has been converted to bytecode, it can be transferred across a network and executed by Java Virtual Machine (JVM).

Is JVM is platform independent?

The JVM is not written in Java and hence cannot be platform independent. The JVM must be platform dependent to allow your Java to run on the specific platform. A JVM for Windows will translate your Java into different system calls than a JVM for OS X.

What is Oracle and Java?

Java is a set of computer software and specifications developed by Sun Microsystems, later acquired by Oracle Corporation, that provides a system for developing application software and deploying it in a cross-platform computing environment.

What is Java software for?

Java is a programming language that developers use to create applications on your computer. Chances are you've downloaded a program that required the Java runtime, and so you probably have it installed it on your system. Java also has a web plug-in that allows you to run these apps in your browser.
 

The first prototype implementation of the Java Virtual Machine, done at Sun Microsystems, Inc., emulated the Java Virtual Machine instruction set in software hosted by a handheld device that resembled a contemporary Personal Digital Assistant (PDA). Oracle's current implementations emulate the Java Virtual Machine on mobile, desktop and server devices, but the Java Virtual Machine does not assume any particular implementation technology, host hardware, or host operating system. It is not inherently interpreted, but can just as well be implemented by compiling its instruction set to that of a silicon CPU. It may also be implemented in microcode or directly in silicon.

The Java Virtual Machine knows nothing of the Java programming language, only of a particular binary format, the class file format. A class file contains Java Virtual Machine instructions (or bytecodes) and a symbol table, as well as other ancillary information.

For the sake of security, the Java Virtual Machine imposes strong syntactic and structural constraints on the code in a class file. However, any language with functionality that can be expressed in terms of a valid class file can be hosted by the Java Virtual Machine. Attracted by a generally available, machine-independent platform, implementors of other languages can turn to the Java Virtual Machine as a delivery vehicle for their languages.

Architecture of Java Virtual Machine

The JVM specification defines the subsystems and their external behavior. The JVM has the following major subsystems:

Class Loader. Responsible for reading Java source code and loading classes into the data areas.

Execution Engine. Responsible for executing instructions from the data areas.The data areas occupy memory that is allocated by the JVM from the underlying OS.

Screenshot_25

Class Loader

The JVM uses different class loaders organized into the following hierarchy:
  • The bootstrap class loader is the parent for other class loaders. It loads the core Java libraries and is the only one written in native code.
  • The extension class loader is a child of the bootstrap class loader. It loads the extension libraries.
  • The system class loader is a child of the extension class loader. It loads the application class files that are found in the classpath.
  • A user-defined class loader is a child of the system class loader or another user-defined class loader.
When a class loader receives a request to load a class, it checks the cache to see if the class has already been loaded, then delegates the request to the parent. If the parent fails to load the class, then the child attempts to load the class itself. A child class loader can check the cache of the parent class loader, but the parent cannot see classes loaded by the child. The design is such because a child class loader should not be allowed to load classes that are already loaded by its parent.

Execution Engine

The execution engine executes commands from the bytecode loaded into the data areas one by one. To make the bytecode commands readable to the machine, the execution engine uses two methods.
  • Interpretation. The execution engine changes each command to machine language as it is encountered.
  • Just-in-time (JIT) compilation. If a method is used frequently, the execution engine compiles it to native code and stores it in the cache. After that, all commands associated with this method are executed directly without interpretation.
Although JIT compilation takes more time than interpretation, it is done only once for a method that might get called thousands of times. Running such method as native code saves a lot of execution time compared to interpreting each command one by one every time it is encountered. JIT compilation is not a requirement of the JVM specification, and it is not the only technique that is used to improve JVM performance. The specification defines only which bytecode commands relate to which native code; it is up to the implementation to define how the execution engine actually performs this conversion.

Memory Model

The Java memory model is built on the concept of automatic memory management. When an object is no longer referenced by an application, a garbage collector discards it and this frees up memory. This is different from many other programming languages, where you have to manually unload the object from memory. The JVM allocates memory from the underlying OS and separates it into the following areas.
  • Heap Space. This is a shared memory area used to hold the objects that a garbage collector scans.
  • Method Area. This area was previously known as the permanent generationwhere loaded classes were stored. It has recently been removed from the JVM, and classes are now loaded as metadata to native memory of the underlying OS.
  • Native Area. This area holds references and variables of primitive types.
Breaking the heap up into generations ensures efficient memory management because the garbage collector does not need to scan the whole heap. Most objects live for a very short time, and those that survive longer will likely not need to be discarded at all until the application terminates. When a Java application creates an object, it is stored in the eden pool of the heap. Once it is full, a minor garbage collection is triggered at the eden pool. First, the garbage collector marks dead objects (those that are not referenced by the application any more) and increments the age of live objects (the age is represented by the number of garbage collections that the object has survived). Then the garbage collector discards dead objects and moves live objects to the survivor pool, leaving the eden pool clear. When a surviving object reaches a certain age, it is moved to the old generation of the heap: the tenured pool. Eventually, the tenured pool fills up and a major garbage collection is triggered to clean it up. When a garbage collection is performed, all application threads are stopped, causing a pause. Minor garbage collections are frequent, but are optimized to quickly remove dead objects, which are the major part of the young generation. Major garbage collections are much slower because they involve mostly live objects. There are different kinds of garbage collectors, some may be faster in certain situations when performing a major garbage collection. The heap size is dynamic. Memory is allocated to the heap only if it is required. When the heap fills up, the JVM reallocates more memory, until the maximum is reached. Memory reallocation also causes the application to stop briefly.

Threads

The JVM runs in a single process, but it can execute several threads concurrently, each one running its own method. This is an essential part of Java. An application such as an instant messenger client, runs at least two threads; one that waits for user input and one that checks the server for incoming messages. Another example is a server application that executes requests in different threads: sometimes each request can involve several threads running concurrently. All threads share the memory and other resources available to the JVM process. Each JVM process starts a main thread at the entry point (the main() method). Other threads are started from it and present an independent path of execution. Threads can run in parallel on separate processors, or they can share one processor. The thread scheduler controls how threads take turns executing on a single processor.

Performance Optimization

The performance of the JVM depends on how well it is configured to match the functionality of the application. Although memory is automatically managed using garbage collection and memory reallocation processes, you have control over their frequency. In general, the more memory you have available for your application, the less memory management processes are required, which pause your application. If garbage collections are occurring more frequently than you would want, you can start the JVM with more maximum heap size. The longer it takes for a generation of the heap to fill up, the fewer garbage collections occur. To configure the maximum heap size, use the -Xmx option when you start the JVM. By default, the maximum heap size is set to either 1/4th of the physical memory available to the OS, or to 1 GB (whichever is the smallest). If the problem is with memory reallocation, you can set the initial heap size to be the same as the maximum. This means that the JVM will never need to allocate more memory to the heap. However, you will also lose the adaptive memory optimization gained from dynamic heap sizing. The heap will be of fixed size from the moment you start your application. To configure the initial heap size, use the -Xms option when you start the JVM. By default, the initial heap size is set to either 1/64th of the physical memory available to the OS, or to some reasonable minimum that is different for different platforms (whichever is the largest). If you know which garbage collections (minor or major) are causing performance degradation, you can set the ratio between the young and old generations without changing the overall heap size. For applications that create a lot of short-lived objects, increase the size of the young generation (this will leave less memory for the old generation). For applications that operate with a lot of longer surviving objects, increase the size of the old generation (by setting less memory for the young generation). The following ways can be used to control the sizes of the young and old generations.
  • Specify the ratio between the young and old generation using the -XX:NewRatio option when you start the JVM. For example, to make the old generation five times larger than the young generation, specify -XX:NewRatio=5. By default, the ratio is set to 2 (the old generation occupies ⅔ of the heap, and the young generation occupies ⅓).
  • Specify the initial and maximum size of the young generation using the -Xmn option when you start the JVM. The old generation size will be set to whatever memory remains on the heap.
  • Specify the initial and maximum size of the young generation separately, using the -XX:NewSize and -XX:MaxNewSize options when you start the JVM. The old generation size will be set to whatever memory remains on the heap.
Most applications (especially servers) require concurrent execution, handling a number of tasks. Some of these tasks are more important at a given moment, while others are background tasks that can be executed whenever the CPU is not busy doing anything else. Tasks are executed in different threads. For example, a server may have a low-priority thread that calculates statistics based on some data and starts a higher-priority thread to handle incoming data, and another higher-priority thread to serve a request for some of the data that was calculated. There can be many sources of data, and many clients requesting data from the server. Each request will briefly stop the execution of the background calculation thread to serve the request. So you have to monitor the number of threads that are running and make sure there is enough CPU time for the thread that is making the necessary calculations. Each thread has a stack that holds the method calls, return addresses, and so on. Some memory is allocated for the stack, and if there are too many threads, this can lead to an OutOfMemory error. Even if you have enough heap memory allocated for objects, your application may be unable to start a new thread. In this case, consider limiting the maximum size of the stack in threads. To configure the thread stack size, use the -Xss option when you start the JVM. By default, the thread stack size is set to 320 KB or 1024 KB, depending on the platform.

Performance Monitoring

Whether you are developing or running a Java application, it is important to monitor the performance of the JVM. Configuring the JVM is not a one-time affair, especially if you are dealing with a server running on Java. You have to constantly check the allocation and usage of both heap and non-heap memory, the number of threads that the application creates, and the number of classes that are loaded into memory. These are the core parameters. Using the Anturis Console, you can set up monitoring of the JVM for any hardware component (such as a computer running a Tomcat web server) in your infrastructure by adding the JVM monitor to the component. The JVM monitor can measure the following metrics.
  • Total memory usage (MB) is the amount of memory that the JVM uses. This metric can affect overall performance of the underlying OS if the JVM consumes all available memory.
  • Heap memory usage (MB) is the amount of memory that the JVM allocates for objects used by the running Java application. Unused objects are regularly removed from the heap by the garbage collector. If this metric grows, it can indicate that your application is not removing references for unused objects, or that you need to configure the garbage collector properly.
  • Non-Heap memory usage (MB) is the amount of memory allocated for the method area and the code cache. The method area is used to store references to loaded classes. If these references are not removed properly, the permanent generation pool can increase every time the application is redeployed, leading to a non-heap memory leak. It can also indicate a thread-creation leak.
  • Total pool memory usage (MB) is all the memory used by the various memory pools allocated by the JVM (that is, the total memory without the code cache area). This can give you an idea of how much memory your application consumes without the JVM overhead.
  • Threads (threads) is the number of active threads in the JVM. For example, each request to a Tomcat server is processed in a separate thread, so this metric can give you an idea of the number of requests that are currently being served, and whether it affects the background tasks that are running in threads set to a lower priority.
  • Classes (classes) is the number of loaded classes. If your application dynamically creates a lot of classes, this can be a source of a severe memory leak.

JamVM

JamVM is an open-source Java Virtual Machine that aims to support the latest version of the JVM specification, while at the same time being compact and easy to understand. JamVM must be used in conjunction with a Java class-library to make a full Java Runtime Environment. Compatible class-libraries are GNU Classpath or the class-library from OpenJDK.

Java Virtual Machine Features

For those interested in the design of virtual machines, JamVM includes a number of optimisations to improve speed and reduce foot-print. A list, in no particular order, is given below.
  • Execution engine supports many levels of optimisation from basic switched interpreter to inline-threaded interpreter with stack-caching (equivalent performance to a simple JIT).
  • Uses native threading (posix threads). Full thread implementation including Thread.interrupt()
  • Object references are direct pointers (i.e. no handles)
  • Supports class loaders
  • Efficient thin locks for fast locking in uncontended cases (the majority of locking) without using spin-locking
  • Two word object header to minimise heap overhead (lock word and class pointer)
  • Stop-the-world garbage collector, with separate mark/sweep and mark/compact phases to minimise heap fragmentation
  • Thread suspension uses signals to reduce suspend latency and improve performance (no suspension checks during normal execution)
  • Full object finalisation support within the garbage collector (with finaliser thread)
  • Full support for Soft/Weak/Phantom References (with Reference Handler thread)
  • Full support for class and class-loader garbage-collection and unloading (including associated shared libraries)
  • Garbage collector can run synchronously or asynchronously within its own thread
  • String constants within class files are stored in hash table to minimise class data overhead (string constants shared between all classes)
  • Supports JNI and dynamic loading for use with standard libraries
  • Uses its own lightweight native interface for internal native methods without overhead of JNI
  • VM support for invokedynamic (JSR 292)
  • VM support for type annotations (JSR 308)
  • VM support for lambda expressions (JSR 335)
  • VM support for method parameter reflection
  • JamVM is written in C, with a small amount of platform dependent assembler, and is easily portable to other architectures.
For detail info on Java click on
Java Tutorials
2f:T2758,

What is an Interface in Java?

An interface in the Java programming language is an abstract type that is used to specify a behavior that classes must implement. ... Interfaces cannot be instantiated, but rather are implemented. A class that implements an interface must implement all of the methods described in the interface, or be an abstract class. For example, we might have defined the following interface for classes that have a position.

public interface Locatable {
     public double getX();
     public double getY();
 }

With the interface defined, we will now need classes that claim to implement the interface. For this, we need to say so up front using an implements clause.

public class Ball implements Locatable { //...
 public class Paddle extends Block implements Locatable { //...

Any class that has such an implements clause has to define all of the methods defined in the interface. Otherwise, there's a compiler error. Thus, both Ball and Paddle must have getX and getY methods; since the interface says these methods take no parameters and return a double, they need to be defined this way in Ball and Paddle too. What makes interfaces useful is that they are types, too. The following would be completely legitimate.

Locatable loc = new Ball();
 System.out.println(loc.getX() + ", " + loc.getY());
 loc = new Paddle();
 System.out.println(loc.getX() + ", " + loc.getY());

You cannot create an instance of an interface: new Locatable() would be illegal. In some sense, with interfaces a class have two superclasses. Only one of these can be a true Java class, but the type conversion behavior makes it feel as if both the actual parent class and the implemented interface are superclasses.

Rules of Using Interface

 

What is JNI?

 

In computing, the Java Native Interface (JNI) is a programming framework that enables Java code running in a Java Virtual Machine (JVM) to call and be called by native applications (programs specific to a hardware and operating system platform) and libraries written in other languages such as C, C++ and assembly.

What is a computer interface?

In computing, an interface is a shared boundary across which two separate components of a computer system exchange information. The exchange can be between software, computer hardware, peripheral devices, humans and combinations of these.

What is a software interface?

user interface - the keyboard, mouse, menus of a computer system. The user interface allows the user to communicate with the operating system. Also see GUI. software interface - the languages and codes that the applications use to communicate with each other and with the hardware.

What is the meaning of native code in Java?

Native code is computer programming (code) that is compiled to run with a particular processor (such as an Intel x86-class processor) and its set of instructions. If the same program is run on a computer with a different processor, software can be provided so that the computer emulates the original processor.

Interface implementation

To declare a class that implements an interface, you include an implements clause in the class declaration. Your class can implement more than one interface, so the implements keyword is followed by a comma-separated list of the interfaces implemented by the class. By convention, the implements clause follows the extends clause, if there is one.

Example of Interface implementation

interface Moveable 
{
 int AVG-SPEED = 40;
 void move();
}

class Vehicle implements Moveable 
{
 public void move()
 {
  System .out. print in ("Average speed is"+AVG-SPEED");
 }
 public static void main (String[] arg)
 {
  Vehicle vc = new Vehicle();
  vc.move();
 }
}

Difference between an interface and an abstract class?

Abstract class

Interface
Abstract class is a class which contain one or more abstract methods, which has to be implemented by its sub classes. Interface is a Java Object containing method declaration but no implementation. The classes which implement the Interfaces must provide the method definition for all the methods.
Abstract class is a Class prefix with an abstract keyword followed by Class definition. Interface is a pure abstract class which starts with interface keyword.
Abstract class can also contain concrete methods. Whereas, Interface contains all abstract methods and final variable declarations.
Abstract classes are useful in a situation that Some general methods should be implemented and specialization behavior should be implemented by child classes. Interfaces are useful in a situation that all properties should be implemented.
Abstract class does not support multiple inheritance Interface support multiple inheritance
Only complete Member of abstract class can be static Member of interface cannot be static

For Indepth understanding of Java Click on

Java Virtual Machines

30:T3201,

What is Exception Handling in java?

The exception is an error event that can happen during the execution of a program and disrupts its normal flow. Java provides a robust and object-oriented way to handle exception scenarios, known as Java Exception Handling.

Java is an object-oriented programming language, whenever an error occurs while executing a statement, creates an exception object and then the normal flow of the program halts and JRE tries to find someone that can handle the raised exception. The exception object contains a lot of debugging information such as method hierarchy, line number where the exception occurred, type of exception etc. When the exception occurs in a method, the process of creating the exception object and handing it over to the runtime environment is called “throwing the exception”.

Table of Contents

What is an error in Java?

An Error is a subclass of Throwable that indicates serious problems that a reasonable application should not try to catch. Most such errors are abnormal conditions. The ThreadDeath error, though a "normal" condition, is also a subclass of Error because most applications should not try to catch it.

What is exception hierarchy in Java?

Exception Hierarchy: All exception classes are subtypes of the java.lang.Exception class. The exception class is a subclass of the Throwable class. Other than the exception class there is another subclass called Error which is derived from the Throwable class.

What is the base class for all exceptions?

Firstly, the base class of all things that can be thrown is Throwable (not Exception ). Under Throwable are two subclasses: Exception and Error. Of these 4 main classes, RuntimeException and Error are unchecked (may be thrown without having to be declared as being thrown).

Why do we use Exception Handling?

Handling the exception is nothing but converting system error-generated messages into user-friendly error messages. Whenever an exception occurs in the java application, JVM will create an object of appropriate exception of subclass and generates a system error message, these system-generated messages are not understandable by the user so need to convert it into a user-friendly error message. You can convert system error messages into user-friendly error messages by using the exception handling feature of java.

For Example: when you divide any number by zero the system generates / by zero so this is not understandable by the user you can convert this message into a user-friendly error message like Don't enter zero for the denominator.

Exception Handling in java

Type of Exception

Checked Exception

The classes that extend Throwable class except RuntimeException and Error are known as checked exceptions e.g.IOException, SQLException etc. Checked exceptions are checked at compile-time.

Unchecked Exception

The classes that extend Runtime Exception are known as unchecked exceptions e.g. Arithmetic Exception, NullPointerException, Array Index Out Of Bounds Exception etc. Unchecked exceptions are not checked at compile-time rather they are checked at runtime.

Java Exception Handling Keywords

There are 5 keywords used in java exception handling.

Syntax for handling the exception

try
{
  // statements cause problems at run time 
}
catch(type of exception-1 object-1)
{
  // statements provide a user-friendly error message 
}
catch(type of exception-2 object-2)
{
  // statements provide a user-friendly error message
}
finally
{
  // statements that will execute compulsory 
}
Example without Exception Handling
class ExceptionDemo 
{
public static void main(String[] args) 
{
int a=10, ans=0;
ans=a/0;
System.out.println("Denominator not be zero");		
}
}

Example of Exception Handling

class ExceptionDemo 
{
public static void main(String[] args) 
{
int a=10, ans=0;
try
{
ans=a/0;
}
catch (Exception e)
{
System.out.println("Denominator not be zero");
}	
}
}

Output:

Denominator not be zero

Java Exception Hierarchy

As stated earlier, when any exception is raised an exception object is getting created. Java Exceptions are hierarchical and inheritance is used to categorize different types of exceptions. Throwable is the parent class of Java Exceptions Hierarchy and it has two child objects – Error and Exception. Exceptions are further divided into checked exceptions and runtime exception.

Exception Handling in java

For indepth understanding of Java Click on:

Java Tutorials
Java virtual Machines
Interface in Java
31:T3985,

Multithreading in java

Multithreading is a Java feature that allows concurrent execution of two or more parts of a program for maximum utilization of CPU. Each part of such program is called a thread. So, threads are light-weight processes within a process.

Example of Multi-thread:

package demotest;
public class GuruMultithread implements Runnable{

    /**
     * @param args
     */
    public static void main(String[] args) {
             Thread guruthread1 = new Thread();
             guruthread1.start();
             Thread guruthread2 = new Thread();
             guruthread2.start();
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub        
    }
}

Life Cycle of a Thread

A thread goes through various stages in its life cycle. For example, a thread is born, started, runs, and then dies. The following diagram shows the complete life cycle of a thread. Multithreading in java

There are various stages in life cycle of thread as shown in above diagram:

Threads can be created by using two mechanisms :

Extending Thread Class in Java Example

One way to create a thread is to create a new class that extends Thread, and then to create an instance of that class. The extending class must override the run() method, which is the entry point for the new thread. It must also call start() to begin execution of the new thread. Screenshot_29

class ExtendingThread extends Thread 
     { 
           String s[]={"Welcome","to","Java","Programming","Language"}; 
           public static void main(String args[]) 
              { 
             ExtendingThread t=new ExtendingThread("Extending Thread Class"); 
              } 
                public ExtendingThread (String n) 
                 { 
                    super(n); 
                    start(); 
                } 
                public void run() 
                  { 
                      String name=getName(); 
                      for(int i=0;i<s.length;i++) 
                          { 
                         try 
                          { 
                            sleep(500); 
                          } 
                            catch(Exception e) 
                               { 
                               } 
                                System.out.println(name+":"+s[i]); 
                          } 
                      } 
      }

Implementing the Runnable Interface

The Clock applet displays the current time and updates its display every second. You can scroll the page and perform other tasks while the clock updates. The reason is that the code that updates the clock's display runs within its own thread. The Clock applet uses a technique different from SimpleThread’s for providing the run method for its thread. Instead of subclassing Thread, Clock implements the Runnable interface and therefore implements the run method defined in it. Clock then creates a thread with itself as the Thread’s target. When created in this way, the Thread gets its run method from its target. The code that accomplishes this is highlighted:

import java.awt.Graphics;
import java.util.*;
import java.text.DateFormat;
import java.applet.Applet;

public class Clock extends Applet implements Runnable {
    private Thread clockThread = null;
    public void start() {
        if (clockThread == null) {
            clockThread = new Thread(this, "Clock");
            clockThread.start();
        }
    }
    public void run() {
        Thread myThread = Thread.currentThread();
        while (clockThread == myThread) {
            repaint();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                //the VM doesn’t want us to sleep anymore,
                //so get back to work
            }
        }
    }
    public void paint(Graphics g) {
        //get the time and convert it to a date
        Calendar cal = Calendar.getInstance();
        Date date = cal.getTime();
        //format it and display it
        DateFormat dateFormatter =
				DateFormat.getTimeInstance();
        g.drawString(dateFormatter.format(date), 5, 10);
    }
    //overrides Applet’s stop method, not Thread’s
    public void stop() {
        clockThread = null;
    }
}

Java Supports Multithreading

Multitasking

Multitasking is a process of executing multiple tasks simultaneously. We use multitasking to utilize the CPU. Multitasking can be achieved by two ways:

Process-based Multitasking (Multiprocessing)

Thread-based Multitasking (Multithreading)

Advantages of Java Multithreading

For indepth understanding of Java click on

Java Tutorials

Java Virtual Machine

Interface in Java

Exception Handling in Java  

32:T2eea,

Polymorphism in Java

Polymorphism is one of the major building blocks of object oriented programming along with inheritance, abstraction and encapsulation. Polymorphism is an Oops concept which advice use of common interface instead of concrete implementation while writing code. When we program for interface our code is capable of handling any new requirement or enhancement arise in near future due to new implementation of our common interface. If we don't use common interface and rely on concrete implementation, we always need to change and duplicate most of our code to support new implementation. Its not only Java but other object oriented language like C++ also supports polymorphism and it comes as fundamental along with other OOPS concepts like Encapsulation , Abstraction and Inheritance. An example of polymorphism is referring the instance of subclass, with reference variable of super-class. e.g.

Object o = new Object(); //o can hold the reference of any subtype
Object o = new String();
Object o = new Integer();

What is meant by run time polymorphism in Java?

Dynamic (run time) polymorphism is the polymorphism existed at run-time. Here, Java compiler does not understand which method is called at compilation time. Only JVM decides which method is called at run-time. Method overloading and method overriding using instance methods are the examples for dynamic polymorphism.

What is meant by compile time polymorphism?

It is also known as Static binding, Early binding and overloading as well. It is also known as Dynamic binding, Late binding and overriding as well. Overloading is compile time polymorphism where more than one methods share the same name with different parameters or signature and different return type.

What is runtime polymorphism or dynamic method dispatch in Java?

Dynamic method dispatch is a mechanism by which a call to an overridden method is resolved at runtime. This is how java implements runtime polymorphism. When an overridden method is called by a reference, java determines which version of that method to execute based on the type of object it refer to.

Is overloading a form of polymorphism?

The keyword in here is overriding, overloading is different and is not considered as polymorphism. with overloading you can define multiple methods "with same name" but with different parameters on same object or class. java doesn't truly offer this level of polymorphism (called also object slicing).
 
In java language, polymorphism is essentially considered into two versions.

Compile time polymorphism

The process of binding the overloaded method within object at compile time is known as Static polymorphism due to static polymorphism utilization of resources (main memory space) is poor because for each and every overloaded method a memory space is created at compile time when it binds with an object. In C++ environment the above problem can be solve by using dynamic polymorphism by implementing with virtual and pure virtual function so most of the C++ developer in real worlds follows only dynamic polymorphism.

Dynamic polymorphism

In dynamic polymorphism method of the program binds with an object at runtime the advantage of dynamic polymorphism is allocating the memory space for the method (either for overloaded method or for override method) at run time.

Example of Dynamic polymorphism.

In below example we create two class Person an Employee, Employee class extends Person class feature and override walk() method. We are calling the walk() method by the reference variable of Parent class. Since it refers to the subclass object and subclass method overrides the Parent class method, subclass method is invoked at runtime. Here method invocation is determined by the JVM not compiler, So it is known as runtime polymorphism.

class Person
{
void walk()
{
System.out.println("Can Run....");
}
}
class Employee extends Person
{
void walk()
{
System.out.println("Running Fast...");
}
public static void main(String arg[])
{
Person p=new Employee(); //upcasting
p.walk();
}
}
Output
Running fast...

How Polymorphism supported in Java

Java has excellent support of polymorphism in terms of Inheritance, method overloading and method overriding. Method overriding allows Java to invoke method based on a particular object at run-time instead of declared type while coding. To get hold of concept let's see an example of polymorphism in Java:

public class TradingSystem{
   public String getDescription(){
   return "electronic trading system";
   }
}
public class DirectMarketAccessSystem extends TradingSystem{
  public String getDescription(){
     return "direct market access system";
   }
}
public class CommodityTradingSystem extends TradingSystem{
   public String getDescription(){
     return "Futures trading system";
   }
}

Where to use Polymorphism in code

Probably this is the most important part of this Java Polymorphism tutorial and It’s good to know where you can use Polymorphism in Java while writing code. Its common practice to always replace concrete implementation with interface it’s not that easy and  comes with practice but here are some common places where I check for polymorphism: Method argument: Always use super type in method argument that will give you leverage to pass any implementation while invoking a method. For example:

public void showDescription(TradingSystem tradingSystem){
 tradingSystem.description();
}

If you have used concrete implementation e.g. CommodityTradingSystem or DMATradingSystem then that code will require frequent changes whenever you add new Trading system. Variable names: Always use Super type while you are storing reference returned from any Factory method in Java, This gives you the flexibility to accommodate any new implementation from Factory. Here is an example of polymorphism while writing Java code which you can use retrieving reference from Factory:

String systemName = Configuration.getSystemName();
TradingSystem system = TradingSystemFactory.getSystem(systemName);

Return type of method The return type of any method is another place where you should be using interface to take advantage of Polymorphism in Java. In fact, this is a requirement of Factory design pattern in Java to use interface as a return type for factory method.

public TradingSystem getSystem(String name)
{
 //code to return appropriate implementation
  }

For indepth understanding of Java click on

Java Tutorials

Java Virtual Machine

Multi threading in java

Exception Handling in Java

Interface in Java

33:T3224,

Inheritance in Java

Inheritance in java is a mechanism in which one object acquires all the properties and behaviors of parent object. The idea behind inheritance in java is that you can create new classes that are built upon existing classes.

How inheritance works

Classes in Java code exist in hierarchies. Classes above a given class in a hierarchy are superclasses of that class. That particular class is a subclass of every class higher up the hierarchy. A subclass inherits from its superclasses. The java.lang.Object class is at the top of the class hierarchy — so every Java class is a subclass of, and inherits from, Object.

For example, suppose you have a Person class that looks like the one in Listing 1.

Listing 1. Public Person class
public class Person {
  public static final String STATE_DELIMITER = "~";
  public Person() {
    // Default constructor
  }
  public enum Gender {
    MALE,
    FEMALE,
   UNKNOWN
 }
  public Person(String name, int age, int height, int weight, String eyeColor, Gender gender) {
 this.name = name;
    this.age = age;
    this.height = height;
    this.weight = weight;
    this.eyeColor = eyeColor;
    this.gender = gender;
  }
 private String name;
 private int age;
 private int height;
 private int weight;
 private String eyeColor;
 private Gender gender;

The Person class in Listing 1 implicitly inherits from Object. Because inheriting from Object is assumed for every class, you don't need to type extends Object for every class you define. But what does it mean to say that a class inherits from its superclass? It simply means that Person has access to the exposed variables and methods in its superclasses. In this case, Person can see and use Object's public and protected methods and variables.

Why multiple inheritance is not supported in java?

To reduce the complexity and simplify the language, multiple inheritance is not supported in java. Consider a scenario where A, B and C are three classes. The C class inherits A and B classes. If A and B classes have same method and you call it from child class object, there will be ambiguity to call method of A or B class. Since compile time errors are better than runtime errors, java renders compile time error if you inherit 2 classes. So whether you have same method or different, there will be compile time error now. 
class A{  
void msg(){System.out.println("Hello");}  
}  
class B{  
void msg(){System.out.println("Welcome");}
}  
class C extends A,B{//suppose if it were     
 Public Static void main(String args[]){  
   C obj=new C();  
  obj.msg();//Now which msg() method would be invoked?  
}  
}

What is inheritance in object oriented programming?

Inheritance (OOP) is when an object or class is based on another object (prototypal inheritance) or class (class-based inheritance), using the same implementation (inheriting from an object or class) specifying implementation to maintain the same behavior (realizing an interface; inheriting behavior).

What is meant by multiple inheritance?

Multiple inheritance is a feature of some object-oriented computer programming languages in which an object or class can inherit characteristics and features from more than one parent object or parent class.

What is the single inheritance?

Single inheritance enables a derived class to inherit properties and behavior from a single parent class. It allows a derived class to inherit the properties and behavior of a base class, thus enabling code reusability as well as adding new features to the existing code.

What Is syntax in Java?

The syntax is mostly derived from C and C++. Unlike C++, Java is almost exclusively an object-oriented language. There are no global functions or variables, but there are data members which are also regarded as global variables. all code belongs to classes and all values are objects.

What is class inheritance?

In object-oriented programming, inheritance enables new objects to take on the properties of existing objects. A class that is used as the basis for inheritance is called a superclass or base class. A class that inherits from a superclass is called a subclass or derived class.

Can private classes be inherited in Java?

A subclass does not inherit the private members of its parent class. However, if the superclass has public or protected methods for accessing its private fields, these can also be used by the subclass. A nested class has access to all theprivate members of its enclosing class—both fields and methods.
 

class hierarchy

Now suppose you have an Employee class that inherits from Person. Employee's class definition would look something like this: 
public class Employee extends Person {
 private String taxpayerIdentificationNumber;
 private String employeeNumber;
 private BigDecimal salary;
  // . . .
}

The Employee inheritance relationship to all of its superclasses (its inheritance graph) implies that Employee has access to all public and protected variables and methods in Person (because Employee directly extends Person), as well as those in Object (because Employee actually extends Object, too, though indirectly). However, because Employee and Person are in the same package, Employee also has access to the package-private (sometimes called friendly) variables and methods in Person.

To go one step deeper into the class hierarchy, you could create a third class that extends Employee:

public class Manager extends Employee {
 // . . .
}
In the Java language, any class can have at most one direct superclass, but a class can have any number of subclasses. That's the most important thing to remember about inheritance hierarchy in the Java language.

Single versus multiple inheritance

Languages like C++ support the concept of multiple inheritance: At any point in the hierarchy, a class can directly inherit from one or more classes. The Java language supports only single inheritance— meaning you can only use the extends keyword with a single class. So the class hierarchy for any Java class always consists of a straight line all the way up to java.lang.Object. For indepth understanding of java click on Interface in java Polymorphism in Java Exception Handling in java Multithreading in java Java Virtual Machine
34:T27d8,

What is Constructors in Java

Java constructors are the methods which are used to initialize objects. Constructor method has the same name as that of class, they are called or invoked when an object of class is created and can't be called explicitly. Attributes of an object may be available when creating objects if no attribute is available then default constructor is called, also some of the attributes may be known initially. It is optional to write constructor method in a class but due to their utility they are used.

Java constructor example

class Programming {
  //constructor method
  Programming() {
    System.out.println("Constructor method called.");
  }
  public static void main(String[] args) {
    Programming object = new Programming(); //creating object
  }
}

Output of program:
Constructors in Java

Types of Constructors

There are three types of constructors:

[button url="http://tekslate.com/tutorials/java-tutorials/" class="other" bg="" hover_bg="" size="0px" color="#eeebeb" radius="0px" width="0px" height="0px" target="_self"] Java Tutorials [/button]

What is the default constructor?

A default constructor is a constructor that either has no parameters, or if it has parameters, all the parameters have default values. If no user-defined constructor exists for a class A and one is needed, the compiler implicitly declares a constructor A::A(). This constructor is an inline public member of its class

Default constructor: If you do not define any constructor in your class, java generates one for you by default. This constructor is known as default constructor. You would not find it in your source code but it would present there. It would look like this if you could see it. Default constructor for class Demo: 
public Demo()
{
}
no-arg constructor: Constructor with no arguments is known as no-arg constructor. The signature is same as default constructor, however body can have any code unlike default constructor where the body does nothing.

What is the use of parameterized constructor?

When an object is declared in a parameterized constructor, the initial values have to be passed as arguments to the constructor function. The normal way of object declaration may not work. The constructors can be called explicitly or implicitly.

Constructor Overloading - Multiple Constructors for a Java Class

A class can have multiple constructors, as long as their signature (the parameters they take) are not the same. You can define as many constructors as you need. When a Java class contains multiple constructors, we say that the constructor is overloaded (comes in multiple versions). Java constructor overloading example: 
public class MyClass {
    private int number = 0;
    public MyClass() {
    }
public MyClass(int theNumber) {
        this.number = theNumber;
  }
}
The Java class above contains two constructors. The first constructor is a no-arg constructor, meaning it takes no parameters (no arguments). The second constructor takes an int parameter. Inside the constructor body the int parameter value is assigned to a field, meaning the value of the parameter is copied into the field. The field is thus initialized to the given parameter value. The keyword this in front of the field name (this.number) is not necessary. It just signals to the compiler that it is the field named number that is being referred to. This is explained in more detail in the section about constructor parameters.

How to Use A Constructor In Java

A constructor in Java is a block of code similar to a method that’s called when an instance of an object is created. Here are the key differences between a constructor and a method:

  • A constructor doesn’t have a return type.

  • The name of the constructor must be the same as the name of the class.

  • Unlike methods, constructors are not considered members of a class.

  • A constructor is called automatically when a new instance of an object is created.

Here’s the basic format for coding a constructor: 
public ClassName (parameter-list) [throws exception...]
{
    statements...
}
The public keyword indicates that other classes can access the constructor. ClassName must be the same as the name of the class that contains the constructor. You code the parameter list the same way that you code it for a method. Notice also that a constructor can throw exceptions if it encounters situations that it can’t recover from. A constructor allows you to provide initial values for class fields when you create the object. Suppose that you have a class named Actor that has fields named firstName and lastName. You can create a constructor for the Actor class: 
public Actor(String first, String last)
{
    firstName = first;
    lastName = last;
}
Then you create an instance of the Actor class by calling this constructor: 
Actor a = new Actor("Arnold", " Schwarzenegger");
A new Actor object for Arnold Schwarzenegger is created. Like methods, constructors can be overloaded. In other words, you can provide more than one constructor for a class if each constructor has a unique signature. Here’s another constructor for the Actor class: 
public Actor(String first, String last, boolean good)
{
    firstName = first;
    lastName = last;
    goodActor = good;
}
This constructor lets you create an Actor object with information besides the actor’s name: 
Actor a = new Actor("Arnold", "Schwarzenegger", false);
If you do not provide a constructor for a class, Java will automatically create a default constructor that has no parameters and doesn’t initialize any fields. This default constructor is called if you specify the new keyword without passing parameters. For example: 
Ball b = new Ball();
Here, a variable of type Ball is created by using the default constructor for the Ball class. If you explicitly declare any constructors for a class, Java does not create a default constructor for the class. As a result, if you declare a constructor that accepts parameters and still want to have an empty constructor (with no parameters and no body), you must explicitly declare an empty constructor for the class.
 
 For indepth understanding  of Java click on
Java Tutoria
Inheritance in Java
Polymorphism in Java
Java Virtual Machine 
Exception Handnlig in java
35:T3d76,

Java Annotations in Java

Annotation is code about the code, that is metadata about the program itself. In other words, organized data about the code, embedded within the code itself. It can be parsed by the compiler, annotation processing tools and can also be made available at run-time too.

We have basic java comments infrastructure using which we add information about the code / logic so that in future, another programmer or the same programmer can understand the code in a better way. Javadoc is an additional step over it, where we add information about the class, methods, variables in the source code. The way we need to add is organized using a syntax. Therefore, we can use a tool and parse those comments and prepare a javadoc document which can be distributed separately.

Javadoc facility gives option for understanding the code in an external way, instead of opening the code the javadoc document can be used separately. IDE benefits using this javadoc as it is able to render information about the code as we develop.

Annotation Types

Documented

When a annotation type is annotated with @Documented then wherever this annotation is used those elements should be documented using Javadoc tool.

Inherited

This meta annotation denotes that the annotation type can be inherited from super class. When a class is annotated with annotation of type that is annotated with Inherited, then its super class will be queried till a matching annotation is found.

Retention

This meta annotation denotes the level till which this annotation will be carried. When an annotation type is annotated with meta annotation Retention, RetentionPolicy has three possible values:

@Retention(RetentionPolicy.RUNTIME)
public @interface Developer {
	String value();
}

Class When the annotation value is given as ‘class’ then this annotation will be compiled and included in the class file.

Runtime The value name itself says, when the retention value is ‘Runtime’ this annotation will be available in JVM at runtime. We can write custom code using reflection package and parse the annotation. I have give an example below.

Source This annotation will be removed at compile time and will not be available at compiled class.

Target

This meta annotation says that this annotation type is applicable for only the element (ElementType) listed. Possible values for ElementType are, CONSTRUCTOR, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE.

@Target(ElementType.FIELD)
public @interface FieldInfo { }

Creating Your Own Annotations

It is possible to create your own (custom) Java annotations. Annotations are defined in their own file, just like a Java class or interface. Here is custom Java annotation example:

@interface MyAnnotation {
    String   value();
    String   name();
    int      age();
    String[] newNames();
}

This example defines an annotation called MyAnnotation which has four elements. Notice the @interfacekeyword. This signals to the Java compiler that this is a Java annotation definition.

Notice that each element is defined similarly to a method definition in an interface. It has a data type and a name. You can use all primitive data types as element data types. You can also use arrays as data type. You cannot use complex objects as data type. To use the above annotation, you could use code like this:

@MyAnnotation(
    value="123",
    name="Jakob",
    age=37,
    newNames={"Jenkov", "Peterson"}
)
public class MyClass {
}

As you can see, I have to specify values for all elements of the MyAnnotation annotation.

Element Default Values

You can specify default values for an element. That way the element becomes optional and can be left out. Here is an example of how the annotation definition looks with a default value for an element:

@interface MyAnnotation {
    String   value() default "";
    String   name();
    int      age();
    String[] newNames();
}

The value element can now be left out when using the annotation. If you leave it out, it will be considered as if you had used the default value for the value element. Here is an example of an annotation with an element value left out, so that element is set to the default value:

@MyAnnotation(
    name="Jakob",
    age=37,
    newNames={"Jenkov", "Peterson"}
)
public class MyClass {
}

Notice that the value element is no longer present.

@Retention

You can specify for your custom annotation if it should be available at runtime, for inspection via reflection. You do so by annotating your annotation definition with the @Retention annotation. Here is how that is done:

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
    String   value() default "";
}

Notice the @Retention annotation added above the MyAnnotation definition:

@Retention(RetentionPolicy.RUNTIME)

The RetentionPolicy class contains two more values you can use:

RetentionPolicy.CLASS means that the annotation is stored in the .class file, but not available at runtime. This is the default retention policy, if you do not specify any retention policy at all.

RetentionPolicy.SOURCE means that the annotation is only available in the source code, and not in the .class files and not a runtime. If you create your own annotations for use with build tools that scan the code, you can use this retention policy. That way the .class files are not polluted unnecessarily.

@Target

You can specify which Java elements your custom annotation can be used to annotate. You do so by annotating your annotation definition with the @Target annotation. Here is a @Target Java annotation example:

import java.lang.annotation.ElementType;
import java.lang.annotation.Target;
@Target({ElementType.METHOD})
public @interface MyAnnotation {
    String   value();
}

This example shows a Java annotation that can only be used to annotate methods.

The ElementType class contains the following possible targets:

Most of these are self explaining, but a few are not. Therefore I will explain the targets which are not obvious.

The ANNOTATION_TYPE target means Java annotation definitions. Thus, the annotation can only be used to annotate other annotations. Like the @Target and @Retention annotations.

The TYPE target means any type. A type is either a class, interface, enum or annotation.

@Inherited

The @Inherited annotation signals that a custom Java annotation used in a class should be inherited by subclasses inheriting from that class. Here is an @Inherited Java annotation example:

java.lang.annotation.Inherited
@Inherited
public @interface MyAnnotation {
}
@MyAnnotation
public class MySuperClass { ... }
public class MySubClass extends MySuperClass { ... }

In this example the class MySubClass inherits the annotation @MyAnnotation because MySubClass inherits from MySuperClass, and MySuperClass has a @MyAnnotation annotation.

@Documented

The @Documented annotation is used to signal to the JavaDoc tool that your custom annotation should be visible in the JavaDoc for classes using your custom annotation. Here is a @Documented Java annotation example:

import java.lang.annotation.Documented;
@Documented
public @interface MyAnnotation {
}
@MyAnnotation
public class MySuperClass { ... }

When generating JavaDoc for the MySuperClass class, the @MyAnnotation is now included in the JavaDoc.

You will not use the @Documented annotation often, but now you know it exists, if you should need it.

Built-in Java Annotations

Java comes with three built-in annotations which are used to give the Java compiler instructions. These annotations are:

Each of these annotations are explained in the following sections.

@Deprecated

The @Deprecated annotation is used to mark a class, method or field as deprecated, meaning it should no longer be used. If your code uses deprecated classes, methods or fields, the compiler will give you a warning. Here is @Deprecated Java annotation example:

@Deprecated
public class MyComponent {
}

The use of the @Deprecated Java annotation above the class declaration marks the class as deprecated.

You can also use the @Deprecated annotation above method and field declarations, to mark the method or field as deprecated.

When you use the @Deprecated annotation, it is a good idea to also use the corresponding @deprecatedJavaDoc symbol, and explain why the class, method or field is deprecated, and what the programmer should use instead. For instance:

@Deprecated
/**
  @deprecated Use MyNewComponent instead.
*/
public class MyComponent {
}

@Override

The @Override Java annotation is used above methods that override methods in a superclass. If the method does not match a method in the superclass, the compiler will give you an error.

The @Override annotation is not necessary in order to override a method in a superclass. It is a good idea to use it still, though. In case someone changed the name of the overridden method in the superclass, your subclass method would no longer override it. Without the @Override annotation you would not find out. With the @Override annotation the compiler would tell you that the method in the subclass is not overriding any method in the superclass.

Here is an @Override Java annotation example:

public class MySuperClass {
    public void doTheThing() {
        System.out.println("Do the thing");
    }
}
public class MySubClass extends MySuperClass{

    @Override
    public void doTheThing() {
        System.out.println("Do it differently");
    }
}

In case the method doTheThing() in MySuperClass changes signature so that the same method in the subclass no longer overrides it, the compiler will generate an error.

@SuppressWarnings

The @SuppressWarnings annotation makes the compiler suppress warnings for a given method. For instance, if a method calls a deprecated method, or makes an insecure type cast, the compiler may generate a warning. You can suppress these warnings by annotating the method containing the code with the @SuppressWarnings annotation.

Here is a @SuppressWarnings Java annotation example:

@SuppressWarnings
public void methodWithWarning() {
}

 

36:T352a,

Encapsulation in java

Encapsulation is a process of wrapping of data and methods in a single unit is called encapsulation. Encapsulation is achieved in java language by class concept.Combining of state and behavior in a single container is known as encapsulation. In java language encapsulation can be achieve using class keyword, state represents declaration of variables on attributes and behavior represents operations in terms of method. Example:

class​​ ​Employee​{ 
private​​ ​​int​​ ​employeeId​; 
​private​​ ​String​ ​employeeName​; 
​private​​ ​String​ ​designation​; 
​public​​ ​​int​​ ​getEmployeeId​()​​ ​​{ 
​return​​ ​employeeId​; 
​}   
​public​​ ​​void​​ ​setEmployeeId​(​int​​ ​employeeId​)​​ ​​{  
​this​.​employeeId​ ​​=​​ ​employeeId​; 
​} 
​public​​ ​String​ ​getEmployeeName​()​​ ​​{ 
​return​​ ​employeeName​; 
​} 
​public​​ ​​void​​ ​setEmployeeName​(​String​ ​employeeName​)​​ ​​{ 
​this​.​employeeName​ ​​=​​ ​employeeName​;  
​}   
​public​​ ​String​ ​getDesignation​()​​ ​​{ 
​return​​ ​designation​; 
​} 
​public​​ ​​void​​ ​setDesignation​(​String​ ​designation​)​​ ​​{ 
​this​.​designation​ ​​=​​ ​designation​; 
​}  
}

How do we achieve encapsulation in Java?

We can achieve complete encapsulation in java by making members of a class private and access them outside the class only through getters and setters. Although a lesser degree of encapsulation can be achieved by making the members public or protected.

What is encapsulation in object oriented programming?

Encapsulation is an Object Oriented Programming concept that binds together the data and functions that manipulate the data, and that keeps both safe from outside interference and misuse. ... C++ supports the properties of encapsulation and data hiding through the creation of user-defined types, called classes.

Why Encapsulation use in Java Code?

Here are some advantages to use encapsulation in Java Code.
  • Encapsulated Code is more flexible and easy to change with new requirements.
  • By providing only getter and setter method access, you can make the class read only.
  • Encapsulation in Java makes unit testing easy.
  • A class can have total control over what is stored in its fields. Suppose you want to set the value of marks field i.e. marks should be positive value, than you can write the logic of positive value in setter method.
  • Encapsulation also helps to write immutable class in Java which are a good choice in multi-threading environments.
  • Encapsulation allows you to change one part of code without affecting other par

Benefits of encapsulation

  • Provides abstraction between an object and its clients.
  • Protects an object from unwanted access by clients.
  • Example: A bank application forbids (restrict) a client to change an Account's balance.

Advantage of Encapsulation in java

  • Objects encapsulate data and implementation details. To the outside world, an object is a black box that exhibits a certain behavior.
  • The behavior of this object is what which is useful for the external world or other objects.
  • An object exposes its behavior by means of public methods or functions.
  • The set of functions an object exposes to other objects or external world acts as the interface of the object.
For indepth understanding of java click on
Java Tutorials
Interface in Java
Multithreading in java
Polymorphism in Java
Java Annotations
37:T346d,

Packages in java

A package is a namespace that organizes a set of related classes and interfaces. Conceptually you can think of packages as being similar to different folders on your computer. You might keep HTML pages in one folder, images in another, and scripts or applications in yet another. Because software written in the Java programming language can be composed of hundreds or thousands of individual classes, it makes sense to keep things organized by placing related classes and interfaces into packages. The Java platform provides an enormous class library (a set of packages) suitable for use in your own applications. This library is known as the "Application Programming Interface", or "API" for short. Its packages represent the tasks most commonly associated with general-purpose programming. For example, a String object contains state and behavior for character strings; a File object allows a programmer to easily create, delete, inspect, compare, or modify a file on the filesystem; a Socket object allows for the creation and use of network sockets; various GUI objects control buttons and checkboxes and anything else related to graphical user interfaces. There are literally thousands of classes to choose from. This allows you, the programmer, to focus on the design of your particular application, rather than the infrastructure required to make it work. Syntax of the Package in Java:

package <Package Name>;

Types of package:

How to use package

There are 2 ways in order to use the public classes stored in package.

...
world.HelloWorld helloWorld = new world.HelloWorld();
world.moon.HelloMoon helloMoon = new world.moon.HelloMoon();
String holeName = helloMoon.getHoleName();
...


import world.*;  // we can call any public classes inside the world package 
import world.moon.*;  // we can call any public classes inside the world.moon package
import java.util.*;  // import all public classes from java.util package
import java.util.Hashtable;  // import only Hashtable class (not all classes in java.util package)

Thus, the code that we use to call the HelloWorld and HelloMoon class should be

...
  HelloWorld helloWorld = new HelloWorld(); // don't have to explicitly specify world.HelloWorld anymore
  HelloMoon helloMoon = new HelloMoon(); // don't have to explicitly specify world.moon.HelloMoon anymore
...  

Note that we can call public classes stored in the package level we do the import only. We can't use any classes that belong to the subpackage of the package we import. For example, if we import package world, we can use only the HelloWorld class, but not the HelloMoon class.

How to create a package

At first create a folder like a name <cei> and store a program. Listing 1: Sample showing Example using package. This is the package program

armstrong.java
public class armstrong
{
	int x=407;
	int r,temp,a=0;
	public void test()
	{
	temp=x;
	while(x>0)
	{
		r=x%10;
		a=a+(r*r*r);
		x=x/10;
	}
	if(temp==a)
	{
		System.out.println("This is Armstrong no..");
	}
else
{
		System.out.println("This is not Armstrong no..");
}	
}	
}

After the creation of the program then compile this program with following syntax:

javac  armstrong.java

If compile this part with successfully then write down this program. Listing 2: Sample showing Example calling package

cal.java
import cei.*;
public class cal{
    public static void main(String args[]){
	   armstrong ob=new armstrong();
	   ob.test(); //this part is calling package method
    }
}

Then compile the code cal.java

javac  cal.java

After that we interpreting this program cal.java

java  cal

Then this call.java will be interpreted and run this program and show the output Output: This is Armstrong no. Packages in java Process to Compile package program and run.

Classpath Packages in Java

CLASSPATH is an environment variable (i.e., global variables of the operating system available to all the processes) needed for the Java compiler and runtime to locate the Java packages used in a Java program. (Why not call PACKAGEPATH?) This is similar to another environment variable PATH, which is used by the CMD shell to find the executable programs. CLASSPATH can be set in one of the following ways:

To check the current setting of the CLASSPATH, issue the following command:

SET CLASSPATH

SET CLASSPATH=.;c:\javaproject\classes;d:\tomcat\lib\servlet-api.jar

java –classpath c:\javaproject\classes com.abc.project1.subproject2.MyClass3

 

How to put two public classes in a package?

Two public classes in a package, have two source files containing one public class, but keep the package name same . For example.

//save as A.java  
package javatpoint;  
public class A{}  
//save as B.java   
package javatpoint;  
public class B{}  

Subpackage in java

Package inside the package is called the subpackage. It should be created to categorize the package further. Let's take an example, Sun Microsystem has definded a package named java that contains many classes like System, String, Reader, Writer, Socket etc. These classes represent a particular group e.g. Reader and Writer classes are for Input/Output operation, Socket and ServerSocket classes are for networking etc and so on. So, Sun has subcategorized the java package into subpackages such as lang, net, io etc. and put the Input/Output related classes in io package, Server and ServerSocket classes in net packages and so on.

package com.javatpoint.core;  
class Simple{  
  public static void main(String args[]){  
   System.out.println("Hello subpackage");  
  }  
}

To Compile: javac -d . Simple.java To Run: java com.javatpoint.core.Simple

Output:Hello subpackage

Advantages of Packages in java

 

38:T64a1,

Java Regular Expressions in Java

A regular expression or REGEX is explained as a specific kind of text pattern that can be used in many advanced applications and with any programming language. They are used for searching, editing and manipulating data.

For example, using regular expressions we can verify if a particular input string matches a given text pattern or to find out a set of characters from a large batch of characters. They are also used in replacing and re-arranging a block of text or splitting a big chunk of data into smaller subsets. Regular expressions are generally not language specific and follow a similar pattern in most of the programming languages, but with slight variation.

Regular expressions are powerful tools and would reduce the time taken for processing a job, when your program needs to manipulate or extract text on computer. By using them skillfully, regular expressions help us to perform many tasks that wouldn't be feasible at all.

Regular expressions are so useful in real life computing that, the various systems and languages have evolved to provide both a fundamental and protracted standard for the grammar and syntax for usage of modern regular expressions. Also Regular expression processors are found in major of the search engines, search and replace place-holders of various word processors and text editors, and in the command lines of utilities that are used in processing text inputs.

Here's a set of strings that have a few things in common:

Note that each of these strings begins with A and ends with string. The Java Regular Expressions API helps you pull out these elements, see the pattern among them, and do interesting things with the information you've gleaned. The Regular Expressions API has three core classes that you use almost all the time:

You'll begin working on a simple regular-expressions pattern that uses these classes shortly. But first, take a look at the regex pattern syntax. Regex pattern syntax A regex pattern describes the structure of the string that the expression tries to find in an input string. The pattern syntax can look strange to the uninitiated, but once you understand it, you'll find it easier to decipher. Table 1 lists some of the most common regex constructs that you use in pattern strings.

Regex construct What qualifies as a match
. Any character
? Zero (0) or one (1) of what came before
* Zero (0) or more of what came before
+ One (1) or more of what came before
[] A range of characters or digits
^ Negation of whatever follows (that is, "not whatever")
\d Any digit (alternatively, [0-9])
\D Any nondigit (alternatively, [^0-9])
\s Any whitespace character (alternatively, [\n\t\f\r])
\S Any nonwhitespace character (alternatively, [^\n\t\f\r])
\w Any word character (alternatively, [a-zA-Z_0-9])
\W Any nonword character (alternatively, [^\w])

The first few constructs are called quantifiers, because they quantify what comes before them. Constructs like \d are predefined character classes. Any character that doesn't have special meaning in a pattern is a literal and matches itself. The first few constructs are called quantifiers, because they quantify what comes before them. Constructs like \d are predefined character classes. Any character that doesn't have special meaning in a pattern is a literal and matches itself.

Pattern matching

Armed with the pattern syntax in Table 1, you can work through the simple example in Listing 1, using the classes in the Java Regular Expressions API.

Listing 1. Pattern matching with regex
Pattern pattern = Pattern.compile("[Aa].*string");
Matcher matcher = pattern.matcher("A string");
boolean didMatch = matcher.matches();
Logger.getAnonymousLogger().info (didMatch);
int patternStartIndex = matcher.start();
Logger.getAnonymousLogger().info (patternStartIndex);
int patternEndIndex = matcher.end();
Logger.getAnonymousLogger().info (patternEndIndex);

First, Listing 1 creates a Pattern class by calling compile()— a static method on Pattern— with a string literal representing the pattern you want to match. That literal uses the regex pattern syntax. In this example, the English translation of the pattern is: Find a string of the form A or a followed by zero or more characters, followed by string.

Methods for matching

Next, Listing 1 calls matcher() on Pattern. That call creates a Matcher instance. The Matcher then searches the string you passed in for matches against the pattern string you used when you created the Pattern. Every Java language string is an indexed collection of characters, starting with 0 and ending with the string length minus one. The Matcher parses the string, starting at 0, and looks for matches against it. After that process is complete, the Matcher contains information about matches found (or not found) in the input string. You can access that information by calling various methods on Matcher:

Listing 1 finds a single match starting at 0 and ending at 7. Thus, the call to matches() returns true, the call to start() returns 0, and the call to end() returns 8.

lookingAt() versus matches()

If your string had more elements than the number of characters in the pattern you searched for, you could use lookingAt() instead of matches(). The lookingAt() method searches for substring matches for a specified pattern. For example, consider the following string:

a string with more than just the pattern.

If you search this string for a.*string, you get a match if you use lookingAt(). But if you use matches(), it returns false, because there's more to the string than what's in the pattern.

Complex patterns in regex

Simple searches are easy with the regex classes, but you can also do highly sophisticated things with the Regular Expressions API. Wikis are based almost entirely on regular expressions. Wiki content is based on string input from users, which is parsed and formatted using regular expressions. Any user can create a link to another topic in a wiki by entering a wiki word, which is typically a series of concatenated words, each of which begins with an uppercase letter, like this:

MyWikiWord

Suppose a user inputs the following string:

Here is a WikiWord followed by AnotherWikiWord, then YetAnotherWikiWord.

You could search for wiki words in this string with a regex pattern like this:

[A-Z][a-z]*([A-Z][a-z]*)+

And here's code to search for wiki words:

String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
while (matcher.find()) {
  Logger.getAnonymousLogger().info("Found this wiki word: " + matcher.group());
}

Run this code, and you can see the three wiki words in your console.

Replacing strings

Searching for matches is useful, but you also can manipulate strings after you find a match for them. You can do that by replacing matched strings with something else, just as you might search for text in a word-processing program and replace it with other text. Matcher has a couple of methods for replacing string elements:

Using Matcher's replace methods is straightforward:

String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
Logger.getAnonymousLogger().info("Before: " + input);
String result = matcher.replaceAll("replacement");
Logger.getAnonymousLogger().info("After: " + result);

This code finds wiki words, as before. When the Matcher finds a match, it replaces the wiki word text with its replacement. When you run the code, you can see the following on your console:

Before: Here is WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is replacement followed by replacement, then replacement.

If you had used replaceFirst(), you would have seen this:

Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a replacement followed by AnotherWikiWord, then SomeWikiWord.

Matching and manipulating groups

When you search for matches against a regex pattern, you can get information about what you found. You've seen some of that capability with the start() and end() methods on Matcher. But it's also possible to reference matches by capturing groups. In each pattern, you typically create groups by enclosing parts of the pattern in parentheses. Groups are numbered from left to right, starting with 1 (group 0 represents the entire match). The code in Listing 2 replaces each wiki word with a string that "wraps" the word:

Listing 2. Matching groups
String input = "Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.";
Pattern pattern = Pattern.compile("[A-Z][a-z]*([A-Z][a-z]*)+");
Matcher matcher = pattern.matcher(input);
Logger.getAnonymousLogger().info("Before: " + input);
String result = matcher.replaceAll("blah$0blah");
Logger.getAnonymousLogger().info("After: " + result);

Run the Listing 2 code, and you get the following console output:

Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a blahWikiWordblah followed by blahAnotherWikiWordblah,then blahSomeWikiWordblah.

Listing 2 references the entire match by including $0 in the replacement string. Any portion of a replacement string of the form $int refers to the group identified by the integer (so $1 refers to group 1, and so on). In other words, $0 is equivalent to matcher.group(0);. You could accomplish the same replacement goal by using other methods. Rather than calling replaceAll(), you could do this:

StringBuffer buffer = new StringBuffer();
while (matcher.find()) {
 matcher.appendReplacement(buffer, "blah$0blah");
}
matcher.appendTail(buffer);
Logger.getAnonymousLogger().info("After: " + buffer.toString());

And you'd get the same result:

Before: Here is a WikiWord followed by AnotherWikiWord, then SomeWikiWord.
After: Here is a blahWikiWordblah followed by blahAnotherWikiWordblah,then blahSomeWikiWordblah.

Common Uses

Regular expressions are majorly used in a wide variety of text processing tasks, and more generally string processing, where the data need not be textual. Common applications include data validation, data scraping, data wrangling, simple parsing, the production of syntax highlighting systems, and many other tasks. While regular expressions would be useful on Internet search engines, processing them across the entire database could consume excessive computer resources depending on the complexity and design of the regex. Some important uses of regular expressions are:

Note:

One of the most important things to do is to take a look at How a Regex Engine Works Internally because knowing how the regex engine works will help us to craft better regexes more easily. It will also help in understanding quickly why a particular regex does work in the way it was initially expected to do so. This will also save lots of guesswork and head scratching when wTe need to wuite more complex regexes. There are two kinds of regular expression engines:

  1. Mostly all the regex flavors available are based on regex-directed engines. This is because certain very7 useful features, such as lazy quantifiers and back references, can only be implemented in regex-directed engines.
  2. You can easily find out whether the regex flavor you intend to use has a text- directed or regex-directed engine. If back references and/or lazy quantifiers are available, you can be certain the engine is regex-directed.
  3. You can do the test by applying the regex «text|text not» to the string '‘text not”. If the resulting match is only “text”, the engine is regex-directed. If the result is “text not”, then it is text-directed. The reason behind this is that the regex-directed engine is an early starter.
  4. Before looking into the examples provided, understanding how the regex engine works will enable you to use its full power and help you avoid common mistakes.

The Regex-Directed Engine Always Returns the Leftmost Match. There are some important points to be noted when working with engines:

Let us consider the example, searching «book» to “He bought a bookshelf for his book." The engine will try to match the first token in the regex «b» to the first character in the match “H“. This fails. There are no other possible permutations of this regex, because it merely consists of a sequence of literal characters. So the regex engine tries to match the «b» with the “e". This fails too, as does matching the «b» with the space. Arriving at the 4th character in the match, «b» matches “b”. The engine will then try to match the second token «o» to the 5th character, “o’’. This succeeds too. But then, «o» fails to match “u”. At that point, the engine knows the regex cannot be matched starting at the 4th character in the match. So it will continue with the 5th: “a”. Again, «b»fails to match here and the engine carries on. At the 30th character in the match, «b» again matches “b”.

A text-directed engine would have returned the same result too. However, it is important that you can follow the steps the engine takes in your mind. In following examples, the way the engine works will have a profound impact on the matches it will find. Some of the results may be surprising. But they are always logical and predetermined, once you know how the engine works.

Algorithms Used in Regex

When using regex, there are at least three different algorithms that decide whether and how7 a given regular expression matches a string.

Converting NFA to DFA

This is the first and quickest method. It is based on a result in formal language theory that permits every non-deterministic finite automaton (NFA) to become into a deterministic finite automaton (DFA). The DFA can be explicitly constructed then run on the resulting input string one by one symbol at a time.

Simulating NFA Directly (DFA/NFA Algorithm)

The next method is to simulate the NFA directly, constructing each DFA state on demand and then discarding it at the next execution step. This method keeps the DFA implicit and avoids increase of the construction cost exponentially, but has an overhead of rising the running cost to 0(m n). The explicit an implicit approaches are called the DFA algorithm and the NFA algorithm respectively Adding caching to the NFA algorithm is often called the "lazy DFA" algorithm or just the DFA algorithm without making a distinction.

Backtracking

The third and final algorithm is to match the pattern against the input string by backtracking. This algorithm is usually called as NFA, but this terminology can be confusing a times. This is used simple implementations which exhibit when matching against expressions like (a|aa)*b that contain both alternation and unbounded quantification. This kind of processing can force the algorithm to consider an exponentially increasing number of sub-cases. This might also lead to security problems called Regular expression Denial of Service.

Common Regex Syntaxes

A regular expression is in the bottom a string patterns that represents text. These descriptions can be applied in several ways. The basic language constructs embrace character classes, quantifiers, and meta-characters. The below section explains the various options we can use to define regular expression.

String literals are used to search a particular match in the text. For example, if we are going to search for a text “test'’ then we can simply write the code like this: Here text and regex both are same. Pattern.matches("test", "test")

A character class is used to match a single character in the input text against multiple allowed characters in the character class, a character class has no relation with a class construct or class files in Java. Examples:

  1. [Tt]est would match all the occurrences of String “test” with either lower case or upper case “T”.
  2. The string "A@BAND@YEA@U" matches the pattern ”[ABC]@." twice even though the string contains three @ signs.
  3. The second @ is not a part of any match, because it is preceded by D and not A, B. or C.

Few more samples: Pattem.matches("[pqr]M, "abed"); It would give false as no p,q or r in the text Pattem.matches("[pqr]M, "r"); Return true as r is found Pattem.matches("[pqr]M, "pq"); Return false as any one of them can be in text not both. The meta characters [ and ] (left and right brackets) are used to specify a character class inside a regular expression. Sometimes we limit the characters that produce matches to a special set of characters. Here is the sample list of various character classes constructs:

  1. Simple: consists in a group of characters set up side by side and matches only those characters. Example: [abc] matches characters a, b, and c.

Let's take a look at the following example:

[csw] cave matches c in [csw] with c in cave.

  1. Negation: starts with the A meta-character and matches only those characters not in that class.

Example: [Aabc] matches all characters except a, b, and c.

Let's see a second example:

[Acsw] cave matches a, v, and e with their counterparts in cave.

  1. Range: involves all characters starting with the character on the left of a hyphen meta character (-) and finishing with the character on the right of the hyphen meta character, matching only those characters in that range.

Example: [a-z] matches all lowercase alphabetic characters.

Let's see another example:

[a-c] clown matches c in [a-c] with c in clown.

  1. Union: involves multiple nested character classes and matches all characters that fit to the resulting union.

Example: [a-d[m-p]] matches characters a through d and m through p.

Let's see a second example:

[ab[c-e]] abcdef matches a, b, c, d, and e with their counterparts in abcdef.

  1. Intersection: involves characters usual to all nested classes and matches only common characters.

Example: [a-z&&[d-f]] matches characters d, e, and f. Other example:

[aeiouv&&[y]] party matches v in [aeiou&&[y]] with v in party..

  1. Subtraction: involve all characters less those indicated in nested negation character classes and matches the remaining characters.

Example: [a-z&&[Am-p]] matches characters a through 1 and q through z.

The following command line offers a second example:

[a-f&&[Aa-c]&&[Ae]] abcdefg matches d and f with their counterparts in abcdefg.

39:T4541,

Arraylist in java

An ArrayList is a dynamic data structure, meaning items can be added and removed from the list. A normal array in java is a static data structure, because you stuck with the initial size of your array.
 

 

What is the ArrayList in Java?

The ArrayList class extends AbstractList and implements the List interface. ArrayList supports dynamic arrays that can grow as needed. Standard Java arrays are of a fixed length. After arrays are created, they cannot grow or shrink, which means that you must know in advance how many elements an array will hold.

Example

The following program illustrates several of the methods supported by ArrayList − 
import java.util.*;
public class ArrayListDemo {
   public static void main(String args[]) {
      // create an array list
      ArrayList al = new ArrayList();
      System.out.println("Initial size of al: " + al.size());
      // add elements to the array list
      al.add("C");
      al.add("A");
      al.add("E");
      al.add("B");
      al.add("D");
      al.add("F");
      al.add(1, "A2");
      System.out.println("Size of al after additions: " + al.size());
      // display the array list
      System.out.println("Contents of al: " + al);
      // Remove elements from the array list
      al.remove("F");
      al.remove(2);
      System.out.println("Size of al after deletions: " + al.size());
      System.out.println("Contents of al: " + al);
   }
}
This will produce the following result −

Output

Initial size of al: 0
Size of al after additions: 7
Contents of al: [C, A2, A, E, B, D, F]
Size of al after deletions: 5
Contents of al: [C, A2, E, B, D]

Arraylist Methods

  • Arraylist add: This is used to add elements to the Array List. If an ArrayList already contains elements, the new element gets added after the last element unless the index is specified.
  • Arraylist remove: The specified element is removed from the list and the size is reduced accordingly. Alternately, you can also specify the index of the element to be removed.
  • Java array size:  This will give you the number of elements in the Array List. Just like arrays, here too the first element starts with index 0.
  • Arraylistcontains:  This method will return true if the list contains the specified element.

User-defined class objects in Java ArrayList

class Student{  
 int rollno;  
  String name;  
  int age;  
  Student(int rollno,String name,int age){  
   this.rollno=rollno;  
   this.name=name;  
   this.age=age;  
}  
}  
import java.util.*;  
public class TestCollection3{  
 public static void main(String args[]){  
  //Creating user-defined class objects  
  Student s1=new Student(101,"Sonoo",23);  
  Student s2=new Student(102,"Ravi",21);  
  Student s2=new Student(103,"Hanumat",25);        
  ArrayList<Student> al=new ArrayList<Student>();//creating arraylist  
  al.add(s1);//adding Student class object  
  al.add(s2);  
  al.add(s3);      
  Iterator itr=al.iterator();  
  //traversing elements of ArrayList object  
  while(itr.hasNext()){  
    Student st=(Student)itr.next();  
    System.out.println(st.rollno+" "+st.name+" "+st.age);  
 }  
 }  
}

The ArrayList data structure

The array is the fundamental data structure built into Java for holding collections of items. Arrays provide two basic operations: You can retrieve the value at an index, or you can change the value at an index. These are quite similar to the List ADT's get and set operations.
array operation equivalent List ADT operation
x = data[i]; x = get(i)
data[i] = x; set(i, x)
This similarity is what inspires the implementation of the List interface using an array to store the data elements. There are other List operations that don't correspond to anything we can do with an array (add and remove); but this is a detail that we can hope to overcome. Overall, it seems like an array is a good candidate for implementing the List interface. Java's built-in libraries already include such an implementation; specifically, the java.util package includes the ArrayList class. To use it, you need to include a import statement at the top of your program definition. 
import java.util.ArrayList;
Like the List interface, the ArrayList class is a generic. Inside a method definition, we can declare a names variable and then assign it to refer to a newly created ArrayList object. 
List<String> names;
 names = new ArrayList<String>();
Once we have a way of referring to an ArrayList object, then we can tell it to do things using the ArrayList methods, which necessarily include all the methods in the List interface. Among these is the add method. 
names.add("Martin");
 names.add("Galloway");
Suppose we want to display all the strings in the ArrayList. List's size and get methods are useful for this. 
for(int i = 0; i < names.size(); i++) {
     System.out.println(names.get(i));
 }

Implementing the ArrayList in Java

implement an arraylist.add() method using nothing but arrays and an array copy method but im having trouble doing it . The specification of the method is that the method inserts an element at a specified position and shifts any of the elements currently in the position to the right and add one to the indices expanding the size of the array by one so all elements fit . Someone please help . 
    private Object [] list;
    final int maxObjects = 100;
    public ListOfObjects()
    {
        list= new Object[maxObjects];
    }
    public ListOfObjects(Object[]o)
    {
        list= o;
    }
    public void add(Object element,int index)
    {
        Object[] newData = new Object[list.length+1];
        for(int i =0; i < index; i++)
        {
            newData[i] = list[i];
            newData[list] = element;
        }
        for(int i = index; i < list.length; i++)
        {
     newData[i+1] = list[i];
        }
    }
3a:Tabe,

Advanced Java Sample Resume

223E Concord Street, Orlando, Florida. (258) 123 456. adlley@gmail.com.

Professional Experience :

Technical Strengths :

Academic Qualifications :   

Professional Experience :

Roles and Responsibilities :

Accomplishments :

Advanced Java Sample Resume Tips For Better Resume :

Download Advanced JAVA Sample Resume (PDF) Here : Advanced JAVA Sample Resume

3b:T216e,

4 Types of Event handling

Action

  1. The method name must be the same as the method which we have specified in the method expression along with the action attribute
  2. Managed bean method must not have any parameters
  3. Managed bean method must have a string return type and it must return a string value.

Action Listener

    1. Managed bean method name must be matched with the method name which we specified in method expression along with action listener attribute
    2. managed bean method must have ”action event” type as parameter
    3. Managed bean method must have ”void” return type & it must not return any value

<h:command button> and<h:command link>

  Screenshot_22  

<h:command Link value =”address details” action Listener =”#<empBean.displayAddressDetails}>”/>  

Value change listener

<h:select many check box>    

<h:select one menu>

<h:select boolean check box>                  

<h:select many menu>

<h:select one radio>

<h:select many list box>

<h:select one list box>

  Screenshot_23  

Phase Listener

In JSF based web appl n it we send a request from client to server then faces servlet will process the request by following request processing life cycle. àIn JSF request processing life cycle includes the phases like restore view, apply Request values, process validations update model values, invoke application  and render response 2In JSF based we apps the main purpose of phase listener is to read each & every phase in JSP request process in life cycle and gives notification before and after the at each and every phase 2If we want to use phase listener in JSF based web appl n we have to follow below steps  

Step-1 Prepare phase listener implementation class

To prepare phase listener class we have to take on user defined class which must implement class to javax.faces event. Phase listener and implement all the methods of phase listener interface. àJavax. Faces. Event. Phase listener interface has the following methods

  1. Public void before phase(phase event pe)
  2. Public void after phase(phase event pe)

2Where before phase() will be executed just before starting each and every phase 2Where after phase() will be executed just after completing each and every phase 2Where get phase Id() will return current  phase Id value. Eg: Public class myphaseListener implements phase listener  

Step-2 - Configure phase listener implementation class in faces- config.xml

The main intention to configure phase listener implementation class in faces- config.xml file is  to give an interaction to faces servlet which class is having implementation for phase listener interface, in order to execute at each and every phase 2To configure phase listener implementation class in faces- config.xml file, we have to use the following lode <faces-config> <life cycle> <phase- listener>fully qualified listeners</phase- listener> </life cycle> </life config> [for example application on event handling refer hand out provide on 21st nov 2013]

Screenshot_24    

3c:T26b1,

Layouts in JSF- Tiles JSF- Tiles Integration: In case of web applications we have to provide very good user interface to improve look and feel To improve look & feel for the web application we have to organize all the web pages in a standardization manner. 2To organize web pages in a standard approach, we have to use layout mechanisms in web applications. 2To provide layout mechanisms in web application we have to use a separate frame work like tiles f/w provided by apache 2Tiles F/W is a commonly used f/w in almost all the web f/w like struts1, struts2,JSF,Spring.. 2If we want to use tiles F/w in JSF based web appl ns then we have to use the following steps   Step-1 Get all the files F/W Specific jar files in web app lib folder 2Commons- beanutils-1.6 2Commons- collections-3.2 2Commons- digester-1.8 2Commons- loggings-1.0.4 2Commons- struts   Step-2 Configure tiles servlef in web. Xml file The main requirement to Configure tiles servlet in web. Xml file is to load all the files definitions at the time at loading web application i.e at the time of web application  deployment i.e at the time at server start up àIn files servlet configuration we have to provide” definitions-config” initialization parameter with the names and location of files configuration file i.e files-dfts.xml file   Web.xml < web-app > < servlet > < servlet-name> faces servlet</ servlet-name> < servlet-class> javax. Faces. Web app. Faces servlef </ > <add-on-startup>1</ > < /servlet > < servlet > < servlet name> titles servlet</ > < servlet-class> org.apach.struts tiles servlet</ > <init-Param> < param-name >definitions-config</ > < param-value >/web-inf/tiles-dets.xml</ > </init-param> <load-on-startup>2</ > < servlet-mapping> < servlet name> faces servlet</> <url-pattern>*.add</> < /web-app >

  Step-3 Prepare layout page The main purpose to prepare layout page is to define a particular template in order to organize all the web pages

  Screenshot_25    

<tiles: insert attribute=”logical- name” flush=”false”/>

</f:Subview>

  Layout.JSP <%@taglib prefix=”f”url=”http://java.sun.com/JSF / cone%> <%@taglib prefix=”files”url=”WEB-INIF/Struts-files.ltd”%> <html> <body > <center > <table height =”100%”width=”100%”> <tr height =”20%”> <td calspan =”2”align=”center” bg color=”maroon”> </f:subview id=”header”> <files: insert attribute=”HEADER”flush=”false”/ > </f:subiview > </td> </tr> <tr height =”70%”> <td width =”20%”bg color=”light blue”> <f:subiview id=”menu” > <files: insert attribute=” menu ”flush=”false”/ > </f:subiview ></td> <td bg color=”light yellow”> </f:subiview id =”body”> <files: insert attribute=” BODY ”flush=”false”/ > </f:subiview > </td></tr> <tr height =”10%”> <td colspan=”2” bg color=”blue”> </f:subiview id =”footer”> <files: insert attribute=” FOOTER ”flush=”false”/ > </f:subiview > </td></tr> </table> </html>   Step-4 Prepare Tiles JSP page In JSF-Tiles applications, each and every JSP Page is treated as a file, we can prepare only no. of JSP pages as per the applicationn requirement like header. JSP, footer.JSP, Log inform. JSP--   Step-5 Prepare Tiles Configuration file The main purpose of files configuration file is to provide as the file def ns which we are going to use in web appl ns

<files-definitions> < definitions name=”--”page=”/--”> < put name=”--”value=”/--”> </definition> <definition name=”--”extends=”/--”> < put name=”--”value=”/--”> </definition> </files-definitions>

  Step-6 In clued tiles defines into JSP Pages To include files defines into a JSP Page, we have to use the following tag from this tag library. <files: insert definition=”--”flush=”false”/> Where ”definition” attribute will take logical names of the def n available in files configurations file Extract struts.jar2 meta-INF2tlds(get struts – files led) and kee in WEB. INF Folder)  

RICH Faces

  1. RICH Faces is an advanced UI Component f/w for easily integrating Ajax capabilities into JSF Application?
  2. RICH Faces is designed on the basis of Ajax, it will improve the other areas of JSF like component Development, performance,..
  3. Rich faces are available in 2 component libraries Ajax controllers Rich faces components
  4. To get the above two libraries in xhtml pages are in JSP Pages, we have to use the following user are name spaces.

Ajax: http://rich faces. Org/arj Rich faceshttp://rich faces. Org/rich

  1. Required jars

Commons-beanu fils-1.7.0 jar Commons-collections-3.1 jar Commons-digestere-1.8 jar Commons-e1-1. 0 jar Commons-email-1. 0 jar Commons-file upload-1. 0 jar Commons-lang-2.1 jar Commons-logging-1.0.4 jar Commons-calidator-1.3.1 jar CSS Parser.0.9.5 jar Lightlight-1.0. jar Jste-1.0. jar Rich faces-components-api-4.3.4. final.jar Rich faces-components-ui-4.3.4. final.jar Rich faces-core-api-4.3.4. final.jar Rich faces-core-api-4.3.4. final.jar Sac-1.3.jar Ojb bc6.jar      

3d:T1733,

JSF Basic GUI Components

  In JSF based web appl ns we will use the following components to prepare user interface <h: input text>2text field <h: input secrete>2password field <h: select many check box>2group of check boxes <h: select  Boolean check box>2single check box <h: select  many list box>2list box with multiple selections <h: select  one list box>2list box with single. Selection <h: select  many menu>2select  box with multiple selection <h: select  one menu>2select  box with single selection <h: select  one radio>2group of radio buttons with single  selection <h:text area>àtext area <h:command button>2button, submit button, reset button <h:command link<> 2There are two ways to provide values to the GUI Components like check boxes, radio buttons, list boxes, select boxes.

  1. Static values
  2. Dynamic values

<h: select many check box id=”sequel” value=”#{student bean. sequal}”> <f: select item item label=”BSC”item value=”BSC”/> =”MCA” =”MCA”/> <h: select many check box>

Private list<string>sequel; Set()— Get()—

<h: select many check box id=”squeal” value=”#{student bean. Squeal}”> <f:select items value=”#”{student bean. qual}”> </h:select many check box>

Public class student bean{ Private static array list<select item>qual; Private list<string> squals; Static { Select item item1=new select item(“BSC”,”BSC”); (“MCA”,”MCA”); (“PHD”,”PH”); Qual=new array list<select item>(); Qual.and(item1); (item2); (item3); } Public Arraylist<select item>getqual(){ Return qual; } Set qual(){---} Set qual(){---}   Data table2 This GUI Component can be used to display data Syntax2 <h: data table value=”--”var=”--”style class=”--”header class=”--” row classes=”--”column classes=”--”> <h:column> <f:facet name=”--”>value</f:facet> </h:column> ------   </h: data table >

     

3e:T1942,

CONVERTERS

In ISF frame work the main purpose of converters is to convert the data from one to another type and from one format to another format

  1. <f:convert number>
  2. <f:convert date time>

  <f:convert number> This log or converter is used to convert a number from one format to another format Syntax <f:convertnumber type=””mininteger digits=”--” max integer digits=”--” minFraction digits=”--” max function digits=”--”currency symbol=”--”> Type  It will take number type like number or currency   Mininteger Digits  It will take a number representing minimum number of integer digits   Max integer digits  It will take a number representing maxm number of integer digits   Minfaction digits  It will take a number representing minimum number of fraction digits   Max faction digits  It will take a number representing mamm number of fraction digits   Currency symbol  It will take Currency symbol like$

  <f:convert date time> This tag or converter can be used to convert date from one format to another format Syntax <f:convert date time type=”--”pattern=”--” Data style=”--”time style=”--”/> Type  It will take date type like date are time or both Pattern  It will take a particular Pattern to allow  date or time Data style It will take the value like short, medium, long full, default.   

Custom converters

If the application requirement is not achieved with predefined converters then JSF has provided an environment to provide user defined converters called as custom converters

  1. Public object get as object(faces context fc. UI Component string val)
  2. Public string getns string(faces context fc,UI Component uc string val)

Public class my converter impotents  converter{ Public object get as object(faces context fc, UI Component uc, string val) { Dss } Public string get as string(faces context fc, UI Component uc object var) { Dss } } : In ISF frame work the main purpose of converters is to convert the data from one to another type and from one format to another format

  1. <f:convert number>
  2. <f:convert date time>
  3.  

<f:convert number> This log or converter is used to convert a number from one format to another format Syntax <f:convertnumber type=””mininteger digits=”--” max integer digits=”--” minFraction digits=”--” max function digits=”--”currency symbol=”--”> Type  It will take number type like number or currency Mininteger Digits  It will take a number representing minimum number of integer digits Max integer digits  It will take a number representing maxm number of integer digits Minfaction digits  It will take a number representing minimum number of fraction digits Max faction digits  It will take a number representing mamm number of fraction digits Currency symbol  It will take Currency symbol like$

<f:convert date time> This tag or converter can be used to convert date from one format to another format Syntax <f:convert date time type=”--”pattern=”--” Data style=”--”time style=”--”/> Type  It will take date type like date are time or both Pattern  It will take a particular Pattern to allow  date or time Data style  It will take the value like short, medium, long full, default.     

Custom converters

If the application requirement is not achieved with predefined converters then JSF has provided an environment to provide user defined converters called as custom converters

  1. Public object get as object(faces context fc. UI Component string val)
  2. Public string getns string(faces context fc,UI Component uc string val)

Public class my converter impotents  converter{ Public object get as object(faces context fc, UI Component uc, string val) { Dss } Public string get as string(faces context fc, UI Component uc object var) { Dss } }

3f:T1798,

ABC.PROPERTIES Sid= student id Sname-student name Saddr-student address Semail-student email Smobile-student mobile Button=add student Javax.faces. validator.  Regexvalidator. Not.matched- detail Value must be provided in “{o}” format Sid-validation-msg=student id must be started with dss   Index.html <html> <head> <meta http-equal=”Refresh” context=”2; url=http://local host:1010/ Jsf2validations app/student add form.dss”> <head> <body> <h1>Application is loading </h1> </body> </html>   Student add form.jsp <%@laglib prefix=”f”url= <%@                            ”h” <html> <f:view> <h1>soft pvt ltd</h1> <h2>student add form</h2> <h:form> <h:panel Grid columns=”3” > <h:output text value=”#{msg.sid}”/> <h: input text id=”sid” value =”#. { student bean.sid}” Required=”true” required message=student IN is required”> <f:validator validator In=”sid validator”/> </h: input text> <h:message for=”sid”/> <h:output text value=”#{msg. sname}”/> <h: input text id=”s name” value =”#. { student bean. name }” Required=”true” required message=student name is required”> </h:input text> <h:message for=”sname”/> <h:output text value=”#{msg. saddr}”/> <h: input text id=”s addr” value =”#. { student bean. naddr }” Required=”true” required message=”student address is required”> <h: message for=”saddr”/> <h:output text value=”#{msg. semail}”/> <h: input text id=”s email” value =”#. { student bean. semail }” Required=”true” required message=”student email is required”> <h: message for=”semail”/> <h:output text value=”#{msg. s mobile}”/> <h: input text id=”s mobile” value =”#. { student bean. S mobile }” Required=”true” required message=”student mobile required”> <f:validate Ragex pattern=”/d{2}-/d{10}$”/> </h:input text> <h: message for=”smobile”/> <h:command button value=”#{msg. button}”action=#{student bean. add}”/> </h:panel Grid> </h:form> </f:view> </body> </html>   Success.jsp <%@laglib prefix=”f”prefix=”h” <html> <body> <f:view><h1>student Registration success</h1></fiview> </body> </html>   Studentbean.java Package com. soft; Public class student bean{ Private string sid; Private string sname; Private string saddres; Private string semail; Private string smobile; Private string saddres; //provide setter()&getter() Public string add(){ Return”success”; } }   SIDVALIDATOR.JAVA Package com.durgasoft; Import java.util.x; Import java. faces. application. applicaiton; Import java. faces. application. facesnessage; Import java. faces. Component.uicomponent; Import java. faces. Context.faces context; Import java. faces. Validator, validator; Import java. faces. Validator, validator exception; Public class SID validator implements validator{ Public Void validate(faces context tc,UI Component ue,object val) Throws validate exception{ String sid=(string)val; If(!sid.strtswith(DSS-“)){ Faces message fm=new faces message(); Application application=fc.get application(); String prop-path=application. Get message bundle(); Resource bundle rb=resource bundle. get bundle(prop-path); Strubg err-msg=rb.get string(“sid-validation-msg”); Fm.set detail.(err-msg); Throw new validate exception (fm); } }   Faces-config.xml <faces-config….. -----xsd> <managed-bean> <managed-bean-name>student bean</managed-bean-name> <managed-bean-scope>session</> <managed-bean> <navigation rule > <from-view-id>/student add from.jsp</  > <navigation case > <from-outcome>success</    > <to-view-id>/success.jsp</    > </navigation case > </navigation rule> <validator> <validator-id>sid validator</   > <validator-class>com. soft.SID Validator</   > </validator> <application> <resource-bundle> <base-name>abc</  > <var>msg</  > </resource-bundle> <message- bundle >abc</message- bundle > </application > </faces-config > Web.xml       Step2 -  Configure user- defined converter class in faces – config.xml file <faces- config> --------- <Converter> <converter -id>converter logical name</  > <converter-class>fully qualified converter class</  > </converter> ----- </faces-config>    Step-3 Use. User- defined converter in both i/p and o/p UI Component To use converter in i/p and o/p UI Components wl have to use the following tag <f:converter conver ID=”--”/> Where “converter Id” attribute will take logical name of the converter class which we provided in [for example appl n on JSF data table, GUI Components & converters refer hand out given o n16 th Nov 2013]    

40:T19dc,

Frame work

As [art of enterprise application development, it is very common and frequent to use the service like 118 n, validations, exception handling, conversions, tag libraries,

Def 1 - Frame work is a per –fabricated s/w components that developers can reuse , share and customize in order to simplify enterprise application development Def 2 - Frame work is semi implemented application , it will  env. To design enterprise application in simplified manner Def 3 - Frame work is a collection of tools and API, which will simplify the enterprise application development. In  enterprise application development, frame work will provide the following advantages

  1. Able to provide he generic services like validations, 118N, Exception handling—predefined
  2. Able to reduce development type
  3. Able to reduce development cost
  4. Able to improve productivity
  5. Able to provide standard flow at execution

2There are 2 types of frame works

  1. Web frame works
  2. Application frame works

  Q) What is the diff. bet n web frame works and application frame works A) Web frame works will provide very good to design and executed only web appl n. Ex  Struts, JSF, XULONK 2 and so on Application frame works will provide very good env to design and execute any type at JAVA/J2EE Application Ex Spring frame works   Q) What are the difference bet n struct and JSF? A) 1)  Both struts and JSF are based web application frame works, where  struts is controller layered frame works but JSF is view layered frame works 2) Struts f/w is very good in the area at data validations Exception handling and layout mechanism, but JSF is not good in these areas. 3) Event handling is very good in JSF F/W but which is not available in struts f/w Note - To get even handling in struts based web application we have to use either java script are Ajax explicitly. 4) JSF Is able to have both client side user interface and server side user interface, but struts, is able to have only client side UI Note - JSF Is able to create a component tree w.r.to the user forms[view j at servers side to represent each and every GUI component available in the respective from. Here component tree is treated as server side user inter face 5) In struts f/w all the GUI Components are state but in JSF F/W all the GUI Components are stateful 6) Component tag library is no good in struts f/w but component tag library is very good in JSF frame works 7) Response Rendering mechanisms are very good in case at JSF. but which are not available in struts frame works 8) Data Conversions are not good in struts f/w, but which are very good in JSF F/W Note - In JSF F/W it  is possible to perform customization over data conversions.     Q) What are the differences bet n spring f/w and JSF f/w? A   1) Spring f/w is an application f/w, it will provide environment to design and execute any type at Java/j2 EE Applications but JSF f/w will provide exe. To design and execute only web applications. 2) In spring f/w only web module is following MVC design pattern, but, JSF frame works is following MVC design pattern completely. 3) Component tag library is not good n spring f/w but  which is very good in JSF f/w 4) Spring f/w has provided inbuilt support to integrate explicit applications like JDBC, Hibernet, EJBs,….But JSF is not providing inbuilt support to integrate the specified explicit application   JSF

  1. Home
  1. Type
  2. Objective
  3. Open/licensed
  4. Initial version
  5. Used version
  6. Latest version
  7. Code supported
  8. Designed plat form

  Q) JSF, IS Technology or frame work? A: JSF 1.0, JSF1.1 version are f/w s, They are not the part of J2EE Technologies. * JSF 1.2 version on wards it was included in J2EE Technologies. *JSF 1.0 AND JSF1.1 are frame work but JSF 1.2 and JSF 2.x are Technologies Java EE5 2 JSF 1.2… Java EE6 2 JSF 2.x …

1.SUN RI(Reference implementation)(by sun) 2.My Faces (by Apache)

  1. Prime Faces
  2. Rich Faces
  3. ICE Faces

  JSF Services

  1. I 18 N
  2. Validations
  3. Convertors
  4. Event Handling
  5. Rend kit
  6. Components tag library

       

41:T37f1,

 Faces servlet 

In general in MVC based web appl? The mole of the controller is

  1. Pick of the request from client
  2. Identify model component
  3. Perform model component loading instantiation data population
  4. Access application logic
  5. Identify target view page
  6. Forward request to target view page

Screenshot_9

 

Above diagram

  1. Restore view
  2. Apply request values
  1. Update model
  2. Invoke application
  3. Render response

  I) Restore view

  1. This phase will check whether the current request is fore any resource or action. If the current request is for any resource then faces servlet will identify the requested resource and by pass the flow of execution directly or render response phase
  2.  IF the present request is for any particular action then faces servlet will perform the following actions

i)Faces servlet will check any ”component free” is existed the present request or not, if any component free is existed then faces servlet will retrieve it ii)It  no component tree is existed w.r.to the present request then Faces servlet has to create new component tree. While preparing component tree Faces servlet will perform the following action

  1. Faces servlet will create a root node for <f:view> tag in component tree and child nodes for each and every JSF component Which are available in the respective page
  2. Faces servlet will store view id value in “UIVIEW ROOT” Object which is compiling along with request.
  3. Faces servlet will store all the  incoming ”locate” provided by client browser in “UIVIEW ROOT” node.
  4. if any Validator are configured for UI Components in page then faces servlet will register all the Validator to the components in component tree.
  5. If any converters are configured for UI Component in page then faces servlet will register all the converters to the components in component tree.
  6. It any listeners are configured fore UI Components in page then faces servlet will register all the listeners to component in component tree.
  7. Faces servlet will identify respective model component or Bean component w.r.to the present request through Faces- config.xml file and perform bean loading and instantiation at the time of bean instantiation default values or any initial values will be stored in bean properties these initial values will be set to the respective components in component tree.
  8. After preparing component tree, Faces servlet will store other component tree in faces context object and Http Session Object

 

  1. Apply Request values

 

  1. Process Validator
  1. In this phase, faces servlet will perform the following actions:
  2. Faces servlet will search fore registered Validator at each and every component in component tree
  3. If any Validator is identified at component then faces servlet will execute all the Validator
  4. It any validation error messages are available then it will add validation error messages to “Faces context” object.
  5. faces servlet will search for the registered convectors at each and every component in component tree
  6. It any convertor is identified then faces servlet will execute that convertors
  7. If any conversion errors are identified then faces servlet will check any error message is available in faces context object,
  8. It any error message is identified then faces servlet will bypass request to “Render Response” phase directly
  9. It no error message is identified in faces context object then faces servlet will bypass request to the next phase id “update model” To perform process Validator phase, faces servlet will execute the following method from UI view root class Public void process Validator()

 

  1. Update model:

In apply request values phase, all the request parameter values we were set to the components which are available in component tree

 

  1. INVOKE APPLICATION

In this phase, faces servlet will perform the following actions.

  1. Faces servlet will get the registered method name from the components like button, hyperlink, check box, radio button,…from component tree.
  2. Faces servlet will execute the respective method in the respective managed bean component.
  3.  If no return value is identified from managed bean component method then faces servlet will bypass request to “Render Response” phase to maintain the same page at client browser.
  4. It any return value is identified from the respective managed Bean component method then faces servlet will identify the target view page from faces – config. Xml file and by pass request to “Render Response” phase to generate response

Public void process application()  

  1. Render Response phase 

In this phase, Faces servlet will convert the respective component tree into the equivalent html or xml or wml and etc formations in order to send response to client browser in html or xml or WML,…formats

  4.Model Component In MVC based web applications, the main purpose at model component is,

  1. To manage application B. logic
  2. To manage users from data in order to perform data validations and conversions,
  3. To manage users from data in order to perform the database operations like insert, update, retrieve,….
  4. To transferee the data from controller layer to view later.

In JSF web applications, Managed bean component is acting as model To prepare managed bean component in JSF based web applications, we have to use the following guide lines

  1. In JSF, Managed bean component should be a POJO class, it should not be extended or implemented from any predefined library.
  2. In JSF based applications, Managed bean class must be public, non abstract and no final
  3. All the properties in managed bean class must match the properties name which we defined along with UI Components in user forms
  4. We must provide set..()methods and getter..() methods for each and every bean property
  5. We have to declare business methods which are registered with the GUI Components like buttons, hyperlinks,…
  6. If we want to provide any construction in managed Bean class then that construct fore must be “Public” and “O-argument”.
  7. Define application logic by declaring business methods

  Ex Public class Login bean { Private string u name; Private string u pwd; Public void set u name(string u name) { This. U name = u name; } Public void set upwd(String upwd) { This. Upwd= upwd; } Public string get u name() { Return u name; } Public string get u pwd() { Return u pwd; } Public string log in() { --- logx--- Return “Success”; } }   Faces configuration File The main purpose of  faces configuration file is to provide the following con fig  details request red by faces servlet.

  1. Bean component configuration
  2. Navigation Rules
  3. Validators
  4. Convertors
  5. Listeners
  6. Local configuration.

The default name and location of faces configuration file is “Faces config.xml” file under WEB.INF folder

CONFIG –FILE <Web - app> <Context. parm> <Param.name>Javax. faces. CONFIG.FILE</paran-bane> <Param. Value>/WEB- INF/classes /my config.xml <Context param ---- <\web.app>

  2faces-config> ----- <managed- bean> <managed- bean-name> bean logical name</managed-bean- name> <managed- bean-class> bean fully qualified name  </managed-bean- class > <managed- bean-score>session/application </managed-bean- scope > </managed-bean > <navigation mull> <from-view-id>/form page</from-view-id> <navigation – case> <from- out come> return value from bean method</from – out come> <to- view- id>/ to page </to-view. id> <\navigation-case> --- <\navigation-mule> --- </faces-config>  

42:T15c2,

Screenshot_21     Abc. Properties Sid=student Id Sname=student name Saddre=student address Semail=student email Smobilel=student mobile Button=add student Javax. faces. validator. Regix validator. NOT.MATCHED-Detail= value must be provided in “{0}”format Sid-validation-msg=student id must be started with Dss   Index.html <html> <head> <meta http-equiv=”Refresh” context=”2;Ural=http://local host:1010/Jsf2 validations app/student add form .dss”> </head> <body> <h1>application is loading</h1> </ body > </html>   Student add form.jsp <%@loglib prefix= ”f”url= <%@                            ”h” <html> </f:view> <h1> soft pvt ltd</h1> <h2>student add form</h2> <h:form> <h:panel Grid column=”3”> <h:output text value=”#{msg.sid}”/> <h:input text id=”sid” value=”#{student Bean.sid}” required=”true ” required message= student IN is required”> <f:validator validator Id=”sid validator”/> </h:input text> <h: message for=”sid”/> <h:output text value=”#{msg. sname}”/> <h:input text id=”sname” value=”#{student Bean.name}” required=”true ” required message= “student name is required”> </h:input text> <h: message for=”s name”/> <h:output text value=”#{msg. saddr}”/> <h:input text id=”saddr” value=”#{student Bean. saddr }” required=”true ” required message= “student address is required”> <h: message for=”saddr”/> <h:output text value=”#{msg. semail}”/> <h:input text id=”semail” value=”#{student Bean. semail }” required=”true ” required message= “student email is required”> </h:input text> <h: message for=”semail”/> <h:output text value=”#{msg. smobile}”/> <h:input text id=”smobile” value=”#{student Bean. smobile}” required=”true ” required message= “student mobile is required”> <f:validate range xpattern=”/d{2}-/d{10}$”/> </h:input text> <h: message for=”smobile”/> <h: command button value=”#{msg. button}”action=”#{student bean. add }”/> </h:parel Grid> </h:from> </f:view> </ body > </html>   Success.JSP <%@Loglib prefix=”f” prefix=”h” <html> </body > </f:view><h1 >student registration success</h1 ></fiview > </body > </html> <body > <f:view> <h1>Registration success</h1> </f:view> </body > </html>   Registration bean.java Package com. durga soft Public class Regiatration bean{ Private strin eid; Private strin ename; Private strin eaddre; Private strin eemail; Private strin emobile; //provide setter()&getter() Public string registration(){ Return ”success”; }   Email validator.java Package com. soft; Import java. Util. iterator; Import java. Util. resource bundle; Import java. Faces. application. application; Import java. Faces. application. application message; Import java. Faces. component. UI Component; Import java. Faces. content. faces context; Import java. Faces. validator. validator; Import java. Faces. validator. Validator exception; Public class email validate implements validate{ Public void validator(faces context)fe, UI Component we, object value)throws  validator exception{ String email=(string)value; If(email. contains(“@”)){ Application application=fe.get application(); String prp-file=application .get message bundle(); Resource bundle bundle=resource bundle. get bundle(pre-file); String err-msg=bundle. Get string(“email- validator”); Faces message fm= new faces message(); Fm.set detail(err-msg); Throw new validator exception(fm); } } }   Faces-config.xml <Faces-config> ----- ----XSD <managed. bean> <managed. Bean-name>studentBean</managed. Bean-name> <managed. Bean-class>com. soft. registration bean <managed. Bean-scope>session</     > </managed. Bean> <navigation-rule> <from-view- id>/employee from.jsp</> <navigation-case> <from-outcome >success </ > <to-view-id>/success.jsp</ > </navigation-rule> <validator> < validator -id>email-validator</  > <validator-class>com.soft.SIDValidator</> </validator> <application> <resource-bundle> <base-name>abc</b> <var>msg<var> </resource-bundle> <message-bundle>abc</ message-bundle> </application> </faces-config>    

43:T2a55,

In  general, in JSF based web applications, it we submit a form data to server then container will take from data request parameters data and store in request object, where faces context will take from data from request object and store in component tree as part at “Apply request values” life cycle phase. After getting form data in component tree, faces servlet will store form data from component tree to model object as part of “update model” life cycle phase after getting data in managed bean object, we will use form data in application logic as part of “Invoke application” life cycle phase.

  1. At client side
  2. At server side

 

Client side data validations

If we check data validity just before submitting form to server then it is called as client side data validations.

  1. Client side data validations are not suggestible in web application, because, then data validations ”java.script” function at client browser then data validations will not be executed.
  2. At client side data validations, data will be interpreted at the same client machine, so that, client side data validations will provide less security for the data

To overcome the above problems, we have to go for server side data validations  

  1. Server side data validations

It we check data validity after strong data in component tree and just before passing data to managed bean object then it is called as server side data validations.

  1. Standard validations
  2. Custom validations

 

  1. Standard validations

Standard data validations are the data validations provided by ISF frame work predefinetly

  1. Required
  2. Length validations
  3. Long range validations
  4. Double Range validations

  Required It is an attribute at each and every input component to check weather data is available or not

  NOTE In JSF all the predefined Validator are having their own predefined message provided by JSF at the following location Extract JSF-api.jaràJavaxàfacesàmessage.properties

Javax. faces. component. UI Input. Required ={o}; validations   Error  value is required

  1. <h:message>
  2. <h:message>

Where<h:message> is used to display a validation message with respect to a particular field <h:message for=”component Id value”/> Eg  <h:message for=”uname”/> Where<h:message>tag can be used to display all the validations messages of the respective fields which are available in the current page. e.g  <h:output text value=”user name”/> <h:input text id=”u name ”value=”reg bean. U name” required=”true”/> <h:message for=”u name”/>   Validate Length

Where minimum attribute will take min length value and maximum attribute will take max length value

Javax. faces. Validator, length Validator, minimum={1}:validation error value is less than allowable minimum of”{0}”

Javax. faces. Validator. Length Validator. maximum=”{1}”: validation error. Value is greater than allowable maximum of “{0}” where{1}will take component name like uname upwd where{0} will take attribute values like ”minimum” and “maximum” on the basis of the validation msg     Eg <h:output te:1 value=”password”/> <h:input text id=”upwd” value=#{reg bean. upwd}/required=”true”> <f:validate length minimum=”6”maximum=”15”/> </h:input text> <h:message for=”upwd”/>   validate long range This Validator can be used to check wheat here the data or on input field is long data or not and the value is available in the specified range or not. Case1  If the provide value is not long data type then this Validator will display the following validation message javax. faces. Validator. lang range Validator. Type={0}; validation error: value is not at correct type Case2  If the provide value is not long data, it we provides only “minimum” attribute without “maximum” attribute and it the provided value in the input field is less than the specified “minimum” attribute value then this Validator will display the following validation message Javax. faces. Validator. Lang range Validator. Minimum= {1}: validation error: value is greater than allowable minimum of”{0}” Case3  It the provided data is long data, it we provide only ”maximum” attribute in<f:validate long range> Validator and if the provided value in input field is greater than ’maximum’ attribute then this Validator will display the following validation message. Javax. faces. validate. Lang range Validator. Maximum={1}; validation error: value is greater than allowable maximum of “{0}” Case4  It the provided value is lang data, it we provided both “minimum” and “maximum” attribute in <f:validate lang range>valid after and if the provided value in put field is less than the provided “minimum” attribute value are greater than the “maximum” attribute value then this Validator will display the following message. Javax.faces. validatore. Long range validatore. Not- in- range ={2}; validation error: specified attribute is not bet n the expected values of {0} and{1} Eg <h:output text value=”user age”/> <h:input text id=”age” value=”#{reg bean. uage}” required=”true”> <f:validate lang range minimum=”18”maximum=”30”> </h: input text > <h: message for=”uage” >    Validate double range This Validator can be used to check whether the data on an input field is double or not and the provided value is a variables within the specified range or not <f:validate double range minimum=”--”maximum=”--”> Where ”minimum” and ”maximum” attributes can be used to provided minimum and maximum values. Case1 If the provided data on the respective  field is not double data then this Validator will display the following error msg. Javax. faces. Validator. double range Validator. type={0}:validation error: value is not of the correct type. Case2 It the provided data is double data, It we provide only ”minimum” attribute without “maximum” attribute In<f:validator double range>Validator and it the provided value is less than the specified minimum value then this validator will display the following validation msg Javax.faces. validator, double range Validator MINIMUM{1}:validation error:value is less then allowable minimum of “{0}”  Case3 It the provided data is double data, It we provide only     ” maximum” attribute without “minimum ” attribute In<f:validator double range>Validator and it the provided value is greater than the specified maxim value then this validator will display this validation msg Javax. faces. Validator, double range Validator maximum{1}:validation error: value is greater than allowable maximum of “{1}”validation error: value is greater than allowable maximum of “{1}” Case4 It we provided data is double data, It we provide both attributes In<f:validator double range>validator and it the provided value is less than the specified min value or greater than validation msg. Javax. faces. validatore, double range validator  NOT-IN RANGE {2}:validation error: Specified attribute is not bet n the expected values of{0}&{1}   Eg <h:output text value=”user salary”/> <h:input text id=”usal” value=#{reg Bean. usal}”required=”true> <f:validator double range minimum=”2500”maximum=”50000”/> </h:input text> <h:message fore=”usal”/>  

44:T5ed,

steps to provide I18N Support in JSF Application  

To prepare properties files, we have to use the following naming convections for the properties file <base-name>-<long>.properties In the properties files, we have to provide locale respective messages in the form of key-value pairs, where keys should be in English and values should be in locale language EX: abe-en. properties:- Income = user name Upwd= password   abc-it. properties u name- user name Upwd= password

To configure locale and properties files in faces configuration file, we have to use the following tags <faces-config> --- <application> <locale-config> <default-locale>en</default-locale> <supported-locale>it</ supported -locale> </locale-config> <resource-bundle> <base-name>abe</base-name> <var>msg</ var > </resource-bundle> </application> ---------- </faces-config>

  1. Access the message from properties file

To access the messages from properties file, we have to use the following <hi output text>gag <h:output text value=”#{msg. uname}”/> <h:output text value=”#{msg. upwd}”/>

45:T3305,

Screenshot_17   

Abc-en-us.properties:

welcome.message=Welcome to the English US version.

Abc-it-IT.properties:

welcome.message=Benvenuti alla versione italiana.

Abc-it-IN.properties:

welcome.message=Benvenuti alla versione indiana.

FORM.HTML:

<html>
  <body>
    <form method="post" action="/i18n">
      <table>
        <tr>
          <td>Select language:</td>
          <td>Select country:</td>
        </tr>
        <tr>
          <td>
            <select name="language">
              <option value="en">English</option>
              <option value="it">Italian</option>
              <option value="hi">Hindi</option>
            </select>
          </td>
          <td>
            <select name="country">
              <option value="us">United States</option>
              <option value="it">Italy</option>
              <option value="in">India</option>
            </select>
          </td>
        </tr>
        <tr>
          <td>
            <input type="submit" value="Submit">
          </td>
        </tr>
      </table>
    </form>
  </body>
</html>

I18NServlet.java:

package com.soft;

import java.io.IOException;
import java.io.PrintWriter;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.util.Date;
import java.util.Locale;
import java.util.ResourceBundle;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/i18n")
public class I18NServlet extends HttpServlet {

  private static final String BUNDLE_NAME = "Abc";
  private static final String WELCOME_MESSAGE_KEY = "welcome.message";
  private static final String HTML_START = "<html><body><h1>";
  private static final String HTML_END = "</h1></body></html>";

  @Override
  protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    try {
      String language = request.getParameter("language");
      String country = request.getParameter("country");
      Locale locale = new Locale(language, country);

      NumberFormat numberFormat = NumberFormat.getInstance(locale);
      DateFormat dateFormat = DateFormat.getDateInstance(DateFormat.DEFAULT, locale);
      ResourceBundle bundle = ResourceBundle.getBundle(BUNDLE_NAME, locale);

      String welcomeMessage = bundle.getString(WELCOME_MESSAGE_KEY);

      PrintWriter out = response.getWriter();
      out.println(HTML_START);
      out.println("Number: " + numberFormat.format(1345.2345) + "<br>");
      out.println("Date: " + dateFormat.format(new Date()) + "<br>");
      out.println("Message: " + welcomeMessage);
      out.println(HTML_END);
    } catch (Exception e) {
      response.sendError(HttpServletResponse.SC_BAD_REQUEST, "Invalid request");
    }
  }
}

Try{ String locate=request. get header(“accept-language”);

String Tokenizer st= new string tokenizer(local, “-”);

Int count= st. count tokens();

Local i=null;

If (count==1){ String long=st.next token();

I=new locale (c lang);

{ If(count==2){ String lang=st. next token();

String country=st. next token();

I=new locale (c lang, country); }

If(count==3){ String lang=st. next token();

String country=st.

next token();

String sys-var=st.

next token();

I=new locale (lang, country), sys-var); }

Number Format

nt=number formal,

get Insurance(l);

  Screenshot_18  

Abc-en. properties

# English language properties file
# Header
Header1 = Durga Software Solutions
Header2 = Registration Form

# Form fields
Sid = Student ID
Sname = Student Name
Semail = Email ID
Smobile = Contact No.

# Button
Button = Register

# Success and failure messages
Success = Student registration successful
Failure = Student registration failed

 Abc-it. Properties

Header1=Durga software solutions Header2=Registration Form Sid=student Id Sname=student Name Semail=email id Smobile=contact no Button=registration Success=student registration success Failure=student registration failure  

Abc-te. Properties

Header1=software solutions
Header2=Darakstu patram
Sid=vidyardu Gurdimpu snkya
Sname=vidyardi peru
Semail=vidyuth samachara Gurthimlu
Smobile=sampradimpu sankya
Button=Darakasthu
Success=Vidyardi Darakastu safalamayinadhi
Failure=Vidyardi Darakastu cifalamayinadhi

Index.html 

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <meta http-equiv="Refresh" content="2;URL=http://localhost:1010/I18napp/registrationform.dss">
        <title>Insert title here</title>
    </head>
    <body>
        <h1>Application is loading…</h1>
    </body>
</html>

Registrationform.JSP

  

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %>
<!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>Insert title here</title>
  </head>
  <body>
    <f:view>
      <h:form>
        <h:panelGrid columns="2">
          <h:outputText value="#{msg.sid}" />
          <h:inputText id="sid" value="#{regBean.sid}" />
          <h:outputText value="#{msg.sname}" />
          <h:inputText id="sname" value="#{regBean.sname}" />
          <h:outputText value="#{msg.semail}" />
          <h:inputText id="semail" value="#{regBean.semail}" />
          <h:outputText value="#{msg.smobile}" />
          <h:inputText id="smobile" value="#{regBean.smobile}" />
          <h:commandButton value="#{msg.button}" action="#{regBean.registration}" />
        </h:panelGrid>
      </h:form>
    </f:view>
  </body>
</html>

Success. Jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1" %>
<%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %>
<!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>Insert title here</title>
   </head>
   <body>
      <f:view>
         <h1><h:outputText value="#{msg.success}" /></h1>
      </f:view>
   </body>
</html>

Failure.jsp

<%@page language="java" contentType="text/html; charset=ISO-8859-1" pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
    <title>Failure Page</title>
</head>
<body>
    <f:view>
        <h1><h:outputText value="#{msg.failure}" /></h1>
    </f:view>
</body>
</html>

Registration Bean.java

package com.soft;

import java.util.Locale;
import javax.faces.component.UIViewRoot;
import javax.faces.context.FacesContext;

public class RegistrationBean {
    private String sid;
    private String sname;
    private String semail;
    private String smobile;

    // getters and setters

    public String registration() {
        String status = "";
        if (sid.startsWith("DSS-")) {
            status = "success";
        } else {
            status = "failure";
        }
        return status;
    }

    public String getRegistrationForm() {
        return "Registration form";
    }
}

Faces-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<Faces-config xmlns="http://Java.sun.com/xml/ns/java" version="1.2">
    <managed-bean>
        <managed-bean-name>regBean</managed-bean-name>
        <managed-bean-class>com.DurgaSoft.RegistrationBean</managed-bean-class>
        <managed-bean-scope>session</managed-bean-scope>
    </managed-bean>
    <navigation-rule>
        <from-view-id>/registrationform.jsp</from-view-id>
        <navigation-case>
            <from-outcome>success</from-outcome>
            <to-view-id>/success.jsp</to-view-id>
        </navigation-case>
        <navigation-case>
            <from-outcome>failure</from-outcome>
            <to-view-id>/failure.jsp</to-view-id>
        </navigation-case>
    </navigation-rule>
    <navigation-rule>
        <from-view-id>/menu.jsp</from-view-id>
        <navigation-case>
            <from-outcome>registration form</from-outcome>
            <to-view-id>/registrationform.jsp</to-view-id>
        </navigation-case>
    </navigation-rule>
    <application>
        <locale-config>
            <default-locale>en</default-locale>
            <supported-locale>it</supported-locale>
            <supported-locale>te</supported-locale>
        </locale-config>
        <resource-bundle>
            <base-name>abc</base-name>
            <var>msg</var>
        </resource-bundle>
    </application>
</Faces-config>

Web.xml

Same as prev. applications.      

46:Tf54,

In java applications, we are able to provide I18N Supported in the form of the following 3 areas.

  1. Number formations
  2. Date formations
  3. Message formations

  1.Number formations

  1. Prepare number format class object

To prepare number format class object, we have to use the following static factory method public static number format get instance(Local l)    2.Format a number w.r.to a local To  format number, we have to use the following method public string format(XXX NUMBER)Where xxx may be byte, short, int, float,… Import java. Text*; Import java. util*; Public class Test { Public static void main(strin[]args) throws exception { Local l=new local(“it”,”It”); Number format nf=number format. Get instance(l); s.o.p(nf.format(12345.234567)); } }  

  1. Date formations

If we want to represent date w.r.to a particular local. We have to use a predefined class java.text. date formal

  1. prepare local object -

Local i= new locale(“en”,”us”);

  1. Create data format object 

To create data format object, we have to use the following static factory method. Public static data format get data insurance (int data- sty, local i)

  1. Format data w.r.t the specified local

To represent data. W.r.t the specified local, public string format(date d) àImport java. text.*; Import java. util.*; Public class test { p.s.v.m() throws exception { Locale l=new locale(“It”,”IT”); Data format dt= Date format. Get date insurance.col); s.o.p(dt. format; new date()))); } }

  1. Message formations

To represent a message w.r.to a particular local we have to use a predefined class provided by java java. util. Resource bundle It we want to use resource bundle in java application  we have to use the following steps

To prepare properties files we have to take a text file and provide locale messages in the from of key- value pairs and we must save properties file with the following naming conversion <base-name>-<long>-<country><sys-var>. prepare files Abc-en-us. Properties Uname= user name Upwd= password

Local I = new locale(“en”,”us”);  

To prepare resource bundle class object we have to  use the following static factory method public static resource bundle[string base – name locale()

To get a message on the basis of a key, we have to use the following method public string get string(string key) Abc-en-us. Properties Welcome=welcome to en us users Abc –it IT Properties Welcome=welcome to it It USERS. Public class test { p.S.V.M()THROWS Exception { Locate I = new locale(“it”,”IT”); Resource bundle rb = resourceBundle. GetBundle(“abc”,i); s.o.p(rb. get string(“welcome”)); } }

47:T283e,

Steps to use Hyperlinks in JSF pages Step1: Prepare hyperlink in JSP or xhtml pages depending on the JSF Version To prepare hyperlink we have to use the following html <h:command link value=”--”action=”--”/> àWhere ”values” attribute will be hyperlink label àWhere ”action” attribute will take JSF expression to refer a managed bean method to execute. Eg - <h:command link value=”login” action=#{log in bean get log in page}”/}   NOTE <h:command link>must be used under<h:form> Step2 -  To prepare action method in managed bean component Prepare a method in managed bean component with string return type and its name must be same as the method name which we specified in action attribute expression in <h:command link>tag Public class log in bean{ Public string get log in page(){ Return ”log in form”; } }    Note - In case of JSF 2.X The return value from action method should be same as the target age name which we want to open in case of annotations. Step3  PREPARE NAVIGATION RULE IN FACES –CONFIGE.XML FILE <Faces-config…}xsd <navigation- rule> <from- view-id>1page where clicked on hyperlink</from – view -d> <navigation- case> <navigation- rule> </faces-config> Note In JSF 2.X,IF we use annotations than this step is not required     Screenshot_16     Login from.jsp <%@tag lib prefix=”f”url=”http://java.sun.com/jsf/core”%> <%@taglib prefix=”h”url=”http://java.sun.com/jsf/html”%> <html> <body> <f:view> <font color=”red”> <h1> software solutions</h1> </h2;Log in page</h2> </font> <h:form> <h:panel Grid column=”2”> <h:ourput text value=”user name”/> <h:in put text id=u name value=”#{log in bean. U name}”/> <h:ourput text value=”password”/> <h:in put text id=u pwd value=”#{log in bean. U pwd}”/> <h: command button value=”log in” action=”#{log in bean. Log in”/> <h3><h: command link value=”registration” Action =”#{ log in bean .get registration page}”/></h3> </h:parel Grid> </h: form></f:view></body></html>   Registration form. JSP - <%@taglib prefix “f” <html> <body> <f:view> <font color=”red”> <h1> soft</h1> <h2> registration page </h2> </font > <h:from> <h:panel Grid column=”2”> <h:output text value=”user name”/> <h: input text id =u name value=”#{reg bean. u name}”/> <h: output text value=”pass word”/> <h:input text id= u pwd value=”#{reg bean, u pewd}”/> <h: ouput text value=”email”/> <h:input text id- u email value=”#{reg bean. uemail}”/> <h:out put text value=”mobile”/> <h: input text id= umoble value=”#{reg bean. U mobile}”/> <h:command button value=”Registration”action =”#{reg bean. registration}”/> </h: panel Grid> </h:form> </f:view> </body> </html>   Success.jsp - <%@ tag lib prefix=”f”--> <html> <body> <f:view> <h:command link value=”login” action=”#{log in bean get log in page}”/> </h:form> </f:view></body></html>   Failure.JSP  <%@ taglib prefix=”f” <html> <body> <f:view> <h1>failure</h1> <h:form> <h:command like value=”registration” action=”#{log in bean. Get registration page}”/> </h:form> </f:view> </body> </html>   Existed.jsp <%@taglib prefix=”f” <html> <body> </f:view> <h1>User already existed</h1> <h:from> <h:command link value=”log in ”action=”#{log in bean. Get language”/> </h: form></f:view></body></html>   Index. Html </html> <head> <meta http-equiv=”Refresh Content=”2;url=http://local host:1010/log in  app/ log in form. dss> </head> <body><h1>Application is Loading</h1> </body> </html>   Log in Bean. Java Package com. soft Import javax. faces. bean. Managed bean; Import javax. faces. bean. sessionscoped; @ Managed bean(name=”log in Bean”) @session scoped Public class log in bean { Private string u name; Private string upwd; //provide getter()& setters() Public string get log in page(){ Return ”log in form”; } Public string get registration page() { Return ”Registration form”; } Public string log in(){ User DAO dao=user dao factory. Get user dao(); String status=dao.check log in ( u name, u pwd); Return status; } }   Registration Bean. Java Package com. soft; Import javax. faces. bean. managed bean; Import javax. faces. bean. Session scoped; @managed Bean (name=”meg Bean”) @Session scoped Public class registration bean{ Private string u name; Private string u pwd; Private string uemail; Private string u mobile; //provide getter()& setter() Public string registration() { User DAO dao=user Dao Factory. get user Dao(); String status=dao. registration (u name. upwd, ue mail, umobile); Return status; } }   User Dao.Java Package com.soft; Public interface user Dao{ Public string check log in(string u name, string u pwd) Public string registration[string u name, String upwd, string uemail, string umobile); }   User Dao Impl.java Package com. soft Import.java. sql. connection; Import .java. sql. Prepared statement Import .java. sql. ResultSet Public class user dao imp/ implements user dao { String status=””; Public storing checkLog in (string uname, string upwd) { Try { Connection con- Connection factory. get Connection(); Prepared statement pst=con.PrepareStatement(“ Select from reg-users where u name=”+u name+”and ResultSet ms=pst.executeQuery(); Boolean b= ms.next(); If(b==true) { Status=”success”; } Else { Status-“failure”; } } Catch(Exception e) {

  1. print stack trace();

} Return status } Public string registration(string uname, string upwd, stromg uemail. String u mobile){ Try{ Connection con- Connection factory. get Connection(); Prepared statement pst=con. prepareStatement (“select*from reg-users where uname=”+u name+”) ResultSet ms=pst. execute query(); Boolean b=ms. next(); If(b==true){ Status=”existed”; } Else{ Pst=con. prepared statement (“insert into reg-users values(????)”); Pst. string(1,uname); Pst. string(2,upwd); Pst. string(3,uemail); Pst. string(4,umobile); Pst. execute(); Status=”success”; } } Catch(Exception e){ Status=”failure”;

  1. print stack trace()

} Return statue; } }   User Dao Factory. Java Package com. soft; Public class user Dao Factory{ Static user Dao dao; Static{ Dao= new userDaoimpl(); } Public static user Dao get user Dao(){ Return dao; } }   Connection factory. Java Package com. soft Import Java.Sql.*; Public class Connection factory { Static Connection; Static{ Try{ Class.for Name(“oracle jdbc. oracle driver”); Con= driver manager. Get Connection(“jdbc. Oracle: thin:@local host:1521: “scoh”,”tiger”); } Catch (Exception c){

  1. print stack trace();

} } Public static Connection getConnection(){ Return con; } }   Web.xml SQN as Designing Java applications w.r.t the users notive Connection  is called as II8N

 

  1. Language

It will be represented in the form of two lower case letters Ex: ”en”,” hi”,” te”,….  

  1. Country

It will be represented in the form at two upper case letters Ex;”us”,” IN”,”IT”,….  

  1. Operating system[system variant]

It will be represented in the form of three lower case letters Ex: ”win”,” lin”,” uni”,….

Public local(String lang) Public local(String lang, String country) Public local(String lang, String country String sys-var)   Ex Local I= New local(“en”); Local I= New local(“en”,” us”); Local I= New local(“en”,”s”,”wub”);                                

48:T133e,

There are 2 types of enterprise application

  1. Web application
  2. Distributed applications

    1) What are the differences between web applications and distributed applications? A: Web applications are the server side applications, which will be designed without distributing application logic over more than one JVM

  2)  Web applications will be designed by using web technologies like CGI, Servlet , JSPS Distributed applications will be designed by using the technologies like socket programming, RMI,EJBS, CORBA, Web services. 3) In case of web application, no separate java program for client in case of distributed application, there is a separate java program fore client and fore server. 4) web application is a collection of web components like servlet, JSPS,--- which will be executed by using only web containers. Distributed application is a collection of distributed components like EJBS, Which will be executed by using EJB Container. 5) Web applications will be executed by both web servers and application servers. Distributed applications will be executed by only application servers. 6) Web applications will provide services for only web client is browser Distributed application will provide services for only type of client.   Note In case of distributed applications, client may be any thing like a java program with main() method. An applet, a servlet, a JSP page, frame work specific components like action classes in struts and managed beans in JSF, 7) The main purpose at web application initially to general static response from server and distributed applications is to generate dynamic response.

8) It we want to use more web application and distributed application with in a single enterprise application then we will use web application to  implement presentation  and part we will use distributed application to implement business logic.   Web application development models To design web application in a standard pattern, we have to use the following models. 1.Model- I Arch 2.Model- I Arch   1.Model- I Arch In this arch, a JSP page is a configure as controller, it will take responsibility to pick up requests clients and to control the entire web application

    Screenshot_5      

  Model –IT Arch

  Screenshot_6   Note Struts  an JSF like frame works are designed on the basis of model II web application architecture lie on the basis of MVC design pattern    

49:T863,

MVC Rules and Regulation

  2In MVC based web application controller must be a servlet and view part must be a set of JSP pages, we should not interchange those two components,   2In MVC based web application we have to send all the requests to controller component only, not to view part, In MVC based web applications, only view part has to generate dynamic response to client, not controller.   2In case of MVC based web application, both controller and view should not interact with data base directly, they have to interact with data base through model part only   2In MVC based web application, controller should interact with model part only to set the data , not to get the data but view part should in with model part only to get the data, not to set he data   2In MVC based web applications there is no restriction about no. of JSP Pages in view part but all he JSP Pages must be provided without java code   2In case of MVC web applications we can provide any no.of JSP pages in view parted but we must provide page controller page navigation, we must not provide page to page navigations,  

4a:T233f,

STEPS TO DESIGN FIRST JSF APPLICATION 2Prepare web application directory structure. In JSF based web applications, we have to provide the following jar files in application lib folder JSF- api.jar                 JStl.jar JSF- impl.jar               Standard.jar JSF- api.jar, JSF- impl.jar files are available in majarra -1.2 – 14 – library. Zip which we have to down load from www.javaserverfaces. Java. Net website.

2 Prepare user interface by using JSF Provided log library 2 Prepare java resources like managed bean classes, DAos, Action classes,… 2 Prepare configuration file, we must require XSD in order to locate XML tags library and to parse xml tags

Extract JSF-  Impl.jar fileàcomà sunà facesà web – faces config – 1 -2. Xsd Copy<Faces- config..> tag [108 line in edit plus] from web-faces config-1-2.xsd. and use in our application faces configuration file 2Prepare web.xml file   Screenshot_10  

Helloform.jsp

<%@ taglib url=http://java.sun.com/jsf/coreprefix=”f”%> /html:” prefix=”h”%> <j:view> <html> <body bgcolor=”light yellow”> <h:form> <h:panel grid columns=”2”> <h:output text value=”user name”/> <h:input text id=”u name” value=”#{hello bean. U name}”/> <h:command button value=”say hello” Action=”#”{ hello bean. say hello }”/> </h:parel grid> </h:from></body> </html></f:view>  

 Wish.jsp

<%@taglib url=”http://java.sun.com/jsf/core”prefix=”f”%> /html:” prefix=”h”%> <f:view> <html> <body bg color=”light yellow”> <font size=”7” color=”red”> Hello…< h: output text value=”#{ hello bean. U name}”/> </font> </body> </html> </f:view>  

Hello bean.java

Package com.  soft; Public class Hello bean { Private string u name; Public void set u name(string u name) { This. u name= u name; } Public string  get u name() { Return u name; } Public string  say hello() { Return ”wish”; }  

Faces-config.xml

<faces- config.xml > ---------- <managed-bean> <managed-bean-name> Hello bean</managed-bean-name> <managed- bean- class>com. soft. Hello bean</managed-bean- class > <managed- bean- scope>session</managed-bean- scope > <managed- bean> <navigation-rule> <from-view -id>/hello from.jsp</from-view-id> <navigation-case> <from-outcome>wish</from- outcome > <to-view-id>/wish.id</from- outcome > </navigation-case> </navigation- rule > </faces. config>  

Web.xml

< Web -app> <servlet> <servlet-name>faces servlet</servlet- name > <servlet-class>javax. Faces. webapp. Faces servlet</servlet- class > <load-on-stratup>1</road-on-startup> </servlet> <servlet-mapping> <servlet- name > Faces servlet </servlet- name > <url-patternny*.dss</url- pattern > </servlet-mapping> <\ Web -app>   Screenshot_10  

Index.html

< html> < head> < meta http-equiv=”Refresh” context=”; URL-http://localhost:1010/log in app/log in form.dss”> < /head> < body> < h1> < font color=”red”> Application is loading…. < /font> </h1> < /body> < /html>    

Login form. Jsp

%@taglib url=”http://JAVA.sun.com/JSF/CORE”prefix=”f”% /html ”prefix=”h”%>   < f:view> < html> <body log color=”light yellow”> <font color=”blue”> <h1>software sol n </h1> < h2>Login form</h2> < /font> <h:form> <font color=”red”> <h1> <h:out put text value=”#{log in bean. error- msg}”/> <h1> <h:out put text value=”#{log in bean. error- msg}”/> </h1> <h:panel Grid column=”2”> <h:out put text value=”user name”/> <h:in put text id=”user name=”#{log in bean. uname}”/> <h: out put text value=”password”/> <h:in put text id=”upwd”value=”#{log in bean. upwd }”/> </h:panel Grid> </h:form> < /body> </html> < /f:view>  

Home.jsp

<%@taglib url=”http://java.sun.com/jsf/core”prefix=”f”%> < f:view> <html> < body log color=”Light yellow”> < font color=”red”size=”7”> < bre>< bre>< bre> Welcome to  soft < bre> <\font> <\ body > <\ html > <\ f:view >  

Login Bean. Java

Package com. soft; Public class login bean { Private string u name; Private string upwd; Private string err-msg; Public void set u name(string u name) { This. U name= u name; } Public string get u name() { Return u name; } Public void set u pwd(string upwd) { This. Upwd= upwd; } Public string get upwd() { Returns upwd; } Public void set err – msg(string err-msg) { This. Err – msg= err-msg; } Public string get err- msg() { Return err-msg; } Public string check log in () { If (u name. equals(“durga”)&& upwd. Equals(“durga”)) { Return ”success”; } Else { Set err-msg(“Invalid username and password”); Return”failure”; } } } Faces-config.xml:- <faces-config— ---xsd <managed-rule> <managed-bean-name>log in bean</ managed-bean-name > <managed-bean-scope>session</ managed-bean- scope > </ managed-bean > <navigation-case> <from-outcome>success</from-out come> <to-view-id>/home.jsp</to-view-id> <navigation-case> <navigation-case> <from-outcome>failure</frin-outcome> <to-view-id>/log in from.jsp</to-view-id> <navigation-case> <\navigation-rule><\faces-config>  

Web.xml

<web-app> <servlet> <servlet-name>faces servlet<\servlet-name> <servlet-class>Java x. faces.web app. faces servlet <servlet-class> <load-on-startup>1<load-on-startup> <servlet> <servlet- mapping> <servlet- name>faces servlef</servlet-name> <url- pattern>*.dss< /url- pattern > </servlet- mapping> </web.app>                  

4b:T2886,

STEPS TO DESIGN JSF 1.2 APPLICATION IN ECLIPSE IDE

Step1 - Prepare dynamic web project with JSF library Step2 - Prepare application specific components like JSP PAGES Managed Beans,….etc Step3 -Run the application  

Prepare Dynamic web project

File2New2Dynamic web project2Project name:JSF app1 2Prepare target runtime2click on new runtime2select apache tomcat 7.0àNextàprovide tomcat<home>dire:c:/tomcat7.02finish Dynamic web module version:3.0 or 2.52configuration: Modify2Select &change java server faces from 2.2 to 1.2 and select the respective check box2 save as 2provide name jstlib1.22 ok2ok Next2next2 selectþGenerate web.xml deployment descriptor 2Next2click on manage library icon2 new2 provide user library Name:JSFlib1.22ok2select JSflib 1.22 add external jars JSf-api.jar JSf-IMPL.jar JSTL.JAR Standard.jar2ok2selectþJSFlib 1.22changes url mapping pattern :.dss2 finish Note:- With the above steps we are able to prepare Jsf app1 project with the default files web.xml and faces-config.xml  

Prepare application Required Resources

Loginform.JSP:- Right click on “web content ”folderà new 2select JSP file2 provide file name: Loginform.jsp2next2select new java Server Faces(JSF)page (html)2finish Note: With these steps log in form.jsp page will be generated, edit log in form.jsp page as per requirement. Similarly success.jsp and failure.jsp  

Log in Bean. Java

Java Resources2ser2Right click on src2new 2class2 package name:car,durgasoft Class name: log in bean 2 finish With the above steps a class will be created in work area *Declare required properties Right click on either of the property Select ”sources”2select getter and setter2select all2ok with the above steps a bean component will be prepared with setter and getters here we have to declare business method with the application logic *Provide bean configuration and its navigation rules in faces-config.xml files as per the requirement  

Run JSF Application

Right click on project()stapp1)2Run as2Run as server2Next2Finish With these steps IDE will start server and it will access current application by opening browser. 2Manually provide/log in.dss in url http://local host:1010/JSf app1/loginform.dss    

4c:T1a8a,

 Developing Registration Application

Screenshot_11  

Index.html

<html> <head> <meta http equiv=”Refest”name=”Generater”content=”2,url=http://localhost:1010/requestion app/registration form.dss”> </head> <body> <br><br> <center> <font size=”6”color=”red”> Application is loading </font> </center> </ body > </html>     

Registration form.jsp

<% @tag lib url=http://JAVA.SUN.COM/JSF/CARE”Prefix=f”%> /html” Prefix=”h”%> <f:view> <html> <body> <font color=”red”> <h1> software solutions</h1> <h2>student Registration form</h2> </font> <h:form> <h:panel grid column=”2”bg color=”Light blur”> <h:out put text value=”student id”/> <h:in put text id=”sid” value=”#{student id}”/> <h:out put text value=”student name”/> <h:in put text id=”s name” value=”#{student Bean.sname}”/> <h:out put text value=”student mail”/> <h:in put text id=”se mail” value=”#{student Bean.se mail }”/> <h:out put text value=”student mobile”/> <h:in put text id=”smobile ” value=”#{student Bean. smobile }”/> <h:command button value=”ADD”action==”#{student Bean. add }”/> <h:panelGrid> </h:from> </body> </html> </f:view>  

Existed.html

<%@ taglib------------------- “f”%> <%                                                                                  “h”%> </f:view> <html> <body bgcolor=”Light yellow”> <br>< br > <center> <b><font size=”6”color=”red”> Student already existed. </font> </b> </center> </body> </html> </f:view>  

Success.jsp

<%@taglib--------> <%@taglib--------> <f:view> <html> <body bgcolor=”light yellow”> <font size=”6”color=”green”> Student registered successfully.. </font> </body></html></f:view>  

Failure.jsp

<%@tag---- <% ---- <f:view> <html> <body bgcolor=”red”> <font size=”8”color=”green”> Student registration failed— </font> </body> </html></t:view>  

Student Bean.java

Package com. soft; Public class student bean{ Private string sid: Private string sname; Private string semail; Private string smobile; Set—()               //provide setter and getter() Getter—() Student action sa=new studentAction(); String status =sa. Addstudent(sid,sname,semail,smobile); Return status; } }  

Student action.java

Package com. soft; Import java.sql.*; Public class studentAction { String status=””; Public string add student(string sid, string sname string email, string smobile) { Type{ Connection con=jdbcultil. get connection(); Prepared statement pst=con. prepared statement(“select* from student where sid=?”); Pst.set string (1,sid); Resultset ms=pst execute query(); Boolern b=ms.next(); If()b==true) { Status=”existed”; } Else{ Pst=con. Prepare statement(“insert into student values(????)”); Pst. setstring(1,sid); Pst. setstring(2,sname); Pst. setstring(3,semail); Pst. setstring(4,smobile); Pst. Execute update(); Status=”Success”; } } Catch(exception() { Status=”failure”; e.print stack ace () } Return status; } }  

Jdbcutil.java

Package com.durgasoft; Import java.sql*; Public class Jdbcutil { Static connection con; Static { Try { Class. fore name(“oracle. jdbc. oracle drivet”); Con=Driver manager. Get connection(“jdbc:oracle; thin:@local host:1521: oricle”,”scot”,”tiger”); } Catch(exception) { e.printstacture(); } } Public static connection get connection() { Return com; } }  

Faces-config.xml

<facs.config=xsd> <managed. bean> <managed. Bean.name>student bean</managed-bean-name> <managed. Bean. class>com. soft. student bean</managed-bean- class > <managed. Bean. scope>session</managed-bean- scope > <managed. Bean> <navigation. rule> <from-view-id>/registrationfrom.jsp</from-view-id> <navigation-case> <from-outcome >success<</from –outcome> <to-view-id>/success.jsp</ to view-id> </navigation. case> <from-outcome>success</from-outcome> <to-view-id> /success.jsp</to-view-id> </navigation. case> <navigation. case> <from-outcome>failure</from-outcome> <to-view-id> / failure.jsp</to-view-id> </navigation. case> <navigation. case> <from-outcome>failure</from-outcome> <to-view-id> / existed.jsp</to-view-id> </navigation. case> </navigation. rule> </faces. config>  

Web.xml

<web-app> <servlet> <servlet-name>faces servlet</servlet-name> <servlet-class>Javax. faces. webapp. faces servlet< /servlef-class > <load-on-startup>1</ load-on-startup > <servlet> <servlet-mapping> <servlet-name> faces servlet< servlet-name> <url-pattern>*.dss<url-pattern> <servlet-mapping> </web-app>

4d:T11f6,

 DIFFERENCE BET N JSF1.X &JSF 2.X

 

JSF1.X JSF 2.X
1.in JSF 1.X version config file is mandatory and annotation is not supports 1.In this JSF config file is optional and in place of config file we are able to use annotations.
1)To represent managed bean metadata, we have to use the following annotations on the top of managed bean class  

  a) Managed bean(name=”---”) Where ”name” member will take logical name of the managed bean class This annotation will be pre presented by a predefined  interfaces javax.faces.bean. managed beam 2)@xxX scoped Eg: @session scoped @Application scoped @page scoped @Request scoped This annotation can be used to represent a particular scope fore the managed bean

  1. ii) In JSF 1.X We are able to use only JSP pages to prepare user interface

In JSF 2.x Version we are able to use both Jsp & xhtml pages to prepare users interface. In case of JSF 1.X version F/W is using explicit navigation system, it must require navigation rules configuration in faces-config.xml file explicitly in order to forward request to target page In case of JSF 2.X Version. f/w has an implicit navigation system it should not require explicit “navigation rules” configuration from faces-config.xml file. It will forward request to  the target pages on the basis of the return value from action method defined in the respective managed bean component.   Note: It the return value from action method is “success” then implicit navigation system will forward request to either success jsp or success. Xhtml file. 4) In case of JSF 1.X version support is available but we have to provide some explicit configuration. In case of JSF 2.x version supported is inbuilt, it shouldn’t require any explicit configuration.

  1. In JSF 1.x Version face lets tag library is not good in JSF 2.X Version, face lets supported cs very good to provide compositions.

  Screenshot_15    

Hello.xhtml

<html xmlns=http://www.w3.org/1999/xhtml Xmln:f=”http:java.sun.com/jsf/core” Xmln:h=”http:java.sun.com/jsf/html” > <f.view> <h:form> <h:panel grid columns=”2”> <h: output text value=”user name”/> <h:input text id=”u name”value=#{user bean. Uname”/} <h:command button value=”say hello” action=#{user bean say hello}”/> </h:panelgrid> </h:form></f:view></html>  

Wish.xhtml

<html xmlns=”http//www.w3.org/1999/xml” Xmln:f=”http//java.sun.com/jsf/core” Xmln:h=”http//java.sun.com/jsf/html”> <f:view> <h1> <h:output text value=”Hello----”/><h:output text value- “#{userBean.u name}”/> </h1> </f:view></html>  

 User Bean.java

Package com. soft Import javax. faces. bean. managed beans; Import javax. faces. bean. Session scoped; @managed bean(name=”user bean”) @session scoped Public class user Bean{ Private string uname; Public setting getuname(){ Return u name; } Public void set u name(String uname){ This. U name=u name; } Public string say Hello(){ Return ”wish”; } }  

Web.xml

//same as prev.example <web-app> <servlet> <servlet-name>faces servlet</servlet-name> <servlet-class>javax.faces.webapp. faces servlet</servlet class> <load-on-startup>1</load.on.strtup> < /servlet > <servlet-mapping> <servlet-name>faces servlet</servlet-name> <url-patterny*.dss</url-pattern>> </servlet-mapping> </web-app>    

4e:T1641,

Introduction

Enterprise & Enterprise Application:-

  1. Presentation layers
  2. Business layers
  3. Persistence layers

  Screenshot_1   JSF is exclusively designed for only presentation layers. Struts main focus in controllers (How to control the web apply)   Enterprise application

  To design enterprise application we have to provide the following 3 Layers

  1. Presentation Layers
  2. Business processing layers
  3. Persistence layer data storage and Access layers

 

  1. Presentation Layers

The main purpose of presentation layers in enterprise appon is,

  1. To improve look and feel for the enterprise appl n
  2. To accept the data from user in order to execute enterprise application.
  3. To perform client side data validations by using java script functions.
  4. To specify deferent types at request like GET. POST… TO prepare presentation layer in enterprise applications. We have to provide a separate logic called as presentation logic.

 

  1. Business processing Layers

It is the heart of enterprise appl n. it will provide very good env… To define and execute business rule and regulation what actually client required.

 

  1. Persistence Layer

This Layer main intention is to provide env. To interact with data base and to provide data persistence.

  System Architecture To design enterprise application First we have to define the degree are height of the enterprise application on the basic at application Requirement

  1-Tier Architecture It will specify to design and execute enterprise application within a single machine i.e we have to provide presentation logic, business logic and persistence logic with in a single machine

  Screenshot_2   TIERE ARCHITECTURE This arch is the conventional architecture. Fore the enterprise application

  Screenshot_3   Tier Architecture

  Screenshot_4   Note- It we increase no of fires in enterprise application their flexibility will be increased to design enterprise application but maintenance cost will be increased

4f:T6ed7,

Welcome to the Java Tutorials. The objective of these tutorials is to provide in depth understand of java from basic questions like what is java tutorial, core java, where it is used, what type of applications are created in java and why use java.

In addition to free Java Tutorials, you can find interview questions, how to tutorials and issues and their resolutions of Java.

JAVA Introduction

Java is a programming language that was created by James Gosling from Sun Microsystems (Sun) in 1991 and first made publicly available in 1995, after Sun Microsystems was inherited by Oracle. The platform was originally designed for interactive television, but it surpassed the technology and design of the digital cable television industry at the time. Today, Java remains an open-source programming language that falls under the GPL (General Public License) The language derives much of its syntax from C and C++, but lacks the power of those languages because it asks less of the user (less customization, more simplicity). For example, tasks such as garbage collection (the process of reducing memory being used by the program) are automated in Java. Five principles were used in the creation of the Java programming language:

Java was built as an exclusively object-oriented programming language—which doesn’t mean much right now, but will later in this guide. For now, suffice it to say that object-oriented programming allows for the creation of efficient, organized, and powerful code. Simply put, Java is a multithreaded, object-oriented, platform-independent programming language. This means that Java programs can perform multiple tasks using object-oriented concepts that can work across all platforms and operating systems. It is the most important factor distinguishing Java from other languages. Java helps us to develop normal desktop applications, mobile applications, and web applications using separate packages such as the J2ME package for mobile application development and the J2EE package for web application development. In this guide, we are going to learn the basics of object-oriented concepts as they apply to Java programming. We have two different types of application development concepts in Java: console-based application and GUI application development. Let’s see how to develop these types of applications using Java.

What is Java?

Java is a programming language that is supported by all devices, whether it is an Android phone, a Windows computer, or an Apple product. Java’s flexibility has made it one of the most popular programming languages around the globe. Java can be used to create web applications, games, Windows applications, database systems, Android apps, and much more. Java’s combined simplicity and power makes it different from other programming languages. Java is simple in that it doesn’t expect too much from the user in terms of memory management or dealing with a vast and complex hive of intricate classes extending from each other. Although this doesn’t make much sense right now, it will once we start learning about inheritance in Java. A Java program is run through a Java Virtual Machine (JVM), which is essentially a software implementation of an operating system that is used to execute Java programs. The compiler (process of converting code into readable instructions for the computer) analyzes the Java code and converts it into byte code, which then allows the computer to understand the instructions issued by the programmer and execute them in the appropriate manner. The distribution of the Java platform comes in two packages: the Java Runtime Environment (JRE) and the Java Development Kit (JDK). The JRE is essentially the Java Virtual Machine (JVM) that runs Java programs. The JDK, on the other hand, is a fully featured software development kit that includes the JRE, compilers, tools, etc. Learn JAVA Tutorials Online A casual user who only wants to run Java programs on their machine would only need to install the JRE, as it contains the JVM that allows Java programs to be executed. However, a Java programmer must download the JDK. We will explore these concepts in greater detail in the next part. As previously stated, Java programming creates an object-oriented and platform-independent program because the Java compiler creates a .class file instead of an .exe file. This .class file is an intermediate file that has byte code, and this is the reason why Java programs are platform independent. However, there are also disadvantages: Java programs take more time to complete their execution because the .class file must first load in the JVM before they are able to run in the OS. We can develop all kinds of applications using Java, but we need to use separate packages for separate application developments. For example, if you want develop a desktop application, then you need to use JDK; if you want to develop an Android application, then you need to use Android SDK, because they have different sets of classes.

Java Language Structure

We will now use this sample code as an example to start the Java learning process. This code should make it easy to understand the basic structure of a Java program.

import java.util.Scanner;
public class ThisIsAClass {
public static void main (String args[]) {
int x = 5;
System.out.println(x);
}
}

The first line import java.util.Scanner; it is using the special keyword import, which allows the programmer to import tools in the Java library that aren’t included by default when starting a new class. After the keyword import, the programmer specifies a specific directory within the Java library for the Scanner tool by typing out: java.util.Scanner, which first accesses the Java library in the Utilities directory before accessing the specific tool needed, which in this case is “Scanner.” By default, when starting a Java class, only the bare minimum tools and functions from the Java library that are needed for any basic program will be provided. For example, you don’t need to import packages for a simple program. If the programmer wants to use more than just the basic functionalities, they must use the “Import” keyword to give themselves more tools to work with. You will also start to notice that there is a semicolon “;” after each statement. This semicolon functions as a period does for an English sentence. When the compiler is going through the program to prepare it for its execution, it will check for semicolons, so it knows where a specific statement ends and a new one starts. The next thing you’ll notice in the sample code is: public class ThisIsAClass. There are three elements to this line that are very important to understand. public—Defines the scope of the class and whether or not other classes have access to the class. This may not make sense now, but you will gain a better understanding of what this means when we learn about “Inheritance and Polymorphism.” class—A class can be thought of as a “section” of code. For example:

Section {everything here is the content of the section}

Again, you will gain a better understanding of how classes can be useful when we learn about Inheritance and Polymorphism. ThisIsAClass—This third and final element of this important line is “ThisIsAClass,” which is simply a custom name that the user can define. You can call this anything, as all it does is give the “Section” or “Class” a name.

Section:              Name              {
    Essay/Contents
}
 In code, it would be presented:
Class              ThisIsAClass              {
 Code
}

Another thing you may be scratching your head over are the curly braces: “{” and “}.” All that these characters do is tell the compiler where a specific section starts and ends. In English, this could be thought of as starting a sentence with a capital letter or indenting a new paragraph. One thing to note is that the spacing in code does not affect whether or not it works. However, it is conventional and efficient to write properly spaced code so that you and other programmers can read and understand it more easily. You will learn how to space as you read more sample code. Eventually, you will start to notice trends in how conventional spacing works in programming.

public static void main (String args[]) {
int x = 5;
System.out.println(“The number is” + x);
}
}

As shown in the above sample code, two curly braces are set in bold to indicate that they communicate with each other. Whatever is written between them is the “Section” or “Class” of name “ThisIsAClass.” The sample applies to the bold and underlined curly braces to indicate that they are separate section dividers for the section within the parent section. The parent section is again considered a class, whereas the section within the parent section is considered a sub-section, or a subclass, or the formal term, a method. A method is essentially a subclass that also has its own special elements, similar to a class but more specific. This contains four elements: a scope (public/private/protected), a return type, a name, and parameters. The scope, return type, and parameters are things you will understand better when we learn about Methods, along with Inheritance and Polymorphism.

This method is a special method because it is named “main” and so it will be the first method that is called. The compiler always looks for the method named “main” at the process start. The main method must hold the following properties: “public static void” and have “String args[]” as the argument in the parameters. There can only be one main method in a Java project. The idea of the main method is that it will be the first method to be called, and so you can think of it as the home base for calling other methods and traveling to other classes (you will learn what this means later). For the remainder of this guide, your program must be written within this main method, as it is a special method that the compiler will always be looking for. The contents of this method will also be introduced when learning about “Variables” later on in this guide. For now, this brief explanation should be enough for you to understand what is going on: int x = 5;—A variable is being declared (a container) that is a type of integer (whole number), and it holds the value of five. The “=” is used to assign values to variables. System.out.println—This is a classic line that every beginner learns; all it does is print a line of text to the console. Example JAVA Tutorials The console is where the program’s output is placed in order for the programmer to test his or her program. The “System.out.println” line contains parenthesis and a string of text within those parentheses. The string of text must be surrounded by quotation marks in order for the program to know that it has to print out text instead of an actual variable like “x.” The reason the user can’t just say: “System.out.println(“The number is: x”);” is because the program won’t know if x is a variable or not. The program reads anything within quotation marks as a piece of text instead of a container holding a value. Therefore, the x must be outside of the quotation marks. Then again, you can’t say System.out.println(“The number is: ” x ); because the program needs a specific keyword to know that the piece of text and the variable are two entities that need to be joined or “concatenated” together. The “+” symbol is used to show that the string of text and the variable “x” are to be connected together; this will allow the program to output “The number is: 5” (without the quotation marks). That is why the line is: “System.out.println(“The number is: ” + x );” Commenting: Commenting is the final fundamental concept to understand in a programming language. Although it is not necessary, it can greatly help you and other programmers around you if you ever forget how the program works. This concept is used by programmers as an opportunity to explain their code using common English. A compiler will always ignore comments, as they aren’t actual code. They are simply explanations that were written to help people understand what was programmed. In order to write a comment, you must use “//” or “/*” and “*/.” The “//” symbol is used to comment on one line. For example, if you were to explain what a certain variable was going to be used for, you would do the following:

int x = 5; // this variable is going to be used to find the total money

The compiler will ignore the commented line, but will process int x = 5. However, you can’t use the “//” symbol with the following:

int x = 5; // this variable is going to be used to find the total money

This is because the “//” symbol is only used for one line, and the comment is on two lines. You could do:

int x = 5; // this variable is going to be used to find the total money

As long as the comment is one line, it is fine. Anything on the line after that symbol is considered a comment. The other technique does the same thing as “//” except it supports multi-line commenting. You must start the comment with “/*” and end it with “*/.” Example:

int x = 5; /* this variable is going to be used to find the total money */

Variables

What is a Variable?

A variable is essentially a storage unit that holds a certain type of data. It is named by the programmer and used to identify the data it stores. A variable can usually be accessed or changed at any time. You can write information to it, take information from it, and even copy the information to store in another variable.

Variable Types

In Java, a variable has a specific type that determines what size it is and the layout of its memory. The Java language defines three types of variables.

Instance Variables

Instance variables are declared within a class but accessed outside of any method, constructor, or block. Instance variables are created with the keyword “new” and are destroyed when the object is destroyed. An instance variable is visible to all methods, constructors, and blocks within the class where it is declared. By giving a variable the keyword “public,” it can be accessed by subclasses within the class. However, it is recommended to set a variable’s access modifier to “private” when possible. All instance variables have a default value, unlike local variables, which do not have default values. Example:

public class Test
{
public int num; // integer named num
public void dog()
{
num = 3;
}
}

In this example, we declare the integer “num” outside of any method, and can easily access it within any method that is inside of the class “Test.”

Class/Static Variables

Static variables are declared outside of any method, constructor, or block, and are declared with the keyword “static.” If a variable is static, only one instance of that variable will exist, regardless of how many instances of the object are called. Static variables are rarely used except for constant values, which are variables that never change. Example:

public class Test
{
public static final int num = 3; // integer named num
public void dog()
{
System.out.println(num);
}
}

In this example, we declare an int called “num” and it set to be public, static, and final. This means that it can be accessed from within subclasses, only one instance of it can ever exist, and the value can never be changed.

Local Variables

Local variables are only declared within methods, blocks, or constructors. They are only created when the method, block, or constructor is created, and then they are destroyed as soon as the method ends. You can only access local variables within the method, block, or constructor where it is called; they are not visible outside of where they are called. Local variables do not have a default value. Example: public void cat(){ // method named cat int x = 0; // int with value of 0 } In this example, a variable named “x” is called within the method “cat.” That variable only exists within the context of cat, and it cannot be directly called or accessed outside of that method.

Data Types

Variables are used to store data. Java has multiple built-in data types that are used to store predefined types of data. These data types are called primitive data types, and are the most basic data types in the Java programming language. You can also create your own data types, which we will go over later. Java has eight primitive data types.

Byte

The byte data type is an 8-bit signed two’s complement integer. It has a default value of zero when it is declared, a maximum value of 127, and a minimum value of -128. A byte is useful when you want to save memory space, especially in large arrays. Example

byte b = 1; // has a value of one

Short

The short data type is a 16-bit signed two’s complement integer. Its maximum range is 32,767 and its minimum value is -32,768. A short is used to save memory or to clarify your code. Example:

short s = 1; // has a value of one

Int

The int data type is a 32-bit signed two’s complement integer. Its maximum value is 2,147,483,647 (231 -1) and its minimum value is -2,147,483,648 (-231). Int is the most commonly used data type for integral numbers, unless memory is a concern. Example:

int i = 1; // has a value of one

Long

The long data type is a 64-bit signed two’s complement integer. Its maximum value is 9,223,372,036,854,775,807 (263 -1) and its minimum value is -9,223,372,036,854,775,808 (-263). This data type is used when a larger number is required than would be possible with an int. Example:

long l = 1; // has a value of one

Float

The floating point data type is a double-precision 64-bit IEEE 754 floating point. The min and max range is too large to discuss here. A float is never used when precision is necessary, such as when dealing with currency. Example:

float f = 1200.5f; //value of one thousand two hundred, and a half

Double

The double point data type is a double-precision 64-bit IEEE 754 floating point. It is often the data type of choice for decimal numbers. The min and max range is too large to discuss here. A float is never used when precision is necessary, such as when dealing with currency. Example:

double d = 1200.5d; // value of one thousand two hundred, and a half

Boolean

A boolean data type represents one bit of data. It can contain two values: true or false. It is used for simple flags to track true or false conditions. Example:

boolean b = true; // has a value of true

Char

The char data type is a single 16-bit Unicode character. Its minimum value is “/u0000” (or 0) and its maximum value is “/uffff” (or 65,535 inclusive) Example:

char c = 'w'; // returns the letter "w"

String

Another commonly used data type is called String. String is not a primitive data type, but it is a very commonly used data type that stores collection of characters or text. Example:

String cat = "meow"; // sets value of cat to "meow"

This example gets a String named “cat” and sets it to the string of characters that spell out “meow.”

Declaring a Variable

The declaration of a variable has three parts: the data type, variable name, and the stored value. Note that there is a specific convention and set of rules that are used when naming variables. A variable name can be any length of Unicode letters and numbers, but it must start with a letter, the dollar sign “$,” or an underscore “_,” or else it will return a syntax error. It is also common naming convention to start the name with a lowercase letter, followed by each subsequent word starting with a capital letter. For example, in the variable named “theName,” the first word “the” starts with a lowercase letter, and each following word, in this case “Name,” starts with a capital letter. Example:

int theName = 123; // value of 123

In the example above, the data type is int and the name of the variable is the  Name. The value stored inside that variable is 123. You can also declare a variable without storing a value in it. Example:

int name; // no value

You can do this if you choose to declare it later.

Using a Variable

After a variable is declared, then you can read its value or change it. After the variable has been initially declared, you can only reference it by its name; you only need to declare its data type when you are declaring the variable. Example:

name = 2; // sets the int "name" to a value of 2

The example above sets the value of name to 2. Notice how I never restated the data type. Example:

System.out.println(name); // prints the value of name to the console

This example reads the value of “name” and writes it to the console. Variables can also be added together for example. Example:

int a; // no value
int b = 1; // value of one
int c = 2; // value of two
a = b + c; // sets a to the value of b + c

In the example above, we set the value of a to equal the value of b and c added together. The addition sign is known as an operator, which we are going to learn about in the following section. It is also possible to a certain extent to combine values of variables that are different data types. Example:

int a; // no value
float b = 1; // value of one
int c = 2; // value of two
a = (int) (b + c); // sets the int "name" to a value of b + c

This example is just like the one before, except we have changed the data type of b from int to float. The only difference when adding them together is that we had to include something called a “cast” in the equation. What a cast does is simply let the compiler know that the value of (b + c) should be of the data type int. Note that for this example, if the value of b + c were to equal a decimal number (for example 3.2), the value of a would not be 3.2 but rather 3, because int does not support decimals.

Assignment

Using what we have learned about variables, we can now create a simple calculator to add numbers together for us. The first thing we will want to do is declare three variables: one to store the value, one to represent the first number we want to add, and one to represent the second number we want to add. We will declare these variables as double so that we can add decimal numbers: double a = 0; // stores value of addition double b = 3.55; // first number to add double c = 52.6; // second number to add Next, we will simply set the value of a to equal the value of b and c combined, and then print out the value of a. a = b + c; System.out.println(a); If you run this program, it will print out 56.15. Now you have created a very simple calculator. I highly encourage you to play around with this and test things for yourself. Change the data type of the variables, add more numbers together, and experiment to understand how things work. Our design of course tutorials and interview questions is practical and informative. At TekSlate, we offer resources to help you learn various IT courses. We avail both written material and demo video tutorials. For in-depth knowledge and practical experience explore Online Java Training.

2:["$","$Lb",null,{"data":{"trending":[{"id":2126,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"$c","description":"$d","title":"Java Swing Tutorial","url_title":"java-swing-tutorial","image_url":"","meta_title":"Java Swing Tutorial | Introduction to Java Swing","meta_desc":"Swing is a GUI toolkit for Java programmers. This tutorial will teach you the basics of the Swing API and show you how to build a simple app.","views":541,"rating":4.3,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2022-11-01T06:59:35.000Z","updated_at":"2022-11-01T06:59:35.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":2125,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"","description":"$e","title":"Java Stream Tutorial","url_title":"java-stream-tutorial","image_url":"","meta_title":"Java 8 Stream Tutorial | Java Stream API Tutorial","meta_desc":"Java 8 Stream tutorial for beginners. Learn how to use Java streams with examples of intermediate and advanced level programming.","views":1456,"rating":4.2,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2022-10-31T07:50:13.000Z","updated_at":"2022-10-31T07:50:13.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":1},{"id":1261,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$f","title":"Stack using Linked List in Data Structures","url_title":"stack-using-linked-list-in-data-structures","image_url":"","meta_title":"Stack using Linked List in Data Structures [Updated 2023]","meta_desc":"Stack using Linked List in Data Structures - Here is the simple program to demonstrate Stack using Linked List in Data Structures.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T22:45:19.000Z","updated_at":"2021-04-16T12:00:44.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1248,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":"","table_of_content":"","description":"$10","title":"Linear Queues in Data Structures","url_title":"linear-queues-in-data-structures","image_url":"","meta_title":"Introduction to Linear Queue in Data Structures","meta_desc":"Explore the basics of Linear Queue in Data Structures. Learn about the implementation and applications of this important data structure.","views":1324,"rating":4.1,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T18:31:27.000Z","updated_at":"2021-04-06T17:22:22.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":14},{"id":277,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":"","table_of_content":"","description":"$11","title":"Advanced Java Interview Questions","url_title":"advanced-java-interview-questions","image_url":"https://newtekslateassets.s3.us-west-2.amazonaws.com/wp-content/uploads/articles/advanced-java-Interview-questions-10032023.png","meta_title":"TOP 90+ Advanced JAVA Interview Questions (2023)","meta_desc":"Advanced JAVA Interview Questions and Answers? Ace your Advance JAVA interview with expert-curated, FAQ's and real-time case study questions and answers. ","views":5897,"rating":4.7,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-05-26T10:59:06.000Z","updated_at":"2021-04-03T13:21:27.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"What are java objects and java applications? ","faq_schema_a1":"Java object is an object that is provided by the execution of an application. When an application is compiled an object of that application is being made. Java application on the other hand is a program that is being written in Java and being read by the Java virtual machine.","faq_schema_q2":"Explain the different ways of using thread?","faq_schema_a2":"The thread could be implemented by using a runnable interface or by inheriting from the Thread class. The former is more advantageous, 'cause when you are going for multiple inheritances. the only interface that can help.","faq_schema_q3":"What is synchronization and why is it important?","faq_schema_a3":"With respect to multithreading, synchronization is the capability to control the access of multiple threads to shared resources. Without synchronization, it is possible for one thread to modify a shared object while another thread is in the process of using or updating that object's value. This often leads to significant errors.","like_counter":9},{"id":174,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":"","table_of_content":"","description":"$12","title":"Data Structures Interview Questions","url_title":"data-structures-interview-questions-answers","image_url":"","meta_title":"TOP 50+ Data Structures Interview Questions (2023)","meta_desc":"Data Structures Interview Questions and Answers - Tekslate experts compiled Algorithm interview questions for freshers & experienced candidates to crack the interview","views":653,"rating":4.4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-02-19T11:18:52.000Z","updated_at":"2021-01-22T14:58:55.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":192,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":"","table_of_content":"","description":"$13","title":"Advanced Java Interview Questions & Answers","url_title":"advanced-java-interview-questions-answers","image_url":"","meta_title":"TOP 50 Advanced Java Interview Questions [2023]","meta_desc":"Looking for Advanced Java Interview Questions with Answers? Here we have compiled set of questions from the students who have attended interviews in Fortune 500 companies","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-02-23T04:52:31.000Z","updated_at":"2021-01-08T14:06:25.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":318,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$14","title":"Core Java Interview Questions","url_title":"core-java-interview-questions","image_url":"","meta_title":"TOP 50 Core Java Interview Questions [UPDATED] - TCS & Cognizant !!!","meta_desc":"Looking for Core Java Interview Questions with Answers? Here we have compiled set of questions from the students who have attended interviews in Fortune 500 companies","views":542,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-06-09T04:49:29.000Z","updated_at":"2020-10-27T14:25:51.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":2},{"id":1181,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"","description":"$15","title":"History of MVC Architecture","url_title":"history-mvc-architecture","image_url":"","meta_title":"History of MVC Architecture | Tekslate","meta_desc":"History of MVC Architecture - in this tutorial learn about MVC architecture in detail. Learn ASP.Net from Experts!","views":549,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-05T04:46:56.000Z","updated_at":"2020-10-17T12:21:17.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":2047,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$16","title":"Core Java Resume","url_title":"core-java-resume","image_url":"","meta_title":"Core Java Sample Resume","meta_desc":"We here share an Core Java developer Fresher and Experienced Sample Resume for Job Interview and also discuss on few Resume Writing Tips.","views":579,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2017-10-10T10:20:01.000Z","updated_at":"2020-10-05T18:09:10.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":103,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"","description":"$17","title":"Core Java Tutorial","url_title":"core-java-tutorials","image_url":"","meta_title":"Learn Core Java Online With Examples | Core Java Tutorial","meta_desc":"Core Java tutorials gives enough knowledge to get up and run with real world application development and object-oriented programming using the Java Language","views":443,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-06-21T12:41:56.000Z","updated_at":"2020-09-26T17:23:14.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":41,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"","description":"$18","title":"JSF Tutorial","url_title":"jsf-tutorials","image_url":"","meta_title":"JSF Tutorial | Java Server Faces Tutorial | JSF Basics","meta_desc":"JSF Tutorial teach you how to write ?custom JSF 2.2 themes ?custom factories ?handlers ?renderers ?components ?Enhance your applications with JSF.","views":3251,"rating":4.4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2015-01-01T08:55:52.000Z","updated_at":"2020-05-26T00:00:00.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":492,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$19","title":"Data Structures Interview Questions","url_title":"interview-questions-on-data-structures","image_url":"","meta_title":"TOP 50 Data Structures Interview Questions [UPDATED] !!!","meta_desc":"Looking for Data Structures Interview Questions with Answers? Here we have compiled set of questions from the students who have attended interviews in Fortune 500 companies","views":798,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-03-24T06:26:27.000Z","updated_at":"2020-03-30T00:00:00.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":1},{"id":93,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":"","table_of_content":"","description":"$1a","title":"Advanced Java Tutorial","url_title":"advanced-java-tutorials","image_url":"","meta_title":"Advanced Java Programming Tutorial | A Complete Guide to JAVA","meta_desc":"Advanced Java tutorial in Tekslate will help you to gain knowledge on advanced object oriented language to improve code maintenance and readability.","views":1088,"rating":4.3,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-06-15T05:12:57.000Z","updated_at":"2019-03-23T00:00:00.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":1249,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$1b","title":"Circular Queue in Data Structures","url_title":"circular-queue-in-data-structures","image_url":"","meta_title":"Circular Queue in Data Structures by Data Structures Expert","meta_desc":"In this tutorial, we will learn about what is Circular Queue in Data Structures and its implimentation.","views":948,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T18:33:25.000Z","updated_at":"2018-09-21T10:04:18.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1251,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$1c","title":"Linear search in Data Structures","url_title":"linear-search-in-data-structures","image_url":"","meta_title":"Linear search in Data Structures","meta_desc":"In this tutorial, we will learn about Linear search in Data Structures. The key which is to be searched, is compared with each element of the list one by on","views":607,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T20:54:04.000Z","updated_at":"2018-09-21T10:00:49.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1250,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$1d","title":"Postfix expression in Data Structures","url_title":"postfix-expression-in-data-structures","image_url":"","meta_title":"Postfix expression in Data Structures","meta_desc":"In this tutorial we will discuss about Postfix expression in Data Structures. Suppose p is an arithmetic expression written in postfix notation.","views":710,"rating":4.2,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T20:57:44.000Z","updated_at":"2018-09-21T10:00:31.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":1254,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$1e","title":"Selection sort in Data Structures","url_title":"selection-sort-in-data-structures","image_url":"","meta_title":"Selection sort in Data Structures","meta_desc":"In this tutorial we will learn about Selection sort in Data Structures. Suppose an array A with ‘n’ elements A[0],A[1],A[2]….. is in memory. The selection sort","views":1079,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T21:00:32.000Z","updated_at":"2018-09-21T10:00:10.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1255,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$1f","title":"Insertion sort in Data Structures","url_title":"insertion-sort-in-data-structures","image_url":"","meta_title":"Insertion sort in Data Structures","meta_desc":"In this tutorial, we will discuss about Insertion sort in Data Structures. Suppose an array ‘A’ with ‘n’ elements A[0]. A910,A[20],---------A[N-1] is in memory. The ins","views":963,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T21:32:42.000Z","updated_at":"2018-09-21T09:58:10.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1256,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$20","title":"Quick sort in Data Structures","url_title":"quick-sort-in-data-structures","image_url":"","meta_title":"Learn Quick sort in Data Structures From Experts","meta_desc":"In this tutorial, we will discuss about Quick Sort in Data Structures and Problem solving with Algorithms and Time Complexity.","views":488,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T21:35:04.000Z","updated_at":"2018-09-21T09:57:54.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1257,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$21","title":"Heap Sort in Data Structures","url_title":"heap-sort-in-data-structures","image_url":"","meta_title":"Learn Heap Sort in Data Structures From Experts ","meta_desc":"In this tutorial, we will discuss on sorting techniques based on Heap Data structures along with examples and algorithms.","views":441,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T21:40:07.000Z","updated_at":"2018-09-21T09:57:41.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1258,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$22","title":"Linked List in Data Structures","url_title":"linked-list-in-data-structures","image_url":"","meta_title":"Linked List in Data Structures","meta_desc":"In this tutorial, we will discuss about Linked List in Data Structures. The term “list” refers to a linear collection of data items. One way to store such","views":640,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T21:43:04.000Z","updated_at":"2018-09-21T09:57:23.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1262,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$23","title":"Queues using Linked list in Data Structures","url_title":"queues-using-linked-list-data-structures","image_url":"","meta_title":"Queues using Linked list in Data Structures","meta_desc":"In this tutorial, we will learn about Queues using Linked list in Data Structures. In configures storage (using arrays), queues where harder to manipulate","views":1064,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T22:47:03.000Z","updated_at":"2018-09-21T09:30:19.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1264,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$24","title":"Binary Trees in Data Structures","url_title":"binary-trees-in-data-structures","image_url":"","meta_title":"Binary Trees in Data Structures","meta_desc":"The objective of this tutorial is to understand Binary Trees in Data Structures. A binary tree T is defined as a finite set of elements, called nodes. T is","views":1077,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T22:51:39.000Z","updated_at":"2018-09-21T09:30:06.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1265,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$25","title":"Binary search tree in Data Structures","url_title":"binary-search-tree-in-data-structures","image_url":"","meta_title":"Binary search tree in Data Structures","meta_desc":"In this tutorial we will learn about Binary search tree in Data Structures. We will also look at few examples of binary search tree and understand their ada","views":287,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T22:53:26.000Z","updated_at":"2018-09-21T09:29:53.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1266,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$26","title":"AVL Trees in Data Structures","url_title":"avl-trees-in-data-structures","image_url":"","meta_title":"AVL Trees in Data Structures","meta_desc":"In this tutorial, we will gain knowledge on AVL Trees in Data Structures. We also discuss on algorithms and data structures in AVL Trees with examples.","views":1074,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T22:59:39.000Z","updated_at":"2018-09-21T09:29:39.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1259,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$27","title":"Circular linked list in Data Structures","url_title":"circular-linked-list-in-data-structures","image_url":"","meta_title":"Circular Linked List In Data Structures","meta_desc":"In this tutorial, we will learn about Circular linked list in Data Structures. A linked list in which the last node points to the first node instead of cont","views":787,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T23:03:38.000Z","updated_at":"2018-09-21T09:29:07.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1260,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$28","title":"Doubly Linked List in Data Structures","url_title":"doubly-linked-list-in-data-structures","image_url":"","meta_title":"Doubly Linked List in Data Structures","meta_desc":"In this tutorial, we will discuss about Doubly Linked List in Data Structures. In a single linked list, it is possible to move only in the direction of link","views":927,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-09T23:06:42.000Z","updated_at":"2018-09-21T09:18:36.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1267,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$29","title":"B Trees in Data Structures","url_title":"b-trees-in-data-structures","image_url":"","meta_title":"Study B Trees in Data Structures From Professionals","meta_desc":"In this tutorial, we will learn about B Trees in Data Structures. A B-tree is a self balancing tree that keeps data sorted and allows searches,Insertion,etc","views":452,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-10T18:34:53.000Z","updated_at":"2018-09-21T09:18:12.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1263,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2a","title":"TREES in Data Structures","url_title":"trees-in-data-structures","image_url":"","meta_title":"TREES in Data Structures","meta_desc":"In this tutorial, we will discuss about TREES in Data Structures. A tree in data structures is a finite set of one or more nodes such that, 1.A distinguish","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-10T18:45:32.000Z","updated_at":"2018-09-21T09:17:59.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1268,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2b","title":"Graphs in Data Structures","url_title":"graphs-in-data-structures","image_url":"","meta_title":"Learn Graphs in Data Structures designed by Experts","meta_desc":"In this tutorial, we will learn about Graphs in Data Structures. Graphs are a fundamental data structures in the world of Programming and more from examples","views":916,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2014-12-10T18:50:26.000Z","updated_at":"2018-09-21T09:17:39.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1727,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2c","title":"JSF Elements","url_title":"jsf-elements","image_url":"","meta_title":"JSF Elements | TekSlate JFS Tutorials Online","meta_desc":"JSF Elements - In JSF Tutorials we will learn about JSF Elements,","views":638,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2015-01-06T23:27:37.000Z","updated_at":"2018-09-20T08:51:37.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":181,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2d","title":"JSF Interview Questions & Answers","url_title":"jsf-interview-questions-answers","image_url":"","meta_title":"TOP 50 JSF Interview Questions [UPDATED] - TCS & Cognizant !!!","meta_desc":"Looking for JSF Interview Questions with Answers? Here we have compiled set of questions from the students who have attended interviews in Fortune 500 companies","views":615,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-02-22T05:29:48.000Z","updated_at":"2018-09-20T06:51:20.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1960,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2e","title":"Java Virtual Machine","url_title":"java-virtual-machine-java","image_url":"","meta_title":"What is Java Virtual Machine (JVM) | Learn Java Online","meta_desc":"The Java platform is the concept of a \"virtual machine\" that executes Java bytecode programs.we will learn Java Virtual Machine in this tutorials.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-14T10:19:53.000Z","updated_at":"2018-09-17T10:44:57.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1961,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$2f","title":"Interface in Java","url_title":"java-interface-in-java","image_url":"","meta_title":"What is an Interface in Java? | Core Java-TekSlate","meta_desc":"In this tutorial we will learn about Interface in java. Interface is one of the core concept. Java Interface is core part of java programming language.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-15T05:27:30.000Z","updated_at":"2018-09-17T10:44:42.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1962,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$30","title":"Exception Handling in java","url_title":"exception-handling-in-java","image_url":"","meta_title":"What is Exception Handling in java? Java Tutorials with Examples","meta_desc":"In this tutorials, we will learn Exception Handling in Java with checked, unchecked and errors with example and usage of keywords.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-15T06:45:13.000Z","updated_at":"2018-09-17T10:44:28.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1963,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$31","title":"Multithreading in java","url_title":"java-multithreading-in-java","image_url":"","meta_title":"Multithreading in java| Learn Java Online - TekSlate","meta_desc":"In this tutorial we will learn about Multithreading in java. Multithreading in Java enables you to write in a way where multiple activities can proceed..","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-16T06:28:25.000Z","updated_at":"2018-09-17T10:18:55.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1967,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$32","title":"Polymorphism in Java","url_title":"polymorphism-in-java","image_url":"","meta_title":"Polymorphism in Java with Examples| Learn Java Online","meta_desc":"In this tutorial we will learn about Polymorphism in java. Polymorphism in Java showing different behaviors at different stages of its life cycle.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-16T08:22:23.000Z","updated_at":"2018-09-17T10:14:30.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1968,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$33","title":"Inheritance in Java","url_title":"java-inheritance-in-java","image_url":"","meta_title":"Inheritance in Java With Examples| Learn Java Online","meta_desc":"In this tutorials we will learn about Inheritance in Java with examples.Inheritance in Java refers to the ability in Java for one class to inherit from....","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-17T06:05:19.000Z","updated_at":"2018-09-17T10:13:51.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1969,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$34","title":"Constructors in Java","url_title":"java-constructors-in-java","image_url":"","meta_title":"What is Constructors in Java | Learn Java Tutorials Online","meta_desc":"In this tutorial, we will learn about Constructors in Java. Constructors in Java Initialize the class variables to default values.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-17T08:50:08.000Z","updated_at":"2018-09-17T10:13:31.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1970,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$35","title":"Java Annotations","url_title":"java-annotations-in-java","image_url":"","meta_title":"Java Annotations With Examples | Learn Java Online-TekSlate","meta_desc":"In this tutorial, we will discuss about Java Annotations. Java Annotations are a kind of meta-data, about elements of your code.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-19T08:25:26.000Z","updated_at":"2018-09-17T10:13:12.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1971,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$36","title":"Encapsulation in java","url_title":"java-encapsulation-in-java","image_url":"","meta_title":"Encapsulation in java | Learn Java Online -TekSlate","meta_desc":"In this tutorial we will learn Encapsulation in java. Encapsulation in javais a process of wrapping of data and methods in a single unit.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-19T08:49:15.000Z","updated_at":"2018-09-17T10:06:55.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1972,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$37","title":"Packages in java","url_title":"packages-in-java","image_url":"","meta_title":"Packages in java With Examples| How to create Packages in Java","meta_desc":"In this tutorial, we will learn Packages in java.Packages in java.Packages in Java is a mechanism to encapsulate a group of classes, interfaces and sub...","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-19T09:30:38.000Z","updated_at":"2018-09-17T10:06:39.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1973,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$38","title":"Java Regular Expressions","url_title":"java-regular-expressions-in-java","image_url":"","meta_title":"What are Java Regular Expressions| Learn Java Online-TekSlate","meta_desc":"In this tutorial we will discuss about Java Regular Expressions. Java Regular Expressions introduces the usage of regular expressions and implementation....","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-20T06:00:37.000Z","updated_at":"2018-09-17T10:06:15.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1974,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$39","title":"Arraylist in Java","url_title":"java-arraylist-in-java","image_url":"","meta_title":"What is the Arraylist in Java | Learn Java Tutorials With Examples","meta_desc":"In Java tutorials, we will learn about Arraylist in Java.Java ArrayList in java collections with add, example and Implementing the ArrayList in Java.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-20T07:03:21.000Z","updated_at":"2018-09-17T10:05:31.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":2008,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3a","title":"Advanced Java Resume","url_title":"advanced-java-resume","image_url":"","meta_title":"Advanced Java Sample Resume","meta_desc":"We here share an Advanced JAVA Fresher and Experienced Sample Resume for Job Interview and also discuss on few Resume Writing Tips.","views":1006,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2017-09-23T08:34:45.000Z","updated_at":"2018-09-17T06:51:40.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1743,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3b","title":"Event Handler Event handling in JSF","url_title":"event-handler-event-handling-jsf","image_url":"","meta_title":"Event Handler Event Handling In JSF","meta_desc":"In this tutorial, we will learn about types of event handler event handling in JSF","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:13:37.000Z","updated_at":"2018-09-17T05:19:47.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1744,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3c","title":"Layouts in JSF- Tiles","url_title":"layouts-jsf-tiles","image_url":"","meta_title":"Layouts In JSF- Tiles","meta_desc":"In this tutorial, we will learn about what are the Layouts in JSF- Tiles and RICH Faces.","views":454,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:13:38.000Z","updated_at":"2018-09-17T05:19:35.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1742,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3d","title":"Basic GUI Components in JSF","url_title":"basic-gui-components-jsf","image_url":"","meta_title":"Basic Gui Components In JSF","meta_desc":"In this tutorial, we will learn about what are the Basic GUI Components in JSF.","views":450,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:14:11.000Z","updated_at":"2018-09-17T05:19:15.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1741,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3e","title":"CONVERTERS IN JSF","url_title":"converters-jsf","image_url":"","meta_title":"Converters In JSF","meta_desc":"In this tutorial, we will learn about what are the converters in JSF.","views":327,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:14:17.000Z","updated_at":"2018-09-17T05:18:50.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1740,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$3f","title":"Developing JSF2 Validations Application","url_title":"developing-jsf2-validations-application","image_url":"","meta_title":"Developing JSF2 Validations Application","meta_desc":"In this tutorial, we will learn about how to JSF2 Validations Application.","views":1021,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:17:13.000Z","updated_at":"2018-09-17T05:18:35.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1726,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$40","title":"FrameWorks in JSF","url_title":"frameworks-jsf","image_url":"","meta_title":"Frameworks In JSF","meta_desc":"In this tutorial, we will learn about what is Framework, Application of Framework in JSF","views":276,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:23:51.000Z","updated_at":"2018-09-17T05:14:31.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1728,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$41","title":"Creation and working with First Servlet in JSF","url_title":"creation-working-first-servlet-jsf","image_url":"","meta_title":"Creation And Working With First Servlet In JSF","meta_desc":"In this tutorial, we will learn about how to Create and working with Faces Servlet in JSF","views":282,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:23:58.000Z","updated_at":"2018-09-17T05:12:42.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1739,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$42","title":"JSF2 Validations Application","url_title":"jsf2-validations-application","image_url":"","meta_title":"JSF2 Validations Application","meta_desc":"In this tutorial, we will learn about JSF2 Validations Application","views":570,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:17:15.000Z","updated_at":"2018-09-17T05:12:19.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1737,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$43","title":"VALIDATIONS in JSF","url_title":"validations-jsf","image_url":"","meta_title":"Validations In JSF","meta_desc":"In this tutorial, we will learn about what are the Validations In JSF","views":187,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:17:31.000Z","updated_at":"2018-09-17T05:10:29.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1736,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$44","title":"steps to provide I18N Support in JSF Application","url_title":"steps-provide-i18n-support-jsf-application","image_url":"","meta_title":"Steps To Provide I18N Support In JSF Application","meta_desc":"In this tutorial, we will learn about what are steps to provide I18N Support in JSF Application","views":526,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:17:39.000Z","updated_at":"2018-09-17T05:09:53.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1735,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$45","title":"Developing I18N Applications in JSF","url_title":"developing-i18n-applications-jsf","image_url":"","meta_title":"Developing I18N Applications In JSF","meta_desc":"In this Developing I18N Applications In JSF tutorial, we will learn about How to make deploy I18N Applications in JSF","views":782,"rating":4.2,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:22:18.000Z","updated_at":"2018-09-17T05:09:11.000Z","status":1,"video_schema_name":"","video_schema_upload_date":"","video_schema_description":"","faq_schema_q1":"","faq_schema_a1":"","faq_schema_q2":"","faq_schema_a2":"","faq_schema_q3":"","faq_schema_a3":"","like_counter":0},{"id":1734,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$46","title":"Introduction to I18N Applications in JSF","url_title":"introduction-i18n-applications-jsf","image_url":"","meta_title":"Introduction To I18N Applications In JSF","meta_desc":"In this tutorial, we will learn about Introduction to I18N Applications in JSF and where I18N is Supported.","views":435,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:23:25.000Z","updated_at":"2018-09-17T05:06:44.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1733,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$47","title":"Steps to use Hyperlinks in JSF pages","url_title":"steps-use-hyperlinks-jsf-pages","image_url":"","meta_title":"Steps To Use Hyperlinks In JSF Pages","meta_desc":"In this tutorial, we will learn about what Steps to use Hyperlinks in JSF pages.","views":430,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:23:29.000Z","updated_at":"2018-09-17T05:05:42.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1725,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$48","title":"Enterprise Application in JSF","url_title":"enterprise-application-jsf","image_url":"","meta_title":"Enterprise Application In JSF","meta_desc":"In this tutorial, we will learn about what is Enterprise Application in JSF.","views":544,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:23:45.000Z","updated_at":"2018-09-17T05:04:15.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1724,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$49","title":"MVC Rules and Regulation in JSF","url_title":"mvc-rules-regulation-jsf","image_url":"","meta_title":"Mvc Rules And Regulation In JSF","meta_desc":"In this tutorial, we will learn about what are MVC Rules and Regulation in JSF.","views":122,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:36.000Z","updated_at":"2018-09-17T04:59:40.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1729,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4a","title":"STEPS TO DESIGN FIRST APPLICATION in JSF","url_title":"steps-design-first-application-jsf","image_url":"","meta_title":"Steps To Design First Application In JSF","meta_desc":"In this tutorial, we will learn about what are the Steps To Design First Application In JSF.","views":387,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:41.000Z","updated_at":"2018-09-17T04:59:25.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1731,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4b","title":"STEPS TO DESIGN JSF 1.2 APPLICATION IN ECLIPSE IDE","url_title":"steps-design-jsf-1-2-application-eclipse-ide","image_url":"","meta_title":"Steps To Design JSF 1.2 Application In Eclipse IDE","meta_desc":"In this tutorial, we will learn about how to Design JSF 1.2 Application In Eclipse IDE.","views":722,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:45.000Z","updated_at":"2018-09-17T04:58:55.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1730,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4c","title":"Developing Registration Application in JSF","url_title":"developing-registration-application-jsf","image_url":"","meta_title":"Developing Registration Application In JSF","meta_desc":"In this tutorial, we will learn about how to develop on Registration Application in JSF","views":991,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:52.000Z","updated_at":"2018-09-17T04:54:46.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1732,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4d","title":"DIFFERENCE BET N JSF1.X &JSF 2.X","url_title":"difference-bet-n-jsf1-x-jsf-2-x","image_url":"","meta_title":"Difference Bet N JSF1.X &JSF 2.X","meta_desc":"In this tutorial, we will learn about what are the differences between JSF1.X &JSF 2.X","views":539,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:48.000Z","updated_at":"2018-09-17T04:54:33.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":1723,"blog_category":174,"blog_type":3,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4e","title":"Introduction to JSF","url_title":"introduction-jsf","image_url":"","meta_title":"Introduction To JSF","meta_desc":"In this tutorial, we will learn about what is JSF and its architecture.","views":979,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-01-09T09:25:56.000Z","updated_at":"2018-09-17T04:54:18.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":477,"blog_category":174,"blog_type":2,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"

JSF (JavaServer Faces) Interview Questions And  Answers

\n

 

","title":"JSF Interview Questions And Answers","url_title":"jsf-interview-questions-and-answers","image_url":"","meta_title":"TOP 50 JSF Interview Questions [UPDATED] - TCS & Cognizant !!!","meta_desc":"Looking for JSF Interview Questions with Answers? Here we have compiled set of questions from the students who have attended interviews in Fortune 500 companies","views":946,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2018-03-15T06:28:36.000Z","updated_at":"2018-09-12T06:00:53.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0},{"id":150,"blog_category":174,"blog_type":1,"wp_id":1,"excerpt":null,"table_of_content":null,"description":"$4f","title":"JAVA Tutorials","url_title":"java-tutorials","image_url":"","meta_title":"Learn Java Tutorials Online With Examples | Learn Online","meta_desc":"Java tutorials gives enough knowledge to get up and run with real world application development and object-oriented programming using the Java Language.","views":0,"rating":4,"author":"1","top_level_cat_id":"4","author_desc":"","course_id":"2","created_at":"2016-12-14T06:47:26.000Z","updated_at":"2017-12-20T10:11:23.000Z","status":1,"video_schema_name":null,"video_schema_upload_date":null,"video_schema_description":null,"faq_schema_q1":null,"faq_schema_a1":null,"faq_schema_q2":null,"faq_schema_a2":null,"faq_schema_q3":null,"faq_schema_a3":null,"like_counter":0}],"type":"blog-cat","categories":[]},"urlName":"core-java"}] a:[["$","meta","0",{"name":"viewport","content":"width=device-width, initial-scale=1"}],["$","meta","1",{"charSet":"utf-8"}],["$","title","2",{"children":"core-java"}],["$","meta","3",{"name":"description","content":"TekSlate provides all the essential resources to help you become a skilled salesforce professional. Here is the list of informative resources that include tutorials, interview questions, and other technical blogs to make it easy for you to master core-java."}],["$","meta","4",{"name":"application-name","content":"tekslatetutor"}],["$","meta","5",{"name":"generator","content":"tekslatetutor"}],["$","link","6",{"rel":"canonical","href":"https://tekslate.com/core-java"}],["$","meta","7",{"property":"og:title","content":"core-java"}],["$","meta","8",{"property":"og:description","content":"TekSlate provides all the essential resources to help you become a skilled salesforce professional. Here is the list of informative resources that include tutorials, interview questions, and other technical blogs to make it easy for you to master core-java."}],["$","meta","9",{"property":"og:url","content":"https://tekslate.com/core-java"}],["$","meta","10",{"property":"og:site_name","content":"tekslatetutor"}],["$","meta","11",{"property":"og:locale","content":"en_US"}],["$","meta","12",{"property":"og:image","content":"https://tekslateassets.s3.amazonaws.com/images/TekSlate_New+Colour.svg"}],["$","meta","13",{"property":"og:image:width","content":"1200"}],["$","meta","14",{"property":"og:image:height","content":"628"}],["$","meta","15",{"property":"og:type","content":"website"}],["$","meta","16",{"name":"twitter:card","content":"summary"}],["$","meta","17",{"name":"twitter:creator","content":"@tekslatetutor"}],["$","meta","18",{"name":"twitter:title","content":"core-java"}],["$","meta","19",{"name":"twitter:description","content":"TekSlate provides all the essential resources to help you become a skilled salesforce professional. Here is the list of informative resources that include tutorials, interview questions, and other technical blogs to make it easy for you to master core-java."}],["$","meta","20",{"name":"twitter:image","content":"https://tekslateassets.s3.amazonaws.com/images/TekSlate_New+Colour.svg"}],["$","link","21",{"rel":"icon","href":"https://tekslateassets.s3.amazonaws.com/images/favicon.svg"}]] 1:null