Skip to content

Java Wissensmap

Main Navigation Übersicht

Appearance

Sidebar Navigation

Java Grundlagen

🟢 Primitive Datentypen vs. Referenztypen

🟢 Autoboxing / Unboxing

🟢 Type Casting (implicit / explicit)

🟡 String Pool & String Immutability

🟢 StringBuilder vs. StringBuffer

🟢 Arrays vs. ArrayList

🟢 Varargs

🟢 Enums

🟡 Annotations (Built-in & Custom)

🟢 Operators & Operator Precedence

🟢 Ternary Operator

🟡 Switch Expressions (Java 14+)

🟡 Pattern Matching (instanceof, switch)

🟡 Sealed Classes

🟡 Records

🟢 var (Local Variable Type Inference)

🟢 Text Blocks

🟢 Static Imports

🟢 Final Keyword (Variablen, Methoden, Klassen)

🟡 Transient Keyword

🔴 Volatile Keyword

🟡 Pass-by-Value vs. Pass-by-Reference in Java

🟡 Stack vs. Heap Memory

🟡 Garbage Collection Grundlagen

🔴 Garbage Collector Typen (G1, ZGC, Shenandoah)

🔴 Memory Leaks erkennen und vermeiden

🔴 ClassLoader-Hierarchie

🔴 Reflection API

🔴 Java Module System (JPMS)

🔴 JVM Architektur (JIT, Bytecode, Class Loading)

🟢 JDK vs. JRE vs. JVM

OOP — Objektorientierte Programmierung

🟢 Klassen & Objekte

🟢 Konstruktoren (Default, Parameterized, Copy)

🟢 Constructor Chaining

🟢 this & super Keyword

🟢 Vererbung (Inheritance)

🟢 Einfachvererbung vs. Mehrfachvererbung

🟢 Method Overloading

🟢 Method Overriding

🟡 Polymorphismus (Compile-time vs. Runtime)

🟢 Abstrakte Klassen

🟢 Interfaces

🟡 Interface Default Methods

🟡 Interface Static Methods

🟡 Functional Interfaces

🟡 Abstrakte Klasse vs. Interface — Wann was?

🟢 Encapsulation / Kapselung

🟢 Access Modifiers (private, protected, public, package-private)

🟡 Komposition vs. Vererbung

🟡 Aggregation vs. Komposition

🟡 Kohäsion & Kopplung

🟡 Liskov Substitution Principle

🟡 SOLID-Prinzipien (einzeln)

🟢 DRY Principle

🟢 KISS Principle

🟢 YAGNI Principle

🟡 Law of Demeter

🟡 Tell, Don't Ask

🟡 Favor Composition over Inheritance

🟡 Dependency Inversion

Collections Framework

🟢 List (ArrayList, LinkedList, Vector, Stack)

🟢 Set (HashSet, LinkedHashSet, TreeSet)

🟡 Queue (PriorityQueue, ArrayDeque)

🟡 Deque

🟢 Map (HashMap, LinkedHashMap, TreeMap, Hashtable)

🔴 ConcurrentHashMap

🔴 WeakHashMap

🟡 EnumSet / EnumMap

🟡 Collections.unmodifiableList / Map / Set

🟢 List.of(), Map.of(), Set.of() (Immutable Collections)

🟡 Iterator vs. ListIterator

🟡 Iterable Interface

🟡 Comparable vs. Comparator

🔴 HashMap Internals (Buckets, Hashing, Rehashing)

🔴 Hash Collisions & Collision Resolution

🟡 equals() und hashCode() Vertrag

🔴 fail-fast vs. fail-safe Iteratoren

🔴 NavigableMap / NavigableSet

🔴 Concurrent Collections (CopyOnWriteArrayList, BlockingQueue)

Generics

🟡 Generische Klassen

🟡 Generische Methoden

🟡 Bounded Type Parameters (extends, super)

🟡 Wildcards (?, extends, super)

🔴 PECS Prinzip (Producer Extends, Consumer Super)

🔴 Type Erasure

🟡 Generics vs. Raw Types

🟢 Diamond Operator

Exception Handling

🟢 Checked vs. Unchecked Exceptions

🟢 Error vs. Exception

🟢 try-catch-finally

🟢 try-with-resources

🟡 AutoCloseable Interface

🟡 Custom Exceptions

🟡 Exception Chaining

🟢 Multi-Catch

🟡 Best Practices (keine leeren Catch-Blöcke, spezifische Exceptions)

🟡 Warum keine Exceptions für Flow Control?

🟢 StackTrace lesen und verstehen

Functional Programming & Streams

🟢 Lambda Expressions

🟡 Functional Interfaces (Predicate, Function, Consumer, Supplier, BiFunction)

🟡 Method References

🟡 Stream API

🟡 Stream vs. Collection

🟡 Intermediate Operations (map, filter, flatMap, peek, sorted, distinct)

🟡 Terminal Operations (collect, forEach, reduce, count, findFirst, anyMatch)

🟡 Collectors (toList, toMap, toSet, groupingBy, partitioningBy, joining)

🔴 Parallel Streams

🔴 Parallel Streams — Gefahren & Wann sinnvoll

🟡 Optional

🟡 Optional Best Practices (nicht als Methodenparameter)

🟡 Stream.of() vs. Arrays.stream()

🔴 Lazy Evaluation in Streams

🔴 Short-Circuiting Operations

Multithreading & Concurrency

🟡 Thread vs. Runnable vs. Callable

🟡 Thread Lifecycle

🟢 start() vs. run()

🟡 synchronized Keyword

🔴 wait(), notify(), notifyAll()

🟡 Deadlock

🔴 Livelock

🔴 Starvation

🟡 Race Conditions

🟡 Thread Safety

🔴 Volatile Keyword

🔴 Atomic Classes (AtomicInteger, AtomicReference)

🔴 ReentrantLock

🔴 ReadWriteLock

🔴 Semaphore

🔴 CountDownLatch

🔴 CyclicBarrier

🟡 ExecutorService

🟡 ThreadPool (FixedThreadPool, CachedThreadPool, ScheduledThreadPool)

🟡 Future & CompletableFuture

🔴 CompletableFuture Chaining (thenApply, thenCompose, thenCombine)

🔴 Fork/Join Framework

🔴 ThreadLocal

🔴 Virtual Threads (Project Loom, Java 21)

🔴 Structured Concurrency

Design Patterns

Creational Patterns

🟢 Singleton

🟡 Factory Method

🟡 Abstract Factory

🟡 Builder

🟡 Prototype

Structural Patterns

🟡 Adapter

🔴 Bridge

🔴 Composite

🟡 Decorator

🟡 Facade

🟡 Proxy

🔴 Flyweight

Behavioral Patterns

🟡 Observer

🟡 Strategy

🟡 Command

🟡 Template Method

🟡 Iterator

🟡 State

🔴 Chain of Responsibility

🔴 Mediator

🔴 Visitor

Weitere Patterns

🟢 Repository Pattern

🟢 DTO Pattern (Data Transfer Object)

🟢 DAO Pattern (Data Access Object)

🟢 MVC Pattern

🟡 Service Layer Pattern

🟡 Dependency Injection Pattern

🔴 Event-Driven Pattern

🔴 Circuit Breaker Pattern

🔴 Saga Pattern

🔴 CQRS Pattern

🔴 Outbox Pattern

🟡 Retry Pattern

🔴 Bulkhead Pattern

Clean Code

🟢 Aussagekräftige Variablen- und Methodennamen

🟢 Methoden: Eine Aufgabe, eine Abstraktionsebene

🟢 Methoden kurz halten

🟢 Keine Magic Numbers / Magic Strings

🟢 Konstanten statt Hardcoded Values

🟢 Boy Scout Rule

🟢 Single Responsibility auf Methodenebene

🟢 Keine verschachtelten if-else-Kaskaden

🟢 Guard Clauses / Early Returns

🟡 Code Smells erkennen

🟢 Long Method

🟡 God Class

🟡 Feature Envy

🟡 Data Clumps

🟡 Primitive Obsession

🟡 Shotgun Surgery

🟡 Divergent Change

🟢 Dead Code entfernen

🟢 Kommentare: Warum, nicht Was

🟢 Keine auskommentierten Codeblöcke

🟢 Konsistente Formatierung

🟡 Immutability bevorzugen

🟡 Defensive Kopien

🟡 Null vermeiden (Optional nutzen)

🟡 Fail Fast Principle

🟡 Package-Struktur sinnvoll aufbauen

Refactoring

🟢 Extract Method

🟡 Extract Class

🟢 Rename Variable / Method / Class

🟢 Inline Variable / Method

🟢 Replace Magic Number with Constant

🟡 Replace Conditional with Polymorphism

🟡 Introduce Parameter Object

🟡 Replace Temp with Query

🟡 Move Method / Move Field

🔴 Replace Inheritance with Delegation

🟡 Decompose Conditional

🟡 Wann Refactoring? Wann nicht?

Testing

🟢 Unit Testing

🟡 Integration Testing

🟡 End-to-End Testing

🟢 Testpyramide

🟢 JUnit 5 Grundlagen

🟢 JUnit 5 Assertions

🟢 JUnit 5 Annotations (@Test, @BeforeEach, @AfterEach, @BeforeAll, @Nested, @ParameterizedTest)

🟡 Parameterized Tests

🟡 Mockito Grundlagen

🟡 Mocking vs. Stubbing vs. Spying

🟡 @Mock, @InjectMocks, @Spy

🟡 when().thenReturn() vs. doReturn().when()

🟡 verify() in Mockito

🟡 ArgumentCaptor

🟡 BDD-Style Testing (given/when/then)

🟡 AssertJ

🔴 Testcontainers

🟡 Testabdeckung (Code Coverage)

🟡 Was testen, was nicht?

🟢 Test Naming Conventions

🟢 AAA Pattern (Arrange, Act, Assert)

🟡 Testbare Klassen schreiben (Dependency Injection)

🟡 TDD (Test-Driven Development)

🔴 Mutation Testing (PIT)

🔴 Contract Testing

🔴 WireMock

🟡 MockMvc (Spring)

🟡 @SpringBootTest vs. @WebMvcTest vs. @DataJpaTest

Spring Framework & Spring Boot

Spring Core

🟢 Dependency Injection (Constructor, Setter, Field)

🟡 Warum Constructor Injection bevorzugt?

🟡 Inversion of Control (IoC)

🟡 Spring ApplicationContext

🟡 Bean Lifecycle

🟡 Bean Scopes (Singleton, Prototype, Request, Session)

🟢 @Component, @Service, @Repository, @Controller

🟡 @Configuration & @Bean

🟢 @Autowired

🟡 @Qualifier

🟡 @Primary

🟢 @Value

🟡 @Profile

🔴 @Conditional

🔴 Spring Expression Language (SpEL)

🔴 Spring Events (ApplicationEvent)

🟡 @Scheduled & Scheduling

Spring Boot

🟡 Spring Boot Auto-Configuration

🟢 application.properties vs. application.yml

🟡 Spring Boot Starter

🟡 Spring Boot Actuator

🟡 Health Checks & Readiness/Liveness Probes

🟡 Externalized Configuration

🟢 Spring Boot DevTools

🟡 Embedded Server (Tomcat, Undertow)

🟡 Spring Boot Profiles

🟡 CommandLineRunner / ApplicationRunner

🟢 Custom Banner (naja, nice to know)

🟡 Spring Boot Logging (SLF4J, Logback)

🟡 Structured Logging

Spring Web / REST

🟢 @RestController vs. @Controller

🟢 @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, @PatchMapping

🟢 @PathVariable, @RequestParam, @RequestBody, @RequestHeader

🟡 ResponseEntity

🟡 @ResponseStatus

🔴 Content Negotiation

🟡 REST Best Practices

🟡 RESTful API Design (Ressourcen, HTTP-Verben, Statuscodes)

🔴 HATEOAS

🟡 API Versioning Strategien

🟡 Pagination & Sorting

🟡 Request Validation (@Valid, @NotNull, @Size, Custom Validators)

🟡 Global Exception Handling (@ControllerAdvice, @ExceptionHandler)

🔴 Problem Detail (RFC 7807)

🟡 CORS Konfiguration

🟡 Swagger / OpenAPI (springdoc-openapi)

Spring Data / JPA / Hibernate

🟡 JPA vs. Hibernate vs. Spring Data JPA

🟢 Entity Mapping (@Entity, @Table, @Column, @Id)

🟡 Primary Key Generation Strategien (AUTO, IDENTITY, SEQUENCE, TABLE)

🟡 Beziehungen (@OneToOne, @OneToMany, @ManyToOne, @ManyToMany)

🟡 FetchType LAZY vs. EAGER

🟡 N+1 Problem

🔴 N+1 Lösungen (JOIN FETCH, EntityGraph, Batch Size)

🟡 Cascade Types

🟡 Orphan Removal

🟢 JPA Repository (CrudRepository, JpaRepository, PagingAndSortingRepository)

🟡 Derived Query Methods

🟡 @Query (JPQL & Native)

🔴 Specifications & Criteria API

🔴 Projections (Interface-based, Class-based)

🟡 Auditing (@CreatedDate, @LastModifiedDate)

🔴 Optimistic Locking (@Version)

🔴 Pessimistic Locking

🔴 Second-Level Cache (Ehcache, Hazelcast)

🟡 Flyway / Liquibase (Database Migrations)

🔴 Spring Data JDBC vs. Spring Data JPA

🟡 Transaction Management (@Transactional)

🔴 Propagation Levels (REQUIRED, REQUIRES_NEW, NESTED, usw.)

🔴 Isolation Levels (READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE)

🔴 Dirty Read, Non-Repeatable Read, Phantom Read

Spring Security

🟢 Authentication vs. Authorization

🟡 SecurityFilterChain

🟡 UserDetailsService

🟡 PasswordEncoder (BCrypt)

🟡 Role-based Access Control

🟡 Method Security (@PreAuthorize, @Secured)

🟡 JWT Authentication

🔴 OAuth2 / OpenID Connect Grundlagen

🟡 CSRF Protection

🟡 CORS & Security

🟡 Spring Security mit Spring Boot 3.x Konfiguration

Spring Cloud / Microservices (Überblick)

🔴 Service Discovery (Eureka)

🔴 API Gateway (Spring Cloud Gateway)

🔴 Config Server

🔴 Circuit Breaker (Resilience4j)

🔴 Load Balancing

🔴 Distributed Tracing (Micrometer Tracing, Zipkin)

🟡 Service-to-Service Communication (RestClient, WebClient, OpenFeign)

Datenbanken & SQL

🟢 SQL Grundlagen (SELECT, INSERT, UPDATE, DELETE)

🟢 JOINs (INNER, LEFT, RIGHT, FULL, CROSS)

🟡 GROUP BY & HAVING

🟡 Subqueries

🟢 Aggregatfunktionen (COUNT, SUM, AVG, MIN, MAX)

🟡 UNION vs. UNION ALL

🟡 Indizes (B-Tree, Hash)

🔴 Composite Indizes

🟡 Wann Indizes sinnvoll sind und wann nicht

🔴 Query Execution Plan lesen (EXPLAIN)

🟡 Normalisierung (1NF, 2NF, 3NF)

🔴 Denormalisierung — Wann sinnvoll?

🟡 ACID-Prinzipien

🟡 Transactions

🔴 Isolation Levels in der Datenbank

🟡 Views

🟡 Stored Procedures

🟡 Triggers

🔴 PostgreSQL-spezifische Features (JSONB, CTEs, Window Functions)

🟡 Connection Pooling (HikariCP)

🟡 NoSQL Grundlagen (Document, Key-Value, Column-Family, Graph)

🟡 SQL vs. NoSQL — Wann was?

🟡 Redis (Caching, Session Store)

🟡 MongoDB Grundlagen (optional)

Architektur

Software-Architektur Grundlagen

🟡 Monolith vs. Microservices

🟡 Vor- und Nachteile von Microservices

🟡 Wann Monolith, wann Microservices?

🔴 Modularer Monolith

🔴 Hexagonale Architektur (Ports & Adapters)

🔴 Clean Architecture

🔴 Onion Architecture

🟢 Layered Architecture (Controller → Service → Repository)

🔴 Domain-Driven Design (DDD) Grundlagen

🔴 Bounded Context

🔴 Aggregate

🔴 Entity vs. Value Object

🔴 Domain Events

🟡 Ubiquitous Language

🔴 Event-Driven Architecture

🔴 Event Sourcing

🔴 CQRS (Command Query Responsibility Segregation)

🟡 Synchrone vs. Asynchrone Kommunikation

🟡 REST vs. gRPC vs. GraphQL

🔴 API Gateway Pattern

🔴 Backend for Frontend (BFF) Pattern

🔴 Strangler Fig Pattern (Migration)

🔴 Sidecar Pattern

🟡 12-Factor App

Message Broker / Kafka

🟡 Warum Message Broker?

🟡 Kafka Grundlagen

🟡 Kafka Topics

🟡 Kafka Partitions

🟡 Kafka Consumer Groups

🟡 Kafka Producers

🔴 Kafka Offset Management

🔴 At-least-once vs. At-most-once vs. Exactly-once Delivery

🟡 Kafka vs. RabbitMQ

🔴 Dead Letter Queue

🔴 Event Schema Evolution (Avro, Schema Registry)

🔴 Kafka Connect

🔴 Kafka Streams Grundlagen

🔴 Idempotenz bei Message Processing

🔴 Ordering Guarantees in Kafka

🟡 Spring Kafka (@KafkaListener, KafkaTemplate)

🔴 Backpressure

Caching

🟢 Warum Caching?

🟡 Cache Strategien (Cache-Aside, Write-Through, Write-Behind)

🔴 Cache Invalidation

🟡 TTL (Time to Live)

🟡 Spring Cache Abstraction (@Cacheable, @CacheEvict)

🟡 Redis als Cache

🔴 Distributed Caching

🔴 Cache Stampede / Thundering Herd

API Design & Kommunikation

🟡 REST Prinzipien (Stateless, Uniform Interface, usw.)

🟡 HTTP Methoden & Idempotenz

🟢 HTTP Statuscodes (2xx, 3xx, 4xx, 5xx) — Die wichtigsten kennen

🟡 Request/Response Body Design

🟡 Error Response Design

🟡 API Dokumentation (OpenAPI / Swagger)

🟡 API Rate Limiting

🟡 API Authentication (API Keys, OAuth2, JWT)

🟡 GraphQL Grundlagen

🔴 gRPC Grundlagen

🟡 WebSockets

🟡 Server-Sent Events (SSE)

🟡 Webhooks

🔴 Idempotency Keys

🔴 API Backward Compatibility

🟢 Semantic Versioning

Build Tools & Dependency Management

🟢 Maven Grundlagen

🟡 Maven Lifecycle (clean, compile, test, package, install, deploy)

🟢 pom.xml Struktur

🟡 Maven Dependency Scopes (compile, test, runtime, provided)

🟡 Maven Profiles

🔴 Maven Multi-Module Projects

🟡 Gradle Grundlagen

🟡 Gradle vs. Maven

🔴 Dependency Conflicts lösen

🟡 BOM (Bill of Materials)

🟢 Maven Wrapper / Gradle Wrapper

Versionskontrolle — Git

🟢 git init, clone, add, commit, push, pull

🟢 Branching & Merging

🟡 Merge vs. Rebase

🟡 Git Flow vs. Trunk-Based Development

🟢 Feature Branches

🟢 Pull Requests / Merge Requests

🟡 Code Review Best Practices

🟡 Cherry-Pick

🟢 Stash

🟡 Interactive Rebase

🔴 Git Bisect

🟢 .gitignore

🟡 Conventional Commits

🟡 Semantic Versioning mit Git Tags

🟡 Merge Conflicts lösen

🟡 Squash Commits

CI/CD & DevOps

🟢 Was ist CI/CD?

🟡 Build Pipeline Grundlagen

🟡 GitHub Actions Grundlagen

🟡 GitLab CI Grundlagen

🟡 Jenkins Grundlagen (optional)

🟡 Pipeline Stages (Build, Test, Lint, Deploy)

🟡 Automatisierte Tests in der Pipeline

🟡 Static Code Analysis (SonarQube, Checkstyle, SpotBugs)

🟡 Code Quality Gates

🔴 Deployment Strategien (Blue-Green, Canary, Rolling)

🔴 Infrastructure as Code Grundlagen

🟡 Environment Variables & Secrets Management

Docker & Containerisierung

🟢 Docker Grundlagen

🟡 Dockerfile schreiben

🟡 Docker Images (Base Image, Layer, Cache)

🟡 Multi-Stage Builds

🟡 Docker Compose

🔴 Docker Networking

🟡 Docker Volumes

🟢 Container vs. VM

🟡 Docker Best Practices (kleine Images, non-root User)

🟡 Container Registries (Docker Hub, GHCR)

🟡 Health Checks in Docker

🟢 .dockerignore

Kubernetes (Grundlagen)

🟡 Warum Kubernetes?

🟡 Pods

🟡 Deployments

🔴 Services (ClusterIP, NodePort, LoadBalancer)

🟡 ConfigMaps & Secrets

🟡 Namespaces

🔴 Ingress

🟡 Liveness & Readiness Probes

🔴 Horizontal Pod Autoscaler

🔴 Helm Charts Grundlagen

🟡 kubectl Grundbefehle

Logging, Monitoring & Observability

🟡 Logging Best Practices

🟢 Log Levels (TRACE, DEBUG, INFO, WARN, ERROR)

🟡 Structured Logging (JSON Logs)

🟡 SLF4J & Logback Konfiguration

🔴 MDC (Mapped Diagnostic Context)

🔴 Correlation IDs

🔴 ELK Stack (Elasticsearch, Logstash, Kibana)

🔴 Prometheus & Grafana

🔴 Micrometer Metrics

🟡 Spring Boot Actuator Endpoints

🔴 Distributed Tracing (Zipkin, Jaeger)

🟡 Alerting Grundlagen

🟡 SLIs, SLOs, SLAs

Security

🟡 OWASP Top 10

🟡 SQL Injection

🟡 Cross-Site Scripting (XSS)

🟡 Cross-Site Request Forgery (CSRF)

🟢 Authentication vs. Authorization

🟡 Hashing vs. Encryption

🟡 Symmetric vs. Asymmetric Encryption

🟡 HTTPS / TLS

🟡 JWT Aufbau & Validierung

🔴 OAuth2 Flows (Authorization Code, Client Credentials)

🟡 API Security Best Practices

🟡 Secrets Management

🟡 Principle of Least Privilege

🟡 Input Validation & Sanitization

🟡 Dependency Vulnerability Scanning (OWASP Dependency Check, Snyk)

🟡 Rate Limiting & Throttling

Netzwerk & Protokolle (Grundlagen)

🟡 HTTP/1.1 vs. HTTP/2 vs. HTTP/3

🟡 TCP vs. UDP

🟢 DNS Grundlagen

🟢 IP-Adressen & Ports

🟢 Request/Response Modell

🟡 Cookies & Sessions

🟡 Headers (Content-Type, Authorization, Cache-Control)

🟢 Status Codes verstehen (200, 201, 204, 301, 400, 401, 403, 404, 409, 500, 502, 503)

🔴 SSL/TLS Handshake Grundlagen

🟡 Load Balancer Grundlagen

🟡 Reverse Proxy (Nginx)

🟡 CDN Grundlagen

Agile & Arbeitsweise

🟢 Scrum Grundlagen

🟢 Sprint, Sprint Planning, Daily, Retro, Review

🟢 User Stories & Acceptance Criteria

🟡 Story Points & Estimation

🟢 Kanban Grundlagen

🟢 Definition of Done

🟡 Definition of Ready

🟡 Backlog Refinement

🟢 Pair Programming

🟡 Code Reviews — Worauf achten?

🟡 Technische Schuld (Tech Debt)

🔴 ADRs (Architecture Decision Records)

🟡 Trunk-Based Development vs. Git Flow

🟡 Feature Flags

🟢 Timeboxing

Interview-spezifische Soft Topics

🟢 Warum OOP?

🟢 Warum Java?

🟡 Java vs. Kotlin

🟡 Java vs. C#

🟡 Java vs. Python — Wann was?

🟢 Warum Spring Boot?

🟡 Warum Microservices?

🟢 Warum REST?

🟡 Warum Kafka?

🟢 Warum Docker?

🟡 Warum Kubernetes?

🟢 Warum CI/CD?

🟢 Warum Testen?

🟢 Warum Clean Code?

🟡 Trade-offs erklären können

🟡 "Es kommt drauf an" — Und dann erklären worauf

🟡 Eigene Projekte und Entscheidungen erklären können

🟡 Technische Entscheidungen begründen können

🟡 Komplexe Themen einfach erklären können

Algorithmen & Datenstrukturen (Grundlagen)

🟡 Big-O Notation

🟢 Arrays

🟡 Linked Lists

🟡 Stacks & Queues

🟡 HashMaps / HashSets intern

🟡 Trees (Binary Tree, BST)

🔴 Graphs Grundlagen

🟡 Sorting (Bubble, Quick, Merge, Insertion)

🟡 Searching (Linear, Binary Search)

🟡 Recursion

🟡 Two Pointer Technik

🟡 Sliding Window

🔴 DFS / BFS

🟡 Wann welche Datenstruktur?

Java Ökosystem & Tooling

🟢 IntelliJ IDEA Shortcuts & Productivity

🟢 Debugging in IntelliJ

🟡 Remote Debugging

🔴 Profiling (VisualVM, JFR, async-profiler)

🔴 Thread Dumps lesen

🔴 Heap Dumps analysieren

🟢 Lombok

🟡 MapStruct

🟡 Jackson (JSON Serialization/Deserialization)

🟡 @JsonProperty, @JsonIgnore, @JsonFormat

🟡 RestClient / WebClient / RestTemplate

🟡 Feign Client

🔴 Micrometer

🔴 Testcontainers

🔴 WireMock

🔴 ArchUnit

🟡 Checkstyle / PMD / SpotBugs

🟡 SonarQube

Auf dieser Seite

Normalisierung (1NF, 2NF, 3NF)

🟡 Mittel📝 Noch nicht bearbeitet

Notizen

Hier deine Notizen eintragen...

Code-Beispiele

java

// Dein Code hier...

Wichtige Punkte

...

Interview-Fragen

...

Pager

Zurück🔴 Query Execution Plan lesen (EXPLAIN)

Weiter🔴 Denormalisierung — Wann sinnvoll?