Merge pull request #2 from eugenp/master

Rebase

README.md

@@ -1,5 +1,3 @@
-**UPDATE**: The price of "Learn Spring Security OAuth" will permanently change on the 11th of December, along with the upcoming OAuth2 material: http://bit.ly/github-lss
-
 The Courses
 ==============================
 

algorithms-genetic/README.md

@@ -5,6 +5,6 @@ This module contains articles about genetic algorithms.
 ### Relevant articles:
 
 - [Introduction to Jenetics Library](https://www.baeldung.com/jenetics)
-- [Ant Colony Optimization](https://www.baeldung.com/java-ant-colony-optimization)
+- [Ant Colony Optimization with a Java Example](https://www.baeldung.com/java-ant-colony-optimization)
 - [Design a Genetic Algorithm in Java](https://www.baeldung.com/java-genetic-algorithm)
 - [The Traveling Salesman Problem in Java](https://www.baeldung.com/java-simulated-annealing-for-traveling-salesman)

algorithms-miscellaneous-1/README.md

@@ -6,8 +6,8 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 ### Relevant articles:
 
 - [Validating Input With Finite Automata in Java](https://www.baeldung.com/java-finite-automata)
-- [Example of Hill Climbing Algorithm](https://www.baeldung.com/java-hill-climbing-algorithm)
-- [Introduction to Minimax Algorithm](https://www.baeldung.com/java-minimax-algorithm)
+- [Example of Hill Climbing Algorithm in Java](https://www.baeldung.com/java-hill-climbing-algorithm)
+- [Introduction to Minimax Algorithm with a Java Implementation](https://www.baeldung.com/java-minimax-algorithm)
 - [How to Calculate Levenshtein Distance in Java?](https://www.baeldung.com/java-levenshtein-distance)
 - [How to Find the Kth Largest Element in Java](https://www.baeldung.com/java-kth-largest-element)
-- More articles: [[next -->]](/../algorithms-miscellaneous-2)
+- More articles: [[next -->]](/algorithms-miscellaneous-2)

algorithms-miscellaneous-2/README.md

@@ -14,4 +14,4 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Displaying Money Amounts in Words](https://www.baeldung.com/java-money-into-words)
 - [A Collaborative Filtering Recommendation System in Java](https://www.baeldung.com/java-collaborative-filtering-recommendations)
 - [Implementing A* Pathfinding in Java](https://www.baeldung.com/java-a-star-pathfinding)
-- More articles: [[<-- prev]](/../algorithms-miscellaneous-1) [[next -->]](/../algorithms-miscellaneous-3)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-1) [[next -->]](/algorithms-miscellaneous-3)

algorithms-miscellaneous-4/README.md

@@ -5,8 +5,8 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 ### Relevant articles:
 
 - [Multi-Swarm Optimization Algorithm in Java](https://www.baeldung.com/java-multi-swarm-algorithm)
-- [Check If a String Contains All The Letters of The Alphabet](https://www.baeldung.com/java-string-contains-all-letters)
-- [Find the Middle Element of a Linked List](https://www.baeldung.com/java-linked-list-middle-element)
+- [Check If a String Contains All The Letters of The Alphabet with Java](https://www.baeldung.com/java-string-contains-all-letters)
+- [Find the Middle Element of a Linked List in Java](https://www.baeldung.com/java-linked-list-middle-element)
 - [Find Substrings That Are Palindromes in Java](https://www.baeldung.com/java-palindrome-substrings)
 - [Find the Longest Substring without Repeating Characters](https://www.baeldung.com/java-longest-substring-without-repeated-characters)
 - [Permutations of an Array in Java](https://www.baeldung.com/java-array-permutations)

algorithms-miscellaneous-5/README.md

@@ -9,11 +9,11 @@ This module contains articles about algorithms. Some classes of algorithms, e.g.
 - [Reversing a Binary Tree in Java](https://www.baeldung.com/java-reversing-a-binary-tree)
 - [Find If Two Numbers Are Relatively Prime in Java](https://www.baeldung.com/java-two-relatively-prime-numbers)
 - [Knapsack Problem Implementation in Java](https://www.baeldung.com/java-knapsack)
-- [How to Determine if a Binary Tree is Balanced](https://www.baeldung.com/java-balanced-binary-tree)
+- [How to Determine if a Binary Tree is Balanced in Java](https://www.baeldung.com/java-balanced-binary-tree)
 - [Overview of Combinatorial Problems in Java](https://www.baeldung.com/java-combinatorial-algorithms)
-- [Prim’s Algorithm](https://www.baeldung.com/java-prim-algorithm)
-- [Maximum Subarray Problem](https://www.baeldung.com/java-maximum-subarray)
-- [How to Merge Two Sorted Arrays](https://www.baeldung.com/java-merge-sorted-arrays)
-- [Median of Stream of Integers using Heap](https://www.baeldung.com/java-stream-integers-median-using-heap)
-- More articles: [[<-- prev]](/../algorithms-miscellaneous-4) [[next -->]](/../algorithms-miscellaneous-6)
+- [Prim’s Algorithm with a Java Implementation](https://www.baeldung.com/java-prim-algorithm)
+- [Maximum Subarray Problem in Java](https://www.baeldung.com/java-maximum-subarray)
+- [How to Merge Two Sorted Arrays in Java](https://www.baeldung.com/java-merge-sorted-arrays)
+- [Median of Stream of Integers using Heap in Java](https://www.baeldung.com/java-stream-integers-median-using-heap)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-4) [[next -->]](/algorithms-miscellaneous-6)
 

algorithms-miscellaneous-6/README.md

@@ -1,12 +1,13 @@
 ### Relevant Articles:
 
-- [Boruvka’s Algorithm for Minimum Spanning Trees](https://www.baeldung.com/java-boruvka-algorithm)
+- [Boruvka’s Algorithm for Minimum Spanning Trees in Java](https://www.baeldung.com/java-boruvka-algorithm)
 - [Gradient Descent in Java](https://www.baeldung.com/java-gradient-descent)
-- [Kruskal’s Algorithm for Spanning Trees](https://www.baeldung.com/java-spanning-trees-kruskal)
+- [Kruskal’s Algorithm for Spanning Trees with a Java Implementation](https://www.baeldung.com/java-spanning-trees-kruskal)
 - [Balanced Brackets Algorithm in Java](https://www.baeldung.com/java-balanced-brackets-algorithm)
 - [Efficiently Merge Sorted Java Sequences](https://www.baeldung.com/java-merge-sorted-sequences)
 - [Introduction to Greedy Algorithms with Java](https://www.baeldung.com/java-greedy-algorithms)
 - [The Caesar Cipher in Java](https://www.baeldung.com/java-caesar-cipher)
 - [Implementing a 2048 Solver in Java](https://www.baeldung.com/2048-java-solver)
-- [Finding Top K Elements in an Array](https://www.baeldung.com/java-array-top-elements)
-- More articles: [[<-- prev]](/../algorithms-miscellaneous-5)
+- [Finding Top K Elements in a Java Array](https://www.baeldung.com/java-array-top-elements)
+- [Reversing a Linked List in Java](https://www.baeldung.com/java-reverse-linked-list)
+- More articles: [[<-- prev]](/algorithms-miscellaneous-5)

algorithms-searching/README.md

@@ -8,8 +8,8 @@ This module contains articles about searching algorithms.
 - [Depth First Search in Java](https://www.baeldung.com/java-depth-first-search)
 - [Interpolation Search in Java](https://www.baeldung.com/java-interpolation-search)
 - [Breadth-First Search Algorithm in Java](https://www.baeldung.com/java-breadth-first-search)
-- [String Search Algorithms for Large Texts](https://www.baeldung.com/java-full-text-search-algorithms)
-- [Monte Carlo Tree Search for Tic-Tac-Toe Game](https://www.baeldung.com/java-monte-carlo-tree-search)
+- [String Search Algorithms for Large Texts with Java](https://www.baeldung.com/java-full-text-search-algorithms)
+- [Monte Carlo Tree Search for Tic-Tac-Toe Game in Java](https://www.baeldung.com/java-monte-carlo-tree-search)
 - [Range Search Algorithm in Java](https://www.baeldung.com/java-range-search)
-- [Fast Pattern Matching of Strings Using Suffix Tree](https://www.baeldung.com/java-pattern-matching-suffix-tree)
-- [Find the Kth Smallest Element in Two Sorted Arrays](https://www.baeldung.com/java-kth-smallest-element-in-sorted-arrays)
+- [Fast Pattern Matching of Strings Using Suffix Tree in Java](https://www.baeldung.com/java-pattern-matching-suffix-tree)
+- [Find the Kth Smallest Element in Two Sorted Arrays in Java](https://www.baeldung.com/java-kth-smallest-element-in-sorted-arrays)

algorithms-sorting-2/README.md

@@ -2,6 +2,6 @@
 
 - [Sorting a String Alphabetically in Java](https://www.baeldung.com/java-sort-string-alphabetically)
 - [Sorting Strings by Contained Numbers in Java](https://www.baeldung.com/java-sort-strings-contained-numbers)
-- [How an In-Place Sorting Algorithm Works](https://www.baeldung.com/java-in-place-sorting)
-- [Partitioning and Sorting Arrays with Many Repeated Entries](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)
+- [Guide to In-Place Sorting Algorithm Works with a Java Implementation](https://www.baeldung.com/java-in-place-sorting)
+- [Partitioning and Sorting Arrays with Many Repeated Entries with Java Examples](https://www.baeldung.com/java-sorting-arrays-with-repeated-entries)
 - More articles: [[<-- prev]](/algorithms-sorting)

apache-libraries/pom.xml

@@ -129,6 +129,11 @@
             <artifactId>zookeeper</artifactId>
             <version>${zookeeper.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-core</artifactId>
+            <version>${jackson.version}</version>
+        </dependency>
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>
             <artifactId>jackson-databind</artifactId>

apache-spark/README.md

@@ -8,3 +8,4 @@ This module contains articles about Apache Spark
 - [Building a Data Pipeline with Kafka, Spark Streaming and Cassandra](https://www.baeldung.com/kafka-spark-data-pipeline)
 - [Machine Learning with Spark MLlib](https://www.baeldung.com/spark-mlib-machine-learning)
 - [Introduction to Spark Graph Processing with GraphFrames](https://www.baeldung.com/spark-graph-graphframes)
+- [Apache Spark: Differences between Dataframes, Datasets and RDDs](https://www.baeldung.com/java-spark-dataframe-dataset-rdd)

apache-spark/src/main/java/com/baeldung/differences/dataframe/dataset/rdd/TouristData.java

@@ -0,0 +1,75 @@
+package com.baeldung.differences.dataframe.dataset.rdd;
+
+
+public class TouristData {
+
+    private String region;
+    private String country;
+    private String year;
+    private String series;
+    private Double value;
+    private String footnotes;
+    private String source;
+
+    public String getRegion() {
+        return region;
+    }
+
+    public void setRegion(String region) {
+        this.region = region;
+    }
+
+    public String getCountry() {
+        return country;
+    }
+
+    public void setCountry(String country) {
+        this.country = country;
+    }
+
+    public String getYear() {
+        return year;
+    }
+
+    public void setYear(String year) {
+        this.year = year;
+    }
+
+    public String getSeries() {
+        return series;
+    }
+
+    public void setSeries(String series) {
+        this.series = series;
+    }
+
+    public Double getValue() {
+        return value;
+    }
+
+    public void setValue(Double value) {
+        this.value = value;
+    }
+
+    public String getFootnotes() {
+        return footnotes;
+    }
+
+    public void setFootnotes(String footnotes) {
+        this.footnotes = footnotes;
+    }
+
+    public String getSource() {
+        return source;
+    }
+
+    public void setSource(String source) {
+        this.source = source;
+    }
+
+    @Override
+    public String toString() {
+        return "TouristData [region=" + region + ", country=" + country + ", year=" + year + ", series=" + series + ", value=" + value + ", footnotes=" + footnotes + ", source=" + source + "]";
+    }
+
+}

apache-spark/src/test/java/com/baeldung/differences/rdd/ActionsUnitTest.java

@@ -0,0 +1,67 @@
+package com.baeldung.differences.rdd;
+
+import static org.junit.Assert.assertEquals;
+
+import java.util.List;
+
+import org.apache.spark.SparkConf;
+import org.apache.spark.api.java.JavaPairRDD;
+import org.apache.spark.api.java.JavaRDD;
+import org.apache.spark.api.java.JavaSparkContext;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import scala.Tuple2;
+
+public class ActionsUnitTest {
+    private static JavaRDD<String> tourists;
+    private static JavaSparkContext sc;
+    public static final String COMMA_DELIMITER = ",(?=([^\"]*\"[^\"]*\")*[^\"]*$)";
+    
+    @BeforeClass
+    public static void init() {
+        SparkConf conf = new SparkConf().setAppName("reduce")
+            .setMaster("local[*]");
+        sc = new JavaSparkContext(conf);
+        tourists = sc.textFile("data/Tourist.csv").filter(line -> !line.startsWith("Region"));
+    }
+    
+    @AfterClass
+    public static void cleanup() {
+        sc.close();
+    }
+
+    @Test
+    public void whenDistinctCount_thenReturnDistinctNumRecords() {
+        JavaRDD<String> countries = tourists.map(line -> {
+            String[] columns = line.split(COMMA_DELIMITER);
+            return columns[1];
+        })
+            .distinct();
+        Long numberOfCountries = countries.count();
+        System.out.println("Count: " + numberOfCountries);
+        
+        assertEquals(Long.valueOf(220), numberOfCountries);
+    }
+    
+    @Test
+    public void whenReduceByKeySum_thenTotalValuePerKey() {
+        JavaRDD<String> touristsExpenditure = tourists.filter(line -> line.split(COMMA_DELIMITER)[3].contains("expenditure"));
+
+        JavaPairRDD<String, Double> expenditurePairRdd = touristsExpenditure.mapToPair(line -> {
+            String[] columns = line.split(COMMA_DELIMITER);
+            return new Tuple2<>(columns[1], Double.valueOf(columns[6]));
+        });
+        List<Tuple2<String, Double>> totalByCountry = expenditurePairRdd.reduceByKey((x, y) -> x + y)
+            .collect();
+        System.out.println("Total per Country: " + totalByCountry);
+        
+        for(Tuple2<String, Double> tuple : totalByCountry) {
+            if (tuple._1.equals("Mexico")) {
+                assertEquals(Double.valueOf(99164), tuple._2);
+            }
+        }
+    }
+
+}

apache-spark/src/test/java/com/baeldung/differences/rdd/DataFrameUnitTest.java

@@ -0,0 +1,74 @@
+package com.baeldung.differences.rdd;
+
+import static org.apache.spark.sql.functions.col;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.apache.spark.sql.DataFrameReader;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class DataFrameUnitTest {
+    private static SparkSession session;
+    private static Dataset<Row> data;
+
+    @BeforeClass
+    public static void init() {
+        session = SparkSession.builder()
+            .appName("TouristDataFrameExample")
+            .master("local[*]")
+            .getOrCreate();
+        DataFrameReader dataFrameReader = session.read();
+        data = dataFrameReader.option("header", "true")
+            .csv("data/Tourist.csv");
+    }
+
+    @AfterClass
+    public static void cleanup() {
+        session.stop();
+    }
+
+    @Test
+    public void whenSelectSpecificColumns_thenColumnsFiltered() {
+        Dataset<Row> selectedData = data.select(col("country"), col("year"), col("value"));
+        selectedData.show();
+        
+        List<String> resultList = Arrays.asList(selectedData.columns());
+        assertTrue(resultList.contains("country"));
+        assertTrue(resultList.contains("year"));
+        assertTrue(resultList.contains("value"));
+        assertFalse(resultList.contains("Series"));
+
+    }
+
+    @Test
+    public void whenFilteringByCountry_thenCountryRecordsSelected() {
+        Dataset<Row> filteredData = data.filter(col("country").equalTo("Mexico"));
+        filteredData.show();
+        
+        filteredData.foreach(record -> {
+            assertEquals("Mexico", record.get(1));
+        });
+        
+    }
+
+    @Test
+    public void whenGroupCountByCountry_thenContryTotalRecords() {
+        Dataset<Row> recordsPerCountry = data.groupBy(col("country"))
+            .count();
+        recordsPerCountry.show();
+        
+        Dataset<Row> filteredData = recordsPerCountry.filter(col("country").equalTo("Sweden"));
+        assertEquals(new Long(12), filteredData.first()
+            .get(1));
+    }
+
+}

apache-spark/src/test/java/com/baeldung/differences/rdd/DatasetUnitTest.java

@@ -0,0 +1,83 @@
+package com.baeldung.differences.rdd;
+
+import static org.apache.spark.sql.functions.col;
+import static org.apache.spark.sql.functions.sum;
+import static org.junit.Assert.assertEquals;
+
+import org.apache.spark.api.java.function.FilterFunction;
+import org.apache.spark.sql.DataFrameReader;
+import org.apache.spark.sql.Dataset;
+import org.apache.spark.sql.Encoders;
+import org.apache.spark.sql.Row;
+import org.apache.spark.sql.SparkSession;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.baeldung.differences.dataframe.dataset.rdd.TouristData;
+
+public class DatasetUnitTest {
+    private static SparkSession session;
+    private static Dataset<TouristData> typedDataset;
+
+    @BeforeClass
+    public static void init() {
+        session = SparkSession.builder()
+            .appName("TouristDatasetExample")
+            .master("local[*]")
+            .getOrCreate();
+        DataFrameReader dataFrameReader = session.read();
+        Dataset<Row> data = dataFrameReader.option("header", "true")
+            .csv("data/Tourist.csv");
+        Dataset<Row> responseWithSelectedColumns = data.select(col("region"), 
+            col("country"), col("year"), col("series"), col("value").cast("double"), 
+            col("footnotes"), col("source"));
+        typedDataset = responseWithSelectedColumns.as(Encoders.bean(TouristData.class));
+    }
+
+    @AfterClass
+    public static void cleanup() {
+        session.stop();
+    }
+
+    @Test
+    public void whenFilteringByCountry_thenCountryRecordsSelected() {
+        Dataset<TouristData> selectedData = typedDataset
+            .filter((FilterFunction<TouristData>) record -> record.getCountry()
+            .equals("Norway"));
+        selectedData.show();
+
+        selectedData.foreach(record -> {
+            assertEquals("Norway", record.getCountry());
+        });
+    }
+
+    @Test
+    public void whenGroupCountByCountry_thenContryTotalRecords() {
+        Dataset<Row> countriesCount = typedDataset.groupBy(typedDataset.col("country"))
+            .count();
+        countriesCount.show();
+
+        assertEquals(Long.valueOf(220), Long.valueOf(countriesCount.count()));
+    }
+
+    @Test
+    public void whenFilteredByPropertyRange_thenRetreiveValidRecords() {
+        // Filter records with existing data for years between 2010 and 2017
+        typedDataset.filter((FilterFunction<TouristData>) record -> record.getYear() != null 
+            && (Long.valueOf(record.getYear()) > 2010 && Long.valueOf(record.getYear()) < 2017))
+            .show();
+    }
+    
+    @Test
+    public void whenSumValue_thenRetreiveTotalValue() {
+        // Total tourist expenditure by country
+        typedDataset.filter((FilterFunction<TouristData>) record -> record.getValue() != null 
+            && record.getSeries()
+            .contains("expenditure"))
+            .groupBy("country")
+            .agg(sum("value"))
+            .show();
+    }
+
+}

apache-spark/src/test/java/com/baeldung/differences/rdd/TransformationsUnitTest.java

@@ -0,0 +1,63 @@
+package com.baeldung.differences.rdd;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.apache.commons.lang3.StringUtils;
+import org.apache.spark.SparkConf;
+import org.apache.spark.api.java.JavaRDD;
+import org.apache.spark.api.java.JavaSparkContext;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class TransformationsUnitTest {
+    
+    public static final String COMMA_DELIMITER = ",(?=([^\"]*\"[^\"]*\")*[^\"]*$)";
+    private static JavaSparkContext sc;
+    private static JavaRDD<String> tourists;
+    
+    @BeforeClass
+    public static void init() {
+        SparkConf conf = new SparkConf().setAppName("uppercaseCountries")
+            .setMaster("local[*]");
+        sc = new JavaSparkContext(conf);
+        tourists = sc.textFile("data/Tourist.csv")
+            .filter(line -> !line.startsWith("Region")); //filter header row
+    }
+    
+    @AfterClass
+    public static void cleanup() {
+        sc.close();
+    }
+
+    @Test
+    public void whenMapUpperCase_thenCountryNameUppercased() {
+        JavaRDD<String> upperCaseCountries = tourists.map(line -> {
+            String[] columns = line.split(COMMA_DELIMITER);
+            return columns[1].toUpperCase();
+        })
+            .distinct();
+        
+        upperCaseCountries.saveAsTextFile("data/output/uppercase.txt");
+        
+        upperCaseCountries.foreach(country -> {
+            //replace non alphanumerical characters
+            country = country.replaceAll("[^a-zA-Z]", "");
+            assertTrue(StringUtils.isAllUpperCase(country));
+        });
+    }
+
+    @Test
+    public void whenFilterByCountry_thenShowRequestedCountryRecords() {
+        JavaRDD<String> touristsInMexico = tourists.filter(line -> line.split(COMMA_DELIMITER)[1].equals("Mexico"));
+        
+        touristsInMexico.saveAsTextFile("data/output/touristInMexico.txt");
+        
+        touristsInMexico.foreach(record -> {
+            assertEquals("Mexico", record.split(COMMA_DELIMITER)[1]);
+        });
+    }
+
+}

core-java-modules/core-java-10/README.md

@@ -10,3 +10,4 @@ This module contains articles about Java 10 core features
 - [Deep Dive Into the New Java JIT Compiler – Graal](https://www.baeldung.com/graal-java-jit-compiler)
 - [Copying Sets in Java](https://www.baeldung.com/java-copy-sets)
 - [Converting between a List and a Set in Java](https://www.baeldung.com/convert-list-to-set-and-set-to-list)
+- [Java IndexOutOfBoundsException “Source Does Not Fit in Dest”](https://www.baeldung.com/java-indexoutofboundsexception)

core-java-modules/core-java-14/src/test/java/com/baeldung/java14/character/IsLetterOrAlphabetUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.java14.character;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+public class IsLetterOrAlphabetUnitTest {
+
+    @Test
+    public void givenACharacter_whenLetter_thenAssertIsLetterTrue() {
+        assertTrue(Character.isLetter(65));
+    }
+
+    @Test
+    public void givenACharacter_whenLetter_thenAssertIsAlphabeticTrue() {
+        assertTrue(Character.isAlphabetic(65));
+    }
+
+    @Test
+    public void givenACharacter_whenAlphabeticAndNotLetter_thenAssertIsLetterFalse() {
+        assertFalse(Character.isLetter(837));
+    }
+
+    @Test
+    public void givenACharacter_whenAlphabeticAndNotLetter_thenAssertIsAlphabeticTrue() {
+        assertTrue(Character.isAlphabetic(837));
+    }
+
+}

core-java-modules/core-java-15/.mvn/jvm.config

@@ -0,0 +1 @@
+--enable-preview

core-java-modules/core-java-15/README.md

@@ -0,0 +1,7 @@
+## Core Java 15
+
+This module contains articles about Java 15. 
+
+### Relevant articles
+
+- TODO: add article links here

core-java-modules/core-java-15/pom.xml

@@ -0,0 +1,77 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project
+    xmlns="http://maven.apache.org/POM/4.0.0"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-15</artifactId>
+    <name>core-java-15</name>
+    <packaging>jar</packaging>
+    <url>http://maven.apache.org</url>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+        <relativePath>../../pom.xml</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>${apache-commons-lang3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-engine</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-api</artifactId>
+            <version>${junit-jupiter.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <version>${maven-compiler-plugin.version}</version>
+                <configuration>
+                    <release>${maven.compiler.release}</release>
+                    <compilerArgs>--enable-preview</compilerArgs>
+                    <source>15</source>
+                    <target>15</target>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>${surefire.plugin.version}</version>
+                <configuration>
+                    <argLine>--enable-preview</argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        <maven.compiler.release>15</maven.compiler.release>
+        <apache-commons-lang3.version>3.11</apache-commons-lang3.version>
+        <assertj.version>3.17.2</assertj.version>
+        <maven-compiler-plugin.version>3.8.1</maven-compiler-plugin.version>
+        <surefire.plugin.version>3.0.0-M3</surefire.plugin.version>
+    </properties>
+
+</project>

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/alternative/Vehicles.java

@@ -0,0 +1,49 @@
+package com.baeldung.sealed.alternative;
+
+public class Vehicles {
+
+    abstract static class Vehicle {
+
+        private final String registrationNumber;
+
+        public Vehicle(String registrationNumber) {
+            this.registrationNumber = registrationNumber;
+        }
+
+        public String getRegistrationNumber() {
+            return registrationNumber;
+        }
+
+    }
+
+    public static final class Car extends Vehicle {
+
+        private final int numberOfSeats;
+
+        public Car(int numberOfSeats, String registrationNumber) {
+            super(registrationNumber);
+            this.numberOfSeats = numberOfSeats;
+        }
+
+        public int getNumberOfSeats() {
+            return numberOfSeats;
+        }
+
+    }
+
+    public static final class Truck extends Vehicle {
+
+        private final int loadCapacity;
+
+        public Truck(int loadCapacity, String registrationNumber) {
+            super(registrationNumber);
+            this.loadCapacity = loadCapacity;
+        }
+
+        public int getLoadCapacity() {
+            return loadCapacity;
+        }
+
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/classes/Car.java

@@ -0,0 +1,21 @@
+package com.baeldung.sealed.classes;
+
+public non-sealed class Car extends Vehicle implements Service {
+
+    private final int numberOfSeats;
+
+    public Car(int numberOfSeats, String registrationNumber) {
+        super(registrationNumber);
+        this.numberOfSeats = numberOfSeats;
+    }
+
+    public int getNumberOfSeats() {
+        return numberOfSeats;
+    }
+
+    @Override
+    public int getMaxServiceIntervalInMonths() {
+        return 12;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/classes/Service.java

@@ -0,0 +1,11 @@
+package com.baeldung.sealed.classes;
+
+public sealed interface Service permits Car, Truck {
+
+    int getMaxServiceIntervalInMonths();
+
+    default int getMaxDistanceBetweenServicesInKilometers() {
+        return 100000;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/classes/Truck.java

@@ -0,0 +1,21 @@
+package com.baeldung.sealed.classes;
+
+public final class Truck extends Vehicle implements Service {
+
+    private final int loadCapacity;
+
+    public Truck(int loadCapacity, String registrationNumber) {
+        super(registrationNumber);
+        this.loadCapacity = loadCapacity;
+    }
+
+    public int getLoadCapacity() {
+        return loadCapacity;
+    }
+
+    @Override
+    public int getMaxServiceIntervalInMonths() {
+        return 18;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/classes/Vehicle.java

@@ -0,0 +1,15 @@
+package com.baeldung.sealed.classes;
+
+public abstract sealed class Vehicle permits Car, Truck {
+
+    protected final String registrationNumber;
+
+    public Vehicle(String registrationNumber) {
+        this.registrationNumber = registrationNumber;
+    }
+
+    public String getRegistrationNumber() {
+        return registrationNumber;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/records/Car.java

@@ -0,0 +1,14 @@
+package com.baeldung.sealed.records;
+
+public record Car(int numberOfSeats, String registrationNumber) implements Vehicle {
+
+    @Override
+    public String getRegistrationNumber() {
+        return registrationNumber;
+    }
+
+    public int getNumberOfSeats() {
+        return numberOfSeats;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/records/Truck.java

@@ -0,0 +1,14 @@
+package com.baeldung.sealed.records;
+
+public record Truck(int loadCapacity, String registrationNumber) implements Vehicle {
+
+    @Override
+    public String getRegistrationNumber() {
+        return registrationNumber;
+    }
+
+    public int getLoadCapacity() {
+        return loadCapacity;
+    }
+
+}

core-java-modules/core-java-15/src/main/java/com/baeldung/sealed/records/Vehicle.java

@@ -0,0 +1,7 @@
+package com.baeldung.sealed.records;
+
+public sealed interface Vehicle permits Car, Truck {
+
+    String getRegistrationNumber();
+
+}