Merge branch 'master' of https://github.com/eugenp/tutorials

2020-07-27 15:57:17 +02:00
parent 23dbbb579d 94555a4510
commit cb9e336bd6
457 changed files with 22516 additions and 520 deletions
@@ -7,4 +7,6 @@
 - [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)
@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.topkelements;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class BruteForceTopKElementsFinder implements TopKElementsFinder<Integer> {
+
+    public List<Integer> findTopK(List<Integer> input, int k) {
+        List<Integer> array = new ArrayList<>(input);
+        List<Integer> topKList = new ArrayList<>();
+
+        for (int i = 0; i < k; i++) {
+            int maxIndex = 0;
+
+            for (int j = 1; j < array.size(); j++) {
+                if (array.get(j) > array.get(maxIndex)) {
+                    maxIndex = j;
+                }
+            }
+
+            topKList.add(array.remove(maxIndex));
+        }
+
+        return topKList;
+    }
+}
@@ -0,0 +1,26 @@
+package com.baeldung.algorithms.topkelements;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class MaxHeapTopKElementsFinder implements TopKElementsFinder<Integer> {
+
+    public List<Integer> findTopK(List<Integer> input, int k) {
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>();
+
+        input.forEach(number -> {
+            maxHeap.add(number);
+
+            if (maxHeap.size() > k) {
+                maxHeap.poll();
+            }
+        });
+
+        List<Integer> topKList = new ArrayList<>(maxHeap);
+        Collections.reverse(topKList);
+
+        return topKList;
+    }
+}
@@ -0,0 +1,7 @@
+package com.baeldung.algorithms.topkelements;
+
+import java.util.List;
+
+public interface TopKElementsFinder<T extends Comparable<T>> {
+    List<T> findTopK(List<T> input, int k);
+}
@@ -0,0 +1,17 @@
+package com.baeldung.algorithms.topkelements;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+public class TreeSetTopKElementsFinder implements TopKElementsFinder<Integer> {
+
+    public List<Integer> findTopK(List<Integer> input, int k) {
+        Set<Integer> sortedSet = new TreeSet<>(Comparator.reverseOrder());
+        sortedSet.addAll(input);
+
+        return sortedSet.stream().limit(k).collect(Collectors.toList());
+    }
+}
@@ -0,0 +1,46 @@
+package com.baeldung.algorithms.topkelements;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class TopKElementsFinderUnitTest {
+    private final TopKElementsFinder<Integer> bruteForceFinder = new BruteForceTopKElementsFinder();
+    private final TopKElementsFinder<Integer> maxHeapFinder = new MaxHeapTopKElementsFinder();
+    private final TopKElementsFinder<Integer> treeSetFinder = new TreeSetTopKElementsFinder();
+
+    private final int k = 4;
+    private final List<Integer> distinctIntegers = Arrays.asList(1, 2, 3, 9, 7, 6, 12);
+    private final List<Integer> distinctIntegersTopK = Arrays.asList(9, 7, 6, 12);
+    private final List<Integer> nonDistinctIntegers = Arrays.asList(1, 2, 3, 3, 9, 9, 7, 6, 12);
+    private final List<Integer> nonDistinctIntegersTopK = Arrays.asList(9, 9, 7, 12);
+
+
+    @Test
+    public void givenArrayDistinctIntegers_whenBruteForceFindTopK_thenReturnKLargest() {
+        assertThat(bruteForceFinder.findTopK(distinctIntegers, k)).containsOnlyElementsOf(distinctIntegersTopK);
+    }
+
+    @Test
+    public void givenArrayDistinctIntegers_whenMaxHeapFindTopK_thenReturnKLargest() {
+        assertThat(maxHeapFinder.findTopK(distinctIntegers, k)).containsOnlyElementsOf(distinctIntegersTopK);
+    }
+
+    @Test
+    public void givenArrayDistinctIntegers_whenTreeSetFindTopK_thenReturnKLargest() {
+        assertThat(treeSetFinder.findTopK(distinctIntegers, k)).containsOnlyElementsOf(distinctIntegersTopK);
+    }
+
+    @Test
+    public void givenArrayNonDistinctIntegers_whenBruteForceFindTopK_thenReturnKLargest() {
+        assertThat(bruteForceFinder.findTopK(nonDistinctIntegers, k)).containsOnlyElementsOf(nonDistinctIntegersTopK);
+    }
+
+    @Test
+    public void givenArrayNonDistinctIntegers_whenMaxHeapFindTopK_thenReturnKLargest() {
+        assertThat(maxHeapFinder.findTopK(nonDistinctIntegers, k)).containsOnlyElementsOf(nonDistinctIntegersTopK);
+    }
+}
@@ -6,4 +6,4 @@ This module contains articles about Apache Shiro

 - [Introduction to Apache Shiro](https://www.baeldung.com/apache-shiro)
 - [Permissions-Based Access Control with Apache Shiro](https://www.baeldung.com/apache-shiro-access-control)
-
+- [Spring Security vs Apache Shiro](https://www.baeldung.com/spring-security-vs-apache-shiro)
@@ -13,4 +13,5 @@ This module contains articles about core Groovy concepts
 - [Converting a String to a Date in Groovy](https://www.baeldung.com/groovy-string-to-date)
 - [Guide to I/O in Groovy](https://www.baeldung.com/groovy-io)
 - [Convert String to Integer in Groovy](https://www.baeldung.com/groovy-convert-string-to-integer)
+- [Groovy Variable Scope](https://www.baeldung.com/groovy/variable-scope)
 - [[More -->]](/core-groovy-2)
@@ -8,7 +8,7 @@ This module contains articles about Java 11 core features
 - [Java 11 Local Variable Syntax for Lambda Parameters](https://www.baeldung.com/java-var-lambda-params)
 - [Java 11 String API Additions](https://www.baeldung.com/java-11-string-api)
 - [Java 11 Nest Based Access Control](https://www.baeldung.com/java-nest-based-access-control)
- [Exploring the New HTTP Client in Java 9 and 11](https://www.baeldung.com/java-9-http-client)
+- [Exploring the New HTTP Client in Java](https://www.baeldung.com/java-9-http-client)
 - [An Introduction to Epsilon GC: A No-Op Experimental Garbage Collector](https://www.baeldung.com/jvm-epsilon-gc-garbage-collector)
 - [Guide to jlink](https://www.baeldung.com/jlink)
 - [Negate a Predicate Method Reference with Java 11](https://www.baeldung.com/java-negate-predicate-method-reference)
@@ -1,12 +1,15 @@
 package com.baeldung.modules.main;

+import com.baeldung.modules.hello.HelloInterface;
 import com.baeldung.modules.hello.HelloModules;
+import java.util.ServiceLoader;

 public class MainApp {
    public static void main(String[] args) {
        HelloModules.doSomething();
-
-        HelloModules module = new HelloModules();
-        module.sayHello();
+        
+        Iterable<HelloInterface> services = ServiceLoader.load(HelloInterface.class);
+        HelloInterface service = services.iterator().next();
+        service.sayHello();
    }
 }
@@ -13,3 +13,4 @@ This module contains articles about core Java features that have been introduced
 - [Java 9 Platform Logging API](https://www.baeldung.com/java-9-logging-api)
 - [Java 9 Reactive Streams](https://www.baeldung.com/java-9-reactive-streams)
 - [Multi-Release JAR Files with Maven](https://www.baeldung.com/maven-multi-release-jars)
+- [The Difference between RxJava API and the Java 9 Flow API](https://www.baeldung.com/rxjava-vs-java-flow-api)
@@ -9,3 +9,4 @@ This module contains articles about Java 9 core features
 - [Iterate Through a Range of Dates in Java](https://www.baeldung.com/java-iterate-date-range)
 - [Initialize a HashMap in Java](https://www.baeldung.com/java-initialize-hashmap)
 - [Immutable ArrayList in Java](https://www.baeldung.com/java-immutable-list)
+- [Easy Ways to Write a Java InputStream to an OutputStream](https://www.baeldung.com/java-inputstream-to-outputstream)
@@ -5,4 +5,4 @@ This module contains complete guides about arrays in Java
 ### Relevant Articles: 
 - [Arrays in Java: A Reference Guide](https://www.baeldung.com/java-arrays-guide)
 - [Guide to the java.util.Arrays Class](https://www.baeldung.com/java-util-arrays)
- [What is [Ljava.lang.Object;?]](https://www.baeldung.com/java-tostring-array)
+- [What is \[Ljava.lang.Object;?](https://www.baeldung.com/java-tostring-array)
@@ -3,6 +3,7 @@
 ## Core Java Collections Cookbooks and Examples

 ### Relevant Articles: 
+
 - [Time Comparison of Arrays.sort(Object[]) and Arrays.sort(int[])](https://www.baeldung.com/arrays-sortobject-vs-sortint)
 - [Java ArrayList vs Vector](https://www.baeldung.com/java-arraylist-vs-vector)
 - [Differences Between HashMap and Hashtable](https://www.baeldung.com/hashmap-hashtable-differences)
@@ -10,3 +11,4 @@
 - [Performance of contains() in a HashSet vs ArrayList](https://www.baeldung.com/java-hashset-arraylist-contains-performance)
 - [Fail-Safe Iterator vs Fail-Fast Iterator](https://www.baeldung.com/java-fail-safe-vs-fail-fast-iterator)
 - [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)
@@ -15,4 +15,5 @@ This module contains articles about advanced topics about multithreading with co
 - [The ABA Problem in Concurrency](https://www.baeldung.com/cs/aba-concurrency)
 - [Introduction to Lock-Free Data Structures](https://www.baeldung.com/lock-free-programming)
 - [Introduction to Exchanger in Java](https://www.baeldung.com/java-exchanger)
+- [Why Not To Start A Thread In The Constructor?](https://www.baeldung.com/java-thread-constructor)
 - [[<-- previous]](/core-java-modules/core-java-concurrency-advanced-2)
@@ -3,10 +3,12 @@
 This module contains articles about basic Java concurrency

 ### Relevant Articles: 
+
 - [How to Delay Code Execution in Java](https://www.baeldung.com/java-delay-code-execution)
 - [wait and notify() Methods in Java](https://www.baeldung.com/java-wait-notify)
 - [Difference Between Wait and Sleep in Java](https://www.baeldung.com/java-wait-and-sleep)
 - [Guide to the Synchronized Keyword in Java](https://www.baeldung.com/java-synchronized)
 - [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)
 - [[<-- Prev]](/core-java-modules/core-java-concurrency-basic)
@@ -1,3 +1,5 @@
 ### Relevant Articles:

 - [Introduction to Lock Striping](https://www.baeldung.com/java-lock-stripping)
+- [Guide to the Java TransferQueue](http://www.baeldung.com/java-transfer-queue)
+- [[<-- Prev]](/core-java-modules/core-java-concurrency-collections)
@@ -3,9 +3,16 @@
    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>
-    <groupId>com.baeldung.concurrent.lock</groupId>
    <artifactId>core-java-concurrency-collections-2</artifactId>
-    <version>0.0.1-SNAPSHOT</version>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-concurrency-collections-2</name>
+    <packaging>jar</packaging>
+    <parent>
+        <groupId>com.baeldung.core-java-modules</groupId>
+        <artifactId>core-java-modules</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../</relativePath>
+    </parent>

    <dependencies>
        <dependency>
@@ -30,19 +37,6 @@
            <scope>test</scope>
        </dependency>
    </dependencies>
-    <build>
-        <sourceDirectory>src</sourceDirectory>
-        <plugins>
-            <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.8.0</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>

    <properties>
        <jmh.version>1.21</jmh.version>
@@ -19,7 +19,7 @@ import org.junit.FixMethodOrder;
 import org.junit.Test;

@FixMethodOrder
-public class TestConcurrentLinkedQueue {
+public class ConcurrentLinkedQueueUnitTest {

    @Test
    public void givenThereIsExistingCollection_WhenAddedIntoQueue_ThenShouldContainElements() {
@@ -18,7 +18,7 @@ import org.junit.FixMethodOrder;
 import org.junit.Test;

@FixMethodOrder
-public class TestLinkedBlockingQueue {
+public class LinkedBlockingQueueUnitTest {

    @Test
    public void givenThereIsExistingCollection_WhenAddedIntoQueue_ThenShouldContainElements() {
@@ -4,7 +4,11 @@ import org.junit.FixMethodOrder;
 import org.junit.Test;
 import org.junit.runners.MethodSorters;

-import java.util.concurrent.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedTransferQueue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TransferQueue;

 import static junit.framework.TestCase.assertEquals;

@@ -10,7 +10,7 @@ This module contains articles about concurrent Java collections
 - [Custom Thread Pools In Java 8 Parallel Streams](http://www.baeldung.com/java-8-parallel-streams-custom-threadpool)
 - [Guide to DelayQueue](http://www.baeldung.com/java-delay-queue)
 - [A Guide to Java SynchronousQueue](http://www.baeldung.com/java-synchronous-queue)
- [Guide to the Java TransferQueue](http://www.baeldung.com/java-transfer-queue)
 - [Guide to the ConcurrentSkipListMap](http://www.baeldung.com/java-concurrent-skip-list-map)
 - [Guide to CopyOnWriteArrayList](http://www.baeldung.com/java-copy-on-write-arraylist)
 - [LinkedBlockingQueue vs ConcurrentLinkedQueue](https://www.baeldung.com/java-queue-linkedblocking-concurrentlinked)
+- [[Next -->]](/core-java-modules/core-java-concurrency-collections-2)
@@ -0,0 +1,31 @@
+package com.baeldung.consoleout;
+
+import java.io.Console;
+
+public class ConsoleAndOut {
+    public static void main(String[] args) {
+        try {
+            printConsoleObject();
+            readPasswordFromConsole();
+        } catch (Exception ex) {
+            // Eating NullPointerExcpetion which will occur when this 
+            // program will be run from mediums other than console
+        }
+        printSysOut();    
+    }
+
+    static void printConsoleObject() {
+        Console console = System.console();
+        console.writer().print(console);
+    }
+
+    static void readPasswordFromConsole() {
+        Console console = System.console();
+        char[] password = console.readPassword("Enter password: ");
+        console.printf(String.valueOf(password));
+    }
+    
+    static void printSysOut() {
+        System.out.println(System.out);
+    }
+}
@@ -0,0 +1,27 @@
+package com.baeldung.consoleout;
+
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.api.Test;
+
+class ConsoleAndOutUnitTest {
+
+    @Test
+    void whenRetreivingConsole_thenPrintConsoleObject() {
+        assertThrows(NullPointerException.class, () -> {
+            ConsoleAndOut.printConsoleObject();  
+        });
+    }
+    
+    @Test
+    void whenReadingPassword_thenReadPassword() {
+        assertThrows(NullPointerException.class, () -> {
+            ConsoleAndOut.readPasswordFromConsole();  
+        });
+    }
+    
+    @Test
+    void whenRetrievingSysOut_thenPrintSysOutObject() {
+        ConsoleAndOut.printSysOut();
+    }
+}
@@ -2,6 +2,7 @@
 This module contains articles about date operations in Java.

 ### Relevant Articles:
+
 - [Get the Current Date Prior to Java 8](https://www.baeldung.com/java-get-the-current-date-legacy)
 - [Skipping Weekends While Adding Days to LocalDate in Java 8](https://www.baeldung.com/java-localdate-add-days-skip-weekends)
 - [Checking If Two Java Dates Are on the Same Day](https://www.baeldung.com/java-check-two-dates-on-same-day)
@@ -9,4 +10,5 @@ This module contains articles about date operations in Java.
 - [How to Set the JVM Time Zone](https://www.baeldung.com/java-jvm-time-zone)
 - [How to determine day of week by passing specific date in Java?](https://www.baeldung.com/java-get-day-of-week)
 - [Finding Leap Years in Java](https://www.baeldung.com/java-leap-year)
+- [Getting the Week Number From Any Date](https://www.baeldung.com/java-get-week-number)
 - [[<-- Prev]](/core-java-modules/core-java-date-operations-1)
@@ -12,3 +12,5 @@ This module contains articles about core java exceptions
 - [Java – Try with Resources](https://www.baeldung.com/java-try-with-resources)
 - [Java Global Exception Handler](https://www.baeldung.com/java-global-exception-handler)
 - [How to Find an Exception’s Root Cause in Java](https://www.baeldung.com/java-exception-root-cause)
+- [Java IOException “Too many open files”](https://www.baeldung.com/java-too-many-open-files)
+- [When Does Java Throw the ExceptionInInitializerError?](https://www.baeldung.com/java-exceptionininitializererror)
@@ -13,4 +13,4 @@ This module contains articles about core Java input and output (IO)
 - [How to Copy a File with Java](https://www.baeldung.com/java-copy-file)
 - [Create a Directory in Java](https://www.baeldung.com/java-create-directory) 
 - [Java IO vs NIO](https://www.baeldung.com/java-io-vs-nio)
- [[<-- Prev]](/core-java-modules/core-java-io)
+- [[<-- Prev]](/core-java-modules/core-java-io)[[More -->]](/core-java-modules/core-java-io-3)
@@ -0,0 +1,9 @@
+## Core Java IO
+
+This module contains articles about core Java input and output (IO)
+
+### Relevant Articles: 
+
+- [Java – Create a File](https://www.baeldung.com/java-how-to-create-a-file)
+- [Check If a Directory Is Empty in Java](https://www.baeldung.com/java-check-empty-directory)
+- [[<-- Prev]](/core-java-modules/core-java-io-2)
--- a/Show More
+++ b/Show More