Update javaxval/src/test/java/org/baeldung/javaxval/messageinterpolator/ParameterMessageInterpolaterIntegrationTest.java

update to use the givenX_whenY_thenZ naming convention for tests

Co-Authored-By: KevinGilmore <[email protected]>

.gitignore

@@ -0,0 +1,87 @@
+*/bin/*
+bin/
+
+*.class
+
+# Package Files #
+*.jar
+*.war
+*.ear
+
+
+# Eclipse
+.settings/
+*.project
+*.classpath
+.prefs
+*.prefs
+.metadata/
+
+# Intellij
+.idea/
+*.iml
+*.iws
+out/
+
+# VSCode
+.vscode/
+
+# Mac
+.DS_Store
+
+# Maven
+log/*
+target/
+
+# Gradle
+.gradle/
+
+spring-openid/src/main/resources/application.properties
+.recommenders/
+/spring-hibernate4/nbproject/
+spring-security-openid/src/main/resources/application.properties
+
+spring-all/*.log
+
+SpringDataInjectionDemo/.mvn/wrapper/maven-wrapper.properties
+
+spring-call-getters-using-reflection/.mvn/wrapper/maven-wrapper.properties
+
+spring-check-if-a-property-is-null/.mvn/wrapper/maven-wrapper.properties
+*.springBeans
+
+20171220-JMeter.csv
+
+.factorypath
+dependency-reduced-pom.xml
+*.so
+*.dylib
+*.dll
+
+xml/src/test/resources/example_dom4j_new.xml
+xml/src/test/resources/example_dom4j_updated.xml
+xml/src/test/resources/example_jaxb_new.xml
+core-java-io/hard_link.txt
+core-java-io/target_link.txt
+core-java/src/main/java/com/baeldung/manifest/MANIFEST.MF
+ethereum/logs/
+jmeter/src/main/resources/*-JMeter.csv
+
+**/node_modules/
+**/dist
+**/tmp
+**/out-tsc
+**/nbproject/
+**/nb-configuration.xml
+core-scala/.cache-main
+core-scala/.cache-tests
+
+
+persistence-modules/hibernate5/transaction.log
+apache-avro/src/main/java/com/baeldung/avro/model/
+jta/transaction-logs/
+software-security/sql-injection-samples/derby.log
+spring-soap/src/main/java/com/baeldung/springsoap/gen/
+/report-*.json
+transaction.log
+*-shell.log

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Eugen Paraschiv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,54 @@
+
+The Courses
+==============================
+
+
+Here's the new "Learn Spring" course: <br/>
+**[>> LEARN SPRING - THE MASTER CLASS](https://www.baeldung.com/learn-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=ls#master-class)**
+
+Here's the Master Class of "REST With Spring" (along with the new announced Boot 2 material): <br/>
+**[>> THE REST WITH SPRING - MASTER CLASS](https://www.baeldung.com/rest-with-spring-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=rws#master-class)**
+
+And here's the Master Class of "Learn Spring Security": <br/>
+**[>> LEARN SPRING SECURITY - MASTER CLASS](https://www.baeldung.com/learn-spring-security-course?utm_source=github&utm_medium=social&utm_content=tutorials&utm_campaign=lss#master-class)**
+
+
+
+Java and Spring Tutorials
+================
+
+This project is **a collection of small and focused tutorials** - each covering a single and well defined area of development in the Java ecosystem. 
+A strong focus of these is, of course, the Spring Framework - Spring, Spring Boot and Spring Security. 
+In additional to Spring, the modules here are covering a number of aspects in Java. 
+
+
+Building the project
+====================
+To do the full build, do: `mvn clean install`
+
+
+Building a single module
+====================
+To build a specific module run the command: `mvn clean install` in the module directory
+
+
+Running a Spring Boot module
+====================
+To run a Spring Boot module run the command: `mvn spring-boot:run` in the module directory
+
+
+Working with the IDE
+====================
+This repo contains a large number of modules. 
+When you're working with an individual module, there's no need to import all of them (or build all of them) - you can simply import that particular module in either Eclipse or IntelliJ. 
+
+
+Running Tests
+=============
+The command `mvn clean install` will run the unit tests in a module.
+To run the integration tests, use the command `mvn clean install -Pintegration-lite-first`
+
+
+
+
+

akka-http/README.md

@@ -0,0 +1,7 @@
+## Akka HTTP
+
+This module contains articles about Akka HTTP. 
+
+### Relevant articles:
+
+- [Introduction to Akka HTTP](https://www.baeldung.com/akka-http)

akka-http/pom.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0"?>
+<project
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"
+	xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>akka-http</artifactId>
+	<name>akka-http</name>
+
+	<parent>
+		<artifactId>parent-modules</artifactId>
+		<groupId>com.baeldung</groupId>
+		<version>1.0.0-SNAPSHOT</version>
+	</parent>
+
+	<dependencies>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-stream_2.12</artifactId>
+			<version>${akka.stream.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-jackson_2.12</artifactId>
+			<version>${akka.http.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.typesafe.akka</groupId>
+			<artifactId>akka-http-testkit_2.12</artifactId>
+			<version>${akka.http.version}</version>
+			<scope>test</scope>
+		</dependency>
+	</dependencies>
+
+	<properties>
+		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
+		<akka.http.version>10.0.11</akka.http.version>
+		<akka.stream.version>2.5.11</akka.stream.version>
+	</properties>
+</project>

akka-http/src/main/java/com/baeldung/akkahttp/User.java

@@ -0,0 +1,26 @@
+package com.baeldung.akkahttp;
+
+public class User {
+
+    private final Long id;
+
+    private final String name;
+
+    public User() {
+        this.name = "";
+        this.id = null;
+    }
+
+    public User(Long id, String name) {
+        this.name = name;
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Long getId() {
+        return id;
+    }
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserActor.java

@@ -0,0 +1,41 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.AbstractActor;
+import akka.actor.Props;
+import akka.japi.pf.FI;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+
+
+class UserActor extends AbstractActor {
+
+  private UserService userService = new UserService();
+
+  static Props props() {
+    return Props.create(UserActor.class);
+  }
+
+  @Override
+  public Receive createReceive() {
+    return receiveBuilder()
+            .match(CreateUserMessage.class, handleCreateUser())
+            .match(GetUserMessage.class, handleGetUser())
+            .build();
+  }
+
+  private FI.UnitApply<CreateUserMessage> handleCreateUser() {
+    return createUserMessageMessage -> {
+      userService.createUser(createUserMessageMessage.getUser());
+      sender().tell(new ActionPerformed(String.format("User %s created.", createUserMessageMessage.getUser()
+              .getName())), getSelf());
+    };
+  }
+
+  private FI.UnitApply<GetUserMessage> handleGetUser() {
+    return getUserMessageMessage -> {
+      sender().tell(userService.getUser(getUserMessageMessage.getUserId()), getSelf());
+    };
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserMessages.java

@@ -0,0 +1,49 @@
+package com.baeldung.akkahttp;
+
+import java.io.Serializable;
+
+public interface UserMessages {
+
+  class ActionPerformed implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    private final String description;
+
+    public ActionPerformed(String description) {
+      this.description = description;
+    }
+
+    public String getDescription() {
+      return description;
+    }
+  }
+
+  class CreateUserMessage implements Serializable {
+
+    private static final long serialVersionUID = 1L;
+    private final User user;
+
+    public CreateUserMessage(User user) {
+      this.user = user;
+    }
+
+    public User getUser() {
+      return user;
+    }
+  }
+
+  class GetUserMessage implements Serializable {
+    private static final long serialVersionUID = 1L;
+    private final Long userId;
+
+    public GetUserMessage(Long userId) {
+      this.userId = userId;
+    }
+
+    public Long getUserId() {
+      return userId;
+    }
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserServer.java

@@ -0,0 +1,70 @@
+package com.baeldung.akkahttp;
+
+import java.util.Optional;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.TimeUnit;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.marshallers.jackson.Jackson;
+import akka.http.javadsl.model.StatusCodes;
+import akka.http.javadsl.server.HttpApp;
+import akka.http.javadsl.server.Route;
+import akka.pattern.PatternsCS;
+import akka.util.Timeout;
+import com.baeldung.akkahttp.UserMessages.ActionPerformed;
+import com.baeldung.akkahttp.UserMessages.CreateUserMessage;
+import com.baeldung.akkahttp.UserMessages.GetUserMessage;
+import scala.concurrent.duration.Duration;
+import static akka.http.javadsl.server.PathMatchers.*;
+
+class UserServer extends HttpApp {
+
+  private final ActorRef userActor;
+
+  Timeout timeout = new Timeout(Duration.create(5, TimeUnit.SECONDS));
+
+  UserServer(ActorRef userActor) {
+    this.userActor = userActor;
+  }
+
+  @Override
+  public Route routes() {
+    return path("users", this::postUser)
+            .orElse(path(segment("users").slash(longSegment()), id ->
+                    route(getUser(id))));
+  }
+
+  private Route getUser(Long id) {
+    return get(() -> {
+      CompletionStage<Optional<User>> user = PatternsCS.ask(userActor, new GetUserMessage(id), timeout)
+              .thenApply(obj -> (Optional<User>) obj);
+
+      return onSuccess(() -> user, performed -> {
+        if (performed.isPresent())
+          return complete(StatusCodes.OK, performed.get(), Jackson.marshaller());
+        else
+          return complete(StatusCodes.NOT_FOUND);
+      });
+    });
+  }
+
+  private Route postUser() {
+    return route(post(() -> entity(Jackson.unmarshaller(User.class), user -> {
+      CompletionStage<ActionPerformed> userCreated = PatternsCS.ask(userActor, new CreateUserMessage(user), timeout)
+              .thenApply(obj -> (ActionPerformed) obj);
+
+      return onSuccess(() -> userCreated, performed -> {
+        return complete(StatusCodes.CREATED, performed, Jackson.marshaller());
+      });
+    })));
+  }
+
+  public static void main(String[] args) throws Exception {
+    ActorSystem system = ActorSystem.create("userServer");
+    ActorRef userActor = system.actorOf(UserActor.props(), "userActor");
+    UserServer server = new UserServer(userActor);
+    server.startServer("localhost", 8080, system);
+  }
+
+}

akka-http/src/main/java/com/baeldung/akkahttp/UserService.java

@@ -0,0 +1,35 @@
+package com.baeldung.akkahttp;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class UserService {
+
+  private final static List<User> users = new ArrayList<>();
+
+  static {
+    users.add(new User(1l, "Alice"));
+    users.add(new User(2l, "Bob"));
+    users.add(new User(3l, "Chris"));
+    users.add(new User(4l, "Dick"));
+    users.add(new User(5l, "Eve"));
+    users.add(new User(6l, "Finn"));
+  }
+
+  public Optional<User> getUser(Long id) {
+    return users.stream()
+            .filter(user -> user.getId()
+                    .equals(id))
+            .findFirst();
+  }
+
+  public void createUser(User user) {
+    users.add(user);
+  }
+
+  public List<User> getUsers(){
+    return users;
+  }
+
+}

akka-http/src/test/java/com/baeldung/akkahttp/UserServerUnitTest.java

@@ -0,0 +1,50 @@
+package com.baeldung.akkahttp;
+
+import akka.actor.ActorRef;
+import akka.actor.ActorSystem;
+import akka.http.javadsl.model.ContentTypes;
+import akka.http.javadsl.model.HttpEntities;
+import akka.http.javadsl.model.HttpRequest;
+import akka.http.javadsl.testkit.JUnitRouteTest;
+import akka.http.javadsl.testkit.TestRoute;
+import org.junit.Test;
+
+public class UserServerUnitTest extends JUnitRouteTest {
+
+  ActorSystem system = ActorSystem.create("helloAkkaHttpServer");
+
+  ActorRef userActorRef = system.actorOf(UserActor.props(), "userActor");
+
+  TestRoute appRoute = testRoute(new UserServer(userActorRef).routes());
+
+  @Test
+  public void whenRequest_thenActorResponds() {
+
+    appRoute.run(HttpRequest.GET("/users/1"))
+            .assertEntity(alice())
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.GET("/users/42"))
+            .assertStatusCode(404);
+
+    appRoute.run(HttpRequest.DELETE("/users/1"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.DELETE("/users/42"))
+            .assertStatusCode(200);
+
+    appRoute.run(HttpRequest.POST("/users")
+            .withEntity(HttpEntities.create(ContentTypes.APPLICATION_JSON, zaphod())))
+            .assertStatusCode(201);
+
+  }
+
+  private String alice() {
+    return "{\"id\":1,\"name\":\"Alice\"}";
+  }
+
+  private String zaphod() {
+    return "{\"id\":42,\"name\":\"Zaphod\"}";
+  }
+
+}

akka-streams/README.md

@@ -0,0 +1,7 @@
+## Akka Streams
+
+This module contains articles about Akka Streams. 
+
+### Relevant articles
+
+- [Guide to Akka Streams](https://www.baeldung.com/akka-streams)

akka-streams/pom.xml

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>akka-streams</artifactId>
+    <name>akka-streams</name>
+
+    <parent>
+        <artifactId>parent-modules</artifactId>
+        <groupId>com.baeldung</groupId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>com.typesafe.akka</groupId>
+            <artifactId>akka-stream_${scala.version}</artifactId>
+            <version>${akkastreams.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.typesafe.akka</groupId>
+            <artifactId>akka-stream-testkit_${scala.version}</artifactId>
+            <version>${akkastreams.version}</version>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <akkastreams.version>2.5.2</akkastreams.version>
+        <scala.version>2.11</scala.version>
+    </properties>
+
+</project>

akka-streams/src/main/java/com/baeldung/akkastreams/AverageRepository.java

@@ -0,0 +1,14 @@
+package com.baeldung.akkastreams;
+
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+
+public class AverageRepository {
+    CompletionStage<Double> save(Double average) {
+        return CompletableFuture.supplyAsync(() -> {
+            System.out.println("saving average: " + average);
+            return average;
+        });
+    }
+}

akka-streams/src/main/java/com/baeldung/akkastreams/DataImporter.java

@@ -0,0 +1,74 @@
+package com.baeldung.akkastreams;
+
+
+import akka.Done;
+import akka.NotUsed;
+import akka.actor.ActorSystem;
+import akka.stream.ActorMaterializer;
+import akka.stream.javadsl.Flow;
+import akka.stream.javadsl.Keep;
+import akka.stream.javadsl.Sink;
+import akka.stream.javadsl.Source;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.stream.Collectors;
+
+public class DataImporter {
+    private final ActorSystem actorSystem;
+    private final AverageRepository averageRepository = new AverageRepository();
+
+    public DataImporter(ActorSystem actorSystem) {
+        this.actorSystem = actorSystem;
+
+    }
+
+    private List<Integer> parseLine(String line) {
+        String[] fields = line.split(";");
+        return Arrays.stream(fields)
+                .map(Integer::parseInt)
+                .collect(Collectors.toList());
+    }
+
+    private Flow<String, Integer, NotUsed> parseContent() {
+        return Flow.of(String.class).mapConcat(this::parseLine);
+    }
+
+    private Flow<Integer, Double, NotUsed> computeAverage() {
+        return Flow.of(Integer.class).grouped(2).mapAsyncUnordered(8, integers ->
+                CompletableFuture.supplyAsync(() -> integers
+                        .stream()
+                        .mapToDouble(v -> v)
+                        .average()
+                        .orElse(-1.0)));
+    }
+
+    Flow<String, Double, NotUsed> calculateAverage() {
+        return Flow.of(String.class)
+                .via(parseContent())
+                .via(computeAverage());
+    }
+
+    private Sink<Double, CompletionStage<Done>> storeAverages() {
+        return Flow.of(Double.class)
+                .mapAsyncUnordered(4, averageRepository::save)
+                .toMat(Sink.ignore(), Keep.right());
+    }
+
+
+    CompletionStage<Done> calculateAverageForContent(String content) {
+        return Source.single(content)
+                .via(calculateAverage())
+                .runWith(storeAverages(), ActorMaterializer.create(actorSystem))
+                .whenComplete((d, e) -> {
+                    if (d != null) {
+                        System.out.println("Import finished ");
+                    } else {
+                        e.printStackTrace();
+                    }
+                });
+    }
+
+}

akka-streams/src/main/resources/logback.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<configuration>
+    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
+        <encoder>
+            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
+            </pattern>
+        </encoder>
+    </appender>
+
+    <root level="INFO">
+        <appender-ref ref="STDOUT" />
+    </root>
+</configuration>

akka-streams/src/test/java/com/baeldung/akkastreams/DataImporterUnitTest.java

@@ -0,0 +1,43 @@
+package com.baeldung.akkastreams;
+
+import akka.NotUsed;
+import akka.actor.ActorSystem;
+import akka.stream.ActorMaterializer;
+import akka.stream.javadsl.Flow;
+import akka.stream.javadsl.Source;
+import akka.stream.testkit.javadsl.TestSink;
+import org.junit.Test;
+
+
+public class DataImporterUnitTest {
+    private final ActorSystem actorSystem = ActorSystem.create();
+
+    @Test
+    public void givenStreamOfIntegers_whenCalculateAverageOfPairs_thenShouldReturnProperResults() {
+        //given
+        Flow<String, Double, NotUsed> tested = new DataImporter(actorSystem).calculateAverage();
+        String input = "1;9;11;0";
+
+        //when
+        Source<Double, NotUsed> flow = Source.single(input).via(tested);
+
+        //then
+        flow
+                .runWith(TestSink.probe(actorSystem), ActorMaterializer.create(actorSystem))
+                .request(4)
+                .expectNextUnordered(5d, 5.5);
+    }
+
+    @Test
+    public void givenStreamOfIntegers_whenCalculateAverageAndSaveToSink_thenShouldFinishSuccessfully() {
+        //given
+        DataImporter dataImporter = new DataImporter(actorSystem);
+        String input = "10;90;110;10";
+
+        //when
+        dataImporter.calculateAverageForContent(input)
+                .thenAccept(d -> actorSystem.terminate());
+
+    }
+
+}

algorithms-genetic/.gitignore

@@ -0,0 +1,4 @@
+/target/
+.settings/
+.classpath
+.project

algorithms-genetic/README.md

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

algorithms-genetic/pom.xml

@@ -0,0 +1,64 @@
+<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>algorithms-genetic</artifactId>
+    <version>0.0.1-SNAPSHOT</version>
+    <name>algorithms-genetic</name>
+    
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-modules</artifactId>
+        <version>1.0.0-SNAPSHOT</version>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-math3</artifactId>
+            <version>${commons-math3.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>commons-codec</groupId>
+            <artifactId>commons-codec</artifactId>
+            <version>${commons-codec.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.jenetics</groupId>
+            <artifactId>jenetics</artifactId>
+            <version>${io.jenetics.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${org.assertj.core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.codehaus.mojo</groupId>
+                    <artifactId>exec-maven-plugin</artifactId>
+                    <version>${exec-maven-plugin.version}</version>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+
+    <properties>
+        <commons-math3.version>3.6.1</commons-math3.version>
+        <io.jenetics.version>3.7.0</io.jenetics.version>
+        <org.assertj.core.version>3.9.0</org.assertj.core.version>
+        <commons-codec.version>1.11</commons-codec.version>
+    </properties>
+
+    
+</project>

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

@@ -0,0 +1,38 @@
+package com.baeldung.algorithms;
+
+import java.util.Scanner;
+
+import com.baeldung.algorithms.ga.annealing.SimulatedAnnealing;
+import com.baeldung.algorithms.ga.ant_colony.AntColonyOptimization;
+import com.baeldung.algorithms.ga.binary.SimpleGeneticAlgorithm;
+
+public class RunAlgorithm {
+
+	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 - Simple Genetic Algorithm");
+		System.out.println("3 - Ant Colony");
+		int decision = in.nextInt();
+		switch (decision) {
+		case 1:
+			System.out.println(
+					"Optimized distance for travel: " + SimulatedAnnealing.simulateAnnealing(10, 10000, 0.9995));
+			break;
+		case 2:
+			SimpleGeneticAlgorithm ga = new SimpleGeneticAlgorithm();
+			ga.runAlgorithm(50, "1011000100000100010000100000100111001000000100000100000000001111");
+			break;
+		case 3:
+			AntColonyOptimization antColony = new AntColonyOptimization(21);
+			antColony.startAntOptimization();
+			break;
+		default:
+			System.out.println("Unknown option");
+			break;
+		}
+		in.close();
+	}
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/annealing/City.java

@@ -0,0 +1,22 @@
+package com.baeldung.algorithms.ga.annealing;
+
+import lombok.Data;
+
+@Data
+public class City {
+
+    private int x;
+    private int y;
+
+    public City() {
+        this.x = (int) (Math.random() * 500);
+        this.y = (int) (Math.random() * 500);
+    }
+
+    public double distanceToCity(City city) {
+        int x = Math.abs(getX() - city.getX());
+        int y = Math.abs(getY() - city.getY());
+        return Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));
+    }
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/annealing/SimulatedAnnealing.java

@@ -0,0 +1,36 @@
+package com.baeldung.algorithms.ga.annealing;
+
+public class SimulatedAnnealing {
+
+    private static Travel travel = new Travel(10);
+
+    public static double simulateAnnealing(double startingTemperature, int numberOfIterations, double coolingRate) {
+        System.out.println("Starting SA with temperature: " + startingTemperature + ", # of iterations: " + numberOfIterations + " and colling rate: " + coolingRate);
+        double t = startingTemperature;
+        travel.generateInitialTravel();
+        double bestDistance = travel.getDistance();
+        System.out.println("Initial distance of travel: " + bestDistance);
+        Travel bestSolution = travel;
+        Travel currentSolution = bestSolution;
+
+        for (int i = 0; i < numberOfIterations; i++) {
+            if (t > 0.1) {
+                currentSolution.swapCities();
+                double currentDistance = currentSolution.getDistance();
+                if (currentDistance < bestDistance) {
+                    bestDistance = currentDistance;
+                } else if (Math.exp((bestDistance - currentDistance) / t) < Math.random()) {
+                    currentSolution.revertSwap();
+                }
+                t *= coolingRate;
+            } else {
+                continue;
+            }
+            if (i % 100 == 0) {
+                System.out.println("Iteration #" + i);
+            }
+        }
+        return bestDistance;
+    }
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/annealing/Travel.java

@@ -0,0 +1,63 @@
+package com.baeldung.algorithms.ga.annealing;
+
+import java.util.ArrayList;
+import java.util.Collections;
+
+import lombok.Data;
+
+@Data
+public class Travel {
+
+    private ArrayList<City> travel = new ArrayList<>();
+    private ArrayList<City> previousTravel = new ArrayList<>();
+
+    public Travel(int numberOfCities) {
+        for (int i = 0; i < numberOfCities; i++) {
+            travel.add(new City());
+        }
+    }
+
+    public void generateInitialTravel() {
+        if (travel.isEmpty())
+            new Travel(10);
+        Collections.shuffle(travel);
+    }
+
+    public void swapCities() {
+        int a = generateRandomIndex();
+        int b = generateRandomIndex();
+        previousTravel = travel;
+        City x = travel.get(a);
+        City y = travel.get(b);
+        travel.set(a, y);
+        travel.set(b, x);
+    }
+
+    public void revertSwap() {
+        travel = previousTravel;
+    }
+
+    private int generateRandomIndex() {
+        return (int) (Math.random() * travel.size());
+    }
+
+    public City getCity(int index) {
+        return travel.get(index);
+    }
+
+    public int getDistance() {
+        int distance = 0;
+        for (int index = 0; index < travel.size(); index++) {
+            City starting = getCity(index);
+            City destination;
+            if (index + 1 < travel.size()) {
+                destination = getCity(index + 1);
+            } else {
+                destination = getCity(0);
+            }
+            distance += starting.distanceToCity(destination);
+        }
+        return distance;
+    }
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/ant_colony/Ant.java

@@ -0,0 +1,37 @@
+package com.baeldung.algorithms.ga.ant_colony;
+
+public class Ant {
+
+	protected int trailSize;
+	protected int trail[];
+	protected boolean visited[];
+
+	public Ant(int tourSize) {
+		this.trailSize = tourSize;
+		this.trail = new int[tourSize];
+		this.visited = new boolean[tourSize];
+	}
+
+	protected void visitCity(int currentIndex, int city) {
+		trail[currentIndex + 1] = city;
+		visited[city] = true;
+	}
+
+	protected boolean visited(int i) {
+		return visited[i];
+	}
+
+	protected double trailLength(double graph[][]) {
+		double length = graph[trail[trailSize - 1]][trail[0]];
+		for (int i = 0; i < trailSize - 1; i++) {
+			length += graph[trail[i]][trail[i + 1]];
+		}
+		return length;
+	}
+
+	protected void clear() {
+		for (int i = 0; i < trailSize; i++)
+			visited[i] = false;
+	}
+
+}

algorithms-genetic/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-genetic/src/main/java/com/baeldung/algorithms/ga/binary/Individual.java

@@ -0,0 +1,44 @@
+package com.baeldung.algorithms.ga.binary;
+
+import lombok.Data;
+
+@Data
+public class Individual {
+
+    protected int defaultGeneLength = 64;
+    private byte[] genes = new byte[defaultGeneLength];
+    private int fitness = 0;
+
+    public Individual() {
+        for (int i = 0; i < genes.length; i++) {
+            byte gene = (byte) Math.round(Math.random());
+            genes[i] = gene;
+        }
+    }
+
+    protected byte getSingleGene(int index) {
+        return genes[index];
+    }
+
+    protected void setSingleGene(int index, byte value) {
+        genes[index] = value;
+        fitness = 0;
+    }
+
+    public int getFitness() {
+        if (fitness == 0) {
+            fitness = SimpleGeneticAlgorithm.getFitness(this);
+        }
+        return fitness;
+    }
+
+    @Override
+    public String toString() {
+        String geneString = "";
+        for (int i = 0; i < genes.length; i++) {
+            geneString += getSingleGene(i);
+        }
+        return geneString;
+    }
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/binary/Population.java

@@ -0,0 +1,40 @@
+package com.baeldung.algorithms.ga.binary;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import lombok.Data;
+
+@Data
+public class Population {
+
+    private List<Individual> individuals;
+
+    public Population(int size, boolean createNew) {
+        individuals = new ArrayList<>();
+        if (createNew) {
+            createNewPopulation(size);
+        }
+    }
+
+    protected Individual getIndividual(int index) {
+        return individuals.get(index);
+    }
+
+    protected Individual getFittest() {
+        Individual fittest = individuals.get(0);
+        for (int i = 0; i < individuals.size(); i++) {
+            if (fittest.getFitness() <= getIndividual(i).getFitness()) {
+                fittest = getIndividual(i);
+            }
+        }
+        return fittest;
+    }
+
+    private void createNewPopulation(int size) {
+        for (int i = 0; i < size; i++) {
+            Individual newIndividual = new Individual();
+            individuals.add(i, newIndividual);
+        }
+    }
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/binary/SimpleGeneticAlgorithm.java

@@ -0,0 +1,117 @@
+package com.baeldung.algorithms.ga.binary;
+
+import lombok.Data;
+
+@Data
+public class SimpleGeneticAlgorithm {
+
+    private static final double uniformRate = 0.5;
+    private static final double mutationRate = 0.025;
+    private static final int tournamentSize = 5;
+    private static final boolean elitism = true;
+    private static byte[] solution = new byte[64];
+
+    public boolean runAlgorithm(int populationSize, String solution) {
+        if (solution.length() != SimpleGeneticAlgorithm.solution.length) {
+            throw new RuntimeException("The solution needs to have " + SimpleGeneticAlgorithm.solution.length + " bytes");
+        }
+        setSolution(solution);
+        Population myPop = new Population(populationSize, true);
+
+        int generationCount = 1;
+        while (myPop.getFittest().getFitness() < getMaxFitness()) {
+            System.out.println("Generation: " + generationCount + " Correct genes found: " + myPop.getFittest().getFitness());
+            myPop = evolvePopulation(myPop);
+            generationCount++;
+        }
+        System.out.println("Solution found!");
+        System.out.println("Generation: " + generationCount);
+        System.out.println("Genes: ");
+        System.out.println(myPop.getFittest());
+        return true;
+    }
+
+    public Population evolvePopulation(Population pop) {
+        int elitismOffset;
+        Population newPopulation = new Population(pop.getIndividuals().size(), false);
+
+        if (elitism) {
+            newPopulation.getIndividuals().add(0, pop.getFittest());
+            elitismOffset = 1;
+        } else {
+            elitismOffset = 0;
+        }
+
+        for (int i = elitismOffset; i < pop.getIndividuals().size(); i++) {
+            Individual indiv1 = tournamentSelection(pop);
+            Individual indiv2 = tournamentSelection(pop);
+            Individual newIndiv = crossover(indiv1, indiv2);
+            newPopulation.getIndividuals().add(i, newIndiv);
+        }
+
+        for (int i = elitismOffset; i < newPopulation.getIndividuals().size(); i++) {
+            mutate(newPopulation.getIndividual(i));
+        }
+
+        return newPopulation;
+    }
+
+    private Individual crossover(Individual indiv1, Individual indiv2) {
+        Individual newSol = new Individual();
+        for (int i = 0; i < newSol.getDefaultGeneLength(); i++) {
+            if (Math.random() <= uniformRate) {
+                newSol.setSingleGene(i, indiv1.getSingleGene(i));
+            } else {
+                newSol.setSingleGene(i, indiv2.getSingleGene(i));
+            }
+        }
+        return newSol;
+    }
+
+    private void mutate(Individual indiv) {
+        for (int i = 0; i < indiv.getDefaultGeneLength(); i++) {
+            if (Math.random() <= mutationRate) {
+                byte gene = (byte) Math.round(Math.random());
+                indiv.setSingleGene(i, gene);
+            }
+        }
+    }
+
+    private Individual tournamentSelection(Population pop) {
+        Population tournament = new Population(tournamentSize, false);
+        for (int i = 0; i < tournamentSize; i++) {
+            int randomId = (int) (Math.random() * pop.getIndividuals().size());
+            tournament.getIndividuals().add(i, pop.getIndividual(randomId));
+        }
+        Individual fittest = tournament.getFittest();
+        return fittest;
+    }
+
+    protected static int getFitness(Individual individual) {
+        int fitness = 0;
+        for (int i = 0; i < individual.getDefaultGeneLength() && i < solution.length; i++) {
+            if (individual.getSingleGene(i) == solution[i]) {
+                fitness++;
+            }
+        }
+        return fitness;
+    }
+
+    protected int getMaxFitness() {
+        int maxFitness = solution.length;
+        return maxFitness;
+    }
+
+    protected void setSolution(String newSolution) {
+        solution = new byte[newSolution.length()];
+        for (int i = 0; i < newSolution.length(); i++) {
+            String character = newSolution.substring(i, i + 1);
+            if (character.contains("0") || character.contains("1")) {
+                solution[i] = Byte.parseByte(character);
+            } else {
+                solution[i] = 0;
+            }
+        }
+    }
+
+}

algorithms-genetic/src/main/java/com/baeldung/algorithms/ga/jenetics/Knapsack.java

@@ -0,0 +1,47 @@
+package com.baeldung.algorithms.ga.jenetics;
+
+import static org.jenetics.engine.EvolutionResult.toBestPhenotype;
+import static org.jenetics.engine.limit.bySteadyFitness;
+
+import java.util.stream.Stream;
+
+import org.jenetics.BitChromosome;
+import org.jenetics.BitGene;
+import org.jenetics.Mutator;
+import org.jenetics.Phenotype;
+import org.jenetics.RouletteWheelSelector;
+import org.jenetics.SinglePointCrossover;
+import org.jenetics.TournamentSelector;
+import org.jenetics.engine.Engine;
+import org.jenetics.engine.EvolutionStatistics;
+
+//The main class.
+public class Knapsack {
+
+    public static void main(String[] args) {
+        int nItems = 15;
+        double ksSize = nItems * 100.0 / 3.0;
+
+        KnapsackFF ff = new KnapsackFF(Stream.generate(KnapsackItem::random)
+            .limit(nItems)
+            .toArray(KnapsackItem[]::new), ksSize);
+
+        Engine<BitGene, Double> engine = Engine.builder(ff, BitChromosome.of(nItems, 0.5))
+            .populationSize(500)
+            .survivorsSelector(new TournamentSelector<>(5))
+            .offspringSelector(new RouletteWheelSelector<>())
+            .alterers(new Mutator<>(0.115), new SinglePointCrossover<>(0.16))
+            .build();
+
+        EvolutionStatistics<Double, ?> statistics = EvolutionStatistics.ofNumber();
+
+        Phenotype<BitGene, Double> best = engine.stream()
+            .limit(bySteadyFitness(7))
+            .limit(100)
+            .peek(statistics)
+            .collect(toBestPhenotype());
+
+        System.out.println(statistics);
+        System.out.println(best);
+    }
+}