Merge branch 'eugenp:master' into master

Author: AndreiBranza

core-java-modules/core-java-arrays-operations-advanced/src/test/java/com/baeldung/arraycompare/ArraysCompareUnitTest.java

@@ -18,8 +18,8 @@ void givenSameContents_whenCompare_thenCorrect() {
 
     @Test
     void givenDifferentContents_whenCompare_thenDifferent() {
-        String[] array1 = new String[] { "A", "B", "C" };
-        String[] array2 = new String[] { "A", "C", "B", "D" };
+        String[] array1 = new String[] { "A", "B", "C", "D"};
+        String[] array2 = new String[] { "A", "C", "B" };
 
         assertThat(Arrays.compare(array1, array2)).isLessThan(0);
         assertThat(Arrays.compare(array2, array1)).isGreaterThan(0);

core-java-modules/core-java-arrays-operations-basic/pom.xml

@@ -56,6 +56,14 @@
                     </execution>
                 </executions>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>10</source>
+                    <target>10</target>
+                </configuration>
+            </plugin>
         </plugins>
     </build>
 

core-java-modules/core-java-arrays-operations-basic/src/main/java/com/baeldung/array/ArrayInitializer.java

@@ -1,21 +1,23 @@
 package com.baeldung.array;
 
 import java.util.Arrays;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
 
 import org.apache.commons.lang3.ArrayUtils;
 
 public class ArrayInitializer {
 
     static int[] initializeArrayInLoop() {
-        int array[] = new int[5];
+        int[] array = new int[5];
         for (int i = 0; i < array.length; i++) {
             array[i] = i + 2;
         }
         return array;
     }
 
     static int[][] initializeMultiDimensionalArrayInLoop() {
-        int array[][] = new int[2][5];
+        int[][] array = new int[2][5];
         for (int i = 0; i < 2; i++) {
             for (int j = 0; j < 5; j++) {
                 array[i][j] = j + 1;
@@ -26,7 +28,7 @@ static int[][] initializeMultiDimensionalArrayInLoop() {
     }
 
     static String[] initializeArrayAtTimeOfDeclarationMethod1() {
-        String array[] = new String[] { "Toyota", "Mercedes", "BMW", "Volkswagen", "Skoda" };
+        String[] array = new String[] { "Toyota", "Mercedes", "BMW", "Volkswagen", "Skoda" };
         return array;
     }
 
@@ -36,30 +38,30 @@ static int[] initializeArrayAtTimeOfDeclarationMethod2() {
     }
 
     static int[] initializeArrayAtTimeOfDeclarationMethod3() {
-        int array[] = { 1, 2, 3, 4, 5 };
+        int[] array = { 1, 2, 3, 4, 5 };
         return array;
     }
 
     static long[] initializeArrayUsingArraysFill() {
-        long array[] = new long[5];
+        long[] array = new long[5];
         Arrays.fill(array, 30);
         return array;
     }
 
     static int[] initializeArrayRangeUsingArraysFill() {
-        int array[] = new int[5];
+        int[] array = new int[5];
         Arrays.fill(array, 0, 3, -50);
         return array;
     }
 
     static int[] initializeArrayUsingArraysCopy() {
-        int array[] = { 1, 2, 3, 4, 5 };
+        int[] array = { 1, 2, 3, 4, 5 };
         int[] copy = Arrays.copyOf(array, 5);
         return copy;
     }
 
     static int[] initializeLargerArrayUsingArraysCopy() {
-        int array[] = { 1, 2, 3, 4, 5 };
+        int[] array = { 1, 2, 3, 4, 5 };
         int[] copy = Arrays.copyOf(array, 6);
         return copy;
     }
@@ -75,4 +77,56 @@ static char[] initializeArrayUsingArraysUtilClone() {
         char[] array = new char[] { 'a', 'b', 'c' };
         return ArrayUtils.clone(array);
     }
+
+    static int[] initializeArrayUsingArraysStream() {
+        int[] array = new int[5];
+        Arrays.setAll(array, i -> i + 1);
+        return array;
+    }
+
+    static int[] initializeArrayWithDefaultValues() {
+        return new int[5];
+    }
+
+    static double[] initializeArrayOfDoubleTypeWithDefaultValues() {
+        return new double[5];
+    }
+
+    static String[] initializeArrayOfStringTypeWithDefaultValues() {
+        return new String[5];
+    }
+
+    static boolean[] initializeArrayOfBooleanTypeWithDefaultValues() {
+        return new boolean[5];
+    }
+
+    static int[][] initializeTwoDimensionalArrayWithDefaultValues() {
+        return new int[2][5];
+    }
+
+    static int[] initializeArrayUsingIntStream() {
+        int[] values = IntStream.of(1, 2, 3, 4, 5)
+            .toArray();
+        return values;
+    }
+
+    static double[] initializeArrayOfDoubleTypeUsingStreamApi() {
+        return Arrays.stream(new double[] { 1.1, 2.2, 3.3, 4.4, 5.5 })
+            .toArray();
+    }
+
+    static int[][][] initializeThreeDimensionalArrayWithDefaultValue() {
+        return new int[2][3][4];
+    }
+
+    static int[][] initializeTwoDimensionalArrayUsingStream() {
+        int[][] matrix = IntStream.range(0, 3)
+            .mapToObj(i -> IntStream.range(0, 4)
+                .map(j -> i * 4 + j)
+                .toArray())
+            .toArray(int[][]::new);
+
+        return matrix;
+    }
+
 }

core-java-modules/core-java-arrays-operations-basic/src/test/java/com/baeldung/array/ArrayInitializerUnitTest.java

@@ -11,10 +11,19 @@
 import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysUtilClone;
 import static com.baeldung.array.ArrayInitializer.initializeLargerArrayUsingArraysCopy;
 import static com.baeldung.array.ArrayInitializer.initializeMultiDimensionalArrayInLoop;
+import static com.baeldung.array.ArrayInitializer.initializeTwoDimensionalArrayWithDefaultValues;
+import static com.baeldung.array.ArrayInitializer.initializeArrayWithDefaultValues;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingArraysStream;
+import static com.baeldung.array.ArrayInitializer.initializeArrayUsingIntStream;
+import static com.baeldung.array.ArrayInitializer.initializeArrayOfDoubleTypeUsingStreamApi;
+import static com.baeldung.array.ArrayInitializer.initializeTwoDimensionalArrayUsingStream;
 import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
 
 import org.junit.Test;
 
+import java.util.Arrays;
+
 public class ArrayInitializerUnitTest {
 
     @Test
@@ -71,4 +80,94 @@ public void whenInitializeLargerArrayRangeUsingArraysSetAll_thenCorrect() {
     public void whenInitializeArrayUsingArraysUtilClone_thenCorrect() {
         assertArrayEquals(new char[] { 'a', 'b', 'c' }, initializeArrayUsingArraysUtilClone());
     }
+
+    @Test
+    public void whenInitializeArrayWithDefault_thenCorrect() {
+        assertArrayEquals(new int[5], initializeArrayWithDefaultValues());
+        int[] array = new int[5];
+        assertArrayEquals(new int[] { 0, 0, 0, 0, 0 }, array);
+    }
+
+    @Test
+    public void whenInitializeArrayOfBooleanTypeWithDefault_thenCorrect() {
+        boolean[] array = new boolean[5];
+        assertArrayEquals(new boolean[] { false, false, false, false, false }, array);
+    }
+
+    @Test
+    public void whenInitializeArrayOfStringTypeWithDefault_thenCorrect() {
+        String[] array = new String[5];
+        assertArrayEquals(new String[] { null, null, null, null, null }, array);
+    }
+
+    @Test
+    public void whenAddingItemsToAnArray_thenCorrect() {
+        int[] numbers = initializeArrayWithDefaultValues();
+        numbers[0] = 10;
+        numbers[1] = 20;
+        numbers[2] = 30;
+        numbers[3] = 40;
+        numbers[4] = 50;
+        assertEquals(5, numbers.length);
+        assertEquals(20, numbers[1]);
+    }
+
+    @Test
+    public void whenInitializeEmptyTwoDimensionalArray_thenCorrect() {
+        assertArrayEquals(new int[2][5], initializeTwoDimensionalArrayWithDefaultValues());
+    }
+
+    @Test
+    public void whenAddingItemsToAnTwoDimensionalArray_thenCorrect() {
+        int[][] matrix = initializeTwoDimensionalArrayWithDefaultValues();
+        matrix[0][0] = 10;
+        matrix[0][1] = 20;
+        matrix[0][2] = 30;
+        matrix[0][3] = 40;
+        matrix[0][4] = 50;
+        matrix[1][0] = 60;
+        matrix[1][1] = 70;
+        matrix[1][2] = 80;
+        matrix[1][3] = 90;
+        matrix[1][4] = 100;
+        assertEquals(2, matrix.length);
+        assertEquals(5, matrix[0].length);
+        assertEquals(5, matrix[1].length);
+        assertEquals(20, matrix[0][1]);
+    }
+
+    @Test
+    public void whenInitializeArrayWithStream_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, initializeArrayUsingArraysStream());
+    }
+
+    @Test
+    public void whenInitializeArrayOfIntegerUsingIntStream_thenCorrect() {
+        assertArrayEquals(new int[] { 1, 2, 3, 4, 5 }, initializeArrayUsingIntStream());
+    }
+
+    @Test
+    public void whenInitializeArrayOfDoubleUsingStreamApi_thenCorrect() {
+        assertArrayEquals(new double[] { 1.1, 2.2, 3.3, 4.4, 5.5 }, initializeArrayOfDoubleTypeUsingStreamApi(), 0.0);
+    }
+
+    @Test
+    public void whenInitializeEmptyThreeDimensionalArray_thenCorrect() {
+        int[][][] threeDimensionalArray = new int[2][3][4];
+        assertEquals(2, threeDimensionalArray.length);
+        assertEquals(3, threeDimensionalArray[0].length);
+        assertEquals(4, threeDimensionalArray[0][0].length);
+    }
+
+    @Test
+    public void whenInitializeTwoDimensionalArrayWithStreamApi_thenCorrect() {
+        assertArrayEquals(new int[][] { { 0, 1, 2, 3 }, { 4, 5, 6, 7 }, { 8, 9, 10, 11 } }, initializeTwoDimensionalArrayUsingStream());
+    }
+
+    @Test
+    public void whenPopulatingAnArrayWithSetAllMethod_thenCorrect() {
+        int[] numbers = new int[5];
+        Arrays.setAll(numbers, i -> i * 2);
+        assertArrayEquals(new int[] { 0, 2, 4, 6, 8 }, numbers);
+    }
 }

libraries-data-db/pom.xml

@@ -163,6 +163,13 @@
             <artifactId>jakarta.xml.bind-api</artifactId>
             <version>${jakarta.xml.bind.version}</version>
         </dependency>
+
+        <!-- TigerBeetle -->
+        <dependency>
+            <groupId>com.tigerbeetle</groupId>
+            <artifactId>tigerbeetle-java</artifactId>
+            <version>0.15.3</version>
+        </dependency>
     </dependencies>
 
     <build>

libraries-data-db/src/main/java/com/baeldung/libraries/tigerbeetle/config/TigerBeetleConfig.java

@@ -0,0 +1,24 @@
+package com.baeldung.libraries.tigerbeetle.config;
+
+import com.tigerbeetle.Client;
+import com.tigerbeetle.UInt128;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.math.BigInteger;
+
+@Configuration
+public class TigerBeetleConfig {
+
+    @Value("${tigerbeetle.clusterID:0}")
+    private BigInteger clusterID;
+
+    @Value("${tb_address:3000}")
+    private String[] replicaAddress;
+
+    @Bean
+    Client tigerBeetleClient() {
+        return new Client(UInt128.asBytes(clusterID), replicaAddress);
+    }
+}

libraries-data-db/src/main/java/com/baeldung/libraries/tigerbeetle/domain/Account.java

@@ -0,0 +1,21 @@
+package com.baeldung.libraries.tigerbeetle.domain;
+
+import lombok.Builder;
+
+import java.math.BigInteger;
+import java.util.UUID;
+
+@Builder
+public record Account(
+    UUID id,
+    BigInteger accountHolderId,
+    int code,
+    int ledger,
+    int userData32,
+    long userData64,
+    BigInteger creditsPosted,
+    BigInteger creditsPending,
+    BigInteger debtsPosted,
+    BigInteger debtsPending,
+    int flags,
+    long timestamp) {}

libraries-data-db/src/main/java/com/baeldung/libraries/tigerbeetle/domain/AccountException.java

@@ -0,0 +1,16 @@
+package com.baeldung.libraries.tigerbeetle.domain;
+
+import com.tigerbeetle.CreateAccountResult;
+
+public class AccountException extends RuntimeException{
+
+    private final CreateAccountResult result;
+
+    public AccountException(CreateAccountResult result) {
+        this.result = result;
+    }
+
+    public CreateAccountResult getResult() {
+        return this.result;
+    }
+}

libraries-data-db/src/main/java/com/baeldung/libraries/tigerbeetle/domain/Balance.java

@@ -0,0 +1,18 @@
+package com.baeldung.libraries.tigerbeetle.domain;
+
+import lombok.Builder;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.UUID;
+
+@Builder
+public record Balance(
+  UUID accountId,
+  Instant timestamp,
+  BigInteger creditsPosted,
+  BigInteger creditsPending,
+  BigInteger debitsPosted,
+  BigInteger debitsPending
+) {
+}

libraries-data-db/src/main/java/com/baeldung/libraries/tigerbeetle/domain/Transfer.java

@@ -0,0 +1,24 @@
+package com.baeldung.libraries.tigerbeetle.domain;
+
+import lombok.Builder;
+
+import java.math.BigInteger;
+import java.time.Instant;
+import java.util.UUID;
+
+@Builder
+public record Transfer(
+  UUID id,
+  BigInteger amount,
+  int code,
+  int ledger,
+  int flags,
+  UUID debitAccountId,
+  UUID creditAccountId,
+  Instant timestamp,
+  int userData32,
+  long userData64,
+  UUID userData128,
+  UUID pendingId
+) {
+}