Merge pull request #2 from eugenp/master

Update from master
2018-02-06 12:49:49 +01:00
parent 68a3585cab 372cba10bb
commit 2ddbff9858
279 changed files with 8767 additions and 943 deletions
@@ -0,0 +1,129 @@
+<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>
+  <groupId>com.baeldung</groupId>
+  <artifactId>activejdbc</artifactId>
+  <version>1.0-SNAPSHOT</version>
+  <packaging>jar</packaging>
+  <name>activejdbc</name>
+  <url>http://maven.apache.org</url>
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <activejdbc.version>1.4.13</activejdbc.version>
+    <environments>development.test,development</environments>
+  </properties>
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.6.0</version>
+        <configuration>
+          <source>1.8</source>
+          <target>1.8</target>
+          <encoding>UTF-8</encoding>
+        </configuration>
+      </plugin>
+      <plugin>
+        <groupId>org.javalite</groupId>
+        <artifactId>activejdbc-instrumentation</artifactId>
+        <version>${activejdbc.version}</version>
+        <executions>
+          <execution>
+            <phase>process-classes</phase>
+            <goals>
+              <goal>instrument</goal>
+            </goals>
+          </execution>
+        </executions>
+      </plugin>
+      <plugin>
+        <groupId>org.javalite</groupId>
+        <artifactId>db-migrator-maven-plugin</artifactId>
+        <version>${activejdbc.version}</version>
+        <configuration>
+          <configFile>${project.basedir}/src/main/resources/database.properties</configFile>
+          <environments>${environments}</environments>
+        </configuration>
+        <dependencies>
+          <dependency>
+            <groupId>mysql</groupId>
+            <artifactId>mysql-connector-java</artifactId>
+            <version>5.1.34</version>
+          </dependency>
+        </dependencies>
+      </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-surefire-plugin</artifactId>
+        <version>2.18.1</version>
+        <configuration>
+          <reportFormat>brief</reportFormat>
+          <trimStackTrace>true</trimStackTrace>
+          <useFile>false</useFile>
+          <includes>
+            <include>**/*Spec*.java</include>
+            <include>**/*Test*.java</include>
+          </includes>
+          <excludes>
+            <exclude>**/helpers/*</exclude>
+            <exclude>**/*$*</exclude>
+          </excludes>
+        </configuration>
+      </plugin>
+    </plugins>
+  </build>
+  <dependencies>
+    <dependency>
+      <groupId>junit</groupId>
+      <artifactId>junit</artifactId>
+      <version>4.12</version>
+      <scope>test</scope>
+    </dependency>
+    <dependency>
+      <groupId>org.javalite</groupId>
+      <artifactId>activejdbc</artifactId>
+      <version>${activejdbc.version}</version>
+      <exclusions>
+        <exclusion>
+          <groupId>opensymphony</groupId>
+          <artifactId>oscache</artifactId>
+        </exclusion>
+      </exclusions>
+    </dependency>
+    <dependency>
+      <groupId>mysql</groupId>
+      <artifactId>mysql-connector-java</artifactId>
+      <version>5.1.34</version>
+    </dependency>
+    <dependency>
+      <groupId>org.slf4j</groupId>
+      <artifactId>slf4j-simple</artifactId>
+      <version>1.7.9</version>
+    </dependency>
+  </dependencies>
+  <repositories>
+    <repository>
+      <id>snapshots1</id>
+      <name>JavaLite Snapshots1</name>
+      <url>http://repo.javalite.io/</url>
+      <snapshots>
+        <enabled>true</enabled>
+        <updatePolicy>always</updatePolicy>
+        <checksumPolicy>warn</checksumPolicy>
+      </snapshots>
+    </repository>
+  </repositories>
+  <pluginRepositories>
+    <pluginRepository>
+      <id>snapshots2</id>
+      <name>JavaLite Snapshots2</name>
+      <url>http://repo.javalite.io/</url>
+      <snapshots>
+        <enabled>true</enabled>
+        <updatePolicy>always</updatePolicy>
+        <checksumPolicy>warn</checksumPolicy>
+      </snapshots>
+    </pluginRepository>
+  </pluginRepositories>
+</project>
@@ -0,0 +1,61 @@
+package com.baeldung;
+
+
+import com.baeldung.model.Employee;
+import com.baeldung.model.Role;
+import org.javalite.activejdbc.Base;
+import org.javalite.activejdbc.LazyList;
+import org.javalite.activejdbc.Model;
+
+public class ActiveJDBCApp
+{
+    public static void main( String[] args )
+    {
+        try {
+            Base.open();
+            ActiveJDBCApp app = new ActiveJDBCApp();
+            app.create();
+            app.update();
+            app.delete();
+            app.deleteCascade();
+        } catch (Exception e) {
+            e.printStackTrace();
+        } finally {
+            Base.close();
+        }
+    }
+
+    protected void create() {
+        Employee employee = new Employee("Hugo","C","M","BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        LazyList<Model> all = Employee.findAll();
+        System.out.println(all.size());
+    }
+
+    protected void update() {
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.set("last_namea","Choi").saveIt();
+        employee = Employee.findFirst("last_name = ?","Choi");
+        System.out.println(employee.getString("first_name") + " " + employee.getString("last_name"));
+    }
+
+    protected void delete() {
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.delete();
+        employee = Employee.findFirst("last_name = ?","Choi");
+        if(null == employee){
+            System.out.println("No such Employee found!");
+        }
+    }
+
+    protected void deleteCascade() {
+        create();
+        Employee employee = Employee.findFirst("first_name = ?","Hugo");
+        employee.deleteCascade();
+        employee = Employee.findFirst("last_name = ?","C");
+        if(null == employee){
+            System.out.println("No such Employee found!");
+        }
+    }
+}
@@ -0,0 +1,19 @@
+package com.baeldung.model;
+
+
+import org.javalite.activejdbc.Model;
+
+public class Employee extends Model {
+
+    public Employee(){
+
+    }
+
+    public Employee(String firstName, String lastName, String gender, String createdBy) {
+        set("first_name1",firstName);
+        set("last_name",lastName);
+        set("gender",gender);
+        set("created_by",createdBy);
+    }
+
+}
@@ -0,0 +1,18 @@
+package com.baeldung.model;
+
+
+import org.javalite.activejdbc.Model;
+import org.javalite.activejdbc.annotations.Table;
+
+@Table("EMP_ROLES")
+public class Role extends Model {
+
+    public Role(){
+
+    }
+
+    public Role(String role,String createdBy){
+        set("role_name",role);
+        set("created_by",createdBy);
+    }
+}
@@ -0,0 +1,25 @@
+# noinspection SqlNoDataSourceInspectionForFile
+
+create table organisation.employees
+(
+	id int not null auto_increment
+		primary key,
+	first_name varchar(100) not null,
+	last_name varchar(100) not null,
+	gender varchar(1) not null,
+	created_at datetime not null,
+	updated_at datetime null,
+	created_by varchar(100) not null,
+	updated_by varchar(100) null
+)ENGINE = InnoDB DEFAULT CHARSET = utf8;
+
+create table organisation.emp_roles
+(
+	id int not null auto_increment primary key,
+	employee_id int not null,
+	role_name varchar(100) not null,
+	created_at datetime not null,
+	updated_at datetime null,
+	created_by varchar(100) not null,
+	updated_by varchar(100) null
+)ENGINE = InnoDB DEFAULT CHARSET = utf8;
@@ -0,0 +1,10 @@
+development.driver=com.mysql.jdbc.Driver
+development.username=root
+development.password=123456
+development.url=jdbc:mysql://localhost/organisation
+
+
+development.test.driver=com.mysql.jdbc.Driver
+development.test.username=root
+development.test.password=123456
+development.test.url=jdbc:mysql://localhost/organisation_test
@@ -0,0 +1,51 @@
+package com.baeldung;
+
+import com.baeldung.model.Employee;
+import com.baeldung.model.Role;
+import org.javalite.activejdbc.test.DBSpec;
+import org.junit.Test;
+
+import java.util.List;
+
+public class ActiveJDBCAppTest extends DBSpec
+{
+    @Test
+    public void ifEmployeeCreated_thenIsValid() {
+        Employee employee = new Employee("B", "N", "M", "BN");
+        the(employee).shouldBe("valid");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_thenShouldPersist() {
+        Employee employee = new Employee("B", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.add(new Role("Lead Java Developer","BN"));
+        a(Role.count()).shouldBeEqual(2);
+        List<Role> roles = employee.getAll(Role.class).orderBy("created_at");
+        the(roles.get(0).getRoleName()).shouldBeEqual("Java Developer");
+        the(roles.get(1).getRoleName()).shouldBeEqual("Lead Java Developer");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_whenNameUpdated_thenShouldShowNewName() {
+        Employee employee = new Employee("Binesh", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.add(new Role("Lead Java Developer","BN"));
+        employee = Employee.findFirst("first_name = ?", "Binesh");
+        employee.set("last_name","Narayanan").saveIt();
+        Employee updated = Employee.findFirst("first_name = ?", "Binesh");
+        the(updated.getLastName()).shouldBeEqual("Narayanan");
+    }
+
+    @Test
+    public void ifEmployeeCreatedWithRoles_whenDeleted_thenShouldNotBeFound() {
+        Employee employee = new Employee("Binesh", "N", "M", "BN");
+        employee.saveIt();
+        employee.add(new Role("Java Developer","BN"));
+        employee.delete();
+        employee = Employee.findFirst("first_name = ?", "Binesh");
+        the(employee).shouldBeNull();
+    }
+}
@@ -0,0 +1,104 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.stream.IntStream;
+
+public class BacktrackingAlgorithm {
+
+    private static final int BOARD_SIZE = 9;
+    private static final int SUBSECTION_SIZE = 3;
+    private static final int BOARD_START_INDEX = 0;
+
+    private static final int NO_VALUE = 0;
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 9;
+
+    private static int[][] board = {
+      {8, 0, 0, 0, 0, 0, 0, 0, 0},
+      {0, 0, 3, 6, 0, 0, 0, 0, 0},
+      {0, 7, 0, 0, 9, 0, 2, 0, 0},
+      {0, 5, 0, 0, 0, 7, 0, 0, 0},
+      {0, 0, 0, 0, 4, 5, 7, 0, 0},
+      {0, 0, 0, 1, 0, 0, 0, 3, 0},
+      {0, 0, 1, 0, 0, 0, 0, 6, 8},
+      {0, 0, 8, 5, 0, 0, 0, 1, 0},
+      {0, 9, 0, 0, 0, 0, 4, 0, 0}
+    };
+
+    public static void main(String[] args) {
+        BacktrackingAlgorithm solver = new BacktrackingAlgorithm();
+        solver.solve(board);
+        solver.printBoard();
+    }
+
+    private void printBoard() {
+        for (int row = BOARD_START_INDEX; row < BOARD_SIZE; row++) {
+            for (int column = BOARD_START_INDEX; column < BOARD_SIZE; column++) {
+                System.out.print(board[row][column] + " ");
+            }
+            System.out.println();
+        }
+    }
+
+    private boolean solve(int[][] board) {
+        for (int r = BOARD_START_INDEX; r < BOARD_SIZE; r++) {
+            for (int c = BOARD_START_INDEX; c < BOARD_SIZE; c++) {
+                if (board[r][c] == NO_VALUE) {
+                    for (int k = MIN_VALUE; k <= MAX_VALUE; k++) {
+                        board[r][c] = k;
+                        if (isValid(board, r, c) && solve(board)) {
+                            return true;
+                        }
+                        board[r][c] = NO_VALUE;
+                    }
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private boolean isValid(int[][] board, int r, int c) {
+        return rowConstraint(board, r) &&
+          columnConstraint(board, c) &&
+          subsectionConstraint(board, r, c);
+    }
+
+    private boolean subsectionConstraint(int[][] board, int r, int c) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        int subsectionRowStart = (r / SUBSECTION_SIZE) * SUBSECTION_SIZE;
+        int subsectionRowEnd = subsectionRowStart + SUBSECTION_SIZE;
+
+        int subsectionColumnStart = (c / SUBSECTION_SIZE) * SUBSECTION_SIZE;
+        int subsectionColumnEnd = subsectionColumnStart + SUBSECTION_SIZE;
+
+        for (int i = subsectionRowStart; i < subsectionRowEnd; i++) {
+            for (int j = subsectionColumnStart; j < subsectionColumnEnd; j++) {
+                if (!checkConstraint(board, i, constraint, j)) return false;
+            }
+        }
+        return true;
+    }
+
+    private boolean columnConstraint(int[][] board, int c) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        return IntStream.range(BOARD_START_INDEX, BOARD_SIZE)
+          .allMatch(i -> checkConstraint(board, i, constraint, c));
+    }
+
+    private boolean rowConstraint(int[][] board, int r) {
+        boolean[] constraint = new boolean[BOARD_SIZE];
+        return IntStream.range(BOARD_START_INDEX, BOARD_SIZE)
+          .allMatch(i -> checkConstraint(board, r, constraint, i));
+    }
+
+    private boolean checkConstraint(int[][] board, int r, boolean[] constraint, int c) {
+        if (board[r][c] != NO_VALUE) {
+            if (!constraint[board[r][c] - 1]) {
+                constraint[board[r][c] - 1] = true;
+            } else {
+                return false;
+            }
+        }
+        return true;
+    }
+}
@@ -0,0 +1,33 @@
+package com.baeldung.algorithms.sudoku;
+
+class ColumnNode extends DancingNode {
+    int size;
+    String name;
+
+    ColumnNode(String n) {
+        super();
+        size = 0;
+        name = n;
+        C = this;
+    }
+
+    void cover() {
+        unlinkLR();
+        for (DancingNode i = this.D; i != this; i = i.D) {
+            for (DancingNode j = i.R; j != i; j = j.R) {
+                j.unlinkUD();
+                j.C.size--;
+            }
+        }
+    }
+
+    void uncover() {
+        for (DancingNode i = this.U; i != this; i = i.U) {
+            for (DancingNode j = i.L; j != i; j = j.L) {
+                j.C.size++;
+                j.relinkUD();
+            }
+        }
+        relinkLR();
+    }
+}
@@ -0,0 +1,133 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+public class DancingLinks {
+
+    private ColumnNode header;
+    private List<DancingNode> answer;
+
+    private void search(int k) {
+        if (header.R == header) {
+            handleSolution(answer);
+        } else {
+            ColumnNode c = selectColumnNodeHeuristic();
+            c.cover();
+
+            for (DancingNode r = c.D; r != c; r = r.D) {
+                answer.add(r);
+
+                for (DancingNode j = r.R; j != r; j = j.R) {
+                    j.C.cover();
+                }
+
+                search(k + 1);
+
+                r = answer.remove(answer.size() - 1);
+                c = r.C;
+
+                for (DancingNode j = r.L; j != r; j = j.L) {
+                    j.C.uncover();
+                }
+            }
+            c.uncover();
+        }
+    }
+
+    private ColumnNode selectColumnNodeHeuristic() {
+        int min = Integer.MAX_VALUE;
+        ColumnNode ret = null;
+        for (ColumnNode c = (ColumnNode) header.R; c != header; c = (ColumnNode) c.R) {
+            if (c.size < min) {
+                min = c.size;
+                ret = c;
+            }
+        }
+        return ret;
+    }
+
+    private ColumnNode makeDLXBoard(boolean[][] grid) {
+        final int COLS = grid[0].length;
+
+        ColumnNode headerNode = new ColumnNode("header");
+        List<ColumnNode> columnNodes = new ArrayList<>();
+
+        for (int i = 0; i < COLS; i++) {
+            ColumnNode n = new ColumnNode(Integer.toString(i));
+            columnNodes.add(n);
+            headerNode = (ColumnNode) headerNode.hookRight(n);
+        }
+        headerNode = headerNode.R.C;
+
+        for (boolean[] aGrid : grid) {
+            DancingNode prev = null;
+            for (int j = 0; j < COLS; j++) {
+                if (aGrid[j]) {
+                    ColumnNode col = columnNodes.get(j);
+                    DancingNode newNode = new DancingNode(col);
+                    if (prev == null)
+                        prev = newNode;
+                    col.U.hookDown(newNode);
+                    prev = prev.hookRight(newNode);
+                    col.size++;
+                }
+            }
+        }
+
+        headerNode.size = COLS;
+
+        return headerNode;
+    }
+
+    DancingLinks(boolean[][] cover) {
+        header = makeDLXBoard(cover);
+    }
+
+    public void runSolver() {
+        answer = new LinkedList<>();
+        search(0);
+    }
+
+    private void handleSolution(List<DancingNode> answer) {
+        int[][] result = parseBoard(answer);
+        printSolution(result);
+    }
+
+    private int size = 9;
+
+    private int[][] parseBoard(List<DancingNode> answer) {
+        int[][] result = new int[size][size];
+        for (DancingNode n : answer) {
+            DancingNode rcNode = n;
+            int min = Integer.parseInt(rcNode.C.name);
+            for (DancingNode tmp = n.R; tmp != n; tmp = tmp.R) {
+                int val = Integer.parseInt(tmp.C.name);
+                if (val < min) {
+                    min = val;
+                    rcNode = tmp;
+                }
+            }
+            int ans1 = Integer.parseInt(rcNode.C.name);
+            int ans2 = Integer.parseInt(rcNode.R.C.name);
+            int r = ans1 / size;
+            int c = ans1 % size;
+            int num = (ans2 % size) + 1;
+            result[r][c] = num;
+        }
+        return result;
+    }
+
+    private static void printSolution(int[][] result) {
+        int N = result.length;
+        for (int[] aResult : result) {
+            StringBuilder ret = new StringBuilder();
+            for (int j = 0; j < N; j++) {
+                ret.append(aResult[j]).append(" ");
+            }
+            System.out.println(ret);
+        }
+        System.out.println();
+    }
+}
@@ -0,0 +1,108 @@
+package com.baeldung.algorithms.sudoku;
+
+import java.util.Arrays;
+
+public class DancingLinksAlgorithm {
+    private static final int BOARD_SIZE = 9;
+    private static final int SUBSECTION_SIZE = 3;
+    private static final int NO_VALUE = 0;
+    private static final int CONSTRAINTS = 4;
+    private static final int MIN_VALUE = 1;
+    private static final int MAX_VALUE = 9;
+    private static final int COVER_START_INDEX = 1;
+
+    private static int[][] board = {
+      {8, 0, 0, 0, 0, 0, 0, 0, 0},
+      {0, 0, 3, 6, 0, 0, 0, 0, 0},
+      {0, 7, 0, 0, 9, 0, 2, 0, 0},
+      {0, 5, 0, 0, 0, 7, 0, 0, 0},
+      {0, 0, 0, 0, 4, 5, 7, 0, 0},
+      {0, 0, 0, 1, 0, 0, 0, 3, 0},
+      {0, 0, 1, 0, 0, 0, 0, 6, 8},
+      {0, 0, 8, 5, 0, 0, 0, 1, 0},
+      {0, 9, 0, 0, 0, 0, 4, 0, 0}
+    };
+
+    public static void main(String[] args) {
+        DancingLinksAlgorithm solver = new DancingLinksAlgorithm();
+        solver.solve(board);
+    }
+
+    private void solve(int[][] board) {
+        boolean[][] cover = initializeExactCoverBoard(board);
+        DancingLinks dlx = new DancingLinks(cover);
+        dlx.runSolver();
+    }
+
+    private int getIndex(int row, int col, int num) {
+        return (row - 1) * BOARD_SIZE * BOARD_SIZE + (col - 1) * BOARD_SIZE + (num - 1);
+    }
+
+    private boolean[][] createExactCoverBoard() {
+        boolean[][] R = new boolean[BOARD_SIZE * BOARD_SIZE * MAX_VALUE][BOARD_SIZE * BOARD_SIZE * CONSTRAINTS];
+
+        int hBase = 0;
+
+        // Cell constraint.
+        for (int r = COVER_START_INDEX; r <= BOARD_SIZE; r++) {
+            for (int c = COVER_START_INDEX; c <= BOARD_SIZE; c++, hBase++) {
+                for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++) {
+                    int index = getIndex(r, c, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Row constrain.
+        for (int r = COVER_START_INDEX; r <= BOARD_SIZE; r++) {
+            for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                for (int c1 = COVER_START_INDEX; c1 <= BOARD_SIZE; c1++) {
+                    int index = getIndex(r, c1, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Column constraint.
+        for (int c = COVER_START_INDEX; c <= BOARD_SIZE; c++) {
+            for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                for (int r1 = COVER_START_INDEX; r1 <= BOARD_SIZE; r1++) {
+                    int index = getIndex(r1, c, n);
+                    R[index][hBase] = true;
+                }
+            }
+        }
+
+        // Subsection constraint
+        for (int br = COVER_START_INDEX; br <= BOARD_SIZE; br += SUBSECTION_SIZE) {
+            for (int bc = COVER_START_INDEX; bc <= BOARD_SIZE; bc += SUBSECTION_SIZE) {
+                for (int n = COVER_START_INDEX; n <= BOARD_SIZE; n++, hBase++) {
+                    for (int rDelta = 0; rDelta < SUBSECTION_SIZE; rDelta++) {
+                        for (int cDelta = 0; cDelta < SUBSECTION_SIZE; cDelta++) {
+                            int index = getIndex(br + rDelta, bc + cDelta, n);
+                            R[index][hBase] = true;
+                        }
+                    }
+                }
+            }
+        }
+        return R;
+    }
+
+    private boolean[][] initializeExactCoverBoard(int[][] board) {
+        boolean[][] R = createExactCoverBoard();
+        for (int i = COVER_START_INDEX; i <= BOARD_SIZE; i++) {
+            for (int j = COVER_START_INDEX; j <= BOARD_SIZE; j++) {
+                int n = board[i - 1][j - 1];
+                if (n != NO_VALUE) {
+                    for (int num = MIN_VALUE; num <= MAX_VALUE; num++) {
+                        if (num != n) {
+                            Arrays.fill(R[getIndex(i, j, num)], false);
+                        }
+                    }
+                }
+            }
+        }
+        return R;
+    }
+}
@@ -0,0 +1,50 @@
+package com.baeldung.algorithms.sudoku;
+
+class DancingNode {
+    DancingNode L, R, U, D;
+    ColumnNode C;
+
+    DancingNode hookDown(DancingNode n1) {
+        assert (this.C == n1.C);
+        n1.D = this.D;
+        n1.D.U = n1;
+        n1.U = this;
+        this.D = n1;
+        return n1;
+    }
+
+    DancingNode hookRight(DancingNode n1) {
+        n1.R = this.R;
+        n1.R.L = n1;
+        n1.L = this;
+        this.R = n1;
+        return n1;
+    }
+
+    void unlinkLR() {
+        this.L.R = this.R;
+        this.R.L = this.L;
+    }
+
+    void relinkLR() {
+        this.L.R = this.R.L = this;
+    }
+
+    void unlinkUD() {
+        this.U.D = this.D;
+        this.D.U = this.U;
+    }
+
+    void relinkUD() {
+        this.U.D = this.D.U = this;
+    }
+
+    DancingNode() {
+        L = R = U = D = this;
+    }
+
+    DancingNode(ColumnNode c) {
+        this();
+        C = c;
+    }
+}
@@ -1,45 +1,19 @@
 package com.baeldung.spliteratorAPI;

-import java.util.Arrays;
 import java.util.List;
-import java.util.Spliterator;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.stream.Collectors;
-import java.util.stream.IntStream;
 import java.util.stream.Stream;
-import java.util.stream.StreamSupport;

 public class Executor {
-	public void executeCustomSpliterator() {
-        Article article = new Article(Arrays.asList(new Author("Ahmad", 0), new Author("Eugen", 0), new Author("Alice", 1), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1),
-            new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0),
-            new Author("Alice", 1), new Author("Mike", 0), new Author("Michał", 0), new Author("Loredana", 1)), 0);
-        Stream<Author> stream = IntStream.range(0, article.getListOfAuthors()
-            .size())
-            .mapToObj(article.getListOfAuthors()::get);
-        System.out.println("count= " + countAutors(stream.parallel()));
-        Spliterator<Author> spliterator = new RelatedAuthorSpliterator(article.getListOfAuthors());
-        Stream<Author> stream2 = StreamSupport.stream(spliterator, true);
-        System.out.println("count= " + countAutors(stream2.parallel()));
-    }

-    public void executeSpliterator() {
-        Spliterator<Article> split1 = generateElements().spliterator();
-        Spliterator<Article> split2 = split1.trySplit();
-        ExecutorService service = Executors.newCachedThreadPool();
-        service.execute(new Task(split1));
-        service.execute(new Task(split2));
-    }
+	public static int countAutors(Stream<Author> stream) {
+		RelatedAuthorCounter wordCounter = stream.reduce(new RelatedAuthorCounter(0, true),
+				RelatedAuthorCounter::accumulate, RelatedAuthorCounter::combine);
+		return wordCounter.getCounter();
+	}

-    private static int countAutors(Stream<Author> stream) {
-        RelatedAuthorCounter wordCounter = stream.reduce(new RelatedAuthorCounter(0, true), RelatedAuthorCounter::accumulate, RelatedAuthorCounter::combine);
-        return wordCounter.getCounter();
-    }
+	public static List<Article> generateElements() {
+		return Stream.generate(() -> new Article("Java")).limit(35000).collect(Collectors.toList());
+	}

-    private List<Article> generateElements() {
-        return Stream.generate(() -> new Article("Java"))
-            .limit(35000)
-            .collect(Collectors.toList());
-    }
-}
+}
@@ -2,46 +2,48 @@ package com.baeldung.spliteratorAPI;

 import java.util.List;
 import java.util.Spliterator;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Consumer;

 public class RelatedAuthorSpliterator implements Spliterator<Author> {
-    private final List<Author> list;
-    private int current = 0;
+	private final List<Author> list;
+	AtomicInteger current = new AtomicInteger();

-    public RelatedAuthorSpliterator(List<Author> list) {
-        this.list = list;
-    }
+	public RelatedAuthorSpliterator(List<Author> list) {
+		this.list = list;
+	}

-    @Override
-    public boolean tryAdvance(Consumer<? super Author> action) {
-        action.accept(list.get(current++));
-        return current < list.size();
-    }
+	@Override
+	public boolean tryAdvance(Consumer<? super Author> action) {

-    @Override
-    public Spliterator<Author> trySplit() {
-        int currentSize = list.size() - current;
-        if (currentSize < 10) {
-            return null;
-        }
-        for (int splitPos = currentSize / 2 + current; splitPos < list.size(); splitPos++) {
-            if (list.get(splitPos)
-                .getRelatedArticleId() == 0) {
-                Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current, splitPos));
-                current = splitPos;
-                return spliterator;
-            }
-        }
-        return null;
-    }
+		action.accept(list.get(current.getAndIncrement()));
+		return current.get() < list.size();
+	}

-    @Override
-    public long estimateSize() {
-        return list.size() - current;
-    }
+	@Override
+	public Spliterator<Author> trySplit() {
+		int currentSize = list.size() - current.get();
+		if (currentSize < 10) {
+			return null;
+		}
+		for (int splitPos = currentSize / 2 + current.intValue(); splitPos < list.size(); splitPos++) {
+			if (list.get(splitPos).getRelatedArticleId() == 0) {
+				Spliterator<Author> spliterator = new RelatedAuthorSpliterator(list.subList(current.get(), splitPos));
+				current.set(splitPos);
+				return spliterator;
+			}
+		}
+		return null;
+	}
+
+	@Override
+	public long estimateSize() {
+		return list.size() - current.get();
+	}
+
+	@Override
+	public int characteristics() {
+		return CONCURRENT;
+	}

-    @Override
-    public int characteristics() {
-        return SIZED + CONCURRENT;
-    }
 }
@@ -1,8 +1,9 @@
 package com.baeldung.spliteratorAPI;

 import java.util.Spliterator;
+import java.util.concurrent.Callable;

-public class Task implements Runnable {
+public class Task implements Callable<String> {
    private Spliterator<Article> spliterator;
    private final static String SUFFIX = "- published by Baeldung";

@@ -11,7 +12,7 @@ public class Task implements Runnable {
    }

    @Override
-    public void run() {
+    public String call() {
        int current = 0;
        while (spliterator.tryAdvance(article -> {
            article.setName(article.getName()
@@ -20,7 +21,7 @@ public class Task implements Runnable {
            current++;
        }
        ;
-        System.out.println(Thread.currentThread()
-            .getName() + ":" + current);
+        return Thread.currentThread()
+            .getName() + ":" + current;
    }
 }
@@ -0,0 +1,44 @@
+package com.baeldung.spliteratorAPI;
+
+import java.util.Arrays;
+import java.util.Spliterator;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import static org.assertj.core.api.Assertions.*;
+import org.junit.Before;
+import org.junit.Test;
+
+public class ExecutorTest {
+	Article article;
+	Stream<Author> stream;
+	Spliterator<Author> spliterator;
+	Spliterator<Article> split1;
+	Spliterator<Article> split2;
+
+	@Before
+	public void init() {
+		article = new Article(Arrays.asList(new Author("Ahmad", 0), new Author("Eugen", 0), new Author("Alice", 1),
+				new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0),
+				new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0),
+				new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1),
+				new Author("Mike", 0), new Author("Alice", 1), new Author("Mike", 0), new Author("Alice", 1),
+				new Author("Mike", 0), new Author("Michał", 0), new Author("Loredana", 1)), 0);
+		stream = article.getListOfAuthors().stream();
+		split1 = Executor.generateElements().spliterator();
+		split2 = split1.trySplit();
+		spliterator = new RelatedAuthorSpliterator(article.getListOfAuthors());
+	}
+
+	@Test
+	public void givenAstreamOfAuthors_whenProcessedInParallelWithCustomSpliterator_coubtProducessRightOutput() {
+		Stream<Author> stream2 = StreamSupport.stream(spliterator, true);
+		assertThat(Executor.countAutors(stream2.parallel())).isEqualTo(9);
+	}
+
+	@Test
+	public void givenSpliterator_whenAppliedToAListOfArticle_thenSplittedInHalf() {
+		assertThat(new Task(split1).call()).containsSequence(Executor.generateElements().size() / 2 + "");
+		assertThat(new Task(split2).call()).containsSequence(Executor.generateElements().size() / 2 + "");
+	}
+}
@@ -0,0 +1,218 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.*;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Collectors;
+
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.collection.IsEmptyCollection.empty;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpClientTest {
+
+    @Test
+    public void shouldReturnSampleDataContentWhenConnectViaSystemProxy() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .proxy(ProxySelector.getDefault())
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample body"));
+    }
+
+    @Test
+    public void shouldNotFollowRedirectWhenSetToDefaultNever() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_MOVED_PERM));
+        assertThat(response.body(), containsString("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldFollowRedirectWhenSetToAlways() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.finalRequest()
+            .uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+    @Test
+    public void shouldReturnOKStatusForAuthenticatedAccess() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/basic-auth"))
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .authenticator(new Authenticator() {
+                @Override
+                protected PasswordAuthentication getPasswordAuthentication() {
+                    return new PasswordAuthentication("postman", "password".toCharArray());
+                }
+            })
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldSendRequestAsync() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample body"))
+            .build();
+        CompletableFuture<HttpResponse<String>> response = HttpClient.newBuilder()
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseJustTwoThreadWhenProcessingSendAsyncRequest() throws URISyntaxException, InterruptedException, ExecutionException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        ExecutorService executorService = Executors.newFixedThreadPool(2);
+
+        CompletableFuture<HttpResponse<String>> response1 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture<HttpResponse<String>> response2 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture<HttpResponse<String>> response3 = HttpClient.newBuilder()
+            .executor(executorService)
+            .build()
+            .sendAsync(request, HttpResponse.BodyHandler.asString());
+
+        CompletableFuture.allOf(response1, response2, response3)
+            .join();
+
+        assertThat(response1.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response2.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response3.get()
+            .statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldNotStoreCookieWhenPolicyAcceptNone() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieManager(new CookieManager(null, CookiePolicy.ACCEPT_NONE))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(httpClient.cookieManager()
+            .get()
+            .getCookieStore()
+            .getCookies(), empty());
+    }
+
+    @Test
+    public void shouldStoreCookieWhenPolicyAcceptAll() throws URISyntaxException, IOException, InterruptedException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpClient httpClient = HttpClient.newBuilder()
+            .cookieManager(new CookieManager(null, CookiePolicy.ACCEPT_ALL))
+            .build();
+
+        httpClient.send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(httpClient.cookieManager()
+            .get()
+            .getCookieStore()
+            .getCookies(), not(empty()));
+    }
+
+    @Test
+    public void shouldProcessMultipleRequestViaStream() throws URISyntaxException, ExecutionException, InterruptedException {
+        List<URI> targets = Arrays.asList(new URI("https://postman-echo.com/get?foo1=bar1"), new URI("https://postman-echo.com/get?foo2=bar2"));
+
+        HttpClient client = HttpClient.newHttpClient();
+
+        List<CompletableFuture<String>> futures = targets.stream()
+            .map(target -> client.sendAsync(HttpRequest.newBuilder(target)
+                .GET()
+                .build(), HttpResponse.BodyHandler.asString())
+                .thenApply(response -> response.body()))
+            .collect(Collectors.toList());
+
+        CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
+            .join();
+
+        if (futures.get(0)
+            .get()
+            .contains("foo1")) {
+            assertThat(futures.get(0)
+                .get(), containsString("bar1"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+        } else {
+            assertThat(futures.get(1)
+                .get(), containsString("bar2"));
+            assertThat(futures.get(1)
+                .get(), containsString("bar1"));
+        }
+
+    }
+
+}
@@ -0,0 +1,171 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.nio.file.Paths;
+import java.security.NoSuchAlgorithmException;
+import java.time.Duration;
+
+import static java.time.temporal.ChronoUnit.SECONDS;
+import static org.hamcrest.CoreMatchers.containsString;
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpRequestTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldUseHttp2WhenWebsiteUsesHttp2() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_2));
+    }
+
+    @Test
+    public void shouldFallbackToHttp1_1WhenWebsiteDoesNotUseHttp2() throws IOException, InterruptedException, URISyntaxException, NoSuchAlgorithmException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .version(HttpClient.Version.HTTP_2)
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.version(), equalTo(HttpClient.Version.HTTP_1_1));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestWithDummyHeaders() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .headers("key1", "value1", "key2", "value2")
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequestTimeoutSet() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .timeout(Duration.of(10, SECONDS))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnNoContentWhenPostWithNoBody() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .POST(HttpRequest.noBody())
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithBodyText() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromString("Sample request body"))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithInputStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromInputStream(() -> new ByteArrayInputStream(sampleData)))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithByteArrayProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        byte[] sampleData = "Sample request body".getBytes();
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromByteArray(sampleData))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample request body"));
+    }
+
+    @Test
+    public void shouldReturnSampleDataContentWhenPostWithFileProcessorStream() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/post"))
+            .headers("Content-Type", "text/plain;charset=UTF-8")
+            .POST(HttpRequest.BodyProcessor.fromFile(Paths.get("src/test/resources/sample.txt")))
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), containsString("Sample file content"));
+    }
+
+}
@@ -0,0 +1,55 @@
+package com.baeldung.java9.httpclient;
+
+import jdk.incubator.http.HttpClient;
+import jdk.incubator.http.HttpRequest;
+import jdk.incubator.http.HttpResponse;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.Matchers.isEmptyString;
+import static org.hamcrest.core.IsNot.not;
+import static org.junit.Assert.assertThat;
+
+/**
+ * Created by adam.
+ */
+public class HttpResponseTest {
+
+    @Test
+    public void shouldReturnStatusOKWhenSendGetRequest() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("https://postman-echo.com/get"))
+            .GET()
+            .build();
+
+        HttpResponse<String> response = HttpClient.newHttpClient()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(response.statusCode(), equalTo(HttpURLConnection.HTTP_OK));
+        assertThat(response.body(), not(isEmptyString()));
+    }
+
+    @Test
+    public void shouldResponseURIDifferentThanRequestUIRWhenRedirect() throws IOException, InterruptedException, URISyntaxException {
+        HttpRequest request = HttpRequest.newBuilder()
+            .uri(new URI("http://stackoverflow.com"))
+            .version(HttpClient.Version.HTTP_1_1)
+            .GET()
+            .build();
+        HttpResponse<String> response = HttpClient.newBuilder()
+            .followRedirects(HttpClient.Redirect.ALWAYS)
+            .build()
+            .send(request, HttpResponse.BodyHandler.asString());
+
+        assertThat(request.uri()
+            .toString(), equalTo("http://stackoverflow.com"));
+        assertThat(response.uri()
+            .toString(), equalTo("https://stackoverflow.com/"));
+    }
+
+}
@@ -33,4 +33,4 @@
 - [Daemon Threads in Java](http://www.baeldung.com/java-daemon-thread)
 - [Implementing a Runnable vs Extending a Thread](http://www.baeldung.com/java-runnable-vs-extending-thread)
 - [How to Kill a Java Thread](http://www.baeldung.com/java-thread-stop)
- [How to Wait for Threads to Finish in the ExecutorService](http://www.baeldung.com/java-executor-wait-for-threads)
+- [ExecutorService - Waiting for Threads to Finish](http://www.baeldung.com/java-executor-wait-for-threads)
@@ -0,0 +1,24 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+public class Job implements Runnable {
+    private String jobName;
+    private JobPriority jobPriority;
+    
+    public Job(String jobName, JobPriority jobPriority) {
+        this.jobName = jobName;
+        this.jobPriority = jobPriority != null ? jobPriority : JobPriority.MEDIUM;
+    }
+
+    public JobPriority getJobPriority() {
+        return jobPriority;
+    }
+
+    @Override
+    public void run() {
+        try {
+            System.out.println("Job:" + jobName + " Priority:" + jobPriority);
+            Thread.sleep(1000);
+        } catch (InterruptedException ignored) {
+        }
+    }
+}
@@ -0,0 +1,7 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+public enum JobPriority {
+    HIGH,
+    MEDIUM,
+    LOW
+}
@@ -0,0 +1,56 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+import java.util.Comparator;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.PriorityBlockingQueue;
+import java.util.concurrent.TimeUnit;
+
+public class PriorityJobScheduler {
+
+    private ExecutorService priorityJobPoolExecutor;
+    private ExecutorService priorityJobScheduler;
+    private PriorityBlockingQueue<Runnable> priorityQueue;
+
+    public PriorityJobScheduler(Integer poolSize, Integer queueSize) {
+        priorityJobPoolExecutor = Executors.newFixedThreadPool(poolSize);
+        Comparator<? super Job> jobComparator = Comparator.comparing(Job::getJobPriority);
+        priorityQueue = new PriorityBlockingQueue<Runnable>(queueSize, 
+          (Comparator<? super Runnable>) jobComparator);
+
+        priorityJobScheduler = Executors.newSingleThreadExecutor();
+        priorityJobScheduler.execute(()->{
+            while (true) {
+                try {
+                    priorityJobPoolExecutor.execute(priorityQueue.take());
+                } catch (InterruptedException e) {
+                    break;
+                }
+            }
+        });
+    }
+
+    public void scheduleJob(Job job) {
+        priorityQueue.add(job);
+    }
+
+    public int getQueuedTaskCount() {
+        return priorityQueue.size();
+    }
+
+    protected void close(ExecutorService scheduler) {
+        scheduler.shutdown();
+        try {
+            if (!scheduler.awaitTermination(5, TimeUnit.SECONDS)) {
+                scheduler.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            scheduler.shutdownNow();
+        }
+    }
+
+    public void closeScheduler() {
+        close(priorityJobPoolExecutor);
+        close(priorityJobScheduler);
+    }
+}
@@ -11,7 +11,10 @@ public class Data {
        while (transfer) {
            try {
                wait();
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
        transfer = true;

@@ -23,7 +26,10 @@ public class Data {
        while (!transfer) {
            try { 
                wait();
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
        transfer = false;
        
@@ -19,7 +19,10 @@ public class Receiver implements Runnable {
            //Thread.sleep() to mimic heavy server-side processing
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
    }
 }
@@ -11,11 +11,11 @@ public class Sender implements Runnable {
 
    public void run() {
        String packets[] = {
-            "First packet",
-            "Second packet",
-            "Third packet",
-            "Fourth packet",
-            "End"
+          "First packet",
+          "Second packet",
+          "Third packet",
+          "Fourth packet",
+          "End"
        };
 
        for (String packet : packets) {
@@ -24,7 +24,10 @@ public class Sender implements Runnable {
            //Thread.sleep() to mimic heavy server-side processing
            try {
                Thread.sleep(ThreadLocalRandom.current().nextInt(1000, 5000));
-            } catch (InterruptedException e) {}
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt(); 
+                System.out.println("Thread Interrupted");
+            }
        }
    }
 }
@@ -0,0 +1,38 @@
+package com.baeldung.concurrent.prioritytaskexecution;
+
+import org.junit.Test;
+
+public class PriorityJobSchedulerUnitTest {
+    private static int POOL_SIZE = 1;
+    private static int QUEUE_SIZE = 10;
+    
+    @Test
+    public void whenMultiplePriorityJobsQueued_thenHighestPriorityJobIsPicked() {
+        Job job1 = new Job("Job1", JobPriority.LOW);
+        Job job2 = new Job("Job2", JobPriority.MEDIUM);
+        Job job3 = new Job("Job3", JobPriority.HIGH);
+        Job job4 = new Job("Job4", JobPriority.MEDIUM);
+        Job job5 = new Job("Job5", JobPriority.LOW);
+        Job job6 = new Job("Job6", JobPriority.HIGH);
+        
+        PriorityJobScheduler pjs = new PriorityJobScheduler(POOL_SIZE, QUEUE_SIZE);
+        
+        pjs.scheduleJob(job1);
+        pjs.scheduleJob(job2);
+        pjs.scheduleJob(job3);
+        pjs.scheduleJob(job4);
+        pjs.scheduleJob(job5);
+        pjs.scheduleJob(job6);
+        
+        // ensure no tasks is pending before closing the scheduler
+        while (pjs.getQueuedTaskCount() != 0);
+        
+        // delay to avoid job sleep (added for demo) being interrupted
+        try {
+            Thread.sleep(2000);
+        } catch (InterruptedException ignored) {
+        }
+        
+        pjs.closeScheduler();
+    }
+}
@@ -13,38 +13,38 @@ import org.junit.Test;

 public class NetworkIntegrationTest {

-	private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
-	private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
-	private String expected;
-	
-	@Before
-	public void setUpStreams() {
-	    System.setOut(new PrintStream(outContent));
-	    System.setErr(new PrintStream(errContent));
-	}
-	
-	@Before
-	public void setUpExpectedOutput() {
-		StringWriter expectedStringWriter = new StringWriter();
-		
-		PrintWriter printWriter = new PrintWriter(expectedStringWriter);
-		printWriter.println("First packet");
-		printWriter.println("Second packet");
-		printWriter.println("Third packet");
-		printWriter.println("Fourth packet");
-		printWriter.close();
-		
-		expected = expectedStringWriter.toString();
-	}
+    private final ByteArrayOutputStream outContent = new ByteArrayOutputStream();
+    private final ByteArrayOutputStream errContent = new ByteArrayOutputStream();
+    private String expected;
+    
+    @Before
+    public void setUpStreams() {
+        System.setOut(new PrintStream(outContent));
+        System.setErr(new PrintStream(errContent));
+    }
+    
+    @Before
+    public void setUpExpectedOutput() {
+        StringWriter expectedStringWriter = new StringWriter();
+        
+        PrintWriter printWriter = new PrintWriter(expectedStringWriter);
+        printWriter.println("First packet");
+        printWriter.println("Second packet");
+        printWriter.println("Third packet");
+        printWriter.println("Fourth packet");
+        printWriter.close();
+        
+        expected = expectedStringWriter.toString();
+    }

-	@After
-	public void cleanUpStreams() {
-	    System.setOut(null);
-	    System.setErr(null);
-	}
-	
-	@Test
-	public void givenSenderAndReceiver_whenSendingPackets_thenNetworkSynchronized() {
+    @After
+    public void cleanUpStreams() {
+        System.setOut(null);
+        System.setErr(null);
+    }
+    
+    @Test
+    public void givenSenderAndReceiver_whenSendingPackets_thenNetworkSynchronized() {
        Data data = new Data();
        Thread sender = new Thread(new Sender(data));
        Thread receiver = new Thread(new Receiver(data));
@@ -54,12 +54,13 @@ public class NetworkIntegrationTest {
        
        //wait for sender and receiver to finish before we test against expected
        try {
-			sender.join();
-			receiver.join();
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
-		
-	    assertEquals(expected, outContent.toString());
-	}
+            sender.join();
+            receiver.join();
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt(); 
+            System.out.println("Thread Interrupted");
+        }
+        
+        assertEquals(expected, outContent.toString());
+    }
 }
@@ -126,3 +126,4 @@
 - [A Guide to Inner Interfaces in Java](http://www.baeldung.com/java-inner-interfaces)
 - [Polymorphism in Java](http://www.baeldung.com/java-polymorphism)
 - [Recursion In Java](http://www.baeldung.com/java-recursion)
+- [A Guide to the finalize Method in Java](http://www.baeldung.com/java-finalize)
@@ -0,0 +1,5 @@
+package com.baeldung.designpatterns.observer;
+
+public interface Channel {
+    public void update(Object o);
+}
--- a/Show More
+++ b/Show More