Software Consultant

Code : 

import java.util.*;
public class Test { 
public static void main(String args[]) { 
Scanner s = new Scanner(System.in);
String word = s.nextLine();
System.out.println("Is "+word+" palindrome? - "+isWordPalindrome(word));
} 


public static boolean isWordPalindrome(String word){ 
String reverseWord = getReverseWord(word); 
//if word equals its reverse, then it is a palindrome
if(word.equals(reverseWord)){ 
return true; 
} 
return false; 
} 

public static String getReverseWord(String word){ 
if(word == null || word.isEmpty()){ 
return word; 
} 

return word.charAt(word.length()- 1) + getReverseWord(word.substring(0, word.length() - 1)); 
} 
} 

TC : O(N), where N = length of the string

1) Class(Method) Area: Class Area stores per-class structures such as the runtime constant pool, field, method data,
and the code for methods.

2) Heap: It is the runtime data area in which the memory is allocated to the objects

3) Stack: Java Stack stores frames. It holds local variables and partial results, and plays a part in method invocation
and return. Each thread has a private JVM stack, created at the same time as the thread. A new frame is created
each time a method is invoked. A frame is destroyed when its method invocation completes.

4) Program Counter Register: PC (program counter) register contains the address of the Java virtual machine
instruction currently being executed.

5) Native Method Stack: It contains all the native methods used in the application.

1) Storage area : In string, the String pool serves as the storage area. For StringBuilder and StringBuffer, heap
memory is the storage area.

2) Mutability : A String is immutable, whereas both the StringBuilder and StringBuffer are mutable.

3) Efficiency : It is quite slow to work with a String. However, StringBuilder is the fastest in performing operations. The
speed of a StringBuffer is more than a String and less than a StringBuilder. (For example appending a character is
fastest in StringBuilder and very slow in String because a new memory is required for the new String with appended
character.)

4) Thread-safe : In the case of a threaded environment, StringBuilder and StringBuffer are used whereas a String is
not used. However, StringBuilder is suitable for an environment with a single thread, and a StringBuffer is suitable for
multiple threads.

The best way of putting a CURSOR to use in a COBOL program is to make use of DECLARE CURSOR, which can be used either in procedure division operation or in working storage. This is being done basically to highlight the SELECT statement. Once DECLARE CURSOR is used, this is followed by OPEN, FETCH and finally CLOSE.

To find number of rows : The user has to use SELECT COUNT (*) on the DB2 query.

To eliminate duplicate values from DB2 SELECT : The user has to use SELECT DISTINCT in the DB2 query.

SELECT A.ID_Name, B.ID_Name
FROM A
INNER JOIN B ON A.ID=B.ID;

Normalization is a process of reducing redundancy by organizing the data into multiple tables. Normalization leads to
better usage of disk spaces and makes it easier to maintain the integrity of the database.


Denormalization is the reverse process of normalization as it combines the tables which have been normalized into a
single table so that data retrieval becomes faster. JOIN operation allows us to create a denormalized form of the data
by reversing the normalization.

A Subquery is also known as a nested query i.e. a query written inside some query. When a Subquery is executed for each of the rows of the outer query then it is termed as a Correlated Subquery.

Example of Non-Correlated Subquery is :

SELECT * from EMP WHERE ‘JOHN’ IN (SELECT Name from DEPT WHERE EMP.EMPID=DEPT.EMPID);

RequestMapping can be used with GET, POST, PUT, and many other request methods using the method attribute on
the annotation. Whereas GetMapping is only an extension of RequestMapping, which helps you to improve clarity on
requests.

Spring Boot automatically configures your application based on the dependencies you have added to the project by
using annotation. The entry point of the spring boot application is the class that contains @SpringBootApplication
annotation and the main method.

Spring Boot automatically scans all the components included in the project by using @ComponentScan annotation.

Here is how MVC works in Spring :

1) DispatcherServlet receives a request.

2) After that, the DispatcherServlet communicates with HandlerMapping. It also revokes the controller associated with
that specific request.

3) The Controller processes this request by calling the service methods, and a ModelAndView object is returned by
the DispatcherServlet.

4) The view name is sent to a ViewResolver to find the actual View to invoke.

5) After that, DispatcherServlet is passed to View to render the result.

6) By using the model data, the View renders and sends back result back to the user.

Few important features of Spring Boot are as follows:

1) Spring CLI – Spring Boot CLI allows you to Groovy for writing Spring boot application and avoids boilerplate code.

2) Starter Dependency – With the help of this feature, Spring Boot aggregates common dependencies together and eventually improves productivity

3) Auto-Configuration – The auto-configuration feature of Spring Boot helps in loading the default configurations according to the project you are working on. In this way, you can avoid any unnecessary WAR files.

4) Spring Initializer – This is basically a web application, which can create an internal project structure for you. So, you do not have to manually set up the structure of the project, instead, you can use this feature.

5) Spring Actuator – This feature provides help while running Spring Boot applications.

6) Logging and Security – The logging and security feature of Spring Boot, ensures that all the applications made using Spring Boot are properly secured without any hassle.

Below are the two significant features of the methods that are defined as the lambda expressions:
1) Lambda expressions can be passed as a parameter to another method.
2) Lambda expressions can be standalone without belonging to any class.

Some of the famous pre-defined functional interfaces from previous Java versions are Runnable, Callable,
Comparator, and Comparable. While Java 8 introduces functional interfaces like Supplier, Consumer, Predicate, etc.
Please refer to the java.util.function doc for other predefined functional interfaces and its description introduced in
Java 8.

Runnable: use to execute the instances of a class over another thread with no arguments and no return value.

Callable: use to execute the instances of a class over another thread with no arguments and it either returns a value
or throws an exception.

Comparator: use to sort different objects in a user-defined order

Comparable: use to sort objects in the natural sort order

The differences between Abstract Class and Interface are as follows :

Abstract Class:

1) Abstract classes have a default constructor and it is called whenever the concrete subclass is instantiated.
2) It contains Abstract methods as well as Non-Abstract methods.
3) The class which extends the Abstract class shouldn’t require the implementation of all the methods, only Abstract
methods need to be implemented in the concrete sub-class.
4) Abstract class contains instance variables.


Interface:

1 )It doesn’t have any constructor and couldn’t be instantiated.
2) The abstract method alone should be declared.
3) Classes that implement the interface should provide the implementation for all the methods.
4) The interface contains only constants.

The super keyword is used to access hidden fields and overridden methods or attributes of the parent class.

Following are the cases when this keyword can be used : 
1) Accessing data members of parent class when the member names of the class and its child subclasses are same.

2) To call the default and parameterized constructor of the parent class inside the child class.

3) Accessing the parent class methods when the child classes have overridden them.

Tip 1 : The cross questioning can go intense some time, think before you speak.

Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.

Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round,
like what are the projects currently the company is investing, which team you are mentoring. How all is the work
environment etc.