Collection :

- is a framework that provides an architecture to store and manipulate the group of

objects
- Java collections can achieve all the operations that we perform on a data
- Some of operations are searching, sorting, insertion manipulation and deletion
- It provides readymade API

List :

- provides the facility to maintain the ordered collection

- It contains the index based methods to insert, update, delete and search the
elements
- It can have duplicate elements also
- we can also store the null elements in the list

ArrayList :

- used a dynamic array for storing the elements

- No size limit
- duplicate elements allow
- maintain the insertion order
- allows random access
- Non-Synchronized

LinkedList :

- uses a doubly linked list to store the elements

- contains duplicate elements
- Non-Synchronized
- maintain insertion order
- manipulation is fast because no shifting needs to occure

Vector :

- Synchronized
- vector is a legacy class
- vector is slow because it is synchronized
- A vector can use the iterator or enumeration interface to traverse the elements

HashSet :

- contains unique elements only

- allows null value
- non-synchrionized
- doesn't maintain the insertion order

LinkedHashSet :

- contains unique elements only

- allow null value
- non-synchrionized
- maintain the insertion order

TreeSet :

- stored in ascending order

- contains unique elements
- doesn't allow null element
- non-synchronized

HashMap :

- store elements in the form of key & value pair

- keys should be unique
- may have one null key and multiple null values
- non-synchronized
- maintain no order

Hashtable :

- Hashtable store data in key and value pair.

- Hashtable is synchronized. It is thread safe and can be shared with many threads.
- Hashtable doesn't allow any null key or value.
- Hashtable is a legacy class.
- Hashtable is slow.
- Hashtable is traversed by Enumerator and Iterator.

Stack :

- It follows the principle LIFO.

- It has only one end from which both the insertion & deletion
take place and that end is known as top.
- it contains only one pointer known as top pointer.
- The top pointer holds the address of the last inserted
or the topmost element of the stack.
- It performs two operations push and pop.
- The push operation inserts the elements in a list.
- The pop operation removes elements in a list.

Queue :

- It follows the principle FIFO.

- It has two ends i.e. front and rear.
- The front end is used for deletion & rear end for insertion.
- It contains two pointers front and rear.
- The front pointer holds the address of the first element.
- The rear pointer holds the address of the last elements in queue.
- It performs two operations enqueue and dequeue.
- The enqueue operation performs the insertion of the element in a queue.
- The dequeue operation performs the deletion of the element in a queue.

LinkedHashMap :

- contains values based on the key

- contains unique elements
- It may have one null key and multiple null values
- Non-synchronized
- maintain insertion order

TreeMap :

- stores in key-value pairs in sorted order

- It contains values based on the key
- contains only unique elements
- cannot have a null key but have multiple null values
- non-synchronized
- maintain ascending order
Abstract Class :

- It can have abstract & non abstract methods

- It needs to be extended and its method implemented
- It cannot be instantiated
- It can have constructor and static methods also
- It can have final methods

Interface :

- It is a blueprint of a class
- It has static final and abstract methods
- is a mechanism to achieve abstraction
- only abstract methods present
- also represents the IS-A relationship
- used to achieve loose coupling

Abstraction :

- Abstraction is a technique by which we can hide the data that is not

required to users.
- It hides all unwanted data so that users can work only with the required data.

Encapsulation :

- Binding or wrapping the code and data together into a single unit it is called
encapsulation
- The main purpose of encapsulation is to provide the security
- To achieve encapsulation declare the variables as private and methods as public
of a class
- The main objective of encapsulation is data hiding or data security

Inheritance :

- The process of acquire properties of one class to another

- The process of acquires parent class variables & methods into child class
- The process in which one object can acquires all properties & methods of parent
class
- Inheritance helps to reuse the code & establish a relationship between different
classes

Polymorphism :

- If one task is perform in different ways it is known as polymorphism

- The process of providing multiple implementation to a method to perform one
operation
based on sub-type or based on parameter type is called as polymorphism
- Two types of polymorphism
- Compile-time polymorphism
- Run-time polymorphism

Strings :

- String is an object that represents sequence of char values

- Strings is immutable which means it cannot be changed
- is a non-primitive/reference datatype.
- is a final class
Error :

- Errors are problems that mainly occure due to the lack of system resources
- It cannot be caught or handled
- It occurs at runtime
- These are mainly unchecked
- Ex : OutOfMemoryError
StackOverFlowError
VirtualMachineError

Exception :

- It is an event that occurs during the execution of the program and interrupts the

normal flow of program instructions.

- Exceptions are occurs at compile time & runtime
- It occurs in the code written by the developers
- It can be recovered by using the try-catch block and throws keyword

Throw :

- The throw keyword is used to throw an exception

Throws :

- The "throws" keyword is used to declare exception.

- It specifies that there may occur an exception in the method
- It doesn't throw an exception
- It is always used with method signature

Super Keyword :

- It is a non-static final reference variable

- super keyword holds super-class / parent class information
- used to differentiate subclass instance variables or methods from superclass
- we can not use super keyword in static methods and static blocks

This keyword :

- this is a keyword
- this is a reference variable that refers to current class object instance members
- this keyword we can to differentiate between local and global variables
- we can use this keyword inside a instance method and inside a constructor only
- we cannot use this keyword inside a static method or static block

Static Keyword :

- The static keyword in Java is mainly used for memory management.

- The static keyword in Java is used to share the same variable or method of a
given class.
- The users can apply static keywords with variables, methods, blocks, and nested
classes

Volatile Keyword :

- Volatile keyword is used to modify the value of a variable by different threads.

- It is also used to make classes thread safe.
- It means that multiple threads can use a method and instance of the classes at
the same time without any problem.
- The volatile keyword can be used either with primitive type or objects.

Transient Keyword :

- The transient keyword can be used with the data members of a class in order to
avoid their serialization.

Hibernate :

- hibernate is an open-source object-Relational Mapping(ORM) framework

- simplifies database interaction by mapping java objects to database tables and
vice-versa

Hibernate methods :
- save
- delete
- update
- load
- get

Session :

- A session in hibernate represents a single threaded unit of work with the

database
- It provides methods for CRUD operations as well as transaction management

Difference between JDBC & Hibernate :

- JDBC is a technology and hibernate is a framework.

- JDBC works with rows and columns whereas hibernate works with class and
variables.
- JDBC does not built-in functions for performing CRUD operations on database.
- Hibernate has built in methods for performing CRUD operations.
- JDBC code is database dependent code and hibernate code is database independent
code.

Spring :

- Spring is a framework using which we can develop web application and web services
both.
- Before Spring Boot, Spring developers would develop this application using XML
based configuration.

Spring Boot :

- Spring Boot is open-source framework.

- Spring Boot is completely new project from spring community.
- In spring boot project, dependencies are managed using pom.xml file,
no need to configure tomcat server separetely, no need to write configuration
using XML.

Spring Annotations :

- Component
- Autowired
- Controller
- Service
- Repository
- RequestParam

SpringBoot Annotations

- SpringBootApplication
- RequestMapping
- GetMapping
- PostMapping
- PutMapping
- DeleteMapping
- RestController
- Value

Iterator :

-An Iterator is an object that can be used to loop through collections, like
ArrayList and HashSet.
-It is called an "iterator" because "iterating" is the technical term for looping.
-To use an Iterator, you must import it from the java.util package.

Wrapper Classes :

-Wrapper classes provide a way to use primitive data types (int, boolean, etc..) as
objects.

Threads :

- Threads allows a program to operate more efficiently by doing multiple things at

the same time.
- Threads can be used to perform complicated tasks in the background without
interrupting the main program.
- There are two ways to create a thread.
It can be created by extending the Thread class and overriding its run() method:
Another way to create a thread is to implement the Runnable interface:

Multithreading :
- Multithreading is a Java feature that allows concurrent execution of two or more
parts of a program for maximum utilization of CPU.
- Each part of such program is called a thread.
- So, threads are light-weight processes within a process.
- Threads can be created by using two mechanisms :
* Extending the Thread class
* Implementing the Runnable Interface

Serialization & Deserialization :

Serialization is a mechanism of converting the state of an object into a byte

stream.
Deserialization is the reverse process where the byte stream is used to recreate
the actual Java object in memory.

Occurance Of letters :

import java.io.*;
import java.util.*;
class HelloWorld {
public static void main(String[] args) {

String name = "Pratik";

 char[] ch = name.toCharArray();
HashMap<Character,Integer> hm = new HashMap<Character,Integer>();
for(char c : ch)
{
if(hm.containsKey(c))
{
hm.put(c,hm.get(c)+1);
}
else
{
hm.put(c,1);
}
}
for(Map.Entry entry : hm.entrySet())
{
System.out.println(entry.getKey()+" -> "+entry.getValue());
System.out.println();
}
}
}