Merge branch 'eugenp:master' into master

algorithms-modules/algorithms-miscellaneous-7/src/main/java/com/baeldung/algorithms/pixelarray/GetPixelArray.java

@@ -0,0 +1,65 @@
+package com.baeldung.algorithms.pixelarray;
+
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+public class GetPixelArray {
+
+    public static int[][] get2DPixelArraySlow(BufferedImage sampleImage) {
+        int width = sampleImage.getWidth();
+        int height = sampleImage.getHeight();
+        int[][] result = new int[height][width];
+
+        for (int row = 0; row < height; row++) {
+            for (int col = 0; col < width; col++) {
+                result[row][col] = sampleImage.getRGB(col, row);
+            }
+        }
+
+        return result;
+    }
+
+    public static int[][] get2DPixelArrayFast(BufferedImage image) {
+        final byte[] pixelData = ((DataBufferByte) image.getRaster().getDataBuffer()).getData();
+        final int width = image.getWidth();
+        final int height = image.getHeight();
+        final boolean hasAlphaChannel = image.getAlphaRaster() != null;
+
+        int[][] result = new int[height][width];
+        if (hasAlphaChannel) {
+            final int numberOfValues = 4;
+            for (int valueIndex = 0, row = 0, col = 0; valueIndex + numberOfValues - 1 < pixelData.length; valueIndex += numberOfValues) {
+                // Getting the values for each pixel from the pixelData array.
+                int argb = 0;
+                argb += (((int) pixelData[valueIndex] & 0xff) << 24); // alpha value
+                argb += ((int) pixelData[valueIndex + 1] & 0xff); // blue value
+                argb += (((int) pixelData[valueIndex + 2] & 0xff) << 8); // green value
+                argb += (((int) pixelData[valueIndex + 3] & 0xff) << 16); // red value
+                result[row][col] = argb;
+
+                col++;
+                if (col == width) {
+                    col = 0;
+                    row++;
+                }
+            }
+        } else {
+            final int numberOfValues = 3;
+            for (int valueIndex = 0, row = 0, col = 0; valueIndex + numberOfValues - 1 < pixelData.length; valueIndex += numberOfValues) {
+                int argb = 0;
+                argb += -16777216; // 255 alpha value (fully opaque)
+                argb += ((int) pixelData[valueIndex] & 0xff); // blue value
+                argb += (((int) pixelData[valueIndex + 1] & 0xff) << 8); // green value
+                argb += (((int) pixelData[valueIndex + 2] & 0xff) << 16); // red value
+                result[row][col] = argb;
+
+                col++;
+                if (col == width) {
+                    col = 0;
+                    row++;
+                }
+            }
+        }
+
+        return result;
+    }
+}

algorithms-modules/algorithms-miscellaneous-7/src/test/java/com/baeldung/algorithms/pixelarray/GetPixelArrayUnitTest.java

@@ -0,0 +1,30 @@
+package com.baeldung.algorithms.pixelarray;
+
+import static com.baeldung.algorithms.pixelarray.GetPixelArray.get2DPixelArrayFast;
+import static com.baeldung.algorithms.pixelarray.GetPixelArray.get2DPixelArraySlow;
+import static org.junit.Assert.*;
+
+import org.junit.Test;
+
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+
+public class GetPixelArrayUnitTest {
+    @Test
+    public void givenImage_whenGetPixelArray_thenBothMethodsReturnEqualValues() {
+        BufferedImage sampleImage = null;
+        try {
+            sampleImage = ImageIO.read(new File("src/main/resources/images/sampleImage.jpg"));
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+
+        int[][] firstResult = get2DPixelArraySlow(sampleImage);
+        int[][] secondResult = get2DPixelArrayFast(sampleImage);
+
+        assertTrue(Arrays.deepEquals(firstResult, secondResult));
+    }
+}

apache-httpclient-2/README.md

@@ -13,4 +13,5 @@ The "REST With Spring" Classes: http://bit.ly/restwithspring
 - [How To Get Cookies From the Apache HttpClient Response](https://www.baeldung.com/java-apache-httpclient-cookies)
 - [Enabling Logging for Apache HttpClient](https://www.baeldung.com/apache-httpclient-enable-logging)
 - [Apache HttpClient vs. CloseableHttpClient](https://www.baeldung.com/apache-httpclient-vs-closeablehttpclient)
+- [Expand Shortened URLs with Apache HttpClient](https://www.baeldung.com/apache-httpclient-expand-url)
 - More articles: [[<-- prev]](../apache-httpclient)

apache-httpclient-2/src/test/java/com/baeldung/httpclient/expandUrl/HttpClientExpandUrlLiveTest.java

@@ -0,0 +1,126 @@
+package com.baeldung.httpclient.expandUrl;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+
+import java.io.IOException;
+import java.util.List;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Lists;
+
+import org.apache.commons.lang3.tuple.ImmutablePair;
+import org.apache.commons.lang3.tuple.Pair;
+
+import org.apache.hc.client5.http.classic.methods.HttpHead;
+import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
+
+import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
+import org.apache.hc.core5.http.Header;
+import org.apache.hc.core5.http.HttpHeaders;
+
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+class HttpClientExpandUrlLiveTest {
+
+    private static CloseableHttpClient httpClient;
+
+    @BeforeAll
+    static void setup() {
+        httpClient = HttpClientBuilder.create()
+            .disableRedirectHandling()
+            .build();
+    }
+
+    @AfterAll
+    static void tearDown() throws IOException {
+        if (httpClient != null) {
+            httpClient.close();
+        }
+    }
+
+    @Test
+    void givenShortenedOnce_whenUrlIsExpanded_thenCorrectResult() throws IOException {
+        final String expectedResult = "https://www.baeldung.com/rest-versioning";
+        final String actualResult = expandSingleLevel("http://bit.ly/3LScTri");
+        assertThat(actualResult, equalTo(expectedResult));
+    }
+
+    @Test
+    void givenShortenedMultiple_whenUrlIsExpanded_thenCorrectResult() throws IOException {
+        final String expectedResult = "https://www.baeldung.com/rest-versioning";
+        final String actualResult = expand("http://t.co/e4rDDbnzmk");
+        assertThat(actualResult, equalTo(expectedResult));
+    }
+
+    private String expand(final String urlArg) throws IOException {
+        String originalUrl = urlArg;
+        String newUrl = expandSingleLevel(originalUrl);
+        while (!originalUrl.equals(newUrl)) {
+            originalUrl = newUrl;
+            newUrl = expandSingleLevel(originalUrl);
+        }
+
+        return newUrl;
+    }
+
+    final String expandSafe(final String urlArg) throws IOException {
+        String originalUrl = urlArg;
+        String newUrl = expandSingleLevelSafe(originalUrl).getRight();
+        final List<String> alreadyVisited = Lists.newArrayList(originalUrl, newUrl);
+        while (!originalUrl.equals(newUrl)) {
+            originalUrl = newUrl;
+            final Pair<Integer, String> statusAndUrl = expandSingleLevelSafe(originalUrl);
+            newUrl = statusAndUrl.getRight();
+            final boolean isRedirect = statusAndUrl.getLeft() == 301 || statusAndUrl.getLeft() == 302;
+            if (isRedirect && alreadyVisited.contains(newUrl)) {
+                throw new IllegalStateException("Likely a redirect loop");
+            }
+            alreadyVisited.add(newUrl);
+        }
+
+        return newUrl;
+    }
+
+    private Pair<Integer, String> expandSingleLevelSafe(final String url) throws IOException {
+        try {
+            HttpHead request = new HttpHead(url);
+            Pair<Integer, String> resp = httpClient.execute(request, response -> {
+                final int statusCode = response.getCode();
+                if (statusCode != 301 && statusCode != 302) {
+                    return new ImmutablePair<>(statusCode, url);
+                }
+                final Header[] headers = response.getHeaders(HttpHeaders.LOCATION);
+                Preconditions.checkState(headers.length == 1);
+                final String newUrl = headers[0].getValue();
+
+                return new ImmutablePair<>(statusCode, newUrl);
+            });
+            return resp;
+        } catch (final IllegalArgumentException uriEx) {
+            return new ImmutablePair<>(500, url);
+        }
+    }
+
+    private String expandSingleLevel(final String url) throws IOException {
+        try {
+            HttpHead request = new HttpHead(url);
+            String expandedUrl = httpClient.execute(request, response -> {
+                final int statusCode = response.getCode();
+                if (statusCode != 301 && statusCode != 302) {
+                    return url;
+                }
+                final Header[] headers = response.getHeaders(HttpHeaders.LOCATION);
+                Preconditions.checkState(headers.length == 1);
+
+                return headers[0].getValue();
+            });
+            return expandedUrl;
+        } catch (final IllegalArgumentException uriEx) {
+            return url;
+        }
+    }
+
+}

core-java-modules/core-java-char/src/test/java/com/baeldung/charandstring/DifferenceBetweenCharAndStringUnitTest.java

@@ -0,0 +1,56 @@
+package com.baeldung.charandstring;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+
+import org.junit.jupiter.api.Test;
+
+public class DifferenceBetweenCharAndStringUnitTest {
+
+    @Test
+    void whenPlusTwoChars_thenGetSumAsInteger() {
+        char h = 'H'; // the value is 72
+        char i = 'i'; // the value is 105
+        assertEquals(177, h + i);
+        assertInstanceOf(Integer.class, h + i);
+    }
+
+    @Test
+    void whenPlusTwoStrings_thenConcatenateThem() {
+        String i = "i";
+        String h = "H";
+        assertEquals("Hi", h + i);
+    }
+
+    @Test
+    void whenPlusCharsAndStrings_thenGetExpectedValues() {
+        char c = 'C';
+        assertEquals("C", "" + c);
+
+        char h = 'H'; // the value is 72
+        char i = 'i'; // the value is 105
+        assertEquals("Hi", "" + h + i);
+        assertEquals("Hi", h + "" + i);
+        assertEquals("177", h + i + "");
+    }
+
+    @Test
+    void whenStringChars_thenGetCharArray() {
+        char h = 'h';
+        char e = 'e';
+        char l = 'l';
+        char o = 'o';
+
+        String hello = "hello";
+        assertEquals(h, hello.charAt(0));
+        assertEquals(e, hello.charAt(1));
+        assertEquals(l, hello.charAt(2));
+        assertEquals(l, hello.charAt(3));
+        assertEquals(o, hello.charAt(4));
+
+        char[] chars = new char[] { h, e, l, l, o };
+        char[] charsFromString = hello.toCharArray();
+        assertArrayEquals(chars, charsFromString);
+    }
+}

core-java-modules/core-java-io-apis-2/README.md

@@ -6,4 +6,4 @@ This module contains articles about core Java input/output(IO) APIs.
 - [Constructing a Relative Path From Two Absolute Paths in Java](https://www.baeldung.com/java-relative-path-absolute)
 - [Java Scanner Taking a Character Input](https://www.baeldung.com/java-scanner-character-input)
 - [Get the Desktop Path in Java](https://www.baeldung.com/java-desktop-path)
-
+- [Integer.parseInt(scanner.nextLine()) and scanner.nextInt() in Java](https://www.baeldung.com/java-scanner-integer)

core-java-modules/core-java-io-conversions-2/src/test/java/com/baeldung/inputstreamtostring/JavaInputStreamToXUnitTest.java

@@ -49,7 +49,7 @@ public class JavaInputStreamToXUnitTest {
         final InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
 
         final StringBuilder textBuilder = new StringBuilder();
-        try (Reader reader = new BufferedReader(new InputStreamReader(inputStream, Charset.forName(StandardCharsets.UTF_8.name())))) {
+        try (Reader reader = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))) {
             int c;
             while ((c = reader.read()) != -1) {
                 textBuilder.append((char) c);
@@ -63,7 +63,7 @@ public class JavaInputStreamToXUnitTest {
         final String originalString = randomAlphabetic(DEFAULT_SIZE);
         final InputStream inputStream = new ByteArrayInputStream(originalString.getBytes());
 
-        final String text = new BufferedReader(new InputStreamReader(inputStream, Charset.forName(StandardCharsets.UTF_8.name())))
+        final String text = new BufferedReader(new InputStreamReader(inputStream, StandardCharsets.UTF_8))
           .lines()
           .collect(Collectors.joining("\n"));
 

core-java-modules/core-java-lang-oop-methods/README.md

@@ -11,3 +11,4 @@ This module contains articles about methods in Java
 - [The Covariant Return Type in Java](https://www.baeldung.com/java-covariant-return-type)
 - [Does a Method’s Signature Include the Return Type in Java?](https://www.baeldung.com/java-method-signature-return-type)
 - [Solving the Hide Utility Class Public Constructor Sonar Warning](https://www.baeldung.com/java-sonar-hide-implicit-constructor)
+- [Best Practices for Passing Many Arguments to a Method in Java](https://www.baeldung.com/java-best-practices-many-parameters-method)

core-java-modules/core-java-lang-oop-methods/src/main/java/com/baeldung/methods/Car.java

@@ -0,0 +1,98 @@
+package com.baeldung.methods;
+
+public class Car {
+
+    private final String make;
+    private final String model;
+    private final int year;
+    private final String color;
+    private final boolean automatic;
+    private final int numDoors;
+    private final String features;
+
+    private Car(CarBuilder carBuilder) {
+        this.make = carBuilder.make;
+        this.model = carBuilder.model;
+        this.year = carBuilder.year;
+        this.color = carBuilder.color;
+        this.automatic = carBuilder.automatic;
+        this.numDoors = carBuilder.numDoors;
+        this.features = carBuilder.features;
+    }
+
+    public String getMake() {
+        return make;
+    }
+
+    public String getModel() {
+        return model;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public String getColor() {
+        return color;
+    }
+
+    public boolean isAutomatic() {
+        return automatic;
+    }
+
+    public int getNumDoors() {
+        return numDoors;
+    }
+
+    public String getFeatures() {
+        return features;
+    }
+
+    public static class CarBuilder {
+
+        private final String make;
+        private final String model;
+        private final int year;
+
+        private String color = "unknown";
+        private boolean automatic = false;
+        private int numDoors = 4;
+        private String features = "";
+
+        public CarBuilder(String make, String model, int year) {
+            this.make = make;
+            this.model = model;
+            this.year = year;
+        }
+
+        public CarBuilder color(String color) {
+            this.color = color;
+            return this;
+        }
+
+        public CarBuilder automatic(boolean automatic) {
+            this.automatic = automatic;
+            return this;
+        }
+
+        public CarBuilder numDoors(int numDoors) {
+            this.numDoors = numDoors;
+            return this;
+        }
+
+        public CarBuilder features(String features) {
+            this.features = features;
+            return this;
+        }
+
+        public Car build() {
+            return new Car(this);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return "Car [make=" + make + ", model=" + model + ", year=" + year + ", color=" + color + ", automatic=" + automatic + ", numDoors=" + numDoors + ", features=" + features + "]";
+    }
+
+}

core-java-modules/core-java-lang-oop-methods/src/main/java/com/baeldung/methods/Motorcycle.java

@@ -0,0 +1,52 @@
+package com.baeldung.methods;
+
+import java.io.Serializable;
+
+public class Motorcycle extends Vehicle implements Serializable {
+
+    private static final long serialVersionUID = 5973661295933599929L;
+
+    private int year;
+    private String features = "";
+
+    public Motorcycle() {
+        super();
+    }
+
+    public Motorcycle(String make, String model, String color, int weight, boolean statusNew, int year) {
+        super(make, model, color, weight, statusNew);
+        this.year = year;
+    }
+
+    public Motorcycle(Vehicle vehicle, int year) {
+        super(vehicle);
+        this.year = year;
+    }
+
+    public int getYear() {
+        return year;
+    }
+
+    public void setYear(int year) {
+        this.year = year;
+    }
+
+    public void setFeatures(String features) {
+        this.features = features;
+    }
+
+    public String getFeatures() {
+        return features;
+    }
+
+    public void addMotorcycleFeatures(String... features) {
+        StringBuilder str = new StringBuilder(this.getFeatures());
+        for (String feature : features) {
+            if (!str.toString().isEmpty())
+                str.append(", ");
+            str.append(feature);
+        }
+        this.setFeatures(str.toString());
+    }
+
+}

core-java-modules/core-java-lang-oop-methods/src/main/java/com/baeldung/methods/Vehicle.java

@@ -0,0 +1,33 @@
+package com.baeldung.methods;
+
+public class Vehicle {
+
+    static String defaultValue = "DEFAULT";
+    private String make = defaultValue;
+    private String model = defaultValue;
+    private String color = defaultValue;
+    private int weight = 0;
+    private boolean statusNew = true;
+
+    public Vehicle() {
+        super();
+    }
+
+    public Vehicle(String make, String model, String color, int weight, boolean statusNew) {
+        this.make = make;
+        this.model = model;
+        this.color = color;
+        this.weight = weight;
+        this.statusNew = statusNew;
+    }
+
+    public Vehicle(Vehicle vehicle) {
+        this(vehicle.make, vehicle.model, vehicle.color, vehicle.weight, vehicle.statusNew);
+    }
+
+    @Override
+    public String toString() {
+        return "Vehicle [make=" + make + ", model=" + model + ", color=" + color + ", weight=" + weight + ", statusNew=" + statusNew + "]";
+    }
+
+}

core-java-modules/core-java-lang-oop-methods/src/main/java/com/baeldung/methods/VehicleProcessor.java

@@ -0,0 +1,20 @@
+package com.baeldung.methods;
+
+public class VehicleProcessor {
+
+    Vehicle processVehicle(String make, String model, String color, int weight, boolean status) {
+        return new Vehicle(make, model, color, weight, status);
+    }
+
+    Vehicle processVehicle(Vehicle vehicle) {
+        return new Vehicle(vehicle);
+    }
+
+    Car processCar(Car car) {
+        return new Car.CarBuilder(car.getMake(), car.getModel(), car.getYear()).color(car.getColor())
+            .automatic(car.isAutomatic())
+            .features(car.getFeatures())
+            .build();
+    }
+
+}

core-java-modules/core-java-lang-oop-methods/src/test/java/com/baeldung/methods/VehicleProcessorUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.methods;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class VehicleProcessorUnitTest {
+
+    VehicleProcessor vehicleProcessor = new VehicleProcessor();
+    Vehicle vehicle = new Vehicle("Ford", "Focus", "red", 2200, true);
+
+    @Test
+    void givenAllArguments_whenMethodCall_thenVerifyCallIsDoneCorrectly() {
+        Vehicle veh = vehicleProcessor.processVehicle("Ford", "Focus", "red", 2200, true);
+        assertThat(veh.toString()).hasToString(vehicle.toString());
+    }
+
+    @Test
+    void givenParameterObject_whenMethodCall_thenVerifyCallIsDoneCorrectly() {
+        Vehicle veh = vehicleProcessor.processVehicle(vehicle);
+        assertThat(veh.toString()).hasToString(vehicle.toString());
+    }
+
+    @Test
+    void givenJavaBeanPattern_whenMethodCall_thenVerifyCallIsDoneCorrectly() {
+        Motorcycle motorcycle = new Motorcycle("Ducati", "Monster", "yellow", 235, true, 2023);
+        motorcycle.setFeatures("GPS");
+
+        vehicleProcessor.processVehicle(motorcycle);
+        assertThat(motorcycle.getFeatures()).isEqualToIgnoringCase("GPS");
+    }
+
+    @Test
+    void givenJavaVarargs_whenMethodCall_thenAssertTheReturnedConcatenatedString() {
+        Motorcycle motorcycle = new Motorcycle("Ducati", "Monster", "red", 350, true, 2023);
+        motorcycle.addMotorcycleFeatures("abs");
+        assertThat(motorcycle.getFeatures()).isEqualToIgnoringCase("abs");
+
+        motorcycle.addMotorcycleFeatures("navi", "charger");
+        assertThat(motorcycle.getFeatures()).isEqualToIgnoringCase("abs, navi, charger");
+
+        motorcycle.addMotorcycleFeatures("wifi", "phone", "satellite");
+        assertThat(motorcycle.getFeatures()).isEqualToIgnoringCase("abs, navi, charger, wifi, phone, satellite");
+    }
+
+    @Test
+    void givenJavaBuilderPattern_whenMethodCall_thenVerifyCallIsDoneCorrectly() {
+        Car car = new Car.CarBuilder("Ford", "Focus", 2023).color("blue")
+            .automatic(true)
+            .features("abs, navi, charger, wifi, phone, satellite")
+            .build();
+
+        Car result = vehicleProcessor.processCar(car);
+
+        assertThat(result.toString()).hasToString(car.toString());
+    }
+
+}

core-java-modules/core-java-networking-4/README.md

@@ -3,3 +3,4 @@
 - [Validating URL in Java](https://www.baeldung.com/java-validate-url)
 - [Validating IPv4 Address in Java](https://www.baeldung.com/java-validate-ipv4-address)
 - [Download a Webpage in Java](https://www.baeldung.com/java-download-webpage)
+- [URL Query Manipulation in Java](https://www.baeldung.com/java-url-query-manipulation)

core-java-modules/core-java-networking/pom.xml

@@ -1,7 +1,7 @@
 <?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">
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <artifactId>core-java-networking</artifactId>
     <name>core-java-networking</name>
@@ -19,6 +19,11 @@
             <artifactId>spring-web</artifactId>
             <version>${springframework.spring-web.version}</version>
         </dependency>
+        <dependency>
+            <groupId>org.apache.httpcomponents</groupId>
+            <artifactId>httpclient</artifactId>
+            <version>${apache.httpclient.version}</version>
+        </dependency>
     </dependencies>
 
     <build>
@@ -27,6 +32,7 @@
 
     <properties>
         <springframework.spring-web.version>4.3.4.RELEASE</springframework.spring-web.version>
+        <apache.httpclient.version>4.5.14</apache.httpclient.version>
     </properties>
 
 </project>

core-java-modules/core-java-networking/src/test/java/com/baeldung/networking/url/UrlUnitTest.java

@@ -1,11 +1,19 @@
 package com.baeldung.networking.url;
 
+import static java.util.stream.Collectors.toList;
 import static org.junit.Assert.assertEquals;
 
 import java.net.MalformedURLException;
+import java.net.URISyntaxException;
 import java.net.URL;
+import java.util.Map;
 
+import org.apache.http.client.utils.URIBuilder;
+import org.apache.http.message.BasicNameValuePair;
 import org.junit.Test;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import com.google.common.collect.ImmutableMap;
 
 public class UrlUnitTest {
 
@@ -101,4 +109,44 @@ public class UrlUnitTest {
         assertEquals("http://baeldung.com:9000/guidelines.txt", url.toString());
     }
 
-}
+    @Test
+    public void givenUrlParameters_whenBuildUrlWithURIBuilder_thenSuccess() throws URISyntaxException, MalformedURLException {
+        URIBuilder uriBuilder = new URIBuilder("http://baeldung.com/articles");
+        uriBuilder.setPort(9090);
+        uriBuilder.addParameter("topic", "java");
+        uriBuilder.addParameter("version", "8");
+        URL url = uriBuilder.build().toURL();
+        assertEquals("http://baeldung.com:9090/articles?topic=java&version=8", url.toString());
+    }
+
+    @Test
+    public void givenUrlParametersInMap_whenBuildUrlWithURIBuilder_thenSuccess() throws URISyntaxException, MalformedURLException {
+        Map<String, String> paramMap = ImmutableMap.of("topic", "java", "version", "8");
+        URIBuilder uriBuilder = new URIBuilder("http://baeldung.com/articles");
+        uriBuilder.setPort(9090);
+        uriBuilder.addParameters(paramMap.entrySet()
+          .stream()
+          .map(entry -> new BasicNameValuePair(entry.getKey(), entry.getValue()))
+          .collect(toList()));
+
+        URL url = uriBuilder.build().toURL();
+        assertEquals("http://baeldung.com:9090/articles?topic=java&version=8", url.toString());
+    }
+
+    @Test
+    public void givenUrlParameters_whenBuildUrlWithSpringUriComponentsBuilder_thenSuccess() throws MalformedURLException {
+        URL url = UriComponentsBuilder.newInstance()
+          .scheme("http")
+          .host("baeldung.com")
+          .port(9090)
+          .path("articles")
+          .queryParam("topic", "java")
+          .queryParam("version", "8")
+          .build()
+          .toUri()
+          .toURL();
+
+        assertEquals("http://baeldung.com:9090/articles?topic=java&version=8", url.toString());
+    }
+
+}

core-java-modules/core-java-perf/README.md

@@ -13,3 +13,4 @@ This module contains articles about performance of Java applications
 - [Capturing a Java Thread Dump](https://www.baeldung.com/java-thread-dump)
 - [JMX Ports](https://www.baeldung.com/jmx-ports)
 - [Calling JMX MBean Method From a Shell Script](https://www.baeldung.com/jmx-mbean-shell-access)
+- [External Debugging With JMXTerm](https://www.baeldung.com/java-jmxterm-external-debugging)

core-java-modules/core-java-regex-2/README.md

@@ -5,4 +5,5 @@
 - [Converting Camel Case and Title Case to Words in Java](https://www.baeldung.com/java-camel-case-title-case-to-words)
 - [How to Use Regular Expressions to Replace Tokens in Strings in Java](https://www.baeldung.com/java-regex-token-replacement)
 - [Creating a Java Array from Regular Expression Matches](https://www.baeldung.com/java-array-regex-matches)
+- [Getting the Text That Follows After the Regex Match in Java](https://www.baeldung.com/java-regex-text-after-match)
 - More articles: [[<-- prev]](/core-java-modules/core-java-regex)

core-java-modules/core-java-streams-3/src/test/java/com/baeldung/streams/flatmap/map/Java8MapAndFlatMapUnitTest.java

@@ -1,4 +1,4 @@
-package com.baeldung.java8;
+package com.baeldung.streams.flatmap.map;
 
 import org.junit.Test;
 
@@ -12,7 +12,7 @@ import java.util.stream.Stream;
 import static java.util.Arrays.asList;
 import static org.junit.Assert.assertEquals;
 
-public class Java8MapAndFlatMap {
+public class Java8MapAndFlatMapUnitTest {
 
     @Test
     public void givenStream_whenCalledMap_thenProduceList() {

core-java-modules/core-java-string-algorithms-3/README.md

@@ -10,3 +10,4 @@ This module contains articles about string-related algorithms.
 - [Check if the First Letter of a String is Uppercase](https://www.baeldung.com/java-check-first-letter-uppercase)
 - [Find the First Non Repeating Character in a String in Java](https://www.baeldung.com/java-find-the-first-non-repeating-character)
 - [Find the First Embedded Occurrence of an Integer in a Java String](https://www.baeldung.com/java-string-find-embedded-integer)
+- [Find the Most Frequent Characters in a String](https://www.baeldung.com/java-string-find-most-frequent-characters)

core-java-modules/core-java-string-operations-5/src/main/java/com/baeldung/firstchardigit/FirstCharDigit.java

@@ -0,0 +1,62 @@
+package com.baeldung.firstchardigit;
+
+import java.util.regex.Pattern;
+
+import com.google.common.base.CharMatcher;
+
+public class FirstCharDigit {
+
+    public static boolean checkUsingCharAtMethod(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        char c = str.charAt(0);
+        return c >= '0' && c <= '9';
+    }
+
+    public static boolean checkUsingIsDigitMethod(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        return Character.isDigit(str.charAt(0));
+    }
+
+    public static boolean checkUsingPatternClass(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        return Pattern.compile("^[0-9].*")
+          .matcher(str)
+          .matches();
+    }
+
+    public static boolean checkUsingMatchesMethod(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        return str.matches("^[0-9].*");
+    }
+
+    public static boolean checkUsingCharMatcherInRangeMethod(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        return CharMatcher.inRange('0', '9')
+          .matches(str.charAt(0));
+    }
+
+    public static boolean checkUsingCharMatcherForPredicateMethod(String str) {
+        if (str == null || str.length() == 0) {
+            return false;
+        }
+
+        return CharMatcher.forPredicate(Character::isDigit)
+          .matches(str.charAt(0));
+    }
+
+}

core-java-modules/core-java-string-operations-5/src/test/java/com/baeldung/firstchardigit/FirstCharDigitUnitTest.java

@@ -0,0 +1,58 @@
+package com.baeldung.firstchardigit;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+class FirstCharDigitUnitTest {
+
+    @Test
+    void givenString_whenUsingCharAtMethod_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingCharAtMethod("12 years"));
+        assertFalse(FirstCharDigit.checkUsingCharAtMethod("years"));
+        assertFalse(FirstCharDigit.checkUsingCharAtMethod(""));
+        assertFalse(FirstCharDigit.checkUsingCharAtMethod(null));
+    }
+
+    @Test
+    void givenString_whenUsingIsDigitMethod_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingIsDigitMethod("10 cm"));
+        assertFalse(FirstCharDigit.checkUsingIsDigitMethod("cm"));
+        assertFalse(FirstCharDigit.checkUsingIsDigitMethod(""));
+        assertFalse(FirstCharDigit.checkUsingIsDigitMethod(null));
+    }
+
+    @Test
+    void givenString_whenUsingPatternClass_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingPatternClass("1 kg"));
+        assertFalse(FirstCharDigit.checkUsingPatternClass("kg"));
+        assertFalse(FirstCharDigit.checkUsingPatternClass(""));
+        assertFalse(FirstCharDigit.checkUsingPatternClass(null));
+    }
+
+    @Test
+    void givenString_whenUsingMatchesMethod_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingMatchesMethod("123"));
+        assertFalse(FirstCharDigit.checkUsingMatchesMethod("ABC"));
+        assertFalse(FirstCharDigit.checkUsingMatchesMethod(""));
+        assertFalse(FirstCharDigit.checkUsingMatchesMethod(null));
+    }
+
+    @Test
+    void givenString_whenUsingCharMatcherInRangeMethod_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingCharMatcherInRangeMethod("2023"));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod("abc"));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod(""));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherInRangeMethod(null));
+    }
+
+    @Test
+    void givenString_whenUsingCharMatcherForPredicateMethod_thenSuccess() {
+        assertTrue(FirstCharDigit.checkUsingCharMatcherForPredicateMethod("100"));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod("abdo"));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod(""));
+        assertFalse(FirstCharDigit.checkUsingCharMatcherForPredicateMethod(null));
+    }
+
+}

core-java-modules/core-java/.gitignore

@@ -1,25 +0,0 @@
-*.class
-
-0.*
-
-#folders#
-/target
-/neoDb*
-/data
-/src/main/webapp/WEB-INF/classes
-*/META-INF/*
-.resourceCache
-
-# Packaged files #
-*.jar
-*.war
-*.ear
-
-# Files generated by integration tests
-backup-pom.xml
-/bin/
-/temp
-
-#IntelliJ specific
-.idea/
-*.iml

core-java-modules/core-java/README.md

@@ -1,4 +0,0 @@
-## Core Java Cookbooks and Examples
-
-### Relevant Articles: 
-

core-java-modules/core-java/customers.xml

@@ -1,95 +0,0 @@
-<?xml version="1.0"?>
-<webRowSet xmlns="http://java.sun.com/xml/ns/jdbc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-xsi:schemaLocation="http://java.sun.com/xml/ns/jdbc http://java.sun.com/xml/ns/jdbc/webrowset.xsd">
-  <properties>
-    <command>SELECT * FROM customers</command>
-    <concurrency>1008</concurrency>
-    <datasource><null/></datasource>
-    <escape-processing>true</escape-processing>
-    <fetch-direction>1000</fetch-direction>
-    <fetch-size>0</fetch-size>
-    <isolation-level>2</isolation-level>
-    <key-columns>
-    </key-columns>
-    <map>
-    </map>
-    <max-field-size>0</max-field-size>
-    <max-rows>0</max-rows>
-    <query-timeout>0</query-timeout>
-    <read-only>true</read-only>
-    <rowset-type>ResultSet.TYPE_SCROLL_INSENSITIVE</rowset-type>
-    <show-deleted>false</show-deleted>
-    <table-name>customers</table-name>
-    <url>jdbc:h2:mem:testdb</url>
-    <sync-provider>
-      <sync-provider-name>com.sun.rowset.providers.RIOptimisticProvider</sync-provider-name>
-      <sync-provider-vendor>Oracle Corporation</sync-provider-vendor>
-      <sync-provider-version>1.0</sync-provider-version>
-      <sync-provider-grade>2</sync-provider-grade>
-      <data-source-lock>1</data-source-lock>
-    </sync-provider>
-  </properties>
-  <metadata>
-    <column-count>2</column-count>
-    <column-definition>
-      <column-index>1</column-index>
-      <auto-increment>false</auto-increment>
-      <case-sensitive>true</case-sensitive>
-      <currency>false</currency>
-      <nullable>0</nullable>
-      <signed>true</signed>
-      <searchable>true</searchable>
-      <column-display-size>11</column-display-size>
-      <column-label>ID</column-label>
-      <column-name>ID</column-name>
-      <schema-name>PUBLIC</schema-name>
-      <column-precision>10</column-precision>
-      <column-scale>0</column-scale>
-      <table-name>CUSTOMERS</table-name>
-      <catalog-name>TESTDB</catalog-name>
-      <column-type>4</column-type>
-      <column-type-name>INTEGER</column-type-name>
-    </column-definition>
-    <column-definition>
-      <column-index>2</column-index>
-      <auto-increment>false</auto-increment>
-      <case-sensitive>true</case-sensitive>
-      <currency>false</currency>
-      <nullable>0</nullable>
-      <signed>true</signed>
-      <searchable>true</searchable>
-      <column-display-size>50</column-display-size>
-      <column-label>NAME</column-label>
-      <column-name>NAME</column-name>
-      <schema-name>PUBLIC</schema-name>
-      <column-precision>50</column-precision>
-      <column-scale>0</column-scale>
-      <table-name>CUSTOMERS</table-name>
-      <catalog-name>TESTDB</catalog-name>
-      <column-type>12</column-type>
-      <column-type-name>VARCHAR</column-type-name>
-    </column-definition>
-  </metadata>
-  <data>
-    <currentRow>
-      <columnValue>1</columnValue>
-      <columnValue>Customer1</columnValue>
-    </currentRow>
-    <currentRow>
-      <columnValue>2</columnValue>
-      <columnValue>Customer2</columnValue>
-    </currentRow>
-    <currentRow>
-      <columnValue>3</columnValue>
-      <columnValue>Customer3</columnValue>
-    </currentRow>
-    <currentRow>
-      <columnValue>4</columnValue>
-      <columnValue>Customer4</columnValue>
-    </currentRow>
-    <currentRow>
-      <columnValue>5</columnValue>
-      <columnValue>Customer5</columnValue>
-    </currentRow>
-  </data>
-</webRowSet>

core-java-modules/core-java/pom.xml

@@ -1,174 +0,0 @@
-<?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>core-java</artifactId>
-    <name>core-java</name>
-    <packaging>jar</packaging>
-
-    <parent>
-        <groupId>com.baeldung.core-java-modules</groupId>
-        <artifactId>core-java-modules</artifactId>
-        <version>0.0.1-SNAPSHOT</version>
-    </parent>
-
-    <dependencies>
-        <dependency>
-            <groupId>org.unix4j</groupId>
-            <artifactId>unix4j-command</artifactId>
-            <version>${unix4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>com.googlecode.grep4j</groupId>
-            <artifactId>grep4j</artifactId>
-            <version>${grep4j.version}</version>
-        </dependency>
-        <!-- web -->
-        <!-- marshalling -->
-        <dependency>
-            <groupId>com.fasterxml.jackson.core</groupId>
-            <artifactId>jackson-databind</artifactId>
-            <version>${jackson.version}</version>
-        </dependency>
-        <!-- logging -->
-        <dependency>
-            <groupId>log4j</groupId>
-            <artifactId>log4j</artifactId>
-            <version>${log4j.version}</version>
-        </dependency>
-        <dependency> <!-- needed to bridge to slf4j for projects that use the log4j APIs directly -->
-            <groupId>org.slf4j</groupId>
-            <artifactId>log4j-over-slf4j</artifactId>
-            <version>${org.slf4j.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>org.projectlombok</groupId>
-            <artifactId>lombok</artifactId>
-            <version>${lombok.version}</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.springframework</groupId>
-            <artifactId>spring-core</artifactId>
-            <version>${spring.core.version}</version>
-        </dependency>
-        <dependency>
-            <groupId>commons-io</groupId>
-            <artifactId>commons-io</artifactId>
-            <version>${commons-io.version}</version>
-        </dependency>
-    </dependencies>
-
-    <build>
-        <finalName>core-java</finalName>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-dependency-plugin</artifactId>
-                <executions>
-                    <execution>
-                        <id>copy-dependencies</id>
-                        <phase>prepare-package</phase>
-                        <goals>
-                            <goal>copy-dependencies</goal>
-                        </goals>
-                        <configuration>
-                            <outputDirectory>${project.build.directory}/libs</outputDirectory>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.codehaus.mojo</groupId>
-                <artifactId>exec-maven-plugin</artifactId>
-                <configuration>
-                    <executable>java</executable>
-                    <mainClass>com.baeldung.outofmemoryerror.OutOfMemoryGCLimitExceed</mainClass>
-                    <arguments>
-                        <argument>-Xmx300m</argument>
-                        <argument>-XX:+UseParallelGC</argument>
-                        <argument>-classpath</argument>
-                        <classpath />
-                        <argument>com.baeldung.outofmemoryerror.OutOfMemoryGCLimitExceed</argument>
-                    </arguments>
-                </configuration>
-            </plugin>
-        </plugins>
-    </build>
-
-    <profiles>
-        <profile>
-            <id>integration</id>
-            <build>
-                <plugins>
-                    <plugin>
-                        <groupId>org.apache.maven.plugins</groupId>
-                        <artifactId>maven-surefire-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <phase>integration-test</phase>
-                                <goals>
-                                    <goal>test</goal>
-                                </goals>
-                                <configuration>
-                                    <excludes>
-                                        <exclude>**/*ManualTest.java</exclude>
-                                    </excludes>
-                                    <includes>
-                                        <include>**/*IntegrationTest.java</include>
-                                        <include>**/*IntTest.java</include>
-                                    </includes>
-                                </configuration>
-                            </execution>
-                        </executions>
-                        <configuration>
-                            <systemPropertyVariables>
-                                <test.mime>json</test.mime>
-                            </systemPropertyVariables>
-                        </configuration>
-                    </plugin>
-                    <plugin>
-                        <groupId>org.codehaus.mojo</groupId>
-                        <artifactId>exec-maven-plugin</artifactId>
-                        <executions>
-                            <execution>
-                                <id>run-benchmarks</id>
-                                <!-- <phase>integration-test</phase> -->
-                                <phase>none</phase>
-                                <goals>
-                                    <goal>exec</goal>
-                                </goals>
-                                <configuration>
-                                    <classpathScope>test</classpathScope>
-                                    <executable>java</executable>
-                                    <arguments>
-                                        <argument>-classpath</argument>
-                                        <classpath />
-                                        <argument>org.openjdk.jmh.Main</argument>
-                                        <argument>.*</argument>
-                                    </arguments>
-                                </configuration>
-                            </execution>
-                        </executions>
-                    </plugin>
-                </plugins>
-            </build>
-        </profile>
-    </profiles>
-
-    <properties>
-        <!-- util -->
-        <unix4j.version>0.4</unix4j.version>
-        <grep4j.version>1.8.7</grep4j.version>
-        <!-- maven plugins -->
-        <spring.core.version>4.3.20.RELEASE</spring.core.version>
-    </properties>
-
-</project>