Friday, February 11, 2022

All Java 8 / J2EE Interview for Experienced

 1.      Functional Interface, Stream API?

Functional interfaces are also called Single Abstract Method interfaces (SAM Interfaces). As name suggest, a functional interface permits exactly one abstract method in it.  Java 8 introduces @FunctionalInterface annotation which can be used for giving compile-time errors it a functional interface violates the contracts.

What are the functional interfaces available in java?

Some of the examples of functional interfaces in Java are Runnable, ActionListener, Comparable interfaces

Stream API:

Java provides a new additional package in Java 8 called java.util.stream. This package consists of classes, interfaces and enum to allows functional-style operations on the elements. You can use stream by importing java.util.stream package.

Stream provides following features:

·       Stream does not store elements. It simply conveys elements from a source such as a data structure, an array, or an I/O channel, through a pipeline of computational operations.

·       Stream is functional in nature. Operations performed on a stream does not modify it's source. For example, filtering a Stream obtained from a collection produces a new Stream without the filtered elements, rather than removing elements from the source collection.

·       Stream is lazy and evaluates code only when required.

·       The elements of a stream are only visited once during the life of a stream. Like an Iterator, a new stream must be generated to revisit the same elements of the source.

·       You can use stream to filter, collect, print, and convert from one data structure to other etc. In the following examples, we have applied various operations with the help of stream.

Java8 Features? Java8 Features

Lambda Expression:  In Java programming language, a Lambda expression (or function) is just an anonymous function, i.e.,function with no name and without being bounded to an identifier.

Lambda expressions are written exactly in the place where it’s needed, typically as a parameter to some other function.

Syntax:

(parameters)->expression

(parameters)->{statements;}

()->expression

(x,y)->x+y

1.      A lambda expression can have zero, one or more parameters.

2.      The type of the parameters can be explicitly declared, or it can be inferred from the context.

3.      Multiple parameters are enclosed in mandatory parentheses and separated by commas. Empty parentheses are used to represent an empty set of parameters.

4.      When there is a single parameter, if its type is inferred, it is not mandatory to use parentheses.

5.      The body of the lambda expressions can contain zero, one, or more statements.

6.      If the body of lambda expression has a single statement, curly brackets are not mandatory and the return type of the anonymous function is the same as that of the body expression. When there is more than one statement in the body then these must be enclosed in curly brackets.

Functional Interfaces

Functional interfaces are also called Single Abstract Method interfaces (SAM Interfaces). As name suggest, a functional interface permits exactly one abstract method in it.

Java 8 introduces @FunctionalInterface annotation which can be used for giving compile-time errors it a functional interface violates the contracts.

Functional Interface Example

//Optional annotation

@FunctionalInterface

public interface MyFirstFunctionalInterface {public void firstWork(); }

For example, given below is a perfectly valid functional interface.

@FunctionalInterface

public interface MyFirstFunctionalInterface{

 public void firstWork();

    @Override

    public String toString();                //Overridden from Object class

     @Override

    public booleanequals(Object obj);        //Overridden from Object class

}

3. Default Methods

Java 8 allows us to add non-abstract methods in the interfaces. These methods must be declared default methods. Default methods were introducing in java 8 to enable the functionality of lambda expression.

Default methods enable us to introduce new functionality to the interfaces of our libraries and ensure binary compatibility with code written for older versions of those interfaces.

public interface Moveable {

    default void move(){

System.out.println("I am moving");    }}

public class Animal implements Moveable{

    public static void main(String[] args){

        Animal tiger = new Animal();

        tiger.move();    }}

Output: I am moving

4. Java 8 Streams

Another major change introduced Java 8 Streams API, which provides a mechanism for processing a set of data in various ways that can include filtering, transformation, or any other way that may be useful to an application.

Streams API in Java 8 supports a different type of iteration where we simply define the set of items to be processed, the operation(s) to be performed on each item, and where the output of those operations is to be stored.

4.1. Stream API Example

In this example, items is collection of String values and we want to remove the entries that begin with some prefix text.

List<String>items;

String prefix;

List<String> filteredList = items. stream().filter(e -> (!e.startsWith(prefix))).collect(Collectors.toList());

5. Java 8 Date/Time API Changes

The new Date and Time APIs/classes (JSR-310), also called as ThreeTen, which have simply changed the way we have been handling dates in java applications.

 

5.1. Date Classes

Date class has even become obsolete. The new classes intended to replace Date class are LocalDate, LocalTime and LocalDateTime.

The LocalDate class represents a date. There is no representation of a time or time-zone.

The LocalTime class represents a time. There is no representation of a date or time-zone.

The LocalDateTime class represents a date-time. There is no representation of a time-zone

Example:

LocalDate localDate = LocalDate.now();

LocalTime localTime = LocalTime.of(12, 20);

LocalDateTime localDateTime = LocalDateTime.now();

OffsetDateTime offsetDateTime = OffsetDateTime.now();

6.StringJoiner

Java added a new final class StringJoiner in java.util package. It is used to construct a sequence of characters separated by a delimiter. Now, you can create string by passing delimiters like comma(,), hyphen(-) etc.

Eg:      public class StringJoinerExample { 

           public static void main(String[] args) { 

//adding prefix and suffix

//StringJoiner joinNames = new StringJoiner(","); // passing comma(,) as delimiter  

StringJoiner joinNames = new StringJoiner(",", "[", "]");   // passing comma(,) and square-brackets as delimiter            

// Adding values to StringJoiner

joinNames.add("Rahul");

joinNames.add("Raju");

joinNames.add("Peter");

joinNames.add("Raheem");

System.out.println(joinNames); }}

Collectors

Collectors is a final class that extends Object class. It provides reduction operations, such as accumulating elements into collections, summarizing elements according to various criteria etc.

Example:

List<Product>productsList = new ArrayList<Product>(); 

        //Adding Products 

productsList.add(newProduct(1,"HP Laptop",25000f)); 

productsList.add(newProduct(2,"Dell Laptop",30000f)); 

productsList.add(newProduct(3,"Lenevo Laptop",28000f)); 

productsList.add(newProduct(4,"Sony Laptop",28000f)); 

productsList.add(newProduct(5,"Apple Laptop",90000f)); 

Set<Float>productPriceList =  productsList.stream() .map(x->x.price)         // fetching price 

.collect(Collectors.toSet());   // collecting as list 

System.out.println(productPriceList);

Example 2:

Long noOfElements = productsList.stream().collect(Collectors.counting()); 

System.out.println("Total elements : "+noOfElements);

Example 3:

Double average = productsList.stream().collect(Collectors.averagingDouble(p->p.price)); 

System.out.println("Average price is: "+average);

 

Supplier : The Supplier Interface is a part of the java. util. function package which has been introduced since Java 8, to implement functional programming in Java. It represents a function which does not take in any argument but produces a value of type T.

 

Java 8 Supplier is a functional interface whose functional method is get(). The Supplier interface represents an operation that takes no argument and returns a result. As this is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference

2. SpringBoot: What different Annotations you implemented?

@SpringBootApplication

single @SpringBootApplication annotation can be used to enable those three features, that is: @EnableAutoConfiguration: enable Spring Boot's auto-configuration mechanism. @ComponentScan: Enable @Component scan on the package where the application is located

3. In Spring Boot, how you can implement DI without bean.xml file

4. Difference between @Autowired and @Qualifer, main significance of @Qualifier, @Primary?

The @Autowired (NoSuchBeanDefinitionException) annotation provides more accurate control over where and how autowiring should be done. This annotation is used to autowire bean on the setter methods, constructor, a property or methods with arbitrary names or multiple arguments. By default, it is a type driven injection.

When you create more than one bean of the same type and want to wire only one of them with a property you can use the @Qualifier annotation along with @Autowired to remove the ambiguity by specifying which exact bean should be wired.

Ex: Here we have two classes, Employee and EmpAccount respectively. In EmpAccount, using @Qualifier its specified that bean with id emp1 must be wired. (NoUniqueBeanDefinitionException)

In Spring framework, the @Primary annotation is used to give higher preference to a bean, when there are multiple beans of same type. The @Primary annotation may be used on any class directly or indirectly annotated with @Component or on methods annotated with @Bean

5.ThreadExecutorService in multithreading.

We use the Executors. newSingleThreadExecutor () method to create an ExecutorService that uses a single worker thread for executing tasks. If a task is submitted for execution and the thread is currently busy executing another task, then the new task will wait in a queue until the thread is free to execute it.

 

The ExecutorService helps in maintaining a pool of threads and assigns them tasks. It also provides the facility to queue up tasks until there is a free thread available if the number of tasks is more than the threads available.

6.Volatile Keyword in Java?

volatile keyword is used to communicate the content of memory between threads.

public final class Singleton {

    private static volatile Singleton instance = null;

    private Singleton() {}

    public static Singleton getInstance() {

        if (instance == null) {

           synchronized(Singleton.class) {

                             if (instance == null) {

                            instance = new Singleton();   }   }   }     return instance;               } }

7. Hibernate: Why we use and what are main features?

 

Hibernate is a Java framework that simplifies the development of Java application to interact with the database. It is an open source, lightweight, ORM (Object Relational Mapping) tool. Hibernate implements the specifications of JPA (Java Persistence API) for data persistence.

·                It provides Simple Querying of data.

·                An application server is not required to operate.

·                The complex associations of objects in the database can be manipulated.

·                Database access is minimized with smart fetching strategies.

·                It manages the mapping of Java classes to database tables without writing any code.

·                Properties of XML file is changed in case of any required change in the database.

There are many features in Hibernate Java framework.

·                Relationship: Hibernate supports relationships like One-To-One, One-To-One, One-To-Many, Many-To-Many.

·                Support Association: Hibernate supports association type of relationship: composition and aggregation.

·                Support Inheritance:  In hibernate, if we save derived class object, then its base class object will also be stored into the database, it means hibernate supports inheritance mechanism.

·                Support Primary Key: Hibernate has capability to generate primary keys automatically while we are storing the records into database

·                Support Composite Key: Hibernate has capability to generate composite primary keys based on the provided meta data.

·                Support Validation: Hibernate support domain model validation which enable by annotation. Hibernate has one of the projects which is called Hibernate Validator which has rich set of validation.

·                Support Full-Text Search: Hibernate has a project which is called Hibernate Search which support full-text search on domain model object.

·                Supports Collection (List/Set/Map): Hibernate supports Java collections data structure: List, Set, Map.

·                Caching: Hibernate supports 2 level of caching, first level and second level. Caching mechanism reduces the number of round trips between an application and the database improve our user experience and performance of application.

·                HQL (Hibernate Query Language): Hibernate has its own query language, i.e. HQL (Hibernate query language) which is database independent

·                No locking of DB: Hibernate says don’t rely on database by writing your own SQL query. Prefer not to write SQL query in project if you are using Hibernate.

·                No need of try-catch-exception block: when we write code in JDBC, we use to catch SQLException and transform into another exception it means, all exceptions are checked exceptions, so we must write code in try-catch-exception and throws. But in hibernate we only have Un-checked/run-time exceptions, so no need to write try-catch-exception block and throws clause. Hibernate we have the translator which converts checked/compile time to Un-checked/run-time

·                Auto-Generation: While we are inserting any record, if we don’t have any particular table in the database, JDBC will rises an error like “View not exist”, and throws exception, but in case of Hibernate, if it not found any table in the database this will create the table for us , if we configured in our meta-data configuration file.

·                Auto-Generation Query on Console: if we have enabled auto generation of query that will print/display on console or log file which help most of the times when you debug any issue.

·                Support Annotation: Hibernate supports annotations, apart from XML

·                Support many databases: Hibernate provided Dialect classes, so we no need to write SQL queries in Hibernate, instead we use the methods provided by that API.

·                Pagination Support: Getting pagination in hibernate is quite simple.

·                Hierarchal Data: fetching of Hierarchal data in Hibernate is very simple, e.g. in catalog system, you can pull catalog -> category -> product -> product variation in one go, which is very complex pull hierarchal data in normal JDBC.

·                Smart Query Generation: If you think from developer mind set, most of the time you are not able to tune our query. why we not able to tune our query? there could be various reason for this: you may know how to tune but don’t have sufficient time, sometimes you know how to tune but due to laziness, sometime don’t know how to tune, sometimes focus is to finish our functionality, sometimes we know but think later point of time will do this but later never come you know. Hibernate generate smart query by us using its smart query generation engine.

·                Support Query Criteria: This is powerful component in Hibernate, which enable rich set of filter and project. if you want to generate your own query on run time that is most difficult to do in simple JDBC and time-consuming test case. But when you are using Query Criteria of Hibernate it’s very easy based on condition specially for search functionality on 3/4 fields.

8.First level cache, second level cache in hibernate?

The main difference between the first level and second level cache in Hibernate is that the first level is maintained at the Session level and accessible only to the Session, while the second level cache is maintained at the SessionFactory level and available to all Sessions.

 

 

9.Different Cache providers?

EHCache: It can cache in memory or on disk and clustered caching and it supports the optional Hibernate query result cache.

 

OSCache: Supports caching to memory and disk in a single JVM with a rich set of expiration policies and query cache support.

 

warmCache:  A cluster cache based on JGroups. It uses clustered invalidation but doesn't support the Hibernate query cache.

 

JBoss Cache: A fully transactional replicated clustered cache also based on the JGroups multicast library. It supports replication or invalidation, synchronous or asynchronous communication, and optimistic and pessimistic locking. The Hibernate query cache is supported.

 

10.Difference between Synchronous and Asynchronous API?

Synchronous means that you call a web service (or function or whatever) and wait until it returns - all other code execution and user interaction is stopped until the call returns.

 Asynchronous means that you do not halt all other operations while waiting for the web service call to return.

 

11.How you use SOAP in project?

12.WSDL and XSD?

XSD defines a schema which is a definition of how an XML document can be structured. You can use it to check that a given XML document is valid and follows the rules you've laid out in the schema.

WSDL is a XML document that describes a web service. It shows which operations are available and how data should be structured to send to those operations. WSDL documents have an associated XSD that show what is valid to put in a WSDL document.

 

13.Oracle: What is inner join and outer join?

Inner Join: Returns records that have matching values in both tables.

E.g. SELECT Orders.OrderID, Customers.CustomerName

FROM Orders INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;

 

LEFT OUTER JOIN: Returns all records from the left table, and the matched records from the right table.

 

E.g. SELECT Customers.CustomerName, Orders.OrderID FROM Customers

LEFT JOIN Orders ON Customers.CustomerID = Orders.CustomerID

ORDER BY Customers.CustomerName;

 

RIGHT (OUTER) JOIN: Returns all records from the right table, and the matched records from the left table.

 

E.g. SELECT Orders.OrderID, Employees.LastName, Employees.FirstName

FROM Orders RIGHT JOIN Employees ON Orders.EmployeeID = Employees.EmployeeID

ORDER BY Orders.OrderID;

 

FULL OUTER JOIN/ FULL JOIN:

 

SELECT Customers.CustomerName, Orders.OrderID

FROM Customers FULL OUTER JOIN Orders ON Customers.CustomerID=Orders.CustomerID

ORDER BY Customers.CustomerName;

 

14.Stored procedure and Stored function difference?

 

The function must return a value but in Stored Procedure it is optional. Even a procedure can return zero or n values.

Functions can have only input parameters for it whereas Procedures can have input or output parameters.

Functions can be called from Procedure whereas Procedures cannot be called from a Function.

Advance Differences between Stored Procedure and Function in SQL Server

The procedure allows SELECT as well as DML(INSERT/UPDATE/DELETE) statement in it whereas Function allows only SELECT statement in it.

Procedures cannot be utilized in a SELECT statement whereas Function can be embedded in a SELECT statement.

Stored Procedures cannot be used in the SQL statements anywhere in the WHERE/HAVING/SELECT section whereas Function can be.

Functions that return tables can be treated as another Rowset. This can be used in JOINs with other tables.

Inline Function can be through of as views that take parameters and can be used in JOINs and other Rowset operations.

 

15.In previous project, how you save documents in Documentum?

Documentum is like a normal filesystem (hard drive) on steroids. Instead of storing your files on your own hard disk, you store them inside the Documentum system. This allows people to access your files if they need to and allows you to access their files. It's kind of like a network file server, but much fancier.

 

16.What is Security Encryption?

Encryption “attempts to make information unreadable by anyone who is not explicitly authorized to view that data”. People or devices can be authorized to access encrypted data in many ways, but typically this access is granted via passwords or decryption keys.

 

17.Difference between Encryption and Encoding?

Encryption is the process of securely encoding data in such a way that only authorized users with a key or password can decrypt the data to reveal the original.

Encoding data is used only when talking about data that is not securely encoded.

 

18.What are different keywords used in DB for select statement?

SELECT

Selects data from a database

SELECT DISTINCT

Selects only distinct (different) values

SELECT INTO

Copies data from one table into a new table

SELECT TOP

Specifies the number of records to return in the result set

19.Lambda expressions?

Lambda expression (or function) is just an anonymous function, i.e.,function with no name and without being bounded to an identifier.

Lambda expressions are written exactly in the place where it’s needed, typically as a parameter to some other function.

Syntax:

(parameters)->expression

(parameters)->{statements;}

()->expression

(x,y)->x+y

20.Messaging queue?

A message queue provides a lightweight buffer which temporarily stores messages, and endpoints that allow software components to connect to the queue in order to send and receive messages. The messages are usually small, and can be things like requests, replies, error messages, or just plain information.

 

21.Condition based annotations?

Using Spring @Conditional annotation you can conditionally register a component. With @Conditional annotation, you need to specify a condition and the component is registered only if the condition is true. For specifying the condition, you need to implement org.springframework.context.annotation.Condition interface.

22.Java Threads and future classes?

Extending the Thread class will make your class unable to extend other classes, because of the single inheritance feature in JAVA. However, this will give you a simpler code structure. If you implement Runnable, you can gain better object-oriented design and consistency and avoid the single inheritance problems.

If you just want to achieve basic functionality of a thread you can simply implement Runnable interface and override run() method. But if you want to do something serious with thread object as it has other methods like suspend(), resume(), etc which are not available in Runnable interface then you may prefer to extend the Thread class.

Signature of thread:

public class Thread extends Object implements Runnable {}

 

Thread Class Priority Constants

MAX_PRIORITY            It represents the maximum priority that a thread can have.

MIN_PRIORITY             It represents the minimum priority that a thread can have.

NORM_PRIORITY It represents the default priority that a thread can have.

Default priority of a thread is 5 (NORM_PRIORITY). The value of MIN_PRIORITY is 1 and the value of MAX_PRIORITY is 10.

Thread class also defines many methods for managing threads.

setName()        to give thread a name

getName()        return thread's name

getPriority()     return thread's priority

isAlive()             checks if thread is still running or not

join()    Wait for a thread to end

run()     Entry point for a thread

sleep() suspend thread for a specified time

start()   start a thread by calling run() method

activeCount()  Returns an estimate of the number of active threads in the current thread's thread group and its subgroups.

checkAccess()  Determines if the currently running thread has permission to modify this thread.

currentThread()            Returns a reference to the currently executing thread object.

dumpStack()    Prints a stack trace of the current thread to the standard error stream.

getId()  Returns the identifier of this Thread.

getState()          Returns the state of this thread.

getThreadGroup()        Returns the thread group to which this thread belongs.

interrupt()        Interrupts this thread.

interrupted()   Tests whether the current thread has been interrupted.

isAlive()             Tests if this thread is alive.

isDaemon()      Tests if this thread is a daemon thread.

isInterrupted() Tests whether this thread has been interrupted.

setDaemon(boolean on)          Marks this thread as either a daemon thread or a user thread.

setPriority(int newPriority)     Changes the priority of this thread.

yield()  A hint to the scheduler that the current thread is willing to yield its current use of a processor.

23. RUNNABLE CALLABLE?

Callable has call() method but Runnable has run() method.  Callable has call method which returns value but Runnable has run method which doesn't return any value. call method can throw checked exception but run method can't throw checked exception.

Callable use submit() method to put in task queue but Runnable use execute() method to put in the task queue.

 

24. How Spring security works and GrantedAuthority and different authorities?

Spring Security Roles as Container: -

User with ROLE_ADMIN role have the authorities to READ, DELETE, WRITE, UPDATE. A user with role ROLE_USER has authority to READ only. User with ROLE_MANAGER can perform READ , WRITE and UPDATE operations.

Granted authority in spring security is a “permission” or “right” given to a role. Some example of the granted authorities can be

1)READ_AUTHORITY   2) WRITE_AUTHORITY   3) UPDATE_AUTHORITY 4) DELETE_AUTHORITY

Eg:

public User(String username,  String password,   boolean enabled,   boolean accountNonExpired,

            boolean credentialsNonExpired,   boolean accountNonLocked,

            Collection<? extends GrantedAuthority> authorities)

Roles can be seen as coarse-grained GrantedAuthorities represented as a String with prefix with “ROLE“. We can use a role directly in Spring security application by using hasRole("CUSTOMER"). For few simple applications, you can think of Roles as a GrantedAuthorities. Here are some examples for the Spring security Roles.

1)      ROLE_ADMIN

2)      ROLE_MANAGER

3)      ROLE_USER

We can also use the roles as container for authorities or privileges. This approach provides flexibility to map roles based on business rules. Let’s take look at few examples to understand it clearly.

User with ROLE_ADMIN role have the authorities to READ,DELETE,WRITE,UPDATE.

A user with role ROLE_USER has authority to READ only.

User with ROLE_MANAGER can perform READ, WRITE and UPDATE operations.

 

Using Granted Authority vs Role in Spring Security

Spring security use the hasRole() and hasAuthority() interchangeably. With Spring security 4, it is more consistent, and we should also be consistent with our approach while using the hasRole() and hasAuthority() method. Let’s keep in mind the following simple rules.

Always add the ROLE_ while using the hasAuthority() method (e.g hasAuthority("ROLE_CUSTOMER")).

While using hasRole(), do not add the ROLE_ prefix as it will be added automatically by Spring security (hasRole("CUSTOMER")).

 

25.How Spring boot connect to DB?

To access the Relational Database by using JdbcTemplate in Spring Boot application, we need to add the Spring Boot Starter JDBC dependency in our build configuration file. Then, if you @Autowired the JdbcTemplate class, Spring Boot automatically connects the Database and sets the DataSource for the JdbcTemplate object.

 

How does spring boot connect to external DB?

Updating the Spring Boot Project Step by Step

Step 1 - Add a Dependency for Your Database Connector to pom. xml. ...

Step 2 - Remove H2 Dependency From pom.xml. Or at least make its scope as test. ...

Step 3 - Setup Your MySQL Database. ...

Step 4 - Configure Your Connection to Your Database. ...

Step 5 - Restart and You Are Ready!

 

How does spring boot application connect to database using JDBC?

How to use JDBC with Spring Boot: - Create Database. Suppose that we have a table named books in a schema named bookshop. ...

Create Spring Boot Project. I use Eclipse IDE. ...

Configure Database Connection Properties. ...

Code Java Model class. ...

Code Spring Boot JDBC Application

 

How do I know if my spring boot is connected to a database?

The easiest way to test the database connection from Spring boot is to start the application and by checking to debug logs. So, let's start the application with debug mode. To check the debug logs from the Hikari connection pool, set your logger in spring boot to debug mode as shown below.

 

26. How two or more Microservices communicate with each other?

Another communication pattern we can leverage in a microservice architecture is message-based communication. Unlike HTTP communication, the services involved do not directly communicate with each other. Instead, the services push messages to a message broker that other services subscribe to.

27.How two or more Microservices communicate with each other asynchronously?

In asynchronous communication microservices use asynchronous messages or http polling to communicate with other microservices, but the client request is served right away.

 

Microservices that communicate in an asynchronous manner can use a protocol such as AMQP to exchange messages via a message broker. The intended service receives the message in its own time. The sending service is not locked to the broker. It simply fires and forgets.

28.Intermediates and Terminals in java8 Streams?

A Stream supports several operations, and these operations are divided into intermediate and terminal operations.

The distinction between this operation is that an intermediate operation is lazy while a terminal operation is not. When you invoke an intermediate operation on a stream, the operation is not executed immediately. It is executed only when a terminal operation is invoked on that stream. In a way, an intermediate operation is memorized and is recalled as soon as a terminal operation is invoked. You can chain multiple intermediate operations and none of them will do anything until you invoke a terminal operation. At that time, all the intermediate operations that you invoked earlier will be invoked along with the terminal operation.

All Intermediate operations return Stream (can be chained), while terminal operations don't. Intermediate Operations are:

filter(Predicate<T>) , map(Function<T>)

flatMap(Function<T>) , sorted(Comparator<T>)

peek(Consumer<T>) , distinct() , limit(long n) , skip(long n)

 

Terminal operations produces a non-stream (cannot be chained) result such as primitive value, a collection, or no value at all. Terminal Operations are:

forEach, forEachOrdered, toArray, reduce, collect, min, max, count, anyMatch

allMatch, noneMatch, findFirst, findAny

 

In Java8 the Stream. reduce () combine elements of a stream and produces a single value. A simple sum operation using a for loop.

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

int result = numbers .stream().reduce(0, (subtotal, element) -> subtotal + element);

assertThat(result).isEqualTo(21);

int result = numbers.stream().reduce(0, Integer::sum);

assertThat(result).isEqualTo(21);

String result = letters.stream().reduce("", String::concat);

assertThat(result).isEqualTo("abcde");

List<Integer> ages = Arrays.asList(25, 30, 45, 28, 32);

int computedAges = ages.parallelStream().reduce(0, (a, b) -> a + b, Integer::sum);

29. In java 8 find the list of duplicated elements - 10,15,8,49,25,98,98,32,15

ArrayList<Integer> numbersList = new ArrayList<>(Arrays.asList(10,15,8,49,25,98,98,32,15));        

System.out.println(numbersList);

//remove duplicated elements

List<Integer> listWithoutDuplicates = numbersList.stream().distinct().collect(Collectors.toList());    

System.out.println(listWithoutDuplicates);

//duplicated elements print

noList.stream().filter(i -> Collections.frequency(noList, i) >1)

                .collect(Collectors.toSet()).forEach(System.out::println);

30.Employee class- write java 8 syntax to sort list of Employee according to age/name?

Collections.sort(Employees, Comparator.comparing(Employee::getFname)

    .thenComparingInt(Employee::getAge));

List<Employee> list=new ArrayList<Employee>();

list.stream().sorted(Comparator.comparing(Employee::getName).thenComparing(Employee::getAge)).collect(Collectors.toList()).forEach(System.out::println);

 

31.Given a list of integers, find out all the numbers starting with 1 using Stream functions? 10,15,8,49,25,98,32?

List<Integer> myList = Arrays.asList(10,15,8,49,25,98,32);

// Convert integer to String

myList.stream().map(s -> s + "").filter(s -> s.startsWith("1"))  .forEach(System.out::println);

 32. What is importance on hashcode and equals method?

The equals() and hashcode() are the two important methods provided by the Object class for comparing objects. Since the Object class is the parent class for all Java objects, hence all objects inherit the default implementation of these two methods.

You must override hashCode() in every class that overrides equals(). Failure to do so will result in a violation of the general contract for Object. hashCode(), which will prevent your class from functioning properly in conjunction with all hash-based collections, including HashMap, HashSet, and Hashtable.

HashCode in Java helps the program to run faster. For example, comparing two objects by their hashcode will give the result 20 times faster than comparing them using the equals() function. This is so because hash data structures like HashMap, internally organize the elements in an array-based data structure.

The difference in equals and hashCode in Java is that the equals is used to compare two objects while the hashCode is used in hashing to decide which group an object should be categorized into

To achieve a fully working custom equality mechanism, it is mandatory to override hashcode() each time you override equals(). Follow the tips below and you'll never have leaks in your custom equality mechanism:

  • If two objects are equal, they MUST have the same hash code.
  • If two objects have the same hash code, it doesn't mean that they are equal.
  • Overriding equals() alone will make your business fail with hashing data structures like: HashSet, HashMap, HashTable ... etc.
  • Overriding hashcode() alone doesn't force Java to ignore memory addresses when comparing two objects.

·       Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.

·       If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.

·       It is not required that if two objects are unequal according to the equals(java.lang.Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of HashTable.

33. Hierarchy of collection

 

The hierarchy of the entire collection framework consists of four core interfaces such as Collection, List, Set, Map, and two specialized interfaces named SortedSet and SortedMap for sorting. All the interfaces and classes for the collection framework are in java.

34. HashMap internal working?

  • equals(): It checks the equality of two objects. It compares the Key, whether they are equal or not. It is a method of the Object class. It can be overridden. If you override the equals() method, then it is mandatory to override the hashCode() method.
  • hashCode(): This is the method of the object class. It returns the memory reference of the object in integer form. The value received from the method is used as the bucket number. The bucket number is the address of the element inside the map. Hash code of null Key is 0.
  • Buckets: Array of the node is called buckets. Each node has a data structure like a LinkedList. More than one node can share the same bucket. It may be different in capacity.

How HashMap works internally in Java 8 with example?

o   In Java 8, HashMap replaces linked list with a binary tree when the number of elements in a bucket reaches certain threshold 12/16=0.75 Load Factor. While converting the list to binary tree, hashcode is used as a branching variable. ... This JDK 8 change applies only to HashMap, LinkedHashMap and ConcurrentHashMap

35. How springboot is different from spring and SPRING MVC?

S.No.

         SPRING MVC

SPRING BOOT

1.

Spring MVC is a Model View, and Controller based web framework widely used to develop web applications.

Spring Boot is built on top of the conventional spring framework, widely used to develop REST APIs.

2.

If we are using Spring MVC, we need to build the configuration manually. 

If we are using Spring Boot, there is no need to build the configuration manually.

3.

In the Spring MVC, a deployment descriptor is required.

In the Spring Boot, there is no need for a deployment descriptor.

4.

Spring MVC specifies each dependency separately.

It wraps the dependencies together in a single unit.

5.

Spring MVC framework consists of four components : Model, View, Controller, and Front Controller.

There are four main layers in Spring Boot: Presentation Layer, Data Access Layer, Service Layer, and Integration Layer.

6.

It takes more time in development.

It reduces development time and increases productivity.

Spring: Spring Framework is the most popular application development framework of Java. The main feature of the Spring Framework is dependency 

Injection or Inversion of Control (IoC). With the help of Spring Framework, we can develop a loosely coupled application. It is better to use if application type or characteristics are purely defined.

36.What is difference between RestController and Controller 
is @service @Component @Controller @Restcontroller interchangeable in springboot context?

@Restcontroller : It is a combination of @Controller and @ResponseBody, used for creating a restful controller. It converts the response to JSON or XML. It ensures that data returned by each method will be written straight into the response body instead of returning a template. 

@Controller: The @Controller is a class-level annotation. It is a specialization of @Component. It marks a class as a web request handler. It is often used to serve web pages. By default, it returns a string that indicates which route to redirect. It is mostly used with @RequestMapping annotation.

Scenario Based Interview Questions: 

1) class A{

 

        A(){} 
     }

 

class B extends A{

B(){ 
super(); 
} 
} 
class C extends B{}

Class Main{

public static void main(String args[]){ 
A a1= new A(); // works fine

A a2= new B(); // Throw exception}

 

Question 2: Given Input is  [ [2, 3, 5], [7, 11, 13], [17, 19, 23] ] o/p : [ 2, 3, 5, 7, 11, 13, 17, 19, 23 ]

List<List<Integer>> list = Arrays.asList(Arrays.asList(2,3,5),Arrays.asList(7,11,13),Arrays.asList(17,19,23)); 
list.stream().flatMap(l->l.stream()).map(ll->ll).collect(Collectors.toList());  

List<Integer> listOfAllIntegers = list.stream().flatMap(x -> x.stream()).collect(Collectors.toList());  System.out.println(listOfAllIntegers); // [2, 3, 5, 7, 11, 13, 17, 19, 23]

// Similar on String data

String[][] dataArray = new String[][]{{"a", "b"}, {"c", "d"}, {"e", "f"}, {"g", "h"}};         

 List<String> listOfAllChars = Arrays.stream(dataArray) .flatMap(x -> Arrays.stream(x))

                                    .collect(Collectors.toList()); 

        System.out.println(listOfAllChars);

 

3)Design search API based on n parameters?

@RequestMapping 
@RestController 
public class MySearch{

 

@PostMapping( 
public searchAPI() {}

 

4) What is Overriding strategy in Java7?

Rules for method overriding:

  • In java, a method can only be written in Subclass, not in same class.
  • The argument list should be exact the same as that of the overridden method.

·       The return type should be the same or a subtype of the return type declared in the original overridden method in the super class.

class A {

public void display() throws NullPointerException {

System.out.println ("Class A");

} }

class B extends A {

public void display() throws RuntimeException {

System.out.println ("Class A");

}  }

5) If you have an array and you want to add x number to every element how to do it?  Sum of elements within array in java8?

int[] a = {10,20,30,40,50};
int sum = IntStream.of(a).sum();
System.out.println("The sum is " + sum);
 
int [] arr = {1,2,3,4};
int sum = Arrays.stream(arr).sum(); //prints 10
 
int[] array = new int[]{1,2,3,4,5};
int sum = IntStream.of(array).reduce( 0,(a, b) -> a + b);
System.out.println("The summation of array is " + sum);
System.out.println("Another way to find summation:" + IntStream.of(array).sum());
 
List<Integer> integers = Arrays.asList(1, 2, 3, 4, 5);
 Integer total = integers.stream().collect(Collectors.summingInt(Integer::intValue));           
  System.out.println(total);           
           
List<Integer> list = Arrays.asList(10, 12, 83, 46, 59);
 Integer sumofElements = list.stream().mapToInt(Integer::intValue).sum();
 System.out.println(sumofElements); 

37. Microservices: suppose you have employee - how would you decide which service should be which microservice? In which of these scenarios will you prefer to use microservices?

Let's look at some of the typical scenarios where you can consider going for microservice style of architecture: Monolithic application migration due to improvements needed in scalability, manageability, agility, or speed of delivery. Re-platform a legacy application by transforming functions/modules to microservices.

 

Microservices design considerations

  • Single Responsibility Principal. A microservice should have single responsibility so that it will be
  • easy to maintain and be reusable. ...
  • Stateless. ...
  • Programming frameworks. ...
  • Data handling. ...
  • Secrets Management. ...
  • Dependency graph. ...
  • Versioning. ...
  • Containers. 

38.Microservice – which rest client have you used ?   Post Man

Microservice Architecture pattern (microservices.io)

39. Profiles in Spring boot?

Spring Boot allows to define profile specific property files in the form of application-{profile}. properties  It automatically loads the properties in an application. properties file for all profiles, and the ones in profile-specific property files only for the specified profile.

40. On what criteria you decide a particular api should be under this microservice?

The Single Responsibility Principle:  Just like with code, where a class should have only a single reason to change, microservices should be modeled in a similar fashion. Building bloated services which are subject to change for more than one business context is a bad practice.

2. Have a separate data store(s) for your microservice

It defeats the purpose of having microservices if you are using a monolithic database that all your microservices share. Any change or downtime to that database would then impact all the microservices that use the database. Choose the right database for your microservice needs, customize the infrastructure and storage to the data that it maintains, and let it be exclusive to your microservice. Ideally, any other microservice that needs access to that data would only access it through the APIs that the microservice with write access has exposed. 

3. Use asynchronous communication to achieve loose coupling

To avoid building a mesh of tightly coupled components, consider using asynchronous communication between microservices. 

a. Make calls to your dependencies asynchronously, example below. 

Example: Let’s say you have a Service A that calls Service B. Once Service B returns a response, Service A returns success to the caller. If the caller is not interested in Service B’s output, then Service A can asynchronously invoke Service B and instantly respond with a success to the caller. 

b. An even better option is to use events for communicating between microservices. Your microservice would publish an event to a message bus either indicating a state change or a failure and whichever microservice is interested in that event, would pick it up and process it. 

Example: In the pizza order system above, sending a notification to the customer once their order is captured, or status messages as the order gets fulfilled and delivered, can happen using asynchronous communication. A notification service can listen to an event that an order has been submitted and process the notification to the customer.

4. Fail fast by using a circuit breaker to achieve fault tolerance

If your microservice is dependent on another system to provide a response, and that system takes forever to respond, your overall response SLAs will be impacted. To avoid this scenario and quickly respond, one simple microservices best practice you can follow is to use a circuit breaker to timeout the external call and return a default response or an error. The Circuit Breaker pattern is explained in the references below. This will isolate the failing services that your service is dependent on without causing cascade failures, keeping your microservice in good health. You can choose to use popular products like Hystrix that Netflix developed. This is better than using the HTTP CONNECT_TIMEOUT and READ_TIMEOUT settings as it does not spin up additional threads beyond what’s been configured.

5. Proxy your microservice requests through an API Gateway

Instead of every microservice in the system performing the functions of API authentication, request / response logging, and throttling, having an API gateway doing these for you upfront will add a lot of value. Clients calling your microservices will connect to the API Gateway instead of directly calling your service. This way you will avoid making all those additional calls from your microservice and the internal URLs of your service would be hidden, giving you the flexibility to redirect the traffic from the API Gateway to a newer version of your service. This is even more necessary when a third party is accessing your service, as you can throttle the incoming traffic and reject unauthorized requests from the API gateway before they reach your microservice. You can also choose to have a separate API gateway that accepts traffic from external networks. 

6. Ensure your API changes are backwards compatible

You can safely introduce changes to your API and release them fast as long as they don’t break existing callers. One possible option is to notify your callers , have them provide a sign off for your changes by doing integration testing. However, this is expensive, as all the dependencies need to line up in an environment and it will slow you down with a lot of coordination. A better option is to adopt contract testing for your APIs. The consumers of your APIs provide contracts on their expected response from your API. You as a provider would integrate those contract tests as part of your builds and these will safeguard against breaking changes. The consumer can test against the stubs that you publish as part of the consumer builds. This way you can go to production faster with independently testing your contract changes.

7. Version your microservices for breaking changes

It's not always possible to make backwards compatible changes. When you are making a breaking change, expose a new version of your endpoint while continuing to support older versions. Consumers can choose to use the new version at their convenience. However, having too many versions of your API can create a nightmare for those maintaining the code. Hence, have a disciplined approach to deprecate older versions by working with your clients or internally rerouting the traffic to the newer versions.

8. Have dedicated infrastructure hosting your microservice

You can have the best designed microservice meeting all the checks, but with a bad design of the hosting platform it would still behave poorly. Isolate your microservice infrastructure from other components to get fault isolation and best performance. It is also important to isolate the infrastructure of the components that your microservice depends on.

Example: In the pizza order example above, let's say the inventory microservice uses an inventory database. It is not only important for the Inventory Service to have dedicated host machines, but also the inventory database needs to have dedicated host machines.

9. Create a separate release train

Your microservice needs to have its own separate release vehicle which is not tied to other components within your organization. This way you are not stepping on each other’s toes and wasting time coordinating with multiple teams.

10. Create Organizational Efficiencies

While microservices give you the freedom to develop and release independently, certain standards need to be followed for cross cutting concerns so that every team doesn’t spend time creating unique solutions for these. This is very important in a distributed architecture such as microservices, where you need to be able to connect all the pieces of the puzzle to see a holistic picture. Hence, enterprise solutions are necessary for API security, log aggregation, monitoring, API documentation, secrets management, config management, distributed tracing, etc. 

41. Why streams are faster compared to collections?

Streams are more about coding convenience and safety. Convenience -- speed tradeoff is working here. It's like your results: stream is slower than collection. Conclusion: much time were spent for stream initialization/values transmitting.

 

Collections are used to store and group the data in a particular data structure like List, Set or Map. But, streams are used to perform complex data processing operations like filtering, matching, mapping etc on stored data such as arrays, collections or I/O resources.

42. Benefits of streams?

There are a lot of benefits to using streams in Java, such as the ability to write functions at a more abstract level which can reduce code bugs, compact functions into fewer and more readable lines of code, and the ease they offer for parallelization

43. Timeout handling in rest client?  rest Client how will you add timeout?   

If a subflow for an operation is processing a message and that subflow does not respond to the client within the expected time limit, a message is routed to the Timeout error handler. The Timeout error handler can then be used to pass a response back to the client to inform that client that the operation has timed out.

 

The default timeout is 10 seconds. The minimum is 1 millisecond, and the maximum is 120 seconds. If the callout is timing out, please try and increase the timeout on the HTTP request to avoid that.

 

How do you set a timeout on a REST call?

Example of setting a custom timeout for HTTP callouts using the Apex HTTPRequest object. The default timeout is 10 seconds. The minimum is 1 millisecond and the maximum is 120 seconds. If the callout is timing out, please try and increase the timeout on the HTTP request to avoid that.

                                        

How do I set timeout in API?

abort ()); const timeout = setTimeout (() => controller.

 

If the timeout is reached before the resource is fetched, then the fetch is aborted.

If the resource is fetched before the timeout is reached then the timeout is cleared.

If the input signal is aborted then the fetch is aborted and the timeout is cleared.

 

RestTemplate default timeout:

private int connectTimeout = - 1; private int readTimeout = - 1; By default, RestTemplate uses timeout property from JDK installed on the machine which is always infinite in not overridden. To override the default JVM timeout, we can pass these properties during JVM start.

 

How do you increase client timeout?

Set the keep-alive options in the client configuration file:

Login to the client machine and open the /etc/ssh/ssh_config file to set the necessary parameter values to increase the SS connection timeout. ServerAliveInterval and ServerAliveCountMax parameters are set to increase the connection timeout.

 

What is the default timeout for rest template?

infinite: The default timeout is infinite. By default, RestTemplate uses SimpleClientHttpRequestFactory and that in turn uses HttpURLConnection.

43. Asynchronous calls handling in spring?

Simply put, annotating a method of a bean with @Async will make it execute in a separate thread. In other words, the caller will not wait for the completion of the called method. One interesting aspect in Spring is that the event support in the framework also has support for async processing if necessary.

 44. Hystrix?

Hystrix is a library that controls the interaction between microservices to provide latency and fault tolerance. Additionally, it makes sense to modify the UI to let the user know that something might not have worked as expected or would take more time.  

Fault tolerance can be achieved with the help of a circuit breaker. It is a pattern that wraps requests to external services and detects when they fail. If a failure is detected, the circuit breaker opens. All the subsequent requests immediately return an error instead of making requests to the unhealthy service. It monitors and detects the service which is down and misbehaves with other services. It rejects calls until it becomes healthy again. 

How to process bulk records to apache Kafka?
45. Hibernate transaction management?

Transaction is an interface available in org.hibernate package which is associated with the session. In the transaction, if any single step fails, the complete transaction will be failed. We can describe transaction with ACID properties.

 A transaction simply represents a unit of work. In such case, if one step fails, the whole transaction fails (which is termed as atomicity). A transaction can be described by ACID properties (Atomicity, Consistency, Isolation and Durability).

Example:-

Session = null;

Transaction tx = null;

try {

session = sessionFactory.openSession();

tx = session.beginTransaction();

//some action.

tx.commit();

}catch (Exception ex) {

46. How to do transaction rollback?

ROLLBACK is the SQL command that is used for reverting changes performed by a transaction. When a ROLLBACK command is issued it reverts all the changes since last COMMIT or ROLLBACK.


How you will create new transactions and @transactional ?

Hibernate deals with database specific transactions, whereas spring provides a general transaction management service. @Transactional is a nice way of configuring transaction management behavior.

 

Transactions : -

Transactions are basically units of work (ie changes to something) that are managed as a single operation that can be either committed or rolled back. There are lots of different types of transactions in the java world - database, messaging systems like JMS, inter application transactions (for those who are not faint of heart) or anything else that may need to be included in a transaction.

 

Spring is designed to be used as an all-encompassing master of objects and services within your application, so its concept of a transaction is at a higher level than the database specific transactions that hibernate concerns itself with. Spring Transactions are designed to give you fine grained control of all your transactional resources while abstracting away the often messy coding required to co-ordinate the transactions.

 

@Transactional

Spring provides a few different methods for using transactions - among others there xml-based aspects, coding to the API and annotation based declarative transactions. The annotation-based transactions are handy because you dont need to add the transaction management boilerplate code to your app (even using PlatformTransactionManager via the API has quite a bit of coding overhead).

So basically what happens with @Transactional is that at runtime spring scans your code base for @Transactional classes and methods and wraps them up in the transaction specific management code, based on what you have configured via the annotation. So a method like this:

 

@Transactional(propagation = REQUIRES_NEW, rollbackFor = {Exception.class})

public void saveAndSendMessage(Foo foo) throws Exception {

    dbManager.save(foo);

    Bar bar = transform(foo);

    jmsSystem.send(bar);

} 

47. Circular Dependency in Spring?

Circular dependency in Spring happens when two or more beans require instance of each other through constructor dependency injections. For example: There is a ClassA that requires an instance of ClassB through constructor injection and ClassB requires an instance of class A through constructor injection.

 

What is meant by circular dependency?

In software engineering, a circular dependency is a relation between two or more modules which either directly or indirectly depend on each other to function properly. Such modules are also known as mutually recursive.

How do you resolve circular dependency when it occurs?

·       Use events to signal from one class to another. ...

·       If the above is true, but you feel that events seem wrong, you can consider applying the Observer pattern.

·       If the communication must truly go both ways, you can use a Mediator through which the components can communicate.

48. What is the difference between Spring Singleton bean scope & Singleton Design pattern? or how are they different?

Singleton pattern is described at per class loader level.

Singleton bean scope is per spring container. Spring simply creates a new instance of that class and that is available in the container to all class loaders which use that container.

Suppose you have two scenarios:

1. There are multiple class loaders inside the same spring container..

2. There are multiple containers using same class loader..

In first case - you will get 1 instance while in case 2 - you will get multiple instances .

49.Difference between microservice and monolith?

A monolithic architecture is built as one large system and is usually one codebase. A monolith is often deployed all at once, both front and end code together, regardless of what was changed.

A microservices architecture however is where an app is built as a suite of small services, each with their own codebase.

50.Scope of beans?

1. singleton(default***): Scopes a single bean definition to a single object instance per Spring IoC container.

2. prototype: Scopes a single bean definition to any number of object instances.

3. request: Scopes a single bean definition to the lifecycle of a single HTTP request; that is every HTTP request will have its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

4. session: Scopes a single bean definition to the lifecycle of a HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

5. global session: Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

51. Can you insert prototype bean to a singleton bean and if yes how?

You cannot dependency-inject a prototype-scoped bean into your singleton bean because that injection occurs only once,  when the Spring container is instantiating the singleton bean and resolving and injecting its dependencies.

If Yes then Singleton beans with prototype-bean dependencies for below method to follow

Lookup Method Injection

When you use singleton-scoped beans with dependencies on prototype beans, be aware that dependencies are resolved at instantiation time. Thus if you dependency-inject a prototype-scoped bean into a singleton-scoped bean, a new prototype bean is instantiated and then dependency-injected into the singleton bean. The prototype instance is the sole instance that is ever supplied to the singleton-scoped bean.

“Lookup method injection is the ability of the container to override methods on container managed beans, to return the lookup result for another named bean in the container. The lookup typically involves a prototype bean as in the scenario described in the preceding section. The Spring Framework implements this method injection by using bytecode generation from the CGLIB library to generate dynamically a subclass that overrides the method”

<!-- a stateful bean deployed as a prototype (non-singleton) -->

<bean id="command" class="fiona.apple.AsyncCommand" scope="prototype">

  <!-- inject dependencies here as required -->

</bean>

 

<!-- commandProcessor uses statefulCommandHelper -->

<bean id="commandManager" class="fiona.apple.CommandManager">

  <lookup-method name="createCommand" bean="command"/>

</bean>

52. How to you include a different web service than the default tomcat server?

In order to be able to deploy additional application on a different port, you will need to create an additional Service configuration. In order to do so, edit the server. xml file once again and additional configuration group. The new group, must have a different name, different ports, both for HTTP and AJP traffic.

<Service name="Catalina">

        <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />

                             <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />

        <Engine name="Catalina" defaultHost="localhost">

            <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/>

            <Host name="localhost"  appBase="webapps" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false"></Host>

        </Engine>

    </Service>

</Server>

In order to be able to deploy additional application on a different port, you will need to create an additional Service configuration. In order to do so, edit the server.xml file once again and additional configuration group. The new group, must have a different name, different ports, both for HTTP and AJP traffic. The Engine and Host groups must also have a different name. Note that in the Engine component attribute the defaultHost entry must correspond to the Host component name. Finally, the appBase attribute of the Host component, must point to the existing directory where the deployment will be performed (I will explain mention the directories you need to create/copy below).

<Service name="Catalina-xyz">

    <Connector port="8081" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8444" />

              <Connector port="8008" protocol="AJP/1.3" redirectPort="8444" />

    <Engine name="Catalina-xyz" defaultHost="xyz">

        <Realm className="org.apache.catalina.realm.UserDatabaseRealm" resourceName="UserDatabase"/>

        <Host name="xyz" appBase="xyz" unpackWARs="true" autoDeploy="true" xmlValidation="false" xmlNamespaceAware="false"></Host>

    </Engine>

</Service>

Before restarting the Tomcat instance, we need to make sure that all required directories are correctly set. First of all, create a Catalina directory copy with the Catalina-xyz name, located in your TOMCAT_HOME directory (you must have both the new and the old directories in the TOMCAT_HOME present). Next, inside of the Catalina-xyz directory rename the localhost to xyz (or whatever name you have chosen for your host). Next, copy the webapps directory (in my case it was located inside the /var/lib/tomcat/ directory) with the xyz name to the same folder. Finally, restart the Tomcat instance. Now you will be able to deploy the two ROOT.war archives to the two different Tomcat ports.

53.Microservice Architecture?

Microservices architecture (often shortened to microservices) refers to an architectural style for developing applications. Microservices allow a large application to be separated into smaller independent parts, with each part having its own realm of responsibility.

 Microservice Architecture is an architectural development style that allows building applications as a collection of small autonomous services developed for a business domain. ... In this Microservices architecture example, each microservice is focused on single business capability.

Broadly speaking, there are two types of microservices:

  • Stateless microservices.
  • Stateful microservices.

  What are Microservices?

Microservices - also known as the microservice architecture - is an architectural style that structures an application as a collection of services that are

  • Highly maintainable and testable
  • Loosely coupled
  • Independently deployable
  • Organized around business capabilities
  • Owned by a small team

The microservice architecture enables the rapid, frequent, and reliable delivery of large, complex applications. It also enables an organization to evolve its technology stack.

 What is Eureka server and client?

 Eureka Server is an application that holds the information about all client-service applications. Every Micro service will register into the Eureka server and Eureka server knows all the client applications running on each port and IP address. Eureka Server is also known as Discovery Server.

54. How do you deploy a Web application in a production server?

Assign deployment attributes for your Web Application:

  1. Open the Administration Console.
  2. Select the Web Applications node.
  3. Select your Web Application.
  4. Assign your Web Application to a WebLogic Server, cluster, or Virtual Host.
  5. Select the File tab and define the appropriate attributes.

 Production deployment. The final stage of every project. When all the hard work you've put in over the course of time goes live to be used by the target audience.

55. How to change the server in spring boot?

You will need to update pom. xml add the dependency for spring-boot-starter-jetty . Also, you will need to exclude default added spring-boot-starter-tomcat dependency.

<dependency>

  <groupId>org.springframework.boot</groupId>

  <artifactId>spring-boot-starter-undertow</artifactId>

</dependency>

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-jetty</artifactId>

</dependency>

spring-boot-starter-web comes with Embedded Tomcat. We need to exclude this dependency.

<dependency>

  <groupId>org.springframework.boot</groupId>

  <artifactId>spring-boot-starter-web</artifactId>

  <exclusions>

    <exclusion>

      <groupId>org.springframework.boot</groupId>

      <artifactId>spring-boot-starter-tomcat</artifactId>

    </exclusion>

  </exclusions>

</dependency>

56. What would happen if hashcode () always return one in Multithreading? What will be behavior if we override hashCode method to always return 1?

Only Override HashCode, Use the default Equals: Only the references to the same object will return true. In other words, those objects you expected to be equal will not be equal by calling the equals method.

57. When a bean is missing how do you handle it?

The @ConditionalOnMissingBean annotation is used to load a bean only if a given bean is missing:

@Bean

@ConditionalOnMissingBean(SomeBean.class)

public SomeBean otherBean(){

    return new SomeBean();

}

 

The above bean will get loaded by Spring only if there is no other bean of this type present in the context. On the other hand, if there is already a bean of the type SomeBean present in the application context, the above bean will not be created.

58. How do we connect to a database, when we need to connect oracle in production and  some other database in development, how do you handle these connection properties?

We must write individual properties files and configure each environment details to be added

59. Code repository, branching in git / Source Control management tool: GIT

·       Git branching allows developers to diverge from the production version of code to fix a bug or add a feature. ...

·       As you create commits in the new branch, Git creates new pointers to track the changes. ...

·       Git knows which branch you have checked out by using a special pointer called HEAD.

Branch Naming Strategies

·       username/description

·       username/workitem

You can name a branch to indicate the branch’s function, like a feature, bug fix, or hotfix:

·       bugfix/description

·       feature/feature-name

·       hotfix/description

Option 1: Creating a Branch

git branch <branch name>

git branch

Option 2: Creating a Branch using Checkout

git checkout -b <branch name>

git branch

Option 3: Creating a Branch from a Commit

git log

git branch <branch name> <identifier>

Option 4: Creating a Branch from Another Branch

git checkout -b feature4 develop

Option 5: Download Branch from Remote Repository

git pull origin <branch name>

git branch

git checkout <branch name>

git branch

Merging Branches

Once you’ve completed work on your branch, it is time to merge it into the main branch. Merging takes your branch changes and implements them into the main branch. Depending on the commit history, Git performs merges two ways: fast-forward and three-way merge.

 

When you merge the hotfix branch into the main branch, Git will move the main branch pointer forward to commit nr7jk. Git does this because the hotfix branch shares a direct ancestor commit with the main branch and is directly ahead of its commit. This commit is a fast-forward merge.

Once you merge the hotfix branch, continue working on the feature1 branch. As you continue making commits on the feature1 branch, the commit history diverges.

Git is unable to move the pointer to the latest commit like in a fast-forward commit. To bring the feature1 branch into the main branch, Git performs a three-way merge. Git takes a snapshot of three different commits to create a new one:

·       The common commit both branches share (a90hb)

·       The latest commit of the branch (az84f)

·       The commit of the branch to merge into (nr7jk)

Merging Branches in a Local Repository

To merge branches locally, use git checkout to switch to the branch you want to merge into. This branch is typically the main branch. Next, use git merge and specify the name of the other branch to bring into this branch. This example merges the jeff/feature1 branch into the main branch. Note that this is a fast-forward merge.

git checkout main

git merge jeff/feature1

Work continues on the main and other branches, so they no longer share a common commit history. Now a developer wants to merge the jeff/feature2 branch into the main branch. Instead, Git performs a three-way (or recursive) merge commit.

git checkout main

git merge jeff/feature2     

Merging Branches to Remote Repository

git push --set-upstream origin <branch name>

Merging Main into a Branch

git checkout <branch name>

git merge main

60. Name all core API of Kafka?

Kafka APIs

·       The Admin API to manage and inspect topics, brokers, and other Kafka objects.

·       The Producer API to publish (write) a stream of events to one or more Kafka topics.

·       The Consumer API to subscribe to (read) one or more topics and to process the stream of events produced to them. 

If there are multiple consumers and multiple producers with single topic how to process records? 

61. How to check logs in microservices? 

The Below are some of logging tools to handle microservice architecture

  • Logstash. Logstash is a free, open-source tool that runs on Java Virtual Machine (JVM). ...
  • Reimann. ...
  • Prometheus. ...
  • Elastic Stack. ...
  • Kibana. ...
  • Glowroot. ...
  • AWS Cloudwatch. ...
  • Datadog.

Here a few microservices logging best practices:

·       Use a Correlation ID

·       Structure logs appropriately

·       Provide informative application logs

·       Visualize log data

·       Use centralized log storage

·       Query logs

·       Handle Failures

62. How are ACID property implemented in microservices world? 

Microservices guidelines strongly recommend you to use the Single Repository Principle(SRP), which means each microservice maintains its own database and no other service should access the other service's database directly. There is no direct and simple way of maintaining ACID principles across multiple databases.

63. Have you worked with multiple Databases in microservices? 

Create a single database for different microservices is anti-pattern, then the correct way is to create a database for each microservice.

It means that we can use different database technologies for different microservices. So one service may use an SQL database and another one a NoSQL database. That's feature allows using the most efficient database depending on the service requirements and functionality.

64. Can multiple microservices share the same database?

In the shared-database-per-service pattern, the same database is shared by several microservices. This pattern does not reduce dependencies between development teams, and introduces runtime coupling because all microservices share the same database.

How do microservices communicate with each other?

Because microservices are distributed and microservices communicate with each other by inter-service communication on network level. Each microservice has its own instance and process. Therefore, services must interact using an inter-service communication protocols like HTTP, gRPC or message brokers AMQP protocol.

How do I interact one microservice from another microservice?

There are two basic messaging patterns that microservices can use to communicate with other microservices.

  1. Synchronous communication. In this pattern, a service calls an API that another service exposes, using a protocol such as HTTP or gRPC. ...
  2. Asynchronous message passing.

Is it considered as a good practice to connect to two different databases in on microservice?

The main thing is that you have only one microservice per database, but it is ok to have multiple databases per microservice if the business case requires it.

Your microservice can abstract multiple data sources, connect them, etc. and then just give consistent api to whoever is using it. And who's using it, doesn't care how many data sources there actually is.

It becomes an issue if you have same database abstracted by multiple microservices. Then your microservice is no longer isolated and can break because the data source you are using was changed by another team who's using the same data source.

 65. How do I manage multiple databases on microservices?

This is one of the main problems in the micro service architecture that is being addressed using the pattern:

·       Database per service

Also associated with this pattern are:

·       Saga pattern

·       Command Query Responsibility Segregation (CQRS)

But this solves only part of the problem.

 Building a micro service architecture is a very complex and extensive task, and it is associated with many problems and design patterns that allow you to minimize these problems. I recommend reading a book "Microservices patterns" that looks at various patterns of micro-service architecture design.

What are the exceptions in Spring boot?

·       Spring BeanDefinitionStoreException.

·       Spring BeanCreationException.

·       Is org Springframework beans factory BeanCreationException?

springframework. beans. factory. BeanCreationException – this is a very common exception thrown when the BeanFactory creates beans of the bean definitions and encounters a problem.

 When Autowiring Spring Beans, a common exception is a. BeanCreationException. . This means that Spring found a bean to create, but was unable to fulfill the dependencies needed to create this this Spring bean

 ·       Spring NoSuchBeanDefinitionException.

·       Unsatisfied Dependency in Spring.

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name defined in file: Unsatisfied dependency expressed through field occurs when a problem occurs when a bean auto-wired on other beans that have not bean loaded in the spring boot application context.

The best solution is to properly isolate beans. The DispatcherServlet is responsible for routing and handling requests so all related beans should go into its context. The ContextLoaderListener , which loads the root context, should initialize any beans the rest of your application needs: services, repositories, etc

 

·       The BeanDefinitionOverrideException in Spring Boot.

 Spring beans are identified by their names within an ApplicationContext.

Thus, bean overriding is a default behavior that happens when we define a bean within an ApplcationContext which has the same name as another bean. It works by simply replacing the former bean in case of a name conflict.

·       Spring Boot Error ApplicationContextException.

Usage of Actuator in Spring Boot?

 Actuator is mainly used to expose operational information about the running application — health, metrics, info, dump, env, etc. It uses HTTP endpoints or JMX beans to enable us to interact with it. Once this dependency is on the classpath, several endpoints are available for us out of the box.

 Spring boot's actuator module allows us to monitor and manage application usages in production environment, without coding and configuration for any of them. These monitoring and management information is exposed via REST like endpoint URLs. ... Returns a complete list of all the Spring beans in your application.

 To enable Spring Boot actuator endpoints to your Spring Boot application, we need to add the Spring Boot Starter actuator dependency in our build configuration file. Maven users can add the below dependency in your pom. xml file. Gradle users can add the below dependency in your build.

 1.                  Experience in cloud

2.                  Working experience under a team of 10+ developers , everyone working under same feature

3.                  No. of team members in last project. Scrum master role handled by

4.                  Experience on NoSQL DB

5.                  Experience on Cassandra DB

6.                  Other components in project apart from micro services.

7.                  Different database/schema for all microservices or same w.r.t last project I worked on.

8.                  Use of functional interface

9.                  what is functional interface

10.              List of Clients previously worked with

11.              Awareness on SDLC cycle 

Method references in java8?
Kubernetes – What is POD ?  Optional – not mandatory  
What have you done in Kubernetes?  Optional – not mandatory  
Where in Kubernetes will you add the scalability? Optional – not mandatory  
What is enterprise integration pattern ?    
Have you worked in Apache camel ?    
Have you worked on Cassandra ?  Optional – not mandatory  
What is partition key ? Optional – not mandatory .

How to process bulk records to apache Kafka

How security handled in current/previous project

Previous project POC s

Asked about previous Springboot project implementation?

1010101010 

How many substring with sum as 2 can be created from this String above? 

Like:  

101 

0101 

public ModelAndView getMembers(HttpServletRequest request, Authentication auth)

{    if(auth != null)    {

      for (GrantedAuthority ga : auth.getAuthorities())       {

         // works find and logs "ADMIN", btw. I'm using SimpleGrantedAuthority

         this.logger.debug("0{}", ga);

      }    } }

public UserDetails loadUserByUsername(String username) {

.....

Collection<GrantedAuthority> authorities = new ArrayList<>();    

    authorities.add(new SimpleGrantedAuthority("ADMIN"));

 return new org.springframework.security.core.userdetails.User(username, password, enabled, true, true, true, authorities);

    ...

}

 GitHub - ChrisJabb21/Employee-Management-System: A Spring boot full stack web application that lets you add, delete, edit and update employees information. Uses Vaadin for the frontend and backend routing. username:user and password:password for the demo showcase login

Abstract factory vs Factory?

The factory method is just a method, it can be overridden in a subclass, whereas the abstract factory is an object that has multiple factory methods on it. The Factory Method pattern uses inheritance and relies on a subclass to handle the desired object instantiation

Threadpools in java?

Java Thread pool represents a group of worker threads that are waiting for the job and reused many times.

In the case of a thread pool, a group of fixed-size threads is created. A thread from the thread pool is pulled out and assigned a job by the service provider. After completion of the job, the thread is contained in the thread pool again.

65. Thread Pool Methods

newFixedThreadPool(int s): The method creates a thread pool of the fixed size s.

newCachedThreadPool(): The method creates a new thread pool that creates the new threads when needed but will still use the previously created thread whenever they are available to use.

Advantage of Java Thread Pool

Better performance It saves time because there is no need to create a new thread.

Real time usage

It is used in Servlet and JSP where the container creates a thread pool to process the request

Example:

import java.util.concurrent.ExecutorService; 

import java.util.concurrent.Executors; 

class WorkerThread implements Runnable { 

    private String message; 

    public WorkerThread(String s){ 

        this.message=s; 

    } 

     public void run() { 

        System.out.println(Thread.currentThread().getName()+" (Start) message = "+message); 

        processmessage();//call processmessage method that sleeps the thread for 2 seconds 

        System.out.println(Thread.currentThread().getName()+" (End)");//prints thread name 

    } 

    private void processmessage() { 

        try {  Thread.sleep(2000);  } catch (InterruptedException e) { e.printStackTrace(); } 

    } 

} 

public class TestThreadPool { 

     public static void main(String[] args) { 

        ExecutorService executor = Executors.newFixedThreadPool(5);//creating a pool of 5 threads 

        for (int i = 0; i < 10; i++) { 

            Runnable worker = new WorkerThread("" + i); 

            executor.execute(worker);//calling execute method of ExecutorService 

          } 

        executor.shutdown(); 

        while (!executor.isTerminated()) {   }   

        System.out.println("Finished all threads"); 

    } 

 } 

66. Builder design pattern?

If a developer forgets to call a particular setter method? We could end up with an object that is only partially initialized, and again, the compiler wouldn't see any problems with it.  Thus, there are two specific problems that we need to solve:

o   Too many constructor arguments /too many constructors to maintain.

o   Incorrect object state/error prone because many fields have same type.

This is where the Builder pattern comes into play.

Builder is a creational design pattern,” which allows constructing complex objects step by step.” Unlike other creational patterns, Builder doesn't require products to have a common interface. That makes it possible to produce different products using the same construction process.

The builder pattern provides a build object which is used to construct a complex object called the product. It encapsulates the logic of constructing the different pieces of the product.”

Builder (recognizable by creational methods returning the instance itself)

Java.lang.StringBuilder#append() (unsynchronized)

Java.lang.StringBuffer#append() (synchronized)

Java.nio.ByteBuffer#put() (also on CharBuffer, ShortBuffer, IntBuffer, LongBuffer, FloatBuffer and DoubleBuffer)

Javax.swing.GroupLayout.Group#addComponent()

All implementations of java.lang.Appendable

Java.util.stream.Stream.Builder.

Builder Design pattern is a creational pattern and should be used when a number of parameters required in the constructor is more than manageable usually 4 or at most 5.

 

Advantages:

1) more maintainable if the number of fields required to create an object is more than 4 or 5.

2) less error prone as users will know what they are passing because of the explicit method call.

3) more robust as only fully constructed object will be available to the client.

 

Disadvantages:

1) verbose and code duplication as Builder needs to copy all fields from Original or Item class.

67. Decorator design pattern?

Usage of Decorator Pattern :  It is used  When you want to add responsibilities transparently and dynamically to objects without affecting other objects.

When you want to add responsibilities to an object that you may want to change in future. Extending functionality by sub-classing is no longer practical.

Decorator pattern achieves a single objective of dynamically adding responsibilities to any object.

A Decorator pattern can be used to attach additional responsibilities to an object either statically or dynamically.

It enhances the extensibility of the object because changes are made by coding new classes. It simplifies the coding by allowing you to develop a series of functionality from targeted classes instead of coding all the behavior into the object.

Usage examples: The Decorator is pretty standard in Java code, especially in code related to streams.

Here are some examples of Decorator in core Java libraries:

All subclasses of java.io.InputStream, OutputStream, Reader and Writer have constructors that accept objects of their own type.

o   java.util.Collections, methods checkedXXX(), synchronizedXXX() and unmodifiableXXX().

o   javax.servlet.http.HttpServletRequestWrapper and HttpServletResponseWrapper.

Identification: Decorator can be recognized by creation methods or constructor that accept objects of the same class or interface as a current class.

68. Versioning in Rest api ?

API versioning is the practice of transparently managing changes to your API. Versioning is effective communication around changes to your API, so consumers know what to expect from it. You are delivering data to the public in some fashion and you need to communicate when you change the way that data is delivered.

69. Difference between Hibernate JPA vs Spring Data JPA?

Hibernate is a JPA provider and ORM that maps Java objects to relational database tables. Spring Data JPA is an abstraction that makes working with the JPA provider less verbose. Using Spring Data JPA you can eliminate a lot of the boilerplate code involved in managing a JPA provider like Hibernate.

Hibernate is a JPA implementation, while Spring Data JPA is a JPA data access abstraction. Spring Data JPA cannot work without a JPA provider.

Spring Data offers a solution to the DDD Repository pattern or the legacy GenericDao custom implementations. It can also generate JPA queries on your behalf through method name conventions.

With Spring Data, you may use Hibernate, EclipseLink, or any other JPA provider. A very interesting benefit of using Spring or Java EE is that you can control transaction boundaries declaratively using the @Transactional annotation.

Spring JDBC is much more lightweight, and it's intended for native querying, and if you only intend to use JDBC alone, then you are better off using Spring JDBC to deal with the JDBC verbosity.

Therefore, Hibernate and Spring Data are complementary rather than competitors.

70. SOLID Principles ?

In Java, SOLID principles are an object-oriented approach that are applied to software structure design. It is conceptualized by Robert C. Martin (also known as Uncle Bob). These five principles have changed the world of object-oriented programming, and also changed the way of writing software.

o   Single Responsibility Principle (SRP)

o   Open-Closed Principle (OCP)

o   Liskov Substitution Principle (LSP)

o   Interface Segregation Principle (ISP)

o   Dependency Inversion Principle (DIP)

Single Responsibility Principle

Just because you can doesn’t mean you should

·       Every class should have a single responsibility

·       There should never be more than one reason for a class to change

·       Your classes should be small. No more than a screen full of code

·       Avoid ‘god’ classes.

·       Split big classes into smaller classes.

·       Class should only have one responsibility. Furthermore, it should only have one reason to change.

Open/Closed Principle

·       Your classes should be open for extension

·       But closed for modification

·       You should be able to extend a classes behaviour, without modifying it.

·       Use private variables with getters and setters – ONLY you need them

·       Use abstract base classes.

·       The open-closed principle. Simply put, classes should be open for extension but closed for modification. In doing so, we stop ourselves from modifying existing code and causing potential new bugs in an otherwise happy application. Of course, the one exception to the rule is when fixing bugs in existing code.

Liskov Substitution Principle

By Barbara Liskov in 1998

·       Objects in a program would be replaceable with instances of their subtypes WITHOUT altering the correctness of the program

·       Violations will often fail the “Is a “test

·       A Square “Is a” rectangle

·       However, a Rectangle “Is Not” a Square.

·       if class A is a subtype of class B, we should be able to replace B with A without disrupting the behaviour of our program.

Interface Segregation Principle

·       Make fine gained interfaces that are client specific

·       May’s client specific interfaces are better than one “general purpose” interface

·       Keep our components focused and minimize dependencies between them.

·       Notice relationship to the Single Responsibility Principle.

·       i.e.  avoid ‘god’ interfaces

·       Larger interfaces should be split into smaller ones. By doing so, we can ensure that implementing classes only need to be concerned about the methods that are of interest to them.

Dependency Inversion Principle

·       Abstraction should not dependent upon details

·       Details should not depend upon abstractions

·       Important that higher level and lower-level objects depend on the same abstract interaction

·       This is not same as Dependency Injection -Which is how objects obtain dependent object

·       The principle of dependency inversion refers to the decoupling of software modules. This way, instead of high-level modules depending on low-level modules, both will depend on abstractions.

Summary

The SOLID principles of OOP will lead you to better quality code

·       Your code will be more testable and easier to maintain

·       A Key theme avoiding tight coupling in your code

71. Redis cache ?

Redis is a popular, open-source, in-memory data structure store that can be used as a database, cache, or message broker. ... Every time that you update or delete information stored in a local cache on one machine, you must update the in-memory caches on all machines that are part of the distributed cache.

You can't store objects directly into Redis. So convert the object into String and then put it in Redis. In order to do that your object must be serialized. Convert the object to ByteArray and use some encoding algorithm (ex base64encoding) and convert it as String then store in Redis.

 Redis is an open-source (BSD licensed), in-memory data structure store, used as a database, cache, and message broker. Redis provides data structures such as strings, hashes, lists, sets, sorted sets with range queries, bitmaps, hyperloglogs, geospatial indexes, and streams.

Advantage of using Redis Cache in your application?

 Like any other Caching Technique, Redis Cache also minimizes the number of network calls made by your application, which in return improves  performance of the application as a whole. One request from an application to the DB is similar to one network call.

 When we perform a DB retrieve operation via an Application, the Redis Cache stores the result in it’s cache. Further, when we perform the same retrieve operation, it returns the result from the cache itself and ignore the second call to database. Similarly, when we perform a DB update operation, the Redis Cache also updated the result in its cache. Needless to say, for delete operation also it deleted the data from the cache accordingly. In this way, there are no chances of getting incorrect data.

 72. What is the difference between bootstrap.properties and application.properties?

They have different conventions for locating the external configuration files. The bootstrap context is searching for a bootstrap. properties or a bootstrap. yaml file, whereas the application context is searching for an application.

 The bootstrap context is responsible for loading configuration properties from the external sources and for decrypting properties in the local external configuration files.

 application.properties files have the lowest precedence compared to other forms of overriding application context properties.

  • Core properties (logging properties, thread properties)
  • Integration properties (RabbitMQ properties, ActiveMQ properties)
  • Web properties (HTTP properties, MVC properties)
  • Security properties (LDAP properties, OAuth2 properties).

Spring security ?

Spring Security is a Java/Java EE framework that provides authentication, authorization, and other security features for enterprise applications.

Core java collections

73. TreeSet/HashMap in java (hashcode and Equals)

Does tree data structure use hashCode and equals how sorting will happen internally in TreeSet TreeMap?

So it is sorting based on the compareTo method and hashcode() method looks insignificant in this scenario. However, Treeset is backed by TreeMap, so internally if TreeMap is used for sorting.

 The data structure for the TreeSet is TreeMap; it contains a SortedSet & NavigableSet interface to keep the elements sorted in ascending order and navigated through the tree.

 74. How the Sorting is Performed Internally in TreeSet

When we implement a TreeSet, it creates a TreeMap to store the elements. It sorts the elements either naturally or using the user define comparator.

When the object of a TreeSet is created, it automatically invokes the default constructor and creates an object of TreeMap and assigns comparator as null. Below code is executed by the Java compiler.

TreeSet is an implementation of SortedSet that does not allow duplicate values. The elements in the TreeSet are by default sorted in ascending order.

TreeSet is not thread-safe and doesn’t allows duplicates , Allows null elements Yes. TreeSet class provides an add method that is used to add a specific element to the TreeSet. It also provides the ‘addAll’ method. This method accepts any other collection as an argument and then adds all the elements of this collection to the TreeSet.

How to Create REST APIs with Java and Spring Boot (twilio.com)

https://github.com/MohammedAliIbrahim/spring-boot-college-management-system.git

 

No comments:

Post a Comment

All Java 8 / J2EE Interview for Experienced

  1.       Functional Interface, Stream API? Functional interfaces are also called Single Abstract Method interfaces (SAM Interfaces). As ...