Java 8 introduced several key features that significantly enhanced the language and its libraries. Here are the principal features:
Lambda Expressions:
Allow you to treat functionality as a method argument, or to create small function-like objects more concisely.
Functional Interfaces:
An interface with just one abstract method, used as the type for lambda expressions and method references.
Stream API:
Introduces a new abstraction for working with sequences of elements and performing operations like filter, map, and reduce on them.
Default Methods:
Allow you to add new methods to interfaces without breaking the existing implementations.
Optional:
A container object which may or may not contain a non-null value, to avoid `NullPointerException`.
New Date and Time API:
A comprehensive new date and time library under `java.time` package, which is more flexible and easier to use than the old java.util.Date and java.util.Calendar classes.
Nashorn JavaScript Engine:
Replaces the old Rhino JavaScript engine, allowing for the embedding of JavaScript code within Java applications.
Method References:
Provide a way to refer to methods without invoking them, which can be used for constructing lambda expressions.

These features aim to make Java code more expressive, readable, and efficient.

Stream API in Java provides a powerful way to work with collections and other data sources. Mapping is one of the key operations available in the Stream API, used to transform elements of a stream. Here's a step-by-step guide on how to use the map function with the Stream API:
Import Required Classes :

Create a Stream:
You can create a stream from various sources, like collections, arrays, or generator functions. For example, creating a stream from a list:
Apply the map Function:
Use the map function to transform each element of the stream. For instance, to convert each name to uppercase:
Collect the Results:
Finally, you can collect the transformed stream back into a list or another collection:
Complete Example:
Here’s a complete example demonstrating how to use the map function with the Stream API:
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class StreamMapExample { public static void main(String[] args) { // Create a list of names List<String> names = Arrays.asList("a14mk", "manoj", "Jack"); // Convert the list to a stream List<String> upperCaseNames = names.stream() // Apply the map function to transform each name to uppercase .map(String::toUpperCase) // Collect the results back into a list .collect(Collectors.toList()); // Print the transformed list upperCaseNames.forEach(System.out::println); } }
Mapping with Complex Objects:
If you are working with a list of objects, you can use the map function to transform specific fields or create new objects. For example:
import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; class Person { String name; int age; Person(String name, int age) { this.name = name; this.age = age; } public String getName() { return name; } public int getAge() { return age; } } public class StreamMapExample { public static void main(String[] args) { // Create a list of persons List<Person> people = Arrays.asList( new Person("a14mk", 25), new Person("manoj", 30), new Person("Jack", 35) ); // Transform the list to get a list of names List<String> names = people.stream().map(Person::getName).collect(Collectors.toList()); // Print the list of names names.forEach(System.out::println); } }
In this example, the map function is used to extract the names from a list of Person objects.

IoC stands for "Inversion of Control", a principle in software engineering where the control of objects or portions of a program is transferred to a framework or container. This concept is fundamental to achieving loose coupling in object-oriented design, which makes applications more modular, flexible, and easier to maintain.
Key Concepts of Inversion of Control : 

How IoC Works:

•   Without IoC.

public class Car { private Engine engine; public Car() { this.engine = new Engine(); // Car class is responsible for creating the Engine instance } }

•  With IoC (Dependency Injection).

public class Car { private Engine engine; public Car(Engine engine) { // Engine instance is injected into Car class this.engine = engine; } }

In the example above, with IoC, the `Car` class does not create the `Engine` instance itself. Instead, it receives it from an external source (typically an IoC container).
Benefits of IoC:

Decoupling: Reduces the dependency between components, making the system more modular. Testability: Easier to test components in isolation since dependencies can be easily mocked or stubbed. Flexibility: Easier to swap out implementations of dependencies without modifying the dependent class. 

 Maintainability: Simplifies code management and maintenance by following the single responsibility principle. 

IoC Containers: IoC containers are frameworks that manage the creation and injection of dependencies. Some popular IoC containers are:
Spring (Java): Provides comprehensive support for dependency injection and IoC. 

PicoContainer (Java): Lightweight and simple to use. 

Unity (C#): A dependency injection container from Microsoft. 

Autofac (C#): A popular IoC container for .NET applications.

 
Example in Spring Framework:

Spring Framework is a well-known example of an IoC container. Here’s how dependency injection is typically configured in a Spring application:

 
XML Configuration:

<bean id="engine" class="com.example.Engine"/> <bean id="car" class="com.example.Car"> <constructor-arg ref="engine"/> </bean>

@Configuration public class AppConfig { @Bean public Engine engine() { return new Engine(); } @Bean public Car car() { return new Car(engine()); } }

@Component public class Engine { // Engine properties and methods } @Component public class Car { private final Engine engine; @Autowired public Car(Engine engine) { this.engine = engine; } }

In these examples, the Spring container manages the lifecycle and injection of the `Engine` dependency into the `Car` class. In summary, IoC is a design principle that helps to create flexible, maintainable, and testable software systems by inverting the control of dependency management. Dependency injection is the most common pattern used to implement IoC, and it is supported by various frameworks and containers across different programming languages.