Merge remote-tracking branch 'upstream/master'

algorithms-miscellaneous-6/README.md

@@ -9,4 +9,5 @@
 - [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)
+- [Reversing a Linked List in Java](https://www.baeldung.com/java-reverse-linked-list)
 - More articles: [[<-- prev]](/../algorithms-miscellaneous-5)

algorithms-miscellaneous-6/src/main/java/com/baeldung/algorithms/linkedlist/LinkedListReversal.java

@@ -0,0 +1,30 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class LinkedListReversal {
+
+    ListNode reverseList(ListNode head) {
+        ListNode previous = null;
+        ListNode current = head;
+        while (current != null) {
+            ListNode nextElement = current.getNext();
+            current.setNext(previous);
+            previous = current;
+            current = nextElement;
+        }
+        return previous;
+    }
+
+    ListNode reverseListRecursive(ListNode head) {
+        if (head == null) {
+            return null;
+        }
+        if (head.getNext() == null) {
+            return head;
+        }
+        ListNode node = reverseListRecursive(head.getNext());
+        head.getNext().setNext(head);
+        head.setNext(null);
+        return node;
+    }
+
+}

algorithms-miscellaneous-6/src/main/java/com/baeldung/algorithms/linkedlist/ListNode.java

@@ -0,0 +1,28 @@
+package com.baeldung.algorithms.linkedlist;
+
+public class ListNode {
+
+    private int data;
+    private ListNode next;
+
+    ListNode(int data) {
+        this.data = data;
+        this.next = null;
+    }
+
+    public int getData() {
+        return data;
+    }
+
+    public ListNode getNext() {
+        return next;
+    }
+
+    public void setData(int data) {
+        this.data = data;
+    }
+
+    public void setNext(ListNode next) {
+        this.next = next;
+    }
+}

algorithms-miscellaneous-6/src/test/java/com/baeldung/algorithms/linkedlist/LinkedListReversalUnitTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.algorithms.linkedlist;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+public class LinkedListReversalUnitTest {
+    @Test
+    public void givenLinkedList_whenIterativeReverse_thenOutputCorrectResult() {
+        ListNode head = constructLinkedList();
+        ListNode node = head;
+        for (int i = 1; i <= 5; i++) {
+            assertNotNull(node);
+            assertEquals(i, node.getData());
+            node = node.getNext();
+        }
+        LinkedListReversal reversal = new LinkedListReversal();
+        node = reversal.reverseList(head);
+        for (int i = 5; i >= 1; i--) {
+            assertNotNull(node);
+            assertEquals(i, node.getData());
+            node = node.getNext();
+        }
+    }
+
+    @Test
+    public void givenLinkedList_whenRecursiveReverse_thenOutputCorrectResult() {
+        ListNode head = constructLinkedList();
+        ListNode node = head;
+        for (int i = 1; i <= 5; i++) {
+            assertNotNull(node);
+            assertEquals(i, node.getData());
+            node = node.getNext();
+        }
+        LinkedListReversal reversal = new LinkedListReversal();
+        node = reversal.reverseListRecursive(head);
+        for (int i = 5; i >= 1; i--) {
+            assertNotNull(node);
+            assertEquals(i, node.getData());
+            node = node.getNext();
+        }
+    }
+
+    private ListNode constructLinkedList() {
+        ListNode head = null;
+        ListNode tail = null;
+        for (int i = 1; i <= 5; i++) {
+            ListNode node = new ListNode(i);
+            if (head == null) {
+                head = node;
+            } else {
+                tail.setNext(node);
+            }
+            tail = node;
+        }
+        return head;
+    }
+}

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/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-collections-3/README.md

@@ -13,3 +13,4 @@
 - [Quick Guide to the Java Stack](https://www.baeldung.com/java-stack)
 - [Convert an Array of Primitives to a List](https://www.baeldung.com/java-primitive-array-to-list)
 - [A Guide to BitSet in Java](https://www.baeldung.com/java-bitset)
+- [Get the First Key and Value From a HashMap](https://www.baeldung.com/java-hashmap-get-first-entry)

core-java-modules/core-java-concurrency-basic-2/README.md

@@ -11,4 +11,5 @@ This module contains articles about basic Java concurrency
 - [Life Cycle of a Thread in Java](https://www.baeldung.com/java-thread-lifecycle)
 - [Guide to AtomicMarkableReference](https://www.baeldung.com/java-atomicmarkablereference)
 - [Why are Local Variables Thread-Safe in Java](https://www.baeldung.com/java-local-variables-thread-safe)
+- [How to Stop Execution After a Certain Time in Java](https://www.baeldung.com/java-stop-execution-after-certain-time)
 - [[<-- Prev]](/core-java-modules/core-java-concurrency-basic)

core-java-modules/core-java-io-3/README.md

@@ -11,4 +11,5 @@ This module contains articles about core Java input and output (IO)
 - [Java Files Open Options](https://www.baeldung.com/java-file-options)
 - [Creating Temporary Directories in Java](https://www.baeldung.com/java-temp-directories)
 - [Reading a Line at a Given Line Number From a File in Java](https://www.baeldung.com/java-read-line-at-number)
+- [Find the Last Modified File in a Directory with Java](https://www.baeldung.com/java-last-modified-file)
 - [[<-- Prev]](/core-java-modules/core-java-io-2)

core-java-modules/core-java-io-3/src/main/java/com/baeldung/lastmodifiedfile/LastModifiedFileApp.java

@@ -0,0 +1,61 @@
+package com.baeldung.lastmodifiedfile;
+
+import java.io.File;
+import java.io.FileFilter;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Optional;
+
+import org.apache.commons.io.comparator.LastModifiedFileComparator;
+import org.apache.commons.io.filefilter.FileFilterUtils;
+
+public class LastModifiedFileApp {
+
+    public static File findUsingIOApi(String sdir) {
+        File dir = new File(sdir);
+        if (dir.isDirectory()) {
+            Optional<File> opFile = Arrays.stream(dir.listFiles(File::isFile))
+              .max((f1, f2) -> Long.compare(f1.lastModified(), f2.lastModified()));
+
+            if (opFile.isPresent()) {
+                return opFile.get();
+            }
+        }
+
+        return null;
+    }
+
+    public static Path findUsingNIOApi(String sdir) throws IOException {
+        Path dir = Paths.get(sdir);
+        if (Files.isDirectory(dir)) {
+            Optional<Path> opPath = Files.list(dir)
+              .filter(p -> !Files.isDirectory(p))
+              .sorted((p1, p2) -> Long.valueOf(p2.toFile().lastModified())
+                .compareTo(p1.toFile().lastModified()))
+              .findFirst();
+
+            if (opPath.isPresent()) {
+                return opPath.get();
+            }
+        }
+
+        return null;
+    }
+
+    public static File findUsingCommonsIO(String sdir) {
+        File dir = new File(sdir);
+        if (dir.isDirectory()) {
+            File[] dirFiles = dir.listFiles((FileFilter) FileFilterUtils.fileFileFilter());
+            if (dirFiles != null && dirFiles.length > 0) {
+                Arrays.sort(dirFiles, LastModifiedFileComparator.LASTMODIFIED_REVERSE);
+                return dirFiles[0];
+            }
+        }
+
+        return null;
+    }
+
+}

core-java-modules/core-java-io-3/src/test/java/com/baeldung/createfile/CreateFileUnitTest.java

@@ -6,6 +6,7 @@ import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 
 import java.io.File;
+import java.io.FileOutputStream;
 import java.io.IOException;
 import java.nio.file.Files;
 import java.nio.file.Path;
@@ -37,6 +38,12 @@ public class CreateFileUnitTest {
         assertTrue(success);
     }
 
+    @Test
+    void givenUsingFileOutputStream_whenCreatingFile_thenCorrect() throws IOException {
+        try(FileOutputStream fileOutputStream = new FileOutputStream(FILE_NAME)){
+        }
+    }
+
     @Test
     public void givenUsingGuava_whenCreatingFile_thenCorrect() throws IOException {
         com.google.common.io.Files.touch(new File(FILE_NAME));

core-java-modules/core-java-io-3/src/test/java/com/baeldung/lastmodifiedfile/LastModifiedFileAppUnitTest.java

@@ -0,0 +1,78 @@
+package com.baeldung.lastmodifiedfile;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+import org.apache.commons.io.FileUtils;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+public class LastModifiedFileAppUnitTest {
+
+    private final static String SOURCEDIRECTORY = "src/test/resources/lastmodfiles";
+
+    @BeforeAll
+    public static void setUpFiles() throws IOException, InterruptedException {
+        File srcDir = new File(SOURCEDIRECTORY);
+        if (!srcDir.exists()) {
+            srcDir.mkdir();
+        }
+
+        FileUtils.cleanDirectory(srcDir);
+
+        File file01 = new File(SOURCEDIRECTORY + "/file01.txt");
+        file01.createNewFile();
+
+        Thread.sleep(2000);
+
+        File file02 = new File(SOURCEDIRECTORY + "/file02.txt");
+        file02.createNewFile();
+
+        Thread.sleep(2000);
+
+        File file03 = new File(SOURCEDIRECTORY + "/file03.txt");
+        file03.createNewFile();
+
+        Thread.sleep(2000);
+
+        Files.write(Paths.get(SOURCEDIRECTORY + "/file02.txt"), "Hello File02".getBytes());
+
+    }
+
+    @Test
+    public void givenDirectory_whenUsingIoApi_thenFindLastModfile() throws IOException {
+        File lastModFile = LastModifiedFileApp.findUsingIOApi(SOURCEDIRECTORY);
+
+        assertThat(lastModFile).isNotNull();
+        assertThat(lastModFile.getName()).isEqualTo("file02.txt");
+    }
+
+    @Test
+    public void givenDirectory_whenUsingNioApi_thenFindLastModfile() throws IOException {
+        Path lastModPath = LastModifiedFileApp.findUsingNIOApi(SOURCEDIRECTORY);
+
+        assertThat(lastModPath).isNotNull();
+        assertThat(lastModPath.toFile().getName()).isEqualTo("file02.txt");
+    }
+
+    @Test
+    public void givenDirectory_whenUsingApacheCommons_thenFindLastModfile() throws IOException {
+        File lastModFile = LastModifiedFileApp.findUsingCommonsIO(SOURCEDIRECTORY);
+
+        assertThat(lastModFile).isNotNull();
+        assertThat(lastModFile.getName()).isEqualTo("file02.txt");
+    }
+
+    @AfterAll
+    public static void cleanUp() throws IOException {
+        File srcDir = new File(SOURCEDIRECTORY);
+        FileUtils.deleteDirectory(srcDir);
+    }
+
+}

core-java-modules/core-java-lang-3/README.md

@@ -6,4 +6,5 @@ This module contains articles about core features in the Java language
 - [Converting a Java String Into a Boolean](https://www.baeldung.com/java-string-to-boolean)
 - [When are Static Variables Initialized in Java?](https://www.baeldung.com/java-static-variables-initialization)
 - [Checking if a Class Exists in Java](https://www.baeldung.com/java-check-class-exists)
+- [The Difference Between a.getClass() and A.class in Java](https://www.baeldung.com/java-getclass-vs-class)
 - [[<-- Prev]](/core-java-modules/core-java-lang-2)

core-java-modules/core-java-lang-3/src/main/java/com/baeldung/getclassobject/Animal.java

@@ -0,0 +1,5 @@
+package com.baeldung.getclassobject;
+
+public class Animal {
+    protected int numberOfEyes;
+}

core-java-modules/core-java-lang-3/src/main/java/com/baeldung/getclassobject/Monkey.java

@@ -0,0 +1,4 @@
+package com.baeldung.getclassobject;
+
+public class Monkey extends Animal {
+}

core-java-modules/core-java-lang-3/src/main/java/com/baeldung/getclassobject/SomeAbstractClass.java

@@ -0,0 +1,4 @@
+package com.baeldung.getclassobject;
+
+public abstract class SomeAbstractClass {
+}

core-java-modules/core-java-lang-3/src/main/java/com/baeldung/getclassobject/SomeInterface.java

@@ -0,0 +1,4 @@
+package com.baeldung.getclassobject;
+
+interface SomeInterface {
+}

core-java-modules/core-java-lang-3/src/main/java/com/baeldung/getclassobject/SomeUtils.java

@@ -0,0 +1,9 @@
+package com.baeldung.getclassobject;
+
+public class SomeUtils {
+    private SomeUtils() {
+        throw new RuntimeException("This Util class is not allowed to be instantiated!");
+    }
+    //  public static utilMethods
+    //  ...
+}

core-java-modules/core-java-lang-3/src/test/java/com/baeldung/getclassobject/GetClassObjectUnitTest.java

@@ -0,0 +1,55 @@
+package com.baeldung.getclassobject;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class GetClassObjectUnitTest {
+    @Test
+    public void givenObjectAndType_whenGettingClassObject_thenTwoMethodsHaveTheSameResult() {
+        String str = "I am an object of the String class";
+        Class fromStrObject = str.getClass();
+        Class clazz = String.class;
+        assertSame(fromStrObject, clazz);
+    }
+
+    @Test
+    public void givenClassInheritance_whenGettingRuntimeTypeAndStaticType_thenGetDifferentResult() {
+        Animal animal = new Monkey();
+        Class runtimeType = animal.getClass();
+        Class staticType = Animal.class;
+        //Not equals
+        assertNotEquals(staticType, runtimeType);
+
+        Class monkeyClass = Monkey.class;
+        assertSame(runtimeType, monkeyClass);
+    }
+
+    @Test
+    public void givenPrimitiveType_whenGettingClassObject_thenOnlyStaticTypeWorks() {
+        int number = 7;
+        // Class numberClass = number.getClass();   <-- compilation error
+        Class intType = int.class;
+
+        assertNotNull(intType);
+        assertEquals("int", intType.getName());
+        assertTrue(intType.isPrimitive());
+    }
+
+    @Test
+    public void givenTypeCannotInstantiate_whenGetTypeStatically_thenGetTypesSuccefully() {
+        Class interfaceType = SomeInterface.class;
+        Class abstractClassType = SomeAbstractClass.class;
+        Class utilClassType = SomeUtils.class;
+
+        assertNotNull(interfaceType);
+        assertTrue(interfaceType.isInterface());
+        assertEquals("SomeInterface", interfaceType.getSimpleName());
+
+        assertNotNull(abstractClassType);
+        assertEquals("SomeAbstractClass", abstractClassType.getSimpleName());
+
+        assertNotNull(utilClassType);
+        assertEquals("SomeUtils", utilClassType.getSimpleName());
+    }
+}

core-java-modules/core-java-reflection-2/README.md

@@ -3,3 +3,4 @@
 - [Reading the Value of ‘private’ Fields from a Different Class in Java](https://www.baeldung.com/java-reflection-read-private-field-value)
 - [Set Field Value With Reflection](https://www.baeldung.com/java-set-private-field-value)
 - [Checking If a Method is Static Using Reflection in Java](https://www.baeldung.com/java-check-method-is-static)
+- [Checking if a Java Class is ‘abstract’ Using Reflection](https://www.baeldung.com/java-reflection-is-class-abstract)

core-java-modules/core-java-reflection-2/src/main/java/com/baeldung/reflection/check/abstractclass/AbstractExample.java

@@ -0,0 +1,15 @@
+package com.baeldung.reflection.check.abstractclass;
+
+import java.time.LocalDate;
+import java.time.LocalTime;
+
+public abstract class AbstractExample {
+
+    public static String getAuthorName() {
+        return "Umang Budhwar";
+    }
+
+    public abstract LocalDate getLocalDate();
+
+    public abstract LocalTime getLocalTime();
+}

core-java-modules/core-java-reflection-2/src/test/java/com/baeldung/reflection/check/abstractclass/AbstractExampleUnitTest.java

@@ -0,0 +1,16 @@
+package com.baeldung.reflection.check.abstractclass;
+
+import java.lang.reflect.Modifier;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class AbstractExampleUnitTest {
+
+    @Test
+    void givenAbstractClass_whenCheckModifierIsAbstract_thenTrue() throws Exception {
+        Class<AbstractExample> clazz = AbstractExample.class;
+        Assertions.assertTrue(Modifier.isAbstract(clazz.getModifiers()));
+    }
+
+}

core-java-modules/core-java-security-2/README.md

@@ -10,4 +10,6 @@ This module contains articles about core Java Security
 - [SHA-256 and SHA3-256 Hashing in Java](https://www.baeldung.com/sha-256-hashing-java)
 - [Checksums in Java](https://www.baeldung.com/java-checksums)
 - [How to Read PEM File to Get Public and Private Keys](https://www.baeldung.com/java-read-pem-file-keys)
+- [Listing the Available Cipher Algorithms](https://www.baeldung.com/java-list-cipher-algorithms)
+- [Get a List of Trusted Certificates in Java](https://www.baeldung.com/java-list-trusted-certificates)
 - More articles: [[<-- prev]](/core-java-modules/core-java-security)

core-java-modules/core-java-security-2/src/test/java/com/baeldung/trustedcert/CertificatesUnitTest.java

@@ -0,0 +1,94 @@
+package com.baeldung.trustedcert;
+
+import org.junit.jupiter.api.Test;
+
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.Certificate;
+import java.security.cert.CertificateException;
+import java.security.cert.PKIXParameters;
+import java.security.cert.TrustAnchor;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Enumeration;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+public class CertificatesUnitTest {
+
+    private static final String GODADDY_CA_ALIAS = "godaddyrootg2ca [jdk]";
+
+    @Test
+    public void whenLoadingCacertsKeyStore_thenCertificatesArePresent() throws Exception {
+        KeyStore keyStore = loadKeyStore();
+        PKIXParameters params = new PKIXParameters(keyStore);
+
+        Set<TrustAnchor> trustAnchors = params.getTrustAnchors();
+        List<Certificate> certificates = trustAnchors.stream()
+          .map(TrustAnchor::getTrustedCert)
+          .collect(Collectors.toList());
+
+        assertFalse(certificates.isEmpty());
+    }
+
+    @Test
+    public void whenLoadingDefaultKeyStore_thenCertificatesArePresent() throws Exception {
+        TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+        trustManagerFactory.init((KeyStore)null);
+
+        List<TrustManager> trustManagers = Arrays.asList(trustManagerFactory.getTrustManagers());
+        List<X509Certificate> certificates = trustManagers.stream()
+          .filter(X509TrustManager.class::isInstance)
+          .map(X509TrustManager.class::cast)
+          .map(trustManager -> Arrays.asList(trustManager.getAcceptedIssuers()))
+          .flatMap(Collection::stream)
+          .collect(Collectors.toList());
+
+        assertFalse(certificates.isEmpty());
+    }
+
+    @Test
+    public void whenLoadingKeyStore_thenGoDaddyCALabelIsPresent() throws Exception {
+        KeyStore keyStore = loadKeyStore();
+
+        Enumeration<String> aliasEnumeration = keyStore.aliases();
+        List<String> aliases = Collections.list(aliasEnumeration);
+
+        assertTrue(aliases.contains(GODADDY_CA_ALIAS));
+    }
+
+    @Test
+    public void whenLoadingKeyStore_thenGoDaddyCertificateIsPresent() throws Exception {
+        KeyStore keyStore = loadKeyStore();
+
+        Certificate goDaddyCertificate = keyStore.getCertificate(GODADDY_CA_ALIAS);
+
+        assertNotNull(goDaddyCertificate);
+    }
+
+    private KeyStore loadKeyStore() throws CertificateException, NoSuchAlgorithmException, IOException, KeyStoreException {
+        String relativeCacertsPath = "/lib/security/cacerts".replace("/", File.separator);
+        String filename = System.getProperty("java.home") + relativeCacertsPath;
+        FileInputStream is = new FileInputStream(filename);
+
+        KeyStore keystore = KeyStore.getInstance(KeyStore.getDefaultType());
+        String password = "changeit";
+        keystore.load(is, password.toCharArray());
+
+        return keystore;
+    }
+}

core-kotlin-modules/core-kotlin-lang/src/main/kotlin/com/baeldung/inline/Inline.kt

@@ -22,30 +22,6 @@ fun main() {
     numbers.each { println(random * it) } // capturing the random variable
 }
 
-fun namedFunction(): Int {
-    return 42
-}
-
-fun anonymous(): () -> Int {
-    return fun(): Int {
-        return 42
-    }
-}
-
-inline fun <T> List<T>.eachIndexed(f: (Int, T) -> Unit) {
-    for (i in indices) {
-        f(i, this[i])
-    }
-}
-
-fun <T> List<T>.indexOf(x: T): Int {
-    eachIndexed { index, value ->
-        if (value == x) return index
-    }
-
-    return -1
-}
-
 /**
  * Generates a random number.
  */