Lead Software Engineer

Hash Set :
1) It implements the Set Interface.

2) It does not allow duplicate values.

3) While adding an element it requires only one object as a parameter.

4) Internally, HashSet uses HashMap to add entries. The key K in a HashSet is the argument supplied in the
add(Object) method. For each value supplied in the add(Object) method, Java assigns a dummy value.

5) It is slower than HashMap.



Hash Map :
1) It implements the Map Interface.

2) The key needs to be unique while two different keys can have the same value.

3) While adding an entry, it requires two object values, the Key and the Value as the parameter.

4) There is no concept of duplicate values.

5) It is faster than HashSet.

Following are the differences between ArrayList and Vector in java :

1) Synchronization : Vector is synchronized, which means that only one thread can access the code at a time,
however, ArrayList is not synchronized, which means that multiple threads can operate on ArrayList at the same time.

2)Data Growth : Both ArrayList and Vector dynamically expand and shrink to make the most use of storage space,
but the manner they do it is different. If the number of elements in an array exceeds its limit, ArrayList increments
50% of the current array size, while vector increments 100%, thereby doubling the current array size.

3) Performance : ArrayList is faster than vector operations because it is non-synchronized, but vector operations are
slower since they are synchronized (thread-safe). When one thread works on a vector, it acquires a lock on it,
requiring any other threads working on it to wait until the lock is released.

4) Ease of Iteration : Vector can traverse over its elements using both Enumeration and Iterator, whereas ArrayList
can only traverse using Iterator.

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

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

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

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

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

Comparable : use to sort objects in the natural sort order

The differences between Abstract Class and Interface are as follows :

Abstract Class:

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



Interface:

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

Multiple inheritances cannot be achieved in java. To overcome this problem the Interface concept is
introduced. An interface is a template which has only method declarations and not the method implementation.

Some imp. points about Interface :

1) All the methods in the interface are internally public abstract void.
2) All the variables in the interface are internally public static final that is constants.
3) Classes can implement the interface and not extends.
4) The class which implements the interface should provide an implementation for all the methods declared in the
interface.

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

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

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

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

In Java, the final keyword is used as defining something as constant /final and represents the non-access modifier.

1) final variable :
i) When a variable is declared as final in Java, the value can’t be modified once it has been assigned.
ii) If any value has not been assigned to that variable, then it can be assigned only by the constructor of the class.


2) final method :
i) A method declared as final cannot be overridden by its children's classes.
ii) A constructor cannot be marked as final because whenever a class is inherited, the constructors are not inherited.
Hence, marking it final doesn't make sense. Java throws compilation error saying - modifier final not allowed here


3) final class :
i) No classes can be inherited from the class declared as final. But that final class can extend other classes for its
usage.

1) Jenkins Pipelines can be either - a Declarative pipeline or a Scripted Pipeline.

2) Declarative pipeline makes use of numerous, generic, predefined build steps/stages (i.e. code snippets) to build
our job according to our build/automation needs.

3) Whereas, with Scripted pipelines, the steps/stages can be custom-defined & used using a groovy syntax which
provides better control & fine-tuned execution levels.

Jenkins is a self-contained, open-source automation server that can be used to automate all sorts of tasks related to
building, testing, and delivering or deploying software. Jenkins can be installed through native system packages,
Docker, or even run standalone by any machine with a Java Runtime Environment (JRE) installed.

In Jenkins, credentials are a set of information used for authentication with internal/external services to accomplish an
action. Jenkins credentials are provisioned & managed by a built-in plugin called - Credentials Binding - plugin.
Jenkins can handle different credentials as follows -

1) Secret text - A token such as an API token, JSON token, etc.
2) Username and password - Basic Authentication can be stored as a credential as well.
3) Secret file - A secret file used to authenticate some secure data services & security handshakes.
4) SSH Username with a private key - An SSH public/private key pair for Machine to Machine authentication.
5) Certificate - a PKCS#12 certificate file and an optional password.
6) Docker Host Certificate Authentication credentials.

And as we can guess, this can be extended to several other extensible credential types like - AWS credential, Azure
secrets, etc. using commonly available plugins.

It is a pipeline job that can be configured to Create a set of Pipeline projects according to the detected branches in
one SCM repository. This can be used to configure pipelines for all branches of a single repository e.g. if we maintain
different branches (i.e. production code branches) for different configurations like locales, currencies, countries, etc.

The language used for writing test scripts in Selenium IDE is called Selenese. It is a set of commands used to test
your web application or system. Selenium commands could be divided into 3 major categories :

1) Actions: These are the commands interacting directly with web applications.
2) Accessors: These are the commands which allow users to store values to a user-defined variable.
3) Assertions: They enable a comparison of the current state of the application with its expected state.

Selenium has the support of majorly 4 navigation commands : 

1) navigate().back(): This command is used for taking the user to the last webpage of the browser history.

2) navigate().forward(): This command is used for taking the user to the next web page of the browser history.

3) navigate().refresh(): This command is used for reloading the web components of a webpage by refreshing it.

4) navigate().to(): This command is used for navigating to a particular URL in a new web browser. It takes the URL to
be migrated to, as a parameter.

The JUnits annotation linked with Selenium are :

1) @Before public void method() – It will perform the method () before each test, this method can prepare the test
2) @Test public void method() – Annotations @Test identifies that this method is a test method environment
3) @After public void method() - To execute a method before this annotation is used, test method must start with
test@Before

Open-source testing tools, Selenium and Cucumber are both used for functional testing. However, there are some
distinctions between them.

Here are some key distinctions between Selenium and Cucumber :

1) Cucumber is a behavior-driven development automation tool that may be used with Selenium. Selenium is a web
browser automation tool for web projects (or Appium).

2) Cucumber is used for acceptance testing, while Selenium is used for automated UI testing.

3) Technical teams (SDETs/programmers) favour Selenium, while non-technical teams often choose Cucumber
(business stakeholders and testers).

4) Cucumber isn't required for Selenium to work. Cucumber's step-definition implementation is based on Selenium or
Appium.

5) The script creation with Selenium is complicated, whereas Cucumber is straightforward.

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

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

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