Java 8, Maven, Spring & More
Interactive Concepts & Examples for
Students
Lambda Expressions
• Definition: Anonymous functions that provide clear and
concise syntax.
• Syntax: (parameters) -> expression
• Example: (a, b) -> a + b
Streams API
• Definition: Process collections in a declarative way.
• Example: names.stream().filter(n ->
n.startsWith("A")).forEach(System.out::println);
Filters in Streams
• Definition: Filter elements using conditions inside streams.
• Example: list.stream().filter(x -> x >
10).collect(Collectors.toList());
java.time API
• Modern API for date and time.
• Example: LocalDate.now(), LocalDateTime.of(2023, 5, 20, 10,
30)
Optionals
• Definition: Wrapper for nullable values to avoid
NullPointerException.
• Example:
Optional.ofNullable(value).ifPresent(System.out::println);
Async & Parallel Programming
• Asynchronous using CompletableFuture.
• Parallel using parallelStream() for better performance on large
data sets.
• Example: CompletableFuture.supplyAsync(() -> fetchData());
JDK vs JRE vs JIT
• JDK: Full development kit with compiler and tools.
• JRE: Runtime environment to run Java apps.
• JIT: Improves performance by compiling bytecode at runtime.
Why Maven?
• Standardized builds and dependency management.
• Easier collaboration and project setup.
Maven Project Structure
• Project is defined using POM.xml.
• Use mvn archetype:generate to create skeleton projects.
Build Lifecycle & Repositories
• Phases: clean, validate, compile, test, package, install,
deploy.
• Repositories: Local, Central, Remote for dependencies.
Scopes and Profiles
• Scopes: compile, test, provided, runtime, system.
• Profiles: Define environment-specific configurations (dev,
prod).
Dependency Injection (DI)
• Promotes loose coupling and easier testing.
• Types: Constructor-based, Setter-based.
Injecting Collections
• Spring allows List, Map, Set injection into beans.
• Example: <list><value>Data1</value></list>
Bean Scopes in Spring
• Singleton (default), Prototype, Request, Session.
• Defines lifecycle and sharing of beans.
Autowiring and Properties
• @Autowired for automatic dependency injection.
• @Value("${property}") to inject external values.
Spring Stereotype Annotations
• @Component - Generic bean
• @Service - Business logic layer
• @Repository - DAO layer
• @Controller - Web layer
Aspect-Oriented Programming (AOP)
• Separates cross-cutting concerns (logging, security).
• AspectJ annotations like @Aspect, @Before, @After used
with Spring AOP.
JUnit - Importance
• Unit Testing ensures individual parts of code work correctly.
• Helps detect bugs early and improves code quality.
JUnit - Assert Statements
• Used to test expected results.
• Example: assertEquals(expected, actual);
JUnit - Testing Exceptions
• Check if a method throws an expected exception.
• Example: assertThrows(IllegalArgumentException.class, () ->
method());
JUnit - Comparing Arrays
• Test equality of arrays.
• Example: assertArrayEquals(expectedArray, resultArray);
JUnit - Parameterized Tests
• Run the same test with different values.
• Example: @ParameterizedTest @ValueSource(ints = {1, 2, 3})
JUnit - Test Suites
• Group multiple test classes into one suite.
• Example: @Suite @SelectClasses({Test1.class, Test2.class})
JUnit - Performance Testing
• Measure test execution time or performance impact.
• Use timeout or System.nanoTime() for performance metrics.
Understanding Servlets
• Servlets handle HTTP requests and generate responses.
• Lifecycle: init(), service(), destroy()
Web Application Request Flow
• Client sends request -> Web Server -> Servlet -> Response to
client
• Involves deployment descriptor (web.xml) or annotations.
Git - Introduction
• Distributed version control system for tracking changes.
• Helps in collaboration and maintaining history.
Git - Basic Commands
• git init, git clone, git add, git commit, git push, git pull
• Track and sync changes with repositories.
Git - Branching & Merging
• Branching allows parallel development.
• Merging integrates changes from different branches.
• Helps manage features, bug fixes, and releases.
