,-Tags – einfach Markdown schreiben." +- icon: "👁" + title: "Besser in Editoren" + desc: "Markdown wird in modernen IDEs und Texteditoren hervorragend dargestellt." +support: + description: "Verfügbar seit JDK 23 (Sept. 2024)" diff --git a/translations/content/de/language/module-import-declarations.yaml b/translations/content/de/language/module-import-declarations.yaml new file mode 100644 index 0000000..0d3ae1b --- /dev/null +++ b/translations/content/de/language/module-import-declarations.yaml @@ -0,0 +1,17 @@ +title: "Modul-Import-Deklarationen" +oldApproach: "Viele Imports" +modernApproach: "import module" +summary: "Alle exportierten Pakete eines Moduls mit einer einzigen Deklaration importieren." +explanation: "Modul-Import-Deklarationen ermöglichen es, alles, was ein Modul exportiert, mit einer Zeile zu importieren. Dies ist besonders nützlich für java.base, das Collections, I/O, Streams und mehr abdeckt." +whyModernWins: +- icon: "🧹" + title: "Eine Zeile" + desc: "Eine Wand von Imports durch einen einzigen Modul-Import ersetzen." +- icon: "📦" + title: "Modulsystem-bewusst" + desc: "Nutzt das Modulsystem zum Import zusammenhängender Pakete." +- icon: "🚀" + title: "Schnellstart" + desc: "Perfekt für Skripte und Prototypen, bei denen Import-Listen lästig sind." +support: + description: "Finalisiert in JDK 25 LTS (JEP 511, Sept. 2025)." diff --git a/translations/content/de/language/pattern-matching-instanceof.yaml b/translations/content/de/language/pattern-matching-instanceof.yaml new file mode 100644 index 0000000..66a9b89 --- /dev/null +++ b/translations/content/de/language/pattern-matching-instanceof.yaml @@ -0,0 +1,17 @@ +title: "Pattern Matching für instanceof" +oldApproach: "instanceof + Cast" +modernApproach: "Pattern-Variable" +summary: "Typprüfung und Cast in einem Schritt mit Pattern Matching kombinieren." +explanation: "Pattern Matching für instanceof eliminiert den überflüssigen Cast nach einer Typprüfung. Die Variable ist automatisch auf den Gültigkeitsbereich beschränkt, in dem das Muster passt, was den Code sicherer und kürzer macht." +whyModernWins: +- icon: "🔄" + title: "Kein überflüssiger Cast" + desc: "Typprüfung und Variablenbindung erfolgen in einem einzigen Ausdruck." +- icon: "📏" + title: "Weniger Zeilen" + desc: "Eine Zeile statt zwei – die Cast-Zeile entfällt vollständig." +- icon: "🛡️" + title: "Gültigkeitsbereich-Sicherheit" + desc: "Die Pattern-Variable ist nur dort im Gültigkeitsbereich, wo der Typ garantiert ist." +support: + description: "Seit JDK 16 allgemein verfügbar (März 2021)" diff --git a/translations/content/de/language/pattern-matching-switch.yaml b/translations/content/de/language/pattern-matching-switch.yaml new file mode 100644 index 0000000..263344e --- /dev/null +++ b/translations/content/de/language/pattern-matching-switch.yaml @@ -0,0 +1,17 @@ +title: "Pattern Matching im switch" +oldApproach: "if-else-Kette" +modernApproach: "Typ-Muster" +summary: "if-else-instanceof-Ketten durch saubere Switch-Typ-Muster ersetzen." +explanation: "Pattern Matching im switch ermöglicht die direkte Typabgleichung, wobei Typtest, Cast und Bindung in einem prägnanten case-Label kombiniert werden. Der Compiler prüft die Vollständigkeit." +whyModernWins: +- icon: "📐" + title: "Strukturiertes Dispatch" + desc: "Switch macht die Verzweigungsstruktur explizit und übersichtlich." +- icon: "🎯" + title: "Ausdrucksform" + desc: "Gibt einen Wert direkt zurück – keine veränderliche Variable nötig." +- icon: "✅" + title: "Erschöpfungsprüfung" + desc: "Der Compiler stellt sicher, dass alle Typen behandelt werden." +support: + description: "Seit JDK 21 LTS allgemein verfügbar (Sept. 2023)" diff --git a/translations/content/de/language/primitive-types-in-patterns.yaml b/translations/content/de/language/primitive-types-in-patterns.yaml new file mode 100644 index 0000000..c38797e --- /dev/null +++ b/translations/content/de/language/primitive-types-in-patterns.yaml @@ -0,0 +1,17 @@ +title: "Primitive Typen in Mustern" +oldApproach: "Manuelle Bereichsprüfungen" +modernApproach: "Primitive Muster" +summary: "Pattern Matching funktioniert jetzt auch mit primitiven Typen, nicht nur mit Objekten." +explanation: "Java 25 erweitert Pattern Matching auf primitive Typen. int, long, double usw. können in Switch-Mustern mit when-Wächtern verwendet werden, wodurch Boxing oder manuelle Bereichsprüfungen entfallen." +whyModernWins: +- icon: "📦" + title: "Kein Boxing" + desc: "Primitive direkt abgleichen – kein Integer-Wrapper erforderlich." +- icon: "🎯" + title: "Muster-Konsistenz" + desc: "Dieselbe Muster-Syntax für Objekte und Primitive." +- icon: "⚡" + title: "Bessere Performance" + desc: "Autoboxing-Overhead beim Pattern Matching vermeiden." +support: + description: "Vorschau in JDK 25 (dritte Vorschau, JEP 507). Erfordert --enable-preview." diff --git a/translations/content/de/language/private-interface-methods.yaml b/translations/content/de/language/private-interface-methods.yaml new file mode 100644 index 0000000..0ba072d --- /dev/null +++ b/translations/content/de/language/private-interface-methods.yaml @@ -0,0 +1,17 @@ +title: "Private Interface-Methoden" +oldApproach: "Duplizierte Logik" +modernApproach: "Private Methoden" +summary: "Gemeinsame Logik in Interfaces mithilfe privater Methoden auslagern." +explanation: "Java 9 erlaubt private Methoden in Interfaces, sodass Code zwischen Default-Methoden geteilt werden kann, ohne Implementierungsdetails an implementierende Klassen preiszugeben." +whyModernWins: +- icon: "🧩" + title: "Code-Wiederverwendung" + desc: "Logik zwischen Default-Methoden ohne Duplizierung teilen." +- icon: "🔐" + title: "Kapselung" + desc: "Implementierungsdetails bleiben vor implementierenden Klassen verborgen." +- icon: "🧹" + title: "DRY-Interfaces" + desc: "Kein Copy-Paste mehr zwischen Default-Methoden." +support: + description: "Seit JDK 9 allgemein verfügbar (Sept. 2017)" diff --git a/translations/content/de/language/record-patterns.yaml b/translations/content/de/language/record-patterns.yaml new file mode 100644 index 0000000..ff4ce5c --- /dev/null +++ b/translations/content/de/language/record-patterns.yaml @@ -0,0 +1,17 @@ +title: "Record-Muster (Destrukturierung)" +oldApproach: "Manueller Zugriff" +modernApproach: "Destrukturierung" +summary: "Records direkt in Mustern destrukturieren – Felder in einem Schritt extrahieren." +explanation: "Record-Muster ermöglichen die Zerlegung der Komponenten eines Records direkt in instanceof und switch. Verschachtelte Muster werden ebenfalls unterstützt, was tiefes Matching ohne Zwischenvariablen ermöglicht." +whyModernWins: +- icon: "🎯" + title: "Direkter Zugriff" + desc: "Record-Komponenten zugreifen, ohne Accessoren manuell aufzurufen." +- icon: "🪆" + title: "Verschachtelbar" + desc: "Muster können verschachtelt werden – innere Records in einem einzigen Ausdruck abgleichen." +- icon: "📏" + title: "Kompakter Code" + desc: "Fünf Zeilen werden zu zwei – weniger Zeremonie, gleiche Klarheit." +support: + description: "Seit JDK 21 LTS allgemein verfügbar (Sept. 2023)" diff --git a/translations/content/de/language/records-for-data-classes.yaml b/translations/content/de/language/records-for-data-classes.yaml new file mode 100644 index 0000000..54176cf --- /dev/null +++ b/translations/content/de/language/records-for-data-classes.yaml @@ -0,0 +1,17 @@ +title: "Records für Datenklassen" +oldApproach: "Ausführliches POJO" +modernApproach: "record" +summary: "Eine Zeile ersetzt mehr als 30 Zeilen Boilerplate für unveränderliche Datenträger." +explanation: "Records generieren automatisch den Konstruktor, Accessoren (x(), y()), equals(), hashCode() und toString(). Sie sind von Natur aus unveränderlich und ideal für DTOs, Wertobjekte und Pattern Matching." +whyModernWins: +- icon: "⚡" + title: "Einzeilige Definition" + desc: "Eine einzige Zeile ersetzt Konstruktor, Getter, equals, hashCode, toString." +- icon: "🔒" + title: "Standardmäßig unveränderlich" + desc: "Alle Felder sind final – keine Setter-Fallstricke." +- icon: "🧩" + title: "Muster-freundlich" + desc: "Records funktionieren mit Destrukturierungsmustern in switch und instanceof." +support: + description: "Seit JDK 16 allgemein verfügbar (März 2021)" diff --git a/translations/content/de/language/sealed-classes.yaml b/translations/content/de/language/sealed-classes.yaml new file mode 100644 index 0000000..b8a3da2 --- /dev/null +++ b/translations/content/de/language/sealed-classes.yaml @@ -0,0 +1,17 @@ +title: "Versiegelte Klassen für Typhierarchien" +oldApproach: "Offene Hierarchie" +modernApproach: "sealed permits" +summary: "Einschränken, welche Klassen einen Typ erweitern dürfen – für erschöpfende Switches." +explanation: "Versiegelte Klassen definieren eine geschlossene Menge von Untertypen. Der Compiler kennt alle möglichen Fälle und ermöglicht erschöpfendes Pattern Matching ohne default-Zweig. In Kombination mit Records modellieren sie algebraische Datentypen." +whyModernWins: +- icon: "🔐" + title: "Kontrollierte Hierarchie" + desc: "Nur erlaubte Untertypen dürfen erweitern – keine überraschenden Unterklassen." +- icon: "✅" + title: "Erschöpfendes Matching" + desc: "Der Compiler prüft, dass der Switch alle Fälle abdeckt – kein default nötig." +- icon: "📐" + title: "Algebraische Datentypen" + desc: "Summentypen natürlich modellieren – sealed + records = ADTs in Java." +support: + description: "Seit JDK 17 LTS allgemein verfügbar (Sept. 2021)" diff --git a/translations/content/de/language/static-members-in-inner-classes.yaml b/translations/content/de/language/static-members-in-inner-classes.yaml new file mode 100644 index 0000000..3b3319c --- /dev/null +++ b/translations/content/de/language/static-members-in-inner-classes.yaml @@ -0,0 +1,17 @@ +title: "Statische Mitglieder in inneren Klassen" +oldApproach: "Statisch verschachtelte Klasse erforderlich" +modernApproach: "Statische Mitglieder in inneren Klassen" +summary: "Statische Mitglieder in inneren Klassen definieren, ohne statisch verschachtelte Klassen verwenden zu müssen." +explanation: "Vor Java 16 konnten nur statisch verschachtelte Klassen statische Mitglieder enthalten. Innere (nicht-statische) Klassen durften keine Statics haben, weil sie eine umschließende Instanz erforderten. Java 16 lockert diese Einschränkung und erlaubt statische Felder, Methoden und sogar verschachtelte Typen in inneren Klassen." +whyModernWins: +- icon: "🔓" + title: "Mehr Flexibilität" + desc: "Innere Klassen können bei Bedarf nun statische Mitglieder haben." +- icon: "🧩" + title: "Gemeinsamer Zustand" + desc: "Gemeinsamen Zustand über Instanzen einer inneren Klasse hinweg verfolgen." +- icon: "📐" + title: "Designfreiheit" + desc: "Kein Hochstufen zu einer statisch verschachtelten Klasse nur wegen eines statischen Felds." +support: + description: "Seit JDK 16 allgemein verfügbar (März 2021)" diff --git a/translations/content/de/language/static-methods-in-interfaces.yaml b/translations/content/de/language/static-methods-in-interfaces.yaml new file mode 100644 index 0000000..a3a95cb --- /dev/null +++ b/translations/content/de/language/static-methods-in-interfaces.yaml @@ -0,0 +1,17 @@ +title: "Statische Methoden in Interfaces" +oldApproach: "Hilfsklassen" +modernApproach: "Statische Interface-Methoden" +summary: "Statische Hilfsmethoden direkt in Interfaces hinzufügen, anstatt separate Hilfsklassen zu verwenden." +explanation: "Vor Java 8 mussten Hilfsmethoden, die sich auf ein Interface bezogen, in einer separaten Klasse leben (z. B. Collections für Collection). Statische Methoden in Interfaces erlauben es, verwandte Hilfsfunktionen zusammenzuhalten. Gängig in modernen APIs wie Comparator.comparing(), Stream.of() und List.of()." +whyModernWins: +- icon: "📦" + title: "Bessere Organisation" + desc: "Verwandte Hilfsfunktionen beim Interface behalten, nicht in einer separaten Klasse." +- icon: "🔍" + title: "Auffindbarkeit" + desc: "Factory- und Hilfsmethoden sind dort zu finden, wo man sie erwartet." +- icon: "🧩" + title: "API-Kohäsion" + desc: "Keine separaten *Utils- oder *Helper-Klassen mehr erforderlich." +support: + description: "Verfügbar seit JDK 8 (März 2014)" diff --git a/translations/content/de/language/switch-expressions.yaml b/translations/content/de/language/switch-expressions.yaml new file mode 100644 index 0000000..fecf8e7 --- /dev/null +++ b/translations/content/de/language/switch-expressions.yaml @@ -0,0 +1,17 @@ +title: "Switch-Ausdrücke" +oldApproach: "Switch-Anweisung" +modernApproach: "Switch-Ausdruck" +summary: "Switch als Ausdruck, der einen Wert zurückgibt – kein break, kein Fall-Through." +explanation: "Switch-Ausdrücke geben einen Wert direkt zurück, verwenden Pfeilsyntax zur Vermeidung von Fall-Through-Fehlern, und der Compiler prüft die Erschöpfung. Dies ersetzt die fehleranfällige Anweisungsform." +whyModernWins: +- icon: "🎯" + title: "Gibt einen Wert zurück" + desc: "Das Switch-Ergebnis direkt zuweisen – keine temporäre Variable nötig." +- icon: "🛡️" + title: "Kein Fall-Through" + desc: "Pfeilsyntax eliminiert versehentliche Fall-Through-Fehler durch fehlendes break." +- icon: "✅" + title: "Erschöpfungsprüfung" + desc: "Der Compiler stellt sicher, dass alle Fälle abgedeckt sind." +support: + description: "Seit JDK 14 allgemein verfügbar (März 2020)" diff --git a/translations/content/de/language/text-blocks-for-multiline-strings.yaml b/translations/content/de/language/text-blocks-for-multiline-strings.yaml new file mode 100644 index 0000000..10fd866 --- /dev/null +++ b/translations/content/de/language/text-blocks-for-multiline-strings.yaml @@ -0,0 +1,17 @@ +title: "Textblöcke für mehrzeilige Strings" +oldApproach: "String-Verkettung" +modernApproach: "Textblöcke" +summary: "Mehrzeilige Strings natürlich mit Triple-Quote-Textblöcken schreiben." +explanation: "Textblöcke erlauben das Schreiben mehrzeiliger Strings genau so, wie sie erscheinen. Keine Escape-Sequenzen für Anführungszeichen oder \\n mehr. Der Compiler entfernt beiläufige Einrückungen automatisch." +whyModernWins: +- icon: "📖" + title: "Lesbar wie gehabt" + desc: "JSON, SQL und HTML sehen im Quellcode wie echtes JSON, SQL und HTML aus." +- icon: "🚫" + title: "Kein Escape-Chaos" + desc: "Eingebettete Anführungszeichen brauchen keine Backslash-Escapes." +- icon: "📐" + title: "Intelligente Einrückung" + desc: "Führende Leerzeichen werden automatisch anhand der Position des schließenden Trennzeichens gekürzt." +support: + description: "Seit JDK 15 allgemein verfügbar (Sept. 2020)" diff --git a/translations/content/de/language/type-inference-with-var.yaml b/translations/content/de/language/type-inference-with-var.yaml new file mode 100644 index 0000000..87f67d2 --- /dev/null +++ b/translations/content/de/language/type-inference-with-var.yaml @@ -0,0 +1,17 @@ +title: "Typinferenz mit var" +oldApproach: "Explizite Typen" +modernApproach: "var-Schlüsselwort" +summary: "var für lokale Variablen-Typinferenz verwenden – weniger Rauschen, gleiche Sicherheit." +explanation: "Seit Java 10 leitet der Compiler lokale Variablentypen aus der rechten Seite ab. Dies reduziert visuelles Rauschen ohne Einbußen bei der Typsicherheit. var empfiehlt sich, wenn der Typ aus dem Kontext offensichtlich ist." +whyModernWins: +- icon: "⚡" + title: "Weniger Boilerplate" + desc: "Komplexe generische Typen müssen nicht auf beiden Seiten der Zuweisung wiederholt werden." +- icon: "👁" + title: "Bessere Lesbarkeit" + desc: "Fokus auf Variablennamen und Werte, nicht auf Typdeklarationen." +- icon: "🔒" + title: "Noch typsicher" + desc: "Der Compiler leitet den genauen Typ ab und erzwingt ihn zur Compile-Zeit." +support: + description: "Seit JDK 10 allgemein verfügbar (März 2018)" diff --git a/translations/content/de/language/unnamed-variables.yaml b/translations/content/de/language/unnamed-variables.yaml new file mode 100644 index 0000000..6fbcb2a --- /dev/null +++ b/translations/content/de/language/unnamed-variables.yaml @@ -0,0 +1,17 @@ +title: "Unbenannte Variablen mit _" +oldApproach: "Ungenutzte Variable" +modernApproach: "_ als Platzhalter" +summary: "_ verwenden, um anzuzeigen, dass eine Variable absichtlich ungenutzt ist." +explanation: "Unbenannte Variablen teilen Lesern und Werkzeugen mit, dass ein Wert bewusst ignoriert wird. Keine 'ignored'- oder 'unused'-Namenskonventionen mehr, keine IDE-Warnungen mehr." +whyModernWins: +- icon: "📢" + title: "Klare Absicht" + desc: "_ sagt explizit 'dieser Wert wird hier nicht benötigt'." +- icon: "🔇" + title: "Keine Warnungen" + desc: "IDEs und Linter markieren absichtlich ungenutzte Variablen nicht mehr." +- icon: "🧹" + title: "Sauberere Lambdas" + desc: "Mehrparametrige Lambdas sind sauberer, wenn nur einige Parameter benötigt werden." +support: + description: "Finalisiert in JDK 22 (JEP 456, März 2024)." diff --git a/translations/content/de/security/key-derivation-functions.yaml b/translations/content/de/security/key-derivation-functions.yaml new file mode 100644 index 0000000..044f677 --- /dev/null +++ b/translations/content/de/security/key-derivation-functions.yaml @@ -0,0 +1,19 @@ +title: Schlüsselableitungsfunktionen +oldApproach: Manuelles PBKDF2 +modernApproach: KDF-API +summary: Kryptografische Schlüssel mit der Standard-KDF-API ableiten. +explanation: Die KDF-API bietet eine standardisierte Schnittstelle für Schlüsselableitungsfunktionen + einschließlich HKDF. Sie ersetzt das umständliche Muster aus SecretKeyFactory und + PBEKeySpec durch eine saubere Builder-API. +whyModernWins: +- icon: 📐 + title: Saubere API + desc: Builder-Muster statt umständlicher KeySpec-Konstruktoren. +- icon: 🔧 + title: HKDF-Unterstützung + desc: Moderner HKDF-Algorithmus neben PBKDF2. +- icon: 🛡️ + title: Standard + desc: Einheitliche API für alle Schlüsselableitungsalgorithmen. +support: + description: In JDK 25 LTS finalisiert (JEP 510, Sept. 2025). diff --git a/translations/content/de/security/pem-encoding.yaml b/translations/content/de/security/pem-encoding.yaml new file mode 100644 index 0000000..b3b3e03 --- /dev/null +++ b/translations/content/de/security/pem-encoding.yaml @@ -0,0 +1,19 @@ +title: PEM-Kodierung/Dekodierung +oldApproach: Manuelles Base64 + Header +modernApproach: PEM-API +summary: Kryptografische Objekte im PEM-Format nativ kodieren und dekodieren. +explanation: Die PEM-API bietet standardisierte Kodierung/Dekodierung für Zertifikate, + Schlüssel und andere kryptografische Objekte im PEM-Format. Kein manuelles Base64-Wrapping + mit BEGIN/END-Headern mehr. +whyModernWins: +- icon: 🧹 + title: Kein manuelles Base64 + desc: PEM-Header, Zeilenumbruch und Base64 werden automatisch behandelt. +- icon: 🔄 + title: Bidirektional + desc: Mit einer API zu PEM kodieren und von PEM dekodieren. +- icon: 🛡️ + title: Standardformat + desc: Erzeugt RFC 7468-konformes PEM-Ausgabeformat. +support: + description: Vorschau in JDK 25 (JEP 470). Erfordert --enable-preview. diff --git a/translations/content/de/security/random-generator.yaml b/translations/content/de/security/random-generator.yaml new file mode 100644 index 0000000..da45762 --- /dev/null +++ b/translations/content/de/security/random-generator.yaml @@ -0,0 +1,22 @@ +title: RandomGenerator-Interface +oldApproach: new Random() / ThreadLocalRandom +modernApproach: RandomGenerator-Factory +summary: Das RandomGenerator-Interface verwenden, um Zufallszahlenalgorithmen per + Name auszuwählen, ohne an eine bestimmte Klasse gebunden zu sein. +explanation: JDK 17 führte RandomGenerator als gemeinsames Interface für alle RNG-Implementierungen + ein. Statt new Random() oder ThreadLocalRandom fest zu kodieren, können Algorithmen + per Name über eine Factory ausgewählt werden, was den Wechsel zwischen für unterschiedliche + Anwendungsfälle optimierten Algorithmen erleichtert (Geschwindigkeit, statistische + Qualität, Teilbarkeit). +whyModernWins: +- icon: 🔧 + title: Algorithmus-agnostisch + desc: Den besten RNG-Algorithmus per Name wählen, ohne die Codestruktur zu ändern. +- icon: ⚡ + title: Bessere Algorithmen + desc: Zugang zu modernen LXM-Generatoren mit überlegenen statistischen Eigenschaften. +- icon: 🔗 + title: Einheitliche API + desc: Eine Schnittstelle für Random, ThreadLocalRandom, SplittableRandom und mehr. +support: + description: Verfügbar seit JDK 17 (September 2021, JEP 356). diff --git a/translations/content/de/security/strong-random.yaml b/translations/content/de/security/strong-random.yaml new file mode 100644 index 0000000..709dda2 --- /dev/null +++ b/translations/content/de/security/strong-random.yaml @@ -0,0 +1,20 @@ +title: Starke Zufallszahlengenerierung +oldApproach: new SecureRandom() +modernApproach: getInstanceStrong() +summary: Die stärkste SecureRandom-Implementierung der Plattform abrufen. +explanation: getInstanceStrong() gibt die SecureRandom-Implementierung zurück, die + auf der Plattform als die stärkste konfiguriert ist. Dies wird durch die Sicherheitseigenschaft + securerandom.strongAlgorithms gesteuert. +whyModernWins: +- icon: 🛡️ + title: Stärkste verfügbare + desc: Wählt automatisch den besten Algorithmus für die Plattform. +- icon: 📖 + title: Explizite Absicht + desc: Kommuniziert klar, dass starke Zufälligkeit erforderlich ist. +- icon: 🔧 + title: Konfigurierbar + desc: Administratoren können den starken Algorithmus über Sicherheitseigenschaften + ändern. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/security/tls-default.yaml b/translations/content/de/security/tls-default.yaml new file mode 100644 index 0000000..c73c089 --- /dev/null +++ b/translations/content/de/security/tls-default.yaml @@ -0,0 +1,20 @@ +title: TLS 1.3 als Standard +oldApproach: Manuelle TLS-Konfiguration +modernApproach: TLS 1.3 als Standard +summary: "TLS 1.3 ist standardmäßig aktiviert — keine explizite Protokollkonfiguration\ + \ erforderlich." +explanation: Java 11 hat TLS 1.3-Unterstützung hinzugefügt und es zum bevorzugten + Protokoll gemacht. Der HttpClient verwendet es automatisch. Keine manuelle Angabe + von Protokollversionen für sichere Verbindungen mehr. +whyModernWins: +- icon: 🛡️ + title: Sicherer + desc: TLS 1.3 entfernt veraltete Cipher-Suites und Handshake-Muster. +- icon: ⚡ + title: Schnellerer Handshake + desc: TLS 1.3 wird in einem statt zwei Roundtrips abgeschlossen. +- icon: 🆓 + title: Keine Konfiguration + desc: "Standardmäßig sicher — keine explizite Protokollauswahl erforderlich." +support: + description: Weitgehend verfügbar seit JDK 11 (Sept. 2018) diff --git a/translations/content/de/streams/collectors-flatmapping.yaml b/translations/content/de/streams/collectors-flatmapping.yaml new file mode 100644 index 0000000..9a57182 --- /dev/null +++ b/translations/content/de/streams/collectors-flatmapping.yaml @@ -0,0 +1,19 @@ +title: Collectors.flatMapping() +oldApproach: Verschachteltes flatMap +modernApproach: flatMapping() +summary: flatMapping() zum Abflachen innerhalb eines Gruppierungs-Collectors verwenden. +explanation: Collectors.flatMapping() wendet eine Eins-zu-viele-Abbildung als nachgelagerten + Collector an. Es ist das Collector-Äquivalent von Stream.flatMap() – nützlich innerhalb + von groupingBy oder partitioningBy. +whyModernWins: +- icon: 🧩 + title: Kombinierbar + desc: Funktioniert als nachgelagerter Collector innerhalb von groupingBy. +- icon: 📐 + title: Einmaliger Durchlauf + desc: Abflachen und Gruppieren in einem einzigen Stream-Durchlauf. +- icon: 🔗 + title: Verschachtelbar + desc: Lässt sich mit anderen nachgelagerten Collectors kombinieren. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/optional-ifpresentorelse.yaml b/translations/content/de/streams/optional-ifpresentorelse.yaml new file mode 100644 index 0000000..39454b1 --- /dev/null +++ b/translations/content/de/streams/optional-ifpresentorelse.yaml @@ -0,0 +1,19 @@ +title: Optional.ifPresentOrElse() +oldApproach: if/else auf Optional +modernApproach: ifPresentOrElse() +summary: Beide Fälle eines Optional – vorhanden und leer – in einem einzigen Aufruf + behandeln. +explanation: ifPresentOrElse() nimmt einen Consumer für den vorhandenen Fall und ein + Runnable für den leeren Fall. Es vermeidet das isPresent/get-Antimuster. +whyModernWins: +- icon: 📏 + title: Einzelner Ausdruck + desc: Beide Fälle werden in einem Methodenaufruf behandelt. +- icon: 🚫 + title: Kein get() + desc: Eliminiert das gefährliche isPresent() + get()-Muster. +- icon: 🔗 + title: Fließend + desc: Kettet sich natürlich nach findUser() oder jeder Optional-zurückgebenden Methode. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/optional-or.yaml b/translations/content/de/streams/optional-or.yaml new file mode 100644 index 0000000..b3b378e --- /dev/null +++ b/translations/content/de/streams/optional-or.yaml @@ -0,0 +1,19 @@ +title: Optional.or() als Fallback +oldApproach: Verschachtelter Fallback +modernApproach: .or()-Kette +summary: Optional-Fallbacks ohne verschachtelte Prüfungen verketten. +explanation: Optional.or() gibt das ursprüngliche Optional zurück, wenn es einen Wert + hat, andernfalls wird der Supplier ausgewertet, um ein alternatives Optional zu + erhalten. Suppliers sind lazy – sie werden nur bei Bedarf aufgerufen. +whyModernWins: +- icon: 🔗 + title: Verkettbar + desc: Fallbacks in einer lesbaren Pipeline stapeln. +- icon: ⚡ + title: Lazy-Auswertung + desc: Fallback-Supplier werden nur bei Bedarf ausgeführt. +- icon: 📖 + title: Deklarativ + desc: "Liest sich wie 'versuche primär, oder sekundär, oder Standard'." +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/predicate-not.yaml b/translations/content/de/streams/predicate-not.yaml new file mode 100644 index 0000000..b9baa44 --- /dev/null +++ b/translations/content/de/streams/predicate-not.yaml @@ -0,0 +1,21 @@ +title: Predicate.not() zur Negation +oldApproach: Lambda-Negation +modernApproach: Predicate.not() +summary: Predicate.not() verwenden, um Methodenreferenzen sauber zu negieren, statt + Lambda-Wrapper zu schreiben. +explanation: Vor Java 11 musste eine Methodenreferenz zur Negation in ein Lambda eingewickelt + werden. Predicate.not() ermöglicht die direkte Negation eines beliebigen Prädikats, + was den Code lesbar und konsistent mit dem Methodenreferenz-Stil im gesamten Stream-Pipeline + hält. +whyModernWins: +- icon: 👁 + title: Sauberere Negation + desc: Keine Lambda-Wrapper für Methodenreferenzen nur zur Negation nötig. +- icon: 🔗 + title: Kombinierbar + desc: Funktioniert mit jedem Predicate und ermöglicht saubere Prädikat-Ketten. +- icon: 📖 + title: Natürlich lesbar + desc: Predicate.not(String::isBlank) liest sich wie natürliche Sprache. +support: + description: Verfügbar seit JDK 11 (September 2018). diff --git a/translations/content/de/streams/stream-gatherers.yaml b/translations/content/de/streams/stream-gatherers.yaml new file mode 100644 index 0000000..77d8103 --- /dev/null +++ b/translations/content/de/streams/stream-gatherers.yaml @@ -0,0 +1,19 @@ +title: Stream-Gatherers +oldApproach: Benutzerdefinierter Collector +modernApproach: gather() +summary: Gatherers für benutzerdefinierte Zwischen-Stream-Operationen verwenden. +explanation: Gatherers sind eine neue Zwischen-Stream-Operation, die komplexe Transformationen + wie gleitende Fenster, Gruppen fester Größe und Scan-Operationen ausdrücken kann, + die mit Standard-Stream-Operationen nicht möglich waren. +whyModernWins: +- icon: 🧩 + title: Kombinierbar + desc: Gatherers lassen sich mit anderen Stream-Operationen kombinieren. +- icon: 📦 + title: Eingebaute Operationen + desc: windowFixed, windowSliding, fold, scan sofort verfügbar. +- icon: 🔧 + title: Erweiterbar + desc: Eigene Gatherers für beliebige Zwischentransformationen schreiben. +support: + description: In JDK 24 finalisiert (JEP 485, März 2025). diff --git a/translations/content/de/streams/stream-iterate-predicate.yaml b/translations/content/de/streams/stream-iterate-predicate.yaml new file mode 100644 index 0000000..70ef16f --- /dev/null +++ b/translations/content/de/streams/stream-iterate-predicate.yaml @@ -0,0 +1,20 @@ +title: Stream.iterate() mit Prädikat +oldApproach: iterate + limit +modernApproach: iterate(seed, pred, op) +summary: Ein Prädikat zum Beenden der Iteration verwenden – wie eine for-Schleife + als Stream. +explanation: "Das dreiargumented Stream.iterate(seed, hasNext, next) funktioniert\ + \ wie eine for-Schleife: seed ist der Startwert, hasNext bestimmt den Abbruch und\ + \ next erzeugt den nächsten Wert." +whyModernWins: +- icon: 🎯 + title: Natürlicher Abbruch + desc: Stopp basierend auf einer Bedingung, nicht einem willkürlichen Limit. +- icon: 📐 + title: For-Schleifen-Äquivalent + desc: Gleiche Semantik wie for(seed; hasNext; next). +- icon: 🛡️ + title: Kein Risiko eines unendlichen Streams + desc: Das Prädikat garantiert die Terminierung. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/stream-mapmulti.yaml b/translations/content/de/streams/stream-mapmulti.yaml new file mode 100644 index 0000000..ac4dd79 --- /dev/null +++ b/translations/content/de/streams/stream-mapmulti.yaml @@ -0,0 +1,19 @@ +title: Stream.mapMulti() +oldApproach: flatMap + List +modernApproach: mapMulti() +summary: Null oder mehr Elemente pro Eingabe ausgeben, ohne Zwischen-Streams zu erstellen. +explanation: mapMulti() ist eine imperative Alternative zu flatMap, die das Erstellen + von Zwischen-Stream-Objekten für jedes Element vermeidet. Es ist effizienter, wenn + die Abbildung eine kleine Anzahl von Elementen erzeugt. +whyModernWins: +- icon: ⚡ + title: Weniger Allokationen + desc: Kein Zwischen-Stream pro Element erstellt. +- icon: 🎯 + title: Imperativer Stil + desc: Schleifen und Bedingungen direkt verwenden. +- icon: 📐 + title: Flexibel + desc: Null, eins oder viele Elemente mit voller Kontrolle ausgeben. +support: + description: Weitgehend verfügbar seit JDK 16 (März 2021) diff --git a/translations/content/de/streams/stream-of-nullable.yaml b/translations/content/de/streams/stream-of-nullable.yaml new file mode 100644 index 0000000..550808c --- /dev/null +++ b/translations/content/de/streams/stream-of-nullable.yaml @@ -0,0 +1,19 @@ +title: Stream.ofNullable() +oldApproach: Null-Prüfung +modernApproach: ofNullable() +summary: Einen Stream mit null oder einem Element aus einem nullable Wert erstellen. +explanation: Stream.ofNullable() gibt einen Ein-Element-Stream zurück, wenn der Wert + nicht null ist, oder einen leeren Stream, wenn er null ist. Eliminiert das ternäre + Null-Prüfungsmuster. +whyModernWins: +- icon: 📏 + title: Prägnant + desc: Ein Aufruf ersetzt den ternären Ausdruck. +- icon: 🔗 + title: flatMap-freundlich + desc: Perfekt innerhalb von flatMap zum Überspringen von null-Werten. +- icon: 🛡️ + title: Null-sicher + desc: Kein NPE-Risiko – null wird zu einem leeren Stream. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/stream-takewhile-dropwhile.yaml b/translations/content/de/streams/stream-takewhile-dropwhile.yaml new file mode 100644 index 0000000..91c6d19 --- /dev/null +++ b/translations/content/de/streams/stream-takewhile-dropwhile.yaml @@ -0,0 +1,20 @@ +title: Stream takeWhile / dropWhile +oldApproach: Manuelle Schleife +modernApproach: takeWhile/dropWhile +summary: Elemente aus einem Stream basierend auf einem Prädikat nehmen oder überspringen. +explanation: takeWhile() gibt Elemente zurück, solange das Prädikat wahr ist, und + stoppt beim ersten Falsch-Wert. dropWhile() überspringt Elemente, solange es wahr + ist, und gibt den Rest zurück. Beide funktionieren am besten bei geordneten Streams. +whyModernWins: +- icon: 🎯 + title: Kurzschlussauswertung + desc: Stoppt die Verarbeitung, sobald das Prädikat fehlschlägt. +- icon: 🔗 + title: Pipeline-freundlich + desc: Kettet sich natürlich mit anderen Stream-Operationen. +- icon: 📖 + title: Deklarativ + desc: "takeWhile liest sich wie natürliche Sprache: 'nehme, solange kleiner als\ + \ 100'." +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/streams/stream-tolist.yaml b/translations/content/de/streams/stream-tolist.yaml new file mode 100644 index 0000000..e8c22fb --- /dev/null +++ b/translations/content/de/streams/stream-tolist.yaml @@ -0,0 +1,19 @@ +title: Stream.toList() +oldApproach: Collectors.toList() +modernApproach: .toList() +summary: Das terminale toList() ersetzt das ausführliche collect(Collectors.toList()). +explanation: "Stream.toList() gibt eine unveränderliche Liste zurück. Es entspricht\ + \ .collect(Collectors.toUnmodifiableList()), ist aber viel kürzer. Hinweis: Das\ + \ Ergebnis ist im Gegensatz zu Collectors.toList() unveränderlich." +whyModernWins: +- icon: 📏 + title: 7 Zeichen vs. 24 + desc: .toList() ersetzt .collect(Collectors.toList()). +- icon: 🔒 + title: Unveränderlich + desc: Die Ergebnisliste kann nicht verändert werden. +- icon: 📖 + title: Fließend + desc: Liest sich am Ende einer Pipeline natürlich. +support: + description: Weitgehend verfügbar seit JDK 16 (März 2021) diff --git a/translations/content/de/streams/virtual-thread-executor.yaml b/translations/content/de/streams/virtual-thread-executor.yaml new file mode 100644 index 0000000..5d1b062 --- /dev/null +++ b/translations/content/de/streams/virtual-thread-executor.yaml @@ -0,0 +1,20 @@ +title: Virtual-Thread-Executor +oldApproach: Fixer Thread-Pool +modernApproach: Virtual-Thread-Executor +summary: Virtual-Thread-Executors für unbegrenzte leichtgewichtige Nebenläufigkeit + verwenden. +explanation: Der Virtual-Thread-Executor erstellt für jede Aufgabe einen neuen virtuellen + Thread. Keine Pool-Dimensionierung nötig – virtuelle Threads sind günstig genug, + um Millionen davon zu erstellen. +whyModernWins: +- icon: ♾️ + title: Keine Dimensionierung + desc: Keine Pool-Größe festzulegen – so viele Threads erstellen wie benötigt. +- icon: ⚡ + title: Leichtgewichtig + desc: Virtuelle Threads verwenden KB statt MB Speicher. +- icon: 🧹 + title: Auto-closeable + desc: try-with-resources übernimmt das Herunterfahren automatisch. +support: + description: Weitgehend verfügbar seit JDK 21 LTS (Sept. 2023) diff --git a/translations/content/de/strings/string-chars-stream.yaml b/translations/content/de/strings/string-chars-stream.yaml new file mode 100644 index 0000000..0b6f8ef --- /dev/null +++ b/translations/content/de/strings/string-chars-stream.yaml @@ -0,0 +1,19 @@ +title: String-Zeichen als Stream +oldApproach: Manuelle Schleife +modernApproach: chars()-Stream +summary: String-Zeichen als Stream-Pipeline verarbeiten. +explanation: String.chars() gibt einen IntStream von Zeichenwerten zurück und ermöglicht + funktionale Verarbeitung. Für Unicode-Unterstützung behandelt codePoints() ergänzende + Zeichen korrekt. +whyModernWins: +- icon: 🔗 + title: Verkettbar + desc: Filter, Map, Collect auf Zeichen-Streams anwenden. +- icon: 📐 + title: Deklarativ + desc: Beschreibt was zu tun ist, nicht wie zu iterieren. +- icon: 🌐 + title: Unicode-bereit + desc: codePoints() behandelt Emojis und ergänzende Zeichen korrekt. +support: + description: Verfügbar seit JDK 8+ (verbessert in 9+) diff --git a/translations/content/de/strings/string-formatted.yaml b/translations/content/de/strings/string-formatted.yaml new file mode 100644 index 0000000..7704dbf --- /dev/null +++ b/translations/content/de/strings/string-formatted.yaml @@ -0,0 +1,19 @@ +title: String.formatted() +oldApproach: String.format() +modernApproach: formatted() +summary: formatted() direkt auf dem Template-String aufrufen. +explanation: String.formatted() ist eine Instanzmethode, die String.format() entspricht, + aber auf dem Formatierungsstring aufgerufen wird. Sie liest sich natürlicher in + einem Links-nach-Rechts-Fluss. +whyModernWins: +- icon: 📖 + title: Natürlich lesbar + desc: Template.formatted(args) fließt besser als String.format(template, args). +- icon: 🔗 + title: Verkettbar + desc: Kann mit anderen String-Methoden verkettet werden. +- icon: 📏 + title: Weniger ausführlich + desc: Entfällt der redundante statische Aufruf von String.format(). +support: + description: Weitgehend verfügbar seit JDK 15 (Sept. 2020) diff --git a/translations/content/de/strings/string-indent-transform.yaml b/translations/content/de/strings/string-indent-transform.yaml new file mode 100644 index 0000000..f35c2f6 --- /dev/null +++ b/translations/content/de/strings/string-indent-transform.yaml @@ -0,0 +1,19 @@ +title: String.indent() und transform() +oldApproach: Manuelle Einrückung +modernApproach: indent() / transform() +summary: Text einrücken und String-Transformationen fließend verketten. +explanation: indent(n) fügt jeder Zeile n Leerzeichen hinzu. transform(fn) wendet + eine beliebige Funktion an und gibt das Ergebnis zurück, was fließendes Verketten + von String-Operationen ermöglicht. +whyModernWins: +- icon: 📏 + title: Eingebaut + desc: Einrückung ist eine häufige Operation – jetzt ein einziger Aufruf. +- icon: 🔗 + title: Verkettbar + desc: transform() ermöglicht fließende Pipelines auf Strings. +- icon: 🧹 + title: Sauberer Code + desc: Kein manuelles Aufteilen von Zeilen und StringBuilder-Schleifen. +support: + description: Weitgehend verfügbar seit JDK 12 (März 2019) diff --git a/translations/content/de/strings/string-isblank.yaml b/translations/content/de/strings/string-isblank.yaml new file mode 100644 index 0000000..6b21000 --- /dev/null +++ b/translations/content/de/strings/string-isblank.yaml @@ -0,0 +1,18 @@ +title: String.isBlank() +oldApproach: trim().isEmpty() +modernApproach: isBlank() +summary: Leere Strings mit einem einzigen Methodenaufruf prüfen. +explanation: isBlank() gibt true zurück, wenn der String leer ist oder nur Leerzeichen + enthält, einschließlich Unicode-Leerzeichen, die trim() übersieht. +whyModernWins: +- icon: 📖 + title: Selbstdokumentierend + desc: isBlank() sagt genau, was es prüft. +- icon: 🌐 + title: Unicode-bewusst + desc: Behandelt alle Unicode-Leerzeichen, nicht nur ASCII. +- icon: ⚡ + title: Keine Allokation + desc: Es wird kein zwischenzeitlicher gekürzter String erstellt. +support: + description: Weitgehend verfügbar seit JDK 11 (Sept. 2018) diff --git a/translations/content/de/strings/string-lines.yaml b/translations/content/de/strings/string-lines.yaml new file mode 100644 index 0000000..30edeed --- /dev/null +++ b/translations/content/de/strings/string-lines.yaml @@ -0,0 +1,21 @@ +title: String.lines() zum Aufteilen von Zeilen +oldApproach: split("\\n") +modernApproach: lines() +summary: String.lines() verwenden, um Text ohne Regex-Overhead in einen Stream von + Zeilen aufzuteilen. +explanation: "String.lines() gibt einen Stream
von Zeilen zurück, aufgeteilt\ + \ nach \\n, \\r oder \\r\\n. Es ist träger und effizienter als split(), vermeidet\ + \ Regex-Kompilierung und lässt sich natürlich in die Stream-API für weitere Verarbeitung\ + \ integrieren." +whyModernWins: +- icon: ⚡ + title: Lazy-Streaming + desc: Zeilen werden bei Bedarf erzeugt, nicht alle auf einmal wie bei split(). +- icon: 🔧 + title: Universelle Zeilenendezeichen + desc: "Behandelt \\n, \\r und \\r\\n automatisch ohne Regex." +- icon: 🔗 + title: Stream-Integration + desc: Gibt einen Stream zur direkten Verwendung mit filter, map, collect zurück. +support: + description: Verfügbar seit JDK 11 (September 2018). diff --git a/translations/content/de/strings/string-repeat.yaml b/translations/content/de/strings/string-repeat.yaml new file mode 100644 index 0000000..088e9dd --- /dev/null +++ b/translations/content/de/strings/string-repeat.yaml @@ -0,0 +1,19 @@ +title: String.repeat() +oldApproach: Schleife mit StringBuilder +modernApproach: repeat() +summary: Einen String n-mal ohne Schleife wiederholen. +explanation: "String.repeat(int) gibt den String n-mal mit sich selbst verkettet\ + \ zurück. Behandelt Randfälle: repeat(0) gibt einen leeren String zurück, repeat(1)\ + \ gibt denselben String zurück." +whyModernWins: +- icon: 📏 + title: Einzeiler + desc: Ersetzt 5 Zeilen StringBuilder-Code durch einen einzigen Aufruf. +- icon: ⚡ + title: Optimiert + desc: Die interne Implementierung ist für große Wiederholungen optimiert. +- icon: 📖 + title: Klare Absicht + desc: repeat(3) vermittelt den Zweck sofort. +support: + description: Weitgehend verfügbar seit JDK 11 (Sept. 2018) diff --git a/translations/content/de/strings/string-strip.yaml b/translations/content/de/strings/string-strip.yaml new file mode 100644 index 0000000..5c30adb --- /dev/null +++ b/translations/content/de/strings/string-strip.yaml @@ -0,0 +1,20 @@ +title: String.strip() vs trim() +oldApproach: trim() +modernApproach: strip() +summary: Unicode-bewusstes Entfernen von Leerzeichen mit strip(), stripLeading(), + stripTrailing(). +explanation: trim() entfernt nur Zeichen ≤ U+0020 (ASCII-Steuerzeichen und Leerzeichen). + strip() verwendet Character.isWhitespace(), das Unicode-Leerzeichen wie geschütztes + Leerzeichen, ideografisches Leerzeichen usw. behandelt. +whyModernWins: +- icon: 🌐 + title: Unicode-korrekt + desc: Behandelt alle Leerzeichen aus allen Schriftsystemen. +- icon: 🎯 + title: Direktional + desc: stripLeading() und stripTrailing() für einseitiges Kürzen. +- icon: 🛡️ + title: Weniger Fehler + desc: Kein unerwartetes Leerzeichen in internationalem Text. +support: + description: Weitgehend verfügbar seit JDK 11 (Sept. 2018) diff --git a/translations/content/de/tooling/aot-class-preloading.yaml b/translations/content/de/tooling/aot-class-preloading.yaml new file mode 100644 index 0000000..96c5b00 --- /dev/null +++ b/translations/content/de/tooling/aot-class-preloading.yaml @@ -0,0 +1,21 @@ +title: AOT-Klassen-Vorabladen +oldApproach: Jedes Mal Kaltstart +modernApproach: AOT-Cache +summary: Klassen-Laden und Kompilierung cachen für sofortigen Start. +explanation: Das AOT-Klassen-Vorabladen speichert geladene und verknüpfte Klassen + aus einem Trainings-Durchlauf im Cache. Bei nachfolgenden Starts werden Klassen + aus dem Cache geladen, wobei Verifizierung und Verknüpfung übersprungen werden. + In Kombination mit AOT-Kompilierung verkürzt dies die Startzeit drastisch. +whyModernWins: +- icon: ⚡ + title: Schnellerer Start + desc: Klassen-Laden, Verifizierung und Verknüpfung überspringen. +- icon: 📦 + title: Gecachter Zustand + desc: Der Trainings-Durchlauf erfasst den idealen Klassenzustand. +- icon: 🔧 + title: Keine Codeänderungen + desc: Funktioniert mit bestehenden Anwendungen – einfach JVM-Flags hinzufügen. +support: + description: Als Standardfunktion in JDK 25 LTS verfügbar (JEPs 514/515, Sept. + 2025). diff --git a/translations/content/de/tooling/built-in-http-server.yaml b/translations/content/de/tooling/built-in-http-server.yaml new file mode 100644 index 0000000..a281708 --- /dev/null +++ b/translations/content/de/tooling/built-in-http-server.yaml @@ -0,0 +1,26 @@ +title: Eingebauter HTTP-Server +oldApproach: Externer Server / Framework +modernApproach: jwebserver-CLI +summary: Java 18 enthält einen eingebauten minimalen HTTP-Server für Prototyping und + Dateiauslieferung. +explanation: JDK 18 hat einen einfachen, abhängigkeitsfreien HTTP-Dateiserver hinzugefügt, + der über das Befehlszeilenwerkzeug jwebserver oder die SimpleFileServer-API zugänglich + ist. Er liefert statische Dateien aus einem angegebenen Verzeichnis ohne Konfiguration. + Das CLI-Tool ist ideal für schnelles Prototyping, Tests und ad-hoc-Dateifreigabe + – keine externen Abhängigkeiten oder Frameworks erforderlich. Die API ermöglicht + die programmatische Verwendung mit anpassbaren Handlern und Ausgabeebenen. +whyModernWins: +- icon: 🚀 + title: Kein Setup + desc: jwebserver in einem beliebigen Verzeichnis ausführen – keine Installation, + Konfiguration oder Abhängigkeiten erforderlich. +- icon: 📦 + title: Im JDK integriert + desc: Wird mit jeder JDK 18+-Installation geliefert, immer verfügbar auf jedem + Rechner mit Java. +- icon: 🧪 + title: Ideal für Prototyping + desc: Statische Dateien sofort für das Testen von HTML, APIs oder Front-End-Entwicklung + bereitstellen. +support: + description: Verfügbar seit JDK 18 (März 2022) diff --git a/translations/content/de/tooling/compact-object-headers.yaml b/translations/content/de/tooling/compact-object-headers.yaml new file mode 100644 index 0000000..2ffbda9 --- /dev/null +++ b/translations/content/de/tooling/compact-object-headers.yaml @@ -0,0 +1,19 @@ +title: Kompakte Objekt-Header +oldApproach: 128-Bit-Header +modernApproach: 64-Bit-Header +summary: Objekt-Header-Größe halbieren für bessere Speicherdichte und Cache-Nutzung. +explanation: Kompakte Objekt-Header reduzieren den Overhead pro Objekt von 128 Bit + auf 64 Bit auf 64-Bit-Plattformen. Dies spart Speicher und verbessert die Cache-Nutzung, + insbesondere für Anwendungen mit vielen kleinen Objekten. +whyModernWins: +- icon: 📦 + title: 50 % kleinere Header + desc: 8 Bytes statt 16 pro Objekt. +- icon: ⚡ + title: Bessere Cache-Nutzung + desc: Mehr Objekte passen in CPU-Cache-Zeilen. +- icon: 📊 + title: Höhere Dichte + desc: Mehr Objekte im gleichen Heap-Bereich. +support: + description: In JDK 25 LTS finalisiert (JEP 519, Sept. 2025). diff --git a/translations/content/de/tooling/jfr-profiling.yaml b/translations/content/de/tooling/jfr-profiling.yaml new file mode 100644 index 0000000..c106378 --- /dev/null +++ b/translations/content/de/tooling/jfr-profiling.yaml @@ -0,0 +1,20 @@ +title: JFR für Profiling +oldApproach: Externer Profiler +modernApproach: Java Flight Recorder +summary: Jede Java-App mit dem eingebauten Flight Recorder profilieren – ohne externe + Tools. +explanation: Java Flight Recorder (JFR) ist ein in die JVM integriertes Profiling-Tool + mit geringem Overhead. Es erfasst Ereignisse für CPU, Speicher, GC, E/A, Threads + und benutzerdefinierte Ereignisse mit minimalem Leistungseinfluss (~1%). +whyModernWins: +- icon: 🆓 + title: Eingebaut + desc: Kein externer Profiler zum Installieren oder Lizenzieren. +- icon: ⚡ + title: Geringer Overhead + desc: ~1% Leistungseinfluss – sicher für den Produktionseinsatz. +- icon: 📊 + title: Umfangreiche Ereignisse + desc: CPU, Speicher, GC, Threads, E/A, Locks und benutzerdefinierte Ereignisse. +support: + description: Weitgehend verfügbar seit JDK 9/11 (Open-Source in 11) diff --git a/translations/content/de/tooling/jshell-prototyping.yaml b/translations/content/de/tooling/jshell-prototyping.yaml new file mode 100644 index 0000000..814cd20 --- /dev/null +++ b/translations/content/de/tooling/jshell-prototyping.yaml @@ -0,0 +1,20 @@ +title: JShell für Prototyping +oldApproach: Datei erstellen + kompilieren + ausführen +modernApproach: JShell-REPL +summary: Java-Ausdrücke interaktiv ausprobieren, ohne Dateien zu erstellen. +explanation: JShell ist eine Read-Eval-Print-Schleife für Java. Ausdrücke testen, + APIs erkunden und Code prototypen, ohne Dateien zu erstellen, zu kompilieren oder + eine main-Methode zu schreiben. Tab-Vervollständigung und kontextbezogene Dokumentation + inklusive. +whyModernWins: +- icon: ⚡ + title: Sofortiges Feedback + desc: Einen Ausdruck eingeben und das Ergebnis sofort sehen. +- icon: 📝 + title: Keine Dateien benötigt + desc: Keine .java-Dateien, kein Kompilierungsschritt. +- icon: 🔍 + title: API-Erkundung + desc: Tab-Vervollständigung hilft beim Entdecken von Methoden und Parametern. +support: + description: Weitgehend verfügbar seit JDK 9 (Sept. 2017) diff --git a/translations/content/de/tooling/junit6-with-jspecify.yaml b/translations/content/de/tooling/junit6-with-jspecify.yaml new file mode 100644 index 0000000..a5228cb --- /dev/null +++ b/translations/content/de/tooling/junit6-with-jspecify.yaml @@ -0,0 +1,28 @@ +title: JUnit 6 mit JSpecify-Nullsicherheit +oldApproach: Nicht annotierte API +modernApproach: "@NullMarked-API" +summary: "JUnit 6 übernimmt @NullMarked von JSpecify und macht Null-Verträge in der\ + \ gesamten Assertion-API explizit." +explanation: "JUnit 5 wurde ohne standardisierte Nullbarkeits-Annotationen ausgeliefert,\ + \ sodass Entwickler raten mussten, ob Assertion-Parameter oder Rückgabewerte null\ + \ sein könnten. JUnit 6 übernimmt JSpecify für sein gesamtes Modul: Die @NullMarked-Annotation\ + \ macht alle nicht annotierten Typen standardmäßig nicht-null, und @Nullable markiert\ + \ die Ausnahmen. Die Assertions-Klasse annotiert Parameter explizit wie assertNull(@Nullable\ + \ Object actual) und fail(@Nullable String message), sodass IDEs und statische Analysatoren\ + \ wie NullAway und Error Prone Null-Missbrauch zur Kompilierungszeit statt zur Laufzeit\ + \ erkennen können." +whyModernWins: +- icon: 📜 + title: Explizite Verträge + desc: "@NullMarked im JUnit-6-Modul dokumentiert die Null-Semantik direkt in der\ + \ API – kein Lesen des Quellcodes erforderlich." +- icon: 🛡️ + title: Sicherheit zur Kompilierzeit + desc: IDEs und Analysatoren warnen, wenn null übergeben wird, wo Nicht-null erwartet + wird, und erkennen Fehler vor dem Testlauf. +- icon: 🌐 + title: Ökosystem-Standard + desc: JSpecify wird von Spring, Guava und anderen übernommen – konsistente Null-Semantik + im gesamten Stack. +support: + description: Verfügbar seit JUnit 6.0 (Oktober 2025, erfordert Java 17+) diff --git a/translations/content/de/tooling/multi-file-source.yaml b/translations/content/de/tooling/multi-file-source.yaml new file mode 100644 index 0000000..24d9238 --- /dev/null +++ b/translations/content/de/tooling/multi-file-source.yaml @@ -0,0 +1,19 @@ +title: Multi-Datei-Quellcode-Launcher +oldApproach: Zuerst alles kompilieren +modernApproach: Quellcode-Launcher +summary: Multi-Datei-Programme ohne expliziten Kompilierungsschritt starten. +explanation: Java 22+ kann referenzierte Quelldateien beim Start aus einer .java-Datei + automatisch kompilieren. Dies macht kleine Multi-Datei-Programme genauso einfach + ausführbar wie Skripte, ohne Maven oder Gradle zu benötigen. +whyModernWins: +- icon: 🚀 + title: Kein Setup + desc: Kein Build-Tool für kleine Multi-Datei-Programme erforderlich. +- icon: 🔗 + title: Automatische Auflösung + desc: Referenzierte Klassen werden automatisch gefunden und kompiliert. +- icon: 📝 + title: Skript-ähnlich + desc: Multi-Datei-Programme wie Skripte ausführen. +support: + description: Verfügbar seit JDK 22 (März 2024) diff --git a/translations/content/de/tooling/single-file-execution.yaml b/translations/content/de/tooling/single-file-execution.yaml new file mode 100644 index 0000000..6ea85f5 --- /dev/null +++ b/translations/content/de/tooling/single-file-execution.yaml @@ -0,0 +1,20 @@ +title: Einzeldatei-Ausführung +oldApproach: Zweistufige Kompilierung +modernApproach: Direktstart +summary: Einzeldatei-Java-Programme direkt ohne javac ausführen. +explanation: Der Java-Launcher kann eine einzelne Quelldatei in einem Befehl kompilieren + und ausführen. In Kombination mit Shebang-Unterstützung unter Unix können Java-Dateien + als Skripte fungieren. Kein separater Kompilierungsschritt erforderlich. +whyModernWins: +- icon: ⚡ + title: Ein einziger Befehl + desc: java Datei.java kompiliert und führt in einem Schritt aus. +- icon: 📝 + title: Skript-ähnlich + desc: Eine Shebang-Zeile hinzufügen, um .java-Dateien zu ausführbaren Skripten + zu machen. +- icon: 🎓 + title: Lernfreundlich + desc: Einsteiger führen Code sofort aus, ohne Build-Tools erlernen zu müssen. +support: + description: Weitgehend verfügbar seit JDK 11 (Sept. 2018) diff --git a/translations/strings/de.yaml b/translations/strings/de.yaml new file mode 100644 index 0000000..e307049 --- /dev/null +++ b/translations/strings/de.yaml @@ -0,0 +1,82 @@ +site: + title: java.evolved + tagline: Java hat sich weiterentwickelt. Dein Code auch. + tagline_line1: Java hat sich weiterentwickelt. + tagline_line2: Dein Code auch. + description: Eine Sammlung moderner Java-Code-Snippets. Jedes alte Java-Muster neben + seiner sauberen, modernen Entsprechung — Seite an Seite. + heroSnippetCount: ✦ {{snippetCount}} moderne Muster · Java 8 → Java 25 + heroOld: Alt + heroModern: Modern + allComparisons: Alle Vergleiche + snippetsBadge: '{{snippetCount}} Snippets' +nav: + allPatterns: ← Alle Muster + toggleTheme: Design wechseln + viewOnGitHub: Auf GitHub ansehen + selectLanguage: Sprache auswählen +breadcrumb: + home: Startseite +sections: + codeComparison: Code-Vergleich + whyModernWins: Warum der moderne Weg gewinnt + oldApproach: Alter Ansatz + modernApproach: Moderner Ansatz + sinceJdk: Seit JDK + difficulty: Schwierigkeitsgrad + jdkSupport: JDK-Unterstützung + howItWorks: Wie es funktioniert + relatedDocs: Zugehörige Dokumentation + relatedPatterns: Verwandte Muster +filters: + show: 'Anzeigen:' + all: Alle +difficulty: + beginner: Einsteiger + intermediate: Fortgeschritten + advanced: Experte +search: + placeholder: Snippets suchen… + noResults: Keine Ergebnisse gefunden. + esc: ESC + searchTrigger: Suchen… + navigate: navigieren + open: öffnen + close: schließen +cards: + old: Alt + modern: Modern + hoverHint: Hover für Modernes → + hoverHintRelated: Hover für Modernes ➜ + touchHint: 👆 tippen oder wischen → +copy: + copy: Kopieren + copied: Kopiert! +share: + label: Teilen +view: + expandAll: Alle ausklappen + collapseAll: Alle einklappen +stats: + modernPatterns: Moderne Muster + jdkVersions: Abgedeckte JDK-Versionen + categories: Kategorien + linesOfPython: Benötigte Python-Zeilen +footer: + tagline: Java hat sich weiterentwickelt. Dein Code auch. + madeWith: Erstellt mit ❤️ von + and: und + inspiredBy: Inspiriert von + viewOnGitHub: Auf GitHub ansehen +copilot: + headline: Modernisiere deine Java-Codebasis mit GitHub Copilot. + description: Lass Copilot dir helfen, veraltete Muster zu modernem Java zu migrieren — automatisch. + appModernization: App-Modernisierung → + javaGuide: Java-Leitfaden → +support: + available: Verfügbar + preview: Vorschau + experimental: Experimentell +untranslated: + notice: Diese Seite wurde noch nicht ins {{localeName}} übersetzt. + viewInEnglish: Auf Englisch ansehen