diff --git a/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteToCharArrayUnitTest.java b/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteToCharArrayUnitTest.java new file mode 100644 index 0000000000..c62520cedc --- /dev/null +++ b/core-java-modules/core-java-arrays-convert/src/test/java/com/baeldung/array/conversions/ByteToCharArrayUnitTest.java @@ -0,0 +1,47 @@ +package com.baeldung.array.conversions; + +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStreamReader; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.StandardCharsets; + +import static org.junit.Assert.assertArrayEquals; + +public class ByteToCharArrayUnitTest { + public static byte[] byteArray = {65, 66, 67, 68}; + public static char[] expected = {'A', 'B', 'C', 'D'}; + + @Test + public void givenByteArray_WhenUsingStandardCharsets_thenConvertToCharArray() { + char[] charArray = new String(byteArray, StandardCharsets.UTF_8).toCharArray(); + assertArrayEquals(expected, charArray); + } + + @Test + public void givenByteArray_WhenUsingSUsingStreams_thenConvertToCharArray() throws IOException { + ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArray); + InputStreamReader reader = new InputStreamReader(inputStream); + ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); + int data; + while ((data = reader.read()) != -1) { + char ch = (char) data; + outputStream.write(ch); + } + char[] charArray = outputStream.toString().toCharArray(); + assertArrayEquals(expected, charArray); + } + + @Test + public void givenByteArray_WhenUsingCharBuffer_thenConvertToCharArray() { + ByteBuffer byteBuffer = ByteBuffer.wrap(byteArray); + CharBuffer charBuffer = StandardCharsets.UTF_8.decode(byteBuffer); + char[] charArray = new char[charBuffer.remaining()]; + charBuffer.get(charArray); + assertArrayEquals(expected, charArray); + } +} diff --git a/core-java-modules/core-java-collections-maps-7/pom.xml b/core-java-modules/core-java-collections-maps-7/pom.xml index a05b1b3528..2d08c0a438 100644 --- a/core-java-modules/core-java-collections-maps-7/pom.xml +++ b/core-java-modules/core-java-collections-maps-7/pom.xml @@ -38,6 +38,16 @@ guava 32.1.2-jre + + org.openjdk.jmh + jmh-core + 1.37 + + + org.openjdk.jmh + jmh-generator-annprocess + 1.37 + diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/BenchmarkMapMethods.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethods.java similarity index 99% rename from core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/BenchmarkMapMethods.java rename to core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethods.java index eca028efe4..563b2ffdae 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/BenchmarkMapMethods.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethods.java @@ -1,4 +1,4 @@ -package com.baeldung.map; +package com.baeldung.map.incrementmapkey; import java.util.HashMap; import java.util.Map; diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethodsJMH.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethodsJMH.java new file mode 100644 index 0000000000..4ddf3886e9 --- /dev/null +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/BenchmarkMapMethodsJMH.java @@ -0,0 +1,68 @@ +package com.baeldung.map.incrementmapkey; + +import java.util.concurrent.TimeUnit; + +import org.openjdk.jmh.annotations.Benchmark; +import org.openjdk.jmh.annotations.BenchmarkMode; +import org.openjdk.jmh.annotations.Fork; +import org.openjdk.jmh.annotations.Mode; +import org.openjdk.jmh.annotations.OutputTimeUnit; +import org.openjdk.jmh.annotations.Scope; +import org.openjdk.jmh.annotations.State; + +@State(Scope.Benchmark) +public class BenchmarkMapMethodsJMH { + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + @Fork(value = 1, warmups = 1) + public void benchMarkGuavaMap() { + IncrementMapValueWays im = new IncrementMapValueWays(); + im.charFrequencyUsingAtomicMap(getString()); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + @Fork(value = 1, warmups = 1) + public void benchContainsKeyMap() { + IncrementMapValueWays im = new IncrementMapValueWays(); + im.charFrequencyUsingContainsKey(getString()); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + @Fork(value = 1, warmups = 1) + public void benchMarkComputeMethod() { + IncrementMapValueWays im = new IncrementMapValueWays(); + im.charFrequencyUsingCompute(getString()); + } + + @Benchmark + @BenchmarkMode(Mode.AverageTime) + @OutputTimeUnit(TimeUnit.NANOSECONDS) + @Fork(value = 1, warmups = 1) + public void benchMarkMergeMethod() { + IncrementMapValueWays im = new IncrementMapValueWays(); + im.charFrequencyUsingMerge(getString()); + } + + public static void main(String[] args) throws Exception { + org.openjdk.jmh.Main.main(args); + } + + private String getString() { + return + "Once upon a time in a quaint village nestled between rolling hills and whispering forests, there lived a solitary storyteller named Elias. Elias was known for spinning tales that transported listeners to magical realms and awakened forgotten dreams.\n" + + "\n" + + "His favorite spot was beneath an ancient oak tree, its sprawling branches offering shade to those who sought refuge from the bustle of daily life. Villagers of all ages would gather around Elias, their faces illuminated by the warmth of his stories.\n" + + "\n" + "One evening, as dusk painted the sky in hues of orange and purple, a curious young girl named Lily approached Elias. Her eyes sparkled with wonder as she asked for a tale unlike any other.\n" + "\n" + + "Elias smiled, sensing her thirst for adventure, and began a story about a forgotten kingdom veiled by mist, guarded by mystical creatures and enchanted by ancient spells. With each word, the air grew thick with anticipation, and the listeners were transported into a world where magic danced on the edges of reality.\n" + + "\n" + "As Elias weaved the story, Lily's imagination took flight. She envisioned herself as a brave warrior, wielding a shimmering sword against dark forces, her heart fueled by courage and kindness.\n" + "\n" + + "The night wore on, but the spell of the tale held everyone captive. The villagers laughed, gasped, and held their breaths, journeying alongside the characters through trials and triumphs.\n" + "\n" + + "As the final words lingered in the air, a sense of enchantment settled upon the listeners. They thanked Elias for the gift of his storytelling, each carrying a piece of the magical kingdom within their hearts.\n" + "\n" + + "Lily, inspired by the story, vowed to cherish the spirit of adventure and kindness in her own life. With a newfound spark in her eyes, she bid Elias goodnight, already dreaming of the countless adventures awaiting her.\n" + "\n" + + "Under the star-studded sky, Elias remained beneath the ancient oak, his heart aglow with the joy of sharing tales that ignited imagination and inspired dreams. And as the night embraced the village, whispers of the enchanted kingdom lingered in the breeze, promising endless possibilities to those who dared to believe."; + } +} diff --git a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/IncrementMapValueWays.java b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/IncrementMapValueWays.java similarity index 98% rename from core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/IncrementMapValueWays.java rename to core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/IncrementMapValueWays.java index 70b3c6c54d..e15b3aae8e 100644 --- a/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/IncrementMapValueWays.java +++ b/core-java-modules/core-java-collections-maps-7/src/main/java/com/baeldung/map/incrementmapkey/IncrementMapValueWays.java @@ -1,4 +1,4 @@ -package com.baeldung.map; +package com.baeldung.map.incrementmapkey; import java.util.HashMap; import java.util.Map; diff --git a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/IncrementMapValueUnitTest.java b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/incrementmapkey/IncrementMapValueUnitTest.java similarity index 97% rename from core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/IncrementMapValueUnitTest.java rename to core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/incrementmapkey/IncrementMapValueUnitTest.java index df4f2b787e..64b9e1155d 100644 --- a/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/IncrementMapValueUnitTest.java +++ b/core-java-modules/core-java-collections-maps-7/src/test/java/com/baeldung/map/incrementmapkey/IncrementMapValueUnitTest.java @@ -1,4 +1,4 @@ -package com.baeldung.map; +package com.baeldung.map.incrementmapkey; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -9,6 +9,8 @@ import java.util.stream.Stream; import org.junit.Assert; import org.junit.Test; +import com.baeldung.map.incrementmapkey.IncrementMapValueWays; + public class IncrementMapValueUnitTest { @Test diff --git a/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java b/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java new file mode 100644 index 0000000000..eb3a511256 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/main/java/com/baeldung/uuid/UUIDPositiveLongGenerator.java @@ -0,0 +1,83 @@ +package com.baeldung.uuid; + +import java.nio.ByteBuffer; +import java.security.SecureRandom; +import java.util.UUID; + +/** + * Methods are called by reflection in the unit test + */ +@SuppressWarnings("unused") +public class UUIDPositiveLongGenerator { + public long getLeastSignificantBits() { + return Math.abs(UUID.randomUUID().getLeastSignificantBits()); + } + + public long getMostSignificantBits() { + return Math.abs(UUID.randomUUID().getMostSignificantBits()); + } + + public long combineByteBuffer() { + UUID uuid = UUID.randomUUID(); + ByteBuffer bb = ByteBuffer.wrap(new byte[16]); + bb.putLong(uuid.getMostSignificantBits()); + bb.putLong(uuid.getLeastSignificantBits()); + bb.rewind(); + return Math.abs(bb.getLong()); + } + + public long combineBitwise() { + UUID uniqueUUID = UUID.randomUUID(); + long mostSignificantBits = uniqueUUID.getMostSignificantBits(); + long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); + return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); + } + + public long combineDirect() { + UUID uniqueUUID = UUID.randomUUID(); + long mostSignificantBits = uniqueUUID.getMostSignificantBits(); + long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); + return Math.abs(mostSignificantBits ^ (leastSignificantBits >> 1)); + } + + public long combinePermutation() { + UUID uuid = UUID.randomUUID(); + long mostSigBits = uuid.getMostSignificantBits(); + long leastSigBits = uuid.getLeastSignificantBits(); + byte[] uuidBytes = new byte[16]; + + for (int i = 0; i < 8; i++) { + uuidBytes[i] = (byte) (mostSigBits >>> (8 * (7 - i))); + uuidBytes[i + 8] = (byte) (leastSigBits >>> (8 * (7 - i))); + } + + long result = 0; + for (byte b : uuidBytes) { + result = (result << 8) | (b & 0xFF); + } + return Math.abs(result); + } + + public long combineWithSecureRandom() { + UUID uniqueUUID = UUID.randomUUID(); + SecureRandom secureRandom = new SecureRandom(); + long randomBits = secureRandom.nextLong(); + + long mostSignificantBits = uniqueUUID.getMostSignificantBits() ^ randomBits; + long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); + + return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); + } + + public long combineWithNanoTime() { + UUID uniqueUUID = UUID.randomUUID(); + long nanoTime = System.nanoTime(); + + long mostSignificantBits = uniqueUUID.getMostSignificantBits() ^ nanoTime; + long leastSignificantBits = uniqueUUID.getLeastSignificantBits(); + + return Math.abs((mostSignificantBits << 32) | (leastSignificantBits & 0xFFFFFFFFL)); + } + + +} diff --git a/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java new file mode 100644 index 0000000000..a4d57b19c2 --- /dev/null +++ b/core-java-modules/core-java-uuid/src/test/java/com/baeldung/uuid/UUIDPositiveLongGeneratorUnitTest.java @@ -0,0 +1,43 @@ +package com.baeldung.uuid; + +import org.junit.jupiter.api.Test; + +import java.lang.reflect.Method; +import java.util.HashSet; +import java.util.Set; + +import static org.assertj.core.api.Assertions.assertThat; + +public class UUIDPositiveLongGeneratorUnitTest { + + private final UUIDPositiveLongGenerator uuidLongGenerator = new UUIDPositiveLongGenerator(); + + private final Set uniqueValues = new HashSet<>(); + + @Test + void whenForeachMethods_thenRetryWhileNotUnique() throws Exception { + for (Method method : uuidLongGenerator.getClass().getDeclaredMethods()) { + long uniqueValue; + do uniqueValue = (long) method.invoke(uuidLongGenerator); while (!isUnique(uniqueValue)); + assertThat(uniqueValue).isPositive(); + } + } + + @Test + void whenGivenLongValue_thenCheckUniqueness() { + long uniqueValue = generateUniqueLong(); + assertThat(uniqueValue).isPositive(); + } + + private long generateUniqueLong() { + long uniqueValue; + do uniqueValue = uuidLongGenerator.combineBitwise(); while (!isUnique(uniqueValue)); + return uniqueValue; + } + + private boolean isUnique(long value) { + // Implement uniqueness checking logic, for example, by checking in the database + return uniqueValues.add(value); + } + +} diff --git a/core-java-modules/core-java-uuid/src/test/resources/logback.xml b/core-java-modules/core-java-uuid/src/test/resources/logback.xml index 56af2d397e..a076f8db47 100644 --- a/core-java-modules/core-java-uuid/src/test/resources/logback.xml +++ b/core-java-modules/core-java-uuid/src/test/resources/logback.xml @@ -2,8 +2,7 @@ - %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n - + %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n diff --git a/spring-jinq/pom.xml b/spring-jinq/pom.xml index 14ac366e74..c1dee7fa9f 100644 --- a/spring-jinq/pom.xml +++ b/spring-jinq/pom.xml @@ -10,9 +10,9 @@ com.baeldung - parent-boot-2 + parent-boot-3 0.0.1-SNAPSHOT - ../parent-boot-2 + ../parent-boot-3 @@ -35,6 +35,11 @@ org.springframework spring-orm + + org.hibernate.orm + hibernate-core + ${hibernate-core.version} + org.springframework.boot @@ -58,7 +63,8 @@ - 1.8.29 + 2.0.1 + 6.4.0.Final \ No newline at end of file diff --git a/spring-jinq/src/main/java/com/baeldung/spring/jinq/config/JinqProviderConfiguration.java b/spring-jinq/src/main/java/com/baeldung/spring/jinq/config/JinqProviderConfiguration.java index 6d921045b7..01e16cf0f7 100644 --- a/spring-jinq/src/main/java/com/baeldung/spring/jinq/config/JinqProviderConfiguration.java +++ b/spring-jinq/src/main/java/com/baeldung/spring/jinq/config/JinqProviderConfiguration.java @@ -1,6 +1,6 @@ package com.baeldung.spring.jinq.config; -import javax.persistence.EntityManagerFactory; +import jakarta.persistence.EntityManagerFactory; import org.jinq.jpa.JinqJPAStreamProvider; import org.springframework.beans.factory.annotation.Autowired; diff --git a/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Car.java b/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Car.java index 263e6c7622..a0b9620629 100644 --- a/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Car.java +++ b/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Car.java @@ -1,19 +1,23 @@ package com.baeldung.spring.jinq.entities; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.JoinColumn; -import javax.persistence.OneToOne; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.ManyToOne; + + @Entity(name = "CAR") public class Car { + @Id private String model; private String description; private int year; private String engine; + @ManyToOne + @JoinColumn(name = "name") private Manufacturer manufacturer; - @Id public String getModel() { return model; } @@ -46,8 +50,6 @@ public class Car { this.engine = engine; } - @OneToOne - @JoinColumn(name = "name") public Manufacturer getManufacturer() { return manufacturer; } diff --git a/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Manufacturer.java b/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Manufacturer.java index f6e5fd23de..0021e45658 100644 --- a/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Manufacturer.java +++ b/spring-jinq/src/main/java/com/baeldung/spring/jinq/entities/Manufacturer.java @@ -2,18 +2,19 @@ package com.baeldung.spring.jinq.entities; import java.util.List; -import javax.persistence.Entity; -import javax.persistence.Id; -import javax.persistence.OneToMany; +import jakarta.persistence.Entity; +import jakarta.persistence.Id; +import jakarta.persistence.OneToMany; @Entity(name = "MANUFACTURER") public class Manufacturer { + @Id private String name; private String city; + @OneToMany(mappedBy = "model") private List cars; - @Id public String getName() { return name; } @@ -30,7 +31,6 @@ public class Manufacturer { this.city = city; } - @OneToMany(mappedBy = "model") public List getCars() { return cars; } @@ -38,5 +38,4 @@ public class Manufacturer { public void setCars(List cars) { this.cars = cars; } - } diff --git a/spring-jinq/src/main/java/com/baeldung/spring/jinq/repositories/BaseJinqRepositoryImpl.java b/spring-jinq/src/main/java/com/baeldung/spring/jinq/repositories/BaseJinqRepositoryImpl.java index 42b81ecc59..e85231f537 100644 --- a/spring-jinq/src/main/java/com/baeldung/spring/jinq/repositories/BaseJinqRepositoryImpl.java +++ b/spring-jinq/src/main/java/com/baeldung/spring/jinq/repositories/BaseJinqRepositoryImpl.java @@ -1,7 +1,7 @@ package com.baeldung.spring.jinq.repositories; -import javax.persistence.EntityManager; -import javax.persistence.PersistenceContext; +import jakarta.persistence.EntityManager; +import jakarta.persistence.PersistenceContext; import org.jinq.jpa.JPAJinqStream; import org.jinq.jpa.JinqJPAStreamProvider; diff --git a/spring-jinq/src/test/java/com/baeldung/SpringContextTest.java b/spring-jinq/src/test/java/com/baeldung/SpringContextTest.java index 1a486d1003..7c65a831c4 100644 --- a/spring-jinq/src/test/java/com/baeldung/SpringContextTest.java +++ b/spring-jinq/src/test/java/com/baeldung/SpringContextTest.java @@ -4,7 +4,6 @@ import com.baeldung.spring.jinq.JinqApplication; import org.junit.jupiter.api.Test; import org.springframework.boot.test.context.SpringBootTest; -import com.baeldung.spring.jinq.JinqApplication; @SpringBootTest(classes = JinqApplication.class) public class SpringContextTest {