resolved conflicts

.travis.yml

@@ -5,7 +5,6 @@ install: travis_wait 40 mvn -q clean install -Dgib.enabled=true
 jdk:
   - oraclejdk8
 
-sudo: false
 addons:
   apt:
     packages:
@@ -14,4 +13,11 @@ addons:
 cache:
   directories:
   - .autoconf
-  - $HOME/.m2
+  - $HOME/.m2
+  
+  sudo: required
+  
+  env:
+    global:
+      JAVA_OPTS="-Xmx2048M -Xss128M -XX:MaxPermSize=2048M -XX:+CMSClassUnloadingEnabled -XX:+UseConcMarkSweepGC"
+      MAVEN_OPTS="-Xmx2048M -Xss128M -XX:MaxPermSize=2048M -XX:+CMSClassUnloadingEnabled -XX:+UseConcMarkSweepGC"

Twitter4J/README.md

@@ -0,0 +1,3 @@
+### Relevant articles
+
+- [Introduction to Twitter4J](http://www.baeldung.com/twitter4j)

Twitter4J/pom.xml

@@ -17,11 +17,6 @@
 	</properties>
 
     <dependencies>
-	    <dependency>
-		    <groupId>org.twitter4j</groupId>
-		    <artifactId>twitter4j-core</artifactId>
-		    <version>4.0.6</version>
-		</dependency>
 		<dependency>
     		<groupId>org.twitter4j</groupId>
     		<artifactId>twitter4j-stream</artifactId>

Twitter4J/src/main/java/com/baeldung/Application.java

@@ -28,11 +28,10 @@ public class Application {
 		 */
 //		ConfigurationBuilder cb = new ConfigurationBuilder();
 //		cb.setDebugEnabled(true)
-//		  .setOAuthConsumerKey("DPHTBsWWO42d8rzshxlK0OwSY")
-//		  .setOAuthConsumerSecret("ACLXkeRY98NiaVCG1ai8fdYt0GoEGJbFeTuxjulSCO7sLKqls1")
-//		  .setOAuthAccessToken("838080188214759428-9MSK1ddPTN5ZZHbddjFI7s75mYgmCFQ")
-//		  .setOAuthAccessTokenSecret("1eXAADpHShAzQh5hGWLBUQHLysOuAKIOapmQQ8U0OVk2c");
-//
+//		  .setOAuthConsumerKey("//TODO")
+//		  .setOAuthConsumerSecret("//TODO")
+//		  .setOAuthAccessToken("//TODO")
+//		  .setOAuthAccessTokenSecret("//TODO");
 //		TwitterFactory tf = new TwitterFactory(cb.build());
 //		Twitter twitter = tf.getSingleton();
 		

algorithms/README.md

@@ -2,3 +2,5 @@
 
 - [Dijkstra Algorithm in Java](http://www.baeldung.com/java-dijkstra)
 - [Introduction to Cobertura](http://www.baeldung.com/cobertura)
+- [Ant Colony Optimization](http://www.baeldung.com/java-ant-colony-optimization)
+- [Validating Input With Finite Automata in Java](http://www.baeldung.com/finite-automata-java)

algorithms/pom.xml

@@ -9,6 +9,7 @@
 		<junit.version>4.12</junit.version>
 		<maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>
 		<exec-maven-plugin.version>1.5.0</exec-maven-plugin.version>
+		<lombok.version>1.16.12</lombok.version>
 	</properties>
 
 	<dependencies>
@@ -18,6 +19,12 @@
 			<version>${junit.version}</version>
 			<scope>test</scope>
 		</dependency>
+		<dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
 	</dependencies>
 
 	<build>

algorithms/src/main/java/com/baeldung/algorithms/RunAlgorithm.java

@@ -9,13 +9,14 @@ import com.baeldung.algorithms.slope_one.SlopeOne;
 
 public class RunAlgorithm {
 
-	public static void main(String[] args) {
+	public static void main(String[] args) throws InstantiationException, IllegalAccessException {
 		Scanner in = new Scanner(System.in);
 		System.out.println("Run algorithm:");
 		System.out.println("1 - Simulated Annealing");
 		System.out.println("2 - Slope One");
 		System.out.println("3 - Simple Genetic Algorithm");
 		System.out.println("4 - Ant Colony");
+		System.out.println("5 - Dijkstra");
 		int decision = in.nextInt();
 		switch (decision) {
 		case 1:
@@ -33,6 +34,9 @@ public class RunAlgorithm {
 			AntColonyOptimization antColony = new AntColonyOptimization(21);
 			antColony.startAntOptimization();
 			break;
+		case 5:
+			System.out.println("Please run the DijkstraAlgorithmTest.");
+			break;
 		default:
 			System.out.println("Unknown option");
 			break;

algorithms/src/main/java/com/baeldung/algorithms/ga/ant_colony/AntColonyOptimization.java

@@ -0,0 +1,203 @@
+package com.baeldung.algorithms.ga.ant_colony;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.OptionalInt;
+import java.util.Random;
+import java.util.stream.IntStream;
+
+public class AntColonyOptimization {
+
+    private double c = 1.0;
+    private double alpha = 1;
+    private double beta = 5;
+    private double evaporation = 0.5;
+    private double Q = 500;
+    private double antFactor = 0.8;
+    private double randomFactor = 0.01;
+
+    private int maxIterations = 1000;
+
+    private int numberOfCities;
+    private int numberOfAnts;
+    private double graph[][];
+    private double trails[][];
+    private List<Ant> ants = new ArrayList<>();
+    private Random random = new Random();
+    private double probabilities[];
+
+    private int currentIndex;
+
+    private int[] bestTourOrder;
+    private double bestTourLength;
+
+    public AntColonyOptimization(int noOfCities) {
+        graph = generateRandomMatrix(noOfCities);
+        numberOfCities = graph.length;
+        numberOfAnts = (int) (numberOfCities * antFactor);
+
+        trails = new double[numberOfCities][numberOfCities];
+        probabilities = new double[numberOfCities];
+        IntStream.range(0, numberOfAnts)
+            .forEach(i -> ants.add(new Ant(numberOfCities)));
+    }
+
+    /**
+     * Generate initial solution
+     */
+    public double[][] generateRandomMatrix(int n) {
+        double[][] randomMatrix = new double[n][n];
+        IntStream.range(0, n)
+            .forEach(i -> IntStream.range(0, n)
+                .forEach(j -> randomMatrix[i][j] = Math.abs(random.nextInt(100) + 1)));
+        return randomMatrix;
+    }
+
+    /**
+     * Perform ant optimization
+     */
+    public void startAntOptimization() {
+        IntStream.rangeClosed(1, 3)
+            .forEach(i -> {
+                System.out.println("Attempt #" + i);
+                solve();
+            });
+    }
+
+    /**
+     * Use this method to run the main logic
+     */
+    public int[] solve() {
+        setupAnts();
+        clearTrails();
+        IntStream.range(0, maxIterations)
+            .forEach(i -> {
+                moveAnts();
+                updateTrails();
+                updateBest();
+            });
+        System.out.println("Best tour length: " + (bestTourLength - numberOfCities));
+        System.out.println("Best tour order: " + Arrays.toString(bestTourOrder));
+        return bestTourOrder.clone();
+    }
+
+    /**
+     * Prepare ants for the simulation
+     */
+    private void setupAnts() {
+        IntStream.range(0, numberOfAnts)
+            .forEach(i -> {
+                ants.forEach(ant -> {
+                    ant.clear();
+                    ant.visitCity(-1, random.nextInt(numberOfCities));
+                });
+            });
+        currentIndex = 0;
+    }
+
+    /**
+     * At each iteration, move ants
+     */
+    private void moveAnts() {
+        IntStream.range(currentIndex, numberOfCities - 1)
+            .forEach(i -> {
+                ants.forEach(ant -> ant.visitCity(currentIndex, selectNextCity(ant)));
+                currentIndex++;
+            });
+    }
+
+    /**
+     * Select next city for each ant
+     */
+    private int selectNextCity(Ant ant) {
+        int t = random.nextInt(numberOfCities - currentIndex);
+        if (random.nextDouble() < randomFactor) {
+            OptionalInt cityIndex = IntStream.range(0, numberOfCities)
+                .filter(i -> i == t && !ant.visited(i))
+                .findFirst();
+            if (cityIndex.isPresent()) {
+                return cityIndex.getAsInt();
+            }
+        }
+        calculateProbabilities(ant);
+        double r = random.nextDouble();
+        double total = 0;
+        for (int i = 0; i < numberOfCities; i++) {
+            total += probabilities[i];
+            if (total >= r) {
+                return i;
+            }
+        }
+
+        throw new RuntimeException("There are no other cities");
+    }
+
+    /**
+     * Calculate the next city picks probabilites
+     */
+    public void calculateProbabilities(Ant ant) {
+        int i = ant.trail[currentIndex];
+        double pheromone = 0.0;
+        for (int l = 0; l < numberOfCities; l++) {
+            if (!ant.visited(l)) {
+                pheromone += Math.pow(trails[i][l], alpha) * Math.pow(1.0 / graph[i][l], beta);
+            }
+        }
+        for (int j = 0; j < numberOfCities; j++) {
+            if (ant.visited(j)) {
+                probabilities[j] = 0.0;
+            } else {
+                double numerator = Math.pow(trails[i][j], alpha) * Math.pow(1.0 / graph[i][j], beta);
+                probabilities[j] = numerator / pheromone;
+            }
+        }
+    }
+
+    /**
+     * Update trails that ants used
+     */
+    private void updateTrails() {
+        for (int i = 0; i < numberOfCities; i++) {
+            for (int j = 0; j < numberOfCities; j++) {
+                trails[i][j] *= evaporation;
+            }
+        }
+        for (Ant a : ants) {
+            double contribution = Q / a.trailLength(graph);
+            for (int i = 0; i < numberOfCities - 1; i++) {
+                trails[a.trail[i]][a.trail[i + 1]] += contribution;
+            }
+            trails[a.trail[numberOfCities - 1]][a.trail[0]] += contribution;
+        }
+    }
+
+    /**
+     * Update the best solution
+     */
+    private void updateBest() {
+        if (bestTourOrder == null) {
+            bestTourOrder = ants.get(0).trail;
+            bestTourLength = ants.get(0)
+                .trailLength(graph);
+        }
+        for (Ant a : ants) {
+            if (a.trailLength(graph) < bestTourLength) {
+                bestTourLength = a.trailLength(graph);
+                bestTourOrder = a.trail.clone();
+            }
+        }
+    }
+
+    /**
+     * Clear trails after simulation
+     */
+    private void clearTrails() {
+        IntStream.range(0, numberOfCities)
+            .forEach(i -> {
+                IntStream.range(0, numberOfCities)
+                    .forEach(j -> trails[i][j] = c);
+            });
+    }
+
+}

algorithms/src/main/java/com/baeldung/algorithms/ga/dijkstra/Dijkstra.java

@@ -1,57 +1,57 @@
-package com.baeldung.algorithms.dijkstra;
-
-import java.util.HashSet;
-import java.util.LinkedList;
-import java.util.Map.Entry;
-import java.util.Set;
-
-public class Dijkstra {
-
-    public static Graph calculateShortestPathFromSource(Graph graph, Node source) {
-
-        source.setDistance(0);
-
-        Set<Node> settledNodes = new HashSet<>();
-        Set<Node> unsettledNodes = new HashSet<>();
-        unsettledNodes.add(source);
-
-        while (unsettledNodes.size() != 0) {
-            Node currentNode = getLowestDistanceNode(unsettledNodes);
-            unsettledNodes.remove(currentNode);
-            for (Entry<Node, Integer> adjacencyPair : currentNode.getAdjacentNodes().entrySet()) {
-                Node adjacentNode = adjacencyPair.getKey();
-                Integer edgeWeigh = adjacencyPair.getValue();
-
-                if (!settledNodes.contains(adjacentNode)) {
-                    CalculateMinimumDistance(adjacentNode, edgeWeigh, currentNode);
-                    unsettledNodes.add(adjacentNode);
-                }
-            }
-            settledNodes.add(currentNode);
-        }
-        return graph;
-    }
-
-    private static void CalculateMinimumDistance(Node evaluationNode, Integer edgeWeigh, Node sourceNode) {
-        Integer sourceDistance = sourceNode.getDistance();
-        if (sourceDistance + edgeWeigh < evaluationNode.getDistance()) {
-            evaluationNode.setDistance(sourceDistance + edgeWeigh);
-            LinkedList<Node> shortestPath = new LinkedList<>(sourceNode.getShortestPath());
-            shortestPath.add(sourceNode);
-            evaluationNode.setShortestPath(shortestPath);
-        }
-    }
-
-    private static Node getLowestDistanceNode(Set<Node> unsettledNodes) {
-        Node lowestDistanceNode = null;
-        int lowestDistance = Integer.MAX_VALUE;
-        for (Node node : unsettledNodes) {
-            int nodeDistance = node.getDistance();
-            if (nodeDistance < lowestDistance) {
-                lowestDistance = nodeDistance;
-                lowestDistanceNode = node;
-            }
-        }
-        return lowestDistanceNode;
-    }
-}
+package com.baeldung.algorithms.ga.dijkstra;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class Dijkstra {
+
+    public static Graph calculateShortestPathFromSource(Graph graph, Node source) {
+
+        source.setDistance(0);
+
+        Set<Node> settledNodes = new HashSet<>();
+        Set<Node> unsettledNodes = new HashSet<>();
+        unsettledNodes.add(source);
+
+        while (unsettledNodes.size() != 0) {
+            Node currentNode = getLowestDistanceNode(unsettledNodes);
+            unsettledNodes.remove(currentNode);
+            for (Entry<Node, Integer> adjacencyPair : currentNode.getAdjacentNodes().entrySet()) {
+                Node adjacentNode = adjacencyPair.getKey();
+                Integer edgeWeigh = adjacencyPair.getValue();
+
+                if (!settledNodes.contains(adjacentNode)) {
+                    CalculateMinimumDistance(adjacentNode, edgeWeigh, currentNode);
+                    unsettledNodes.add(adjacentNode);
+                }
+            }
+            settledNodes.add(currentNode);
+        }
+        return graph;
+    }
+
+    private static void CalculateMinimumDistance(Node evaluationNode, Integer edgeWeigh, Node sourceNode) {
+        Integer sourceDistance = sourceNode.getDistance();
+        if (sourceDistance + edgeWeigh < evaluationNode.getDistance()) {
+            evaluationNode.setDistance(sourceDistance + edgeWeigh);
+            LinkedList<Node> shortestPath = new LinkedList<>(sourceNode.getShortestPath());
+            shortestPath.add(sourceNode);
+            evaluationNode.setShortestPath(shortestPath);
+        }
+    }
+
+    private static Node getLowestDistanceNode(Set<Node> unsettledNodes) {
+        Node lowestDistanceNode = null;
+        int lowestDistance = Integer.MAX_VALUE;
+        for (Node node : unsettledNodes) {
+            int nodeDistance = node.getDistance();
+            if (nodeDistance < lowestDistance) {
+                lowestDistance = nodeDistance;
+                lowestDistanceNode = node;
+            }
+        }
+        return lowestDistanceNode;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/ga/dijkstra/Graph.java

@@ -1,21 +1,21 @@
-package com.baeldung.algorithms.dijkstra;
-
-import java.util.HashSet;
-import java.util.Set;
-
-public class Graph {
-
-    private Set<Node> nodes = new HashSet<>();
-
-    public void addNode(Node nodeA) {
-        nodes.add(nodeA);
-    }
-
-    public Set<Node> getNodes() {
-        return nodes;
-    }
-
-    public void setNodes(Set<Node> nodes) {
-        this.nodes = nodes;
-    }
-}
+package com.baeldung.algorithms.ga.dijkstra;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class Graph {
+
+    private Set<Node> nodes = new HashSet<>();
+
+    public void addNode(Node nodeA) {
+        nodes.add(nodeA);
+    }
+
+    public Set<Node> getNodes() {
+        return nodes;
+    }
+
+    public void setNodes(Set<Node> nodes) {
+        this.nodes = nodes;
+    }
+}

algorithms/src/main/java/com/baeldung/algorithms/ga/dijkstra/Node.java

@@ -1,58 +1,58 @@
-package com.baeldung.algorithms.dijkstra;
-
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.List;
-import java.util.Map;
-
-public class Node {
-
-    private String name;
-
-    private LinkedList<Node> shortestPath = new LinkedList<>();
-
-    private Integer distance = Integer.MAX_VALUE;
-
-    private Map<Node, Integer> adjacentNodes = new HashMap<>();
-
-    public Node(String name) {
-        this.name = name;
-    }
-
-    public void addDestination(Node destination, int distance) {
-        adjacentNodes.put(destination, distance);
-    }
-
-    public String getName() {
-        return name;
-    }
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    public Map<Node, Integer> getAdjacentNodes() {
-        return adjacentNodes;
-    }
-
-    public void setAdjacentNodes(Map<Node, Integer> adjacentNodes) {
-        this.adjacentNodes = adjacentNodes;
-    }
-
-    public Integer getDistance() {
-        return distance;
-    }
-
-    public void setDistance(Integer distance) {
-        this.distance = distance;
-    }
-
-    public List<Node> getShortestPath() {
-        return shortestPath;
-    }
-
-    public void setShortestPath(LinkedList<Node> shortestPath) {
-        this.shortestPath = shortestPath;
-    }
-
-}
+package com.baeldung.algorithms.ga.dijkstra;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+public class Node {
+
+    private String name;
+
+    private LinkedList<Node> shortestPath = new LinkedList<>();
+
+    private Integer distance = Integer.MAX_VALUE;
+
+    private Map<Node, Integer> adjacentNodes = new HashMap<>();
+
+    public Node(String name) {
+        this.name = name;
+    }
+
+    public void addDestination(Node destination, int distance) {
+        adjacentNodes.put(destination, distance);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public Map<Node, Integer> getAdjacentNodes() {
+        return adjacentNodes;
+    }
+
+    public void setAdjacentNodes(Map<Node, Integer> adjacentNodes) {
+        this.adjacentNodes = adjacentNodes;
+    }
+
+    public Integer getDistance() {
+        return distance;
+    }
+
+    public void setDistance(Integer distance) {
+        this.distance = distance;
+    }
+
+    public List<Node> getShortestPath() {
+        return shortestPath;
+    }
+
+    public void setShortestPath(LinkedList<Node> shortestPath) {
+        this.shortestPath = shortestPath;
+    }
+
+}

algorithms/src/main/java/com/baeldung/automata/FiniteStateMachine.java

@@ -0,0 +1,20 @@
+package com.baeldung.automata;
+
+/**
+ * Finite state machine.
+ */
+public interface FiniteStateMachine {
+
+    /**
+     * Follow a transition, switch the state of the machine.
+     * @param c Char.
+     * @return A new finite state machine with the new state.
+     */
+    FiniteStateMachine switchState(final CharSequence c);
+
+    /**
+     * Is the current state a final one?
+     * @return true or false.
+     */
+    boolean canStop();
+}

algorithms/src/main/java/com/baeldung/automata/RtFiniteStateMachine.java

@@ -0,0 +1,30 @@
+package com.baeldung.automata;
+
+/**
+ * Default implementation of a finite state machine.
+ * This class is immutable and thread-safe.
+ */
+public final class RtFiniteStateMachine implements FiniteStateMachine {
+
+    /**
+     * Current state.
+     */
+    private State current;
+
+    /**
+     * Ctor.
+     * @param initial Initial state of this machine.
+     */
+    public RtFiniteStateMachine(final State initial) {
+        this.current = initial;
+    }
+
+    public FiniteStateMachine switchState(final CharSequence c) {
+        return new RtFiniteStateMachine(this.current.transit(c));
+    }
+
+    public boolean canStop() {
+        return this.current.isFinal();
+    }
+
+}

algorithms/src/main/java/com/baeldung/automata/RtState.java

@@ -0,0 +1,42 @@
+package com.baeldung.automata;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * State in a finite state machine.
+ */
+public final class RtState implements State {
+
+    private List<Transition> transitions;
+    private boolean isFinal;
+
+    public RtState() {
+        this(false);
+    }
+    
+    public RtState(final boolean isFinal) {
+        this.transitions = new ArrayList<>();
+        this.isFinal = isFinal;
+    }
+
+    public State transit(final CharSequence c) {
+        for(final Transition t : this.transitions) {
+            if(t.isPossible(c)) {
+                return t.state();
+            }
+        }
+        throw new IllegalArgumentException("Input not accepted: " + c);
+    }
+
+    public boolean isFinal() {
+        return this.isFinal;
+    }
+
+    @Override
+    public State with(Transition tr) {
+        this.transitions.add(tr);
+        return this;
+    }
+
+}

algorithms/src/main/java/com/baeldung/automata/RtTransition.java

@@ -0,0 +1,31 @@
+package com.baeldung.automata;
+
+
+/**
+ * Transition in finite state machine.
+ */
+public final class RtTransition implements Transition {
+
+    private String rule;
+    private State next;
+    
+    /**
+     * Ctor.
+     * @param rule Rule that a character has to meet 
+     *  in order to get to the next state.  
+     * @param next Next state.
+     */
+    public RtTransition (String rule, State next) {
+        this.rule = rule;
+        this.next = next;
+    }
+    
+    public State state() {
+        return this.next;
+    }
+
+    public boolean isPossible(CharSequence c) {
+        return this.rule.equalsIgnoreCase(String.valueOf(c));
+    }
+
+}

algorithms/src/main/java/com/baeldung/automata/State.java

@@ -0,0 +1,29 @@
+package com.baeldung.automata;
+
+/**
+ * State. Part of a finite state machine.
+ */
+public interface State {
+
+    /**
+     * Add a Transition to this state.
+     * @param tr Given transition.
+     * @return Modified State.
+     */
+    State with(final Transition tr);
+
+    /**
+     * Follow one of the transitions, to get 
+     * to the next state.
+     * @param c Character.
+     * @return State.
+     * @throws IllegalStateException if the char is not accepted.
+     */
+    State transit(final CharSequence c);
+    
+    /**
+     * Can the automaton stop on this state?
+     * @return true or false
+     */
+    boolean isFinal();
+}

algorithms/src/main/java/com/baeldung/automata/Transition.java

@@ -0,0 +1,20 @@
+package com.baeldung.automata;
+
+/**
+ * Transition in a finite State machine.
+ */
+public interface Transition {
+
+    /**
+     * Is the transition possible with the given character?
+     * @param c char.
+     * @return true or false.
+     */
+    boolean isPossible(final CharSequence c);
+
+    /**
+     * The state to which this transition leads.
+     * @return State.
+     */
+    State state();
+}

algorithms/src/test/java/algorithms/AntColonyOptimizationTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.algorithms;
+package algorithms;
 
 import org.junit.Assert;
 import org.junit.Test;

algorithms/src/test/java/algorithms/BinaryGeneticAlgorithmUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.algorithms;
+package algorithms;
 
 import org.junit.Assert;
 import org.junit.Test;