Merge remote-tracking branch 'eugenp/master'

JGit/src/main/java/com/baeldung/jgit/porcelain/Log.java

@@ -28,14 +28,14 @@ public class Log {
                 System.out.println("Had " + count + " commits overall on current branch");
 
                 logs = git.log()
-                        .add(repository.resolve("remotes/origin/testbranch"))
+                        .add(repository.resolve(git.getRepository().getFullBranch()))
                         .call();
                 count = 0;
                 for (RevCommit rev : logs) {
                     System.out.println("Commit: " + rev /* + ", name: " + rev.getName() + ", id: " + rev.getId().getName() */);
                     count++;
                 }
-                System.out.println("Had " + count + " commits overall on test-branch");
+                System.out.println("Had " + count + " commits overall on "+git.getRepository().getFullBranch());
 
                 logs = git.log()
                         .all()

JGit/src/test/java/com/baeldung/jgit/JGitBugIntegrationTest.java

@@ -1,3 +1,5 @@
+package com.baeldung.jgit;
+
 import com.baeldung.jgit.helper.Helper;
 import org.eclipse.jgit.lib.ObjectLoader;
 import org.eclipse.jgit.lib.ObjectReader;

algorithms-miscellaneous-1/pom.xml

@@ -17,6 +17,11 @@
             <artifactId>commons-math3</artifactId>
             <version>${commons-math3.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.google.guava</groupId>
+            <artifactId>guava</artifactId>
+            <version>${guava.version}</version>
+        </dependency>
         <dependency>
             <groupId>commons-codec</groupId>
             <artifactId>commons-codec</artifactId>
@@ -73,6 +78,7 @@
         <commons-math3.version>3.6.1</commons-math3.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
+        <guava.version>25.1-jre</guava.version>
     </properties>
 
 </project>

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/factorial/Factorial.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.factorial;
+
+import java.math.BigInteger;
+import java.util.stream.LongStream;
+
+import org.apache.commons.math3.util.CombinatoricsUtils;
+
+import com.google.common.math.BigIntegerMath;
+
+public class Factorial {
+
+    public long factorialUsingForLoop(int n) {
+        long fact = 1;
+        for (int i = 2; i <= n; i++) {
+            fact = fact * i;
+        }
+        return fact;
+    }
+
+    public long factorialUsingStreams(int n) {
+        return LongStream.rangeClosed(1, n)
+            .reduce(1, (long x, long y) -> x * y);
+    }
+
+    public long factorialUsingRecursion(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        return n * factorialUsingRecursion(n - 1);
+    }
+
+    private Long[] factorials = new Long[20];
+
+    public long factorialUsingMemoize(int n) {
+
+        if (factorials[n] != null) {
+            return factorials[n];
+        }
+
+        if (n <= 2) {
+            return n;
+        }
+        long nthValue = n * factorialUsingMemoize(n - 1);
+        factorials[n] = nthValue;
+        return nthValue;
+    }
+
+    public BigInteger factorialHavingLargeResult(int n) {
+        BigInteger result = BigInteger.ONE;
+        for (int i = 2; i <= n; i++)
+            result = result.multiply(BigInteger.valueOf(i));
+        return result;
+    }
+
+    public long factorialUsingApacheCommons(int n) {
+        return CombinatoricsUtils.factorial(n);
+    }
+
+    public BigInteger factorialUsingGuava(int n) {
+        return BigIntegerMath.factorial(n);
+    }
+
+}

algorithms-miscellaneous-1/src/main/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharacters.java

@@ -0,0 +1,54 @@
+package com.baeldung.algorithms.string;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class LongestSubstringNonRepeatingCharacters {
+
+    public static String getUniqueCharacterSubstringBruteForce(String input) {
+        String output = "";
+        for (int start = 0; start < input.length(); start++) {
+            Set<Character> visited = new HashSet<>();
+            int end = start;
+            for (; end < input.length(); end++) {
+                char currChar = input.charAt(end);
+                if (visited.contains(currChar)) {
+                    break;
+                } else {
+                    visited.add(currChar);
+                }
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end);
+            }
+        }
+        return output;
+    }
+
+    public static String getUniqueCharacterSubstring(String input) {
+        Map<Character, Integer> visited = new HashMap<>();
+        String output = "";
+        for (int start = 0, end = 0; end < input.length(); end++) {
+            char currChar = input.charAt(end);
+            if (visited.containsKey(currChar)) {
+                start = Math.max(visited.get(currChar) + 1, start);
+            }
+            if (output.length() < end - start + 1) {
+                output = input.substring(start, end + 1);
+            }
+            visited.put(currChar, end);
+        }
+        return output;
+    }
+
+    public static void main(String[] args) {
+        if(args.length > 0) {
+            System.out.println(getUniqueCharacterSubstring(args[0]));
+        } else {
+            System.err.println("This program expects command-line input. Please try again!");
+        }
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/factorial/FactorialUnitTest.java

@@ -0,0 +1,72 @@
+package com.baeldung.algorithms.factorial;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.math.BigInteger;
+
+import org.junit.Before;
+import org.junit.Test;
+
+public class FactorialUnitTest {
+
+    Factorial factorial;
+
+    @Before
+    public void setup() {
+        factorial = new Factorial();
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingForLoop_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingForLoop(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingStreams_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingStreams(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingRecursion_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingRecursion(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingMemoize_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(120);
+
+        n = 6;
+
+        assertThat(factorial.factorialUsingMemoize(n)).isEqualTo(720);
+    }
+
+    @Test
+    public void whenCalculatingFactorialHavingLargeResult_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialHavingLargeResult(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingApacheCommons_thenCorrect() {
+        int n = 5;
+
+        assertThat(factorial.factorialUsingApacheCommons(n)).isEqualTo(120);
+    }
+
+    @Test
+    public void whenCalculatingFactorialUsingGuava_thenCorrect() {
+        int n = 22;
+
+        assertThat(factorial.factorialUsingGuava(n)).isEqualTo(new BigInteger("1124000727777607680000"));
+    }
+
+}

algorithms-miscellaneous-1/src/test/java/com/baeldung/algorithms/string/LongestSubstringNonRepeatingCharactersUnitTest.java

@@ -0,0 +1,31 @@
+package com.baeldung.algorithms.string;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstring;
+import static com.baeldung.algorithms.string.LongestSubstringNonRepeatingCharacters.getUniqueCharacterSubstringBruteForce;
+
+public class LongestSubstringNonRepeatingCharactersUnitTest {
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringBruteForceCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstringBruteForce(""));
+        assertEquals("A", getUniqueCharacterSubstringBruteForce("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstringBruteForce("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstringBruteForce("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstringBruteForce("always be coding"));
+    }
+
+    @Test
+    void givenString_whenGetUniqueCharacterSubstringCalled_thenResultFoundAsExpectedUnitTest() {
+        assertEquals("", getUniqueCharacterSubstring(""));
+        assertEquals("A", getUniqueCharacterSubstring("A"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("AABCDEF"));
+        assertEquals("ABCDEF", getUniqueCharacterSubstring("ABCDEFF"));
+        assertEquals("NGISAWE", getUniqueCharacterSubstring("CODINGISAWESOME"));
+        assertEquals("be coding", getUniqueCharacterSubstring("always be coding"));
+    }
+
+}

algorithms-miscellaneous-2/pom.xml

@@ -33,6 +33,11 @@
             <artifactId>jgrapht-core</artifactId>
             <version>${org.jgrapht.core.version}</version>
         </dependency>
+        <dependency>
+        	<groupId>org.jgrapht</groupId>
+        	<artifactId>jgrapht-ext</artifactId>
+        	<version>${org.jgrapht.ext.version}</version>
+        </dependency>
         <dependency>
             <groupId>pl.allegro.finance</groupId>
             <artifactId>tradukisto</artifactId>
@@ -83,6 +88,7 @@
         <commons-math3.version>3.6.1</commons-math3.version>
         <tradukisto.version>1.0.1</tradukisto.version>
         <org.jgrapht.core.version>1.0.1</org.jgrapht.core.version>
+        <org.jgrapht.ext.version>1.0.1</org.jgrapht.ext.version>
         <org.assertj.core.version>3.9.0</org.assertj.core.version>
         <commons-codec.version>1.11</commons-codec.version>
     </properties>

algorithms-miscellaneous-2/src/test/java/com/baeldung/jgrapht/GraphImageGenerationUnitTest.java

@@ -0,0 +1,47 @@
+package com.baeldung.jgrapht;
+
+import static org.junit.Assert.assertTrue;
+import java.awt.Color;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import javax.imageio.ImageIO;
+import org.jgrapht.ext.JGraphXAdapter;
+import org.jgrapht.graph.DefaultDirectedGraph;
+import org.jgrapht.graph.DefaultEdge;
+import org.junit.Before;
+import org.junit.Test;
+import com.mxgraph.layout.mxCircleLayout;
+import com.mxgraph.layout.mxIGraphLayout;
+import com.mxgraph.util.mxCellRenderer;
+
+public class GraphImageGenerationUnitTest {
+    static DefaultDirectedGraph<String, DefaultEdge> g;
+
+    @Before
+    public void createGraph() throws IOException {
+        File imgFile = new File("src/test/resources/graph.png");
+        imgFile.createNewFile();
+        g = new DefaultDirectedGraph<String, DefaultEdge>(DefaultEdge.class);
+        String x1 = "x1";
+        String x2 = "x2";
+        String x3 = "x3";
+        g.addVertex(x1);
+        g.addVertex(x2);
+        g.addVertex(x3);
+        g.addEdge(x1, x2);
+        g.addEdge(x2, x3);
+        g.addEdge(x3, x1);
+    }
+
+    @Test
+    public void givenAdaptedGraph_whenWriteBufferedImage_ThenFileShouldExist() throws IOException {
+        JGraphXAdapter<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, DefaultEdge>(g);
+        mxIGraphLayout layout = new mxCircleLayout(graphAdapter);
+        layout.execute(graphAdapter.getDefaultParent());
+        File imgFile = new File("src/test/resources/graph.png");
+        BufferedImage image = mxCellRenderer.createBufferedImage(graphAdapter, null, 2, Color.WHITE, true, null);
+        ImageIO.write(image, "PNG", imgFile);
+        assertTrue(imgFile.exists());
+    }
+}

algorithms-sorting/src/main/java/com/baeldung/algorithms/mergesort/MergeSort.java

@@ -34,7 +34,7 @@ public class MergeSort {
 
         while (i < left && j < right) {
 
-            if (l[i] < r[j])
+            if (l[i] <= r[j])
                 a[k++] = l[i++];
             else
                 a[k++] = r[j++];

core-java-arrays/README.md

@@ -12,4 +12,4 @@
 - [Arrays in Java: A Reference Guide](https://www.baeldung.com/java-arrays-guide)
 - [How to Invert an Array in Java](http://www.baeldung.com/java-invert-array)
 - [Array Operations in Java](http://www.baeldung.com/java-common-array-operations)
-
+- [Intersection Between two Integer Arrays](https://www.baeldung.com/java-array-intersection)

core-java-collections/README.md

@@ -51,3 +51,4 @@
 - [Java List Initialization in One Line](https://www.baeldung.com/java-init-list-one-line)
 - [ClassCastException: Arrays$ArrayList cannot be cast to ArrayList](https://www.baeldung.com/java-classcastexception-arrays-arraylist)
 - [A Guide to EnumMap](https://www.baeldung.com/java-enum-map)
+- [Ways to Iterate Over a List in Java](https://www.baeldung.com/java-iterate-list)

core-java-concurrency/README.md

@@ -31,3 +31,4 @@
 - [Runnable vs. Callable in Java](http://www.baeldung.com/java-runnable-callable)
 - [Brief Introduction to Java Thread.yield()](https://www.baeldung.com/java-thread-yield)
 - [Print Even and Odd Numbers Using 2 Threads](https://www.baeldung.com/java-even-odd-numbers-with-2-threads)
+- [Java CyclicBarrier vs CountDownLatch](https://www.baeldung.com/java-cyclicbarrier-countdownlatch)

core-java-concurrency/src/main/java/com/baeldung/concurrent/Scheduledexecutorservice/ScheduledExecutorServiceDemo.java

@@ -1,34 +1,52 @@
 package com.baeldung.concurrent.Scheduledexecutorservice;
 
 import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 
 public class ScheduledExecutorServiceDemo {
 
-	public void execute() {
+	private void execute() {
 		ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
-
-		ScheduledFuture<?> scheduledFuture = executorService.schedule(() -> {
-			// Task
-		}, 1, TimeUnit.SECONDS);
-
-		executorService.scheduleAtFixedRate(() -> {
-			// Task
-		}, 1, 10, TimeUnit.SECONDS);
-
-		executorService.scheduleWithFixedDelay(() -> {
-			// Task
-		}, 1, 10, TimeUnit.SECONDS);
-
-		Future<String> future = executorService.schedule(() -> {
-			// Task
-			return "Hellow world";
-		}, 1, TimeUnit.SECONDS);
-
+		getTasksToRun().apply(executorService);
 		executorService.shutdown();
 	}
 
+	private void executeWithMultiThread() {
+		ScheduledExecutorService executorService = Executors.newScheduledThreadPool(2);
+		getTasksToRun().apply(executorService);
+		executorService.shutdown();
+	}
+
+	private Function<ScheduledExecutorService, Void> getTasksToRun() {
+		return (executorService -> {
+			ScheduledFuture<?> scheduledFuture1 = executorService.schedule(() -> {
+				// Task
+			}, 1, TimeUnit.SECONDS);
+
+			ScheduledFuture<?> scheduledFuture2 = executorService.scheduleAtFixedRate(() -> {
+				// Task
+			}, 1, 10, TimeUnit.SECONDS);
+
+			ScheduledFuture<?> scheduledFuture3 = executorService.scheduleWithFixedDelay(() -> {
+				// Task
+			}, 1, 10, TimeUnit.SECONDS);
+
+			ScheduledFuture<String> scheduledFuture4 = executorService.schedule(() -> {
+				// Task
+				return "Hellow world";
+			}, 1, TimeUnit.SECONDS);
+			return null;
+		});
+	}
+
+	public static void main(String... args) {
+		ScheduledExecutorServiceDemo demo = new ScheduledExecutorServiceDemo();
+		demo.execute();
+		demo.executeWithMultiThread();
+	}
+
+
 }

core-java-concurrency/src/main/java/com/baeldung/concurrent/daemon/MultipleThreadsExample.java

@@ -0,0 +1,12 @@
+package com.baeldung.concurrent.daemon;
+
+public class MultipleThreadsExample {
+    public static void main(String[] args) {
+        NewThread t1 = new NewThread();
+        t1.setName("MyThread-1");
+        NewThread t2 = new NewThread();
+        t2.setName("MyThread-2");
+        t1.start();
+        t2.start();
+    }
+}

core-java-concurrency/src/main/java/com/baeldung/concurrent/daemon/NewThread.java

@@ -1,14 +1,18 @@
 package com.baeldung.concurrent.daemon;
 
 public class NewThread extends Thread {
-
     public void run() {
     	long startTime = System.currentTimeMillis();
         while (true) {
             for (int i = 0; i < 10; i++) {
-                System.out.println("New Thread is running..." + i);
+                System.out.println(this.getName() + ": New Thread is running..." + i);
+                try {
+                    //Wait for one sec so it doesn't print too fast
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
             }
-            
             // prevent the Thread to run forever. It will finish it's execution after 2 seconds
             if (System.currentTimeMillis() - startTime > 2000) {
             	Thread.currentThread().interrupt();

core-java-concurrency/src/main/java/com/baeldung/concurrent/daemon/SingleThreadExample.java

@@ -0,0 +1,8 @@
+package com.baeldung.concurrent.daemon;
+
+public class SingleThreadExample {
+    public static void main(String[] args) {
+        NewThread t = new NewThread();
+        t.start();
+    }
+}

core-java-lang/README.md

@@ -58,4 +58,4 @@
 - [Inheritance and Composition (Is-a vs Has-a relationship) in Java](http://www.baeldung.com/java-inheritance-composition)
 - [A Guide to Constructors in Java](https://www.baeldung.com/java-constructors)
 - [Retrieving a Class Name in Java](https://www.baeldung.com/java-class-name)
-
+- [Java equals() and hashCode() Contracts](https://www.baeldung.com/java-equals-hashcode-contracts)

core-java-net/README.md

@@ -1,3 +0,0 @@
-=========
-
-## Core Java Net

core-java-networking/README.md

@@ -0,0 +1,7 @@
+=========
+
+## Core Java Networking
+
+### Relevant Articles
+
+- [Connecting Through Proxy Servers in Core Java](https://www.baeldung.com/java-connect-via-proxy-server)

core-java-networking/pom.xml

@@ -1,10 +1,10 @@
 <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-net</artifactId>
+    <artifactId>core-java-networking</artifactId>
     <version>0.1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
-    <name>core-java-net</name>
+    <name>core-java-networking</name>
 
     <parent>
         <groupId>com.baeldung</groupId>
@@ -14,6 +14,6 @@
     </parent>
 
     <build>
-        <finalName>core-java-net</finalName>
+        <finalName>core-java-networking</finalName>
     </build>
 </project>