repo stringclasses 1k
values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1
value | license stringclasses 6
values | commit_sha stringclasses 1k
values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2
classes |
|---|---|---|---|---|---|---|---|---|
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P29_RoundFloatNumber/src/main/java/modern/challenge/Main.java | Chapter01/P29_RoundFloatNumber/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
float v = 14.9877655f;
int d = 5;
float resultV1 = Numbers.roundToDecimalsV1(v, d);
float resultV2 = Numbers.roundToDecimalsV2(v, d);
float resultV3 = Numbers.roundToDecimalsV3(v, d);
float resultV4 = Numbers.roundToDecimalsV4(v, d);
System.out.println(v + " / result (V1): " + resultV1);
System.out.println(v + " / result (V2): " + resultV2);
System.out.println(v + " / result (V3): " + resultV3);
System.out.println(v + " / result (V4): " + resultV4);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P25_MultiplyHigh/src/main/java/modern/challenge/Main.java | Chapter01/P25_MultiplyHigh/src/main/java/modern/challenge/Main.java | package modern.challenge;
import org.joou.ULong;
import static org.joou.Unsigned.ulong;
public class Main {
public static void main(String[] args) {
long x = 234253490223L;
long y = -565951223449L;
long resultSigned = Math.multiplyHigh(x, y);
System.out.println("Result (signed): " + resultSigned);
long resultUnsigned = Math.unsignedMultiplyHigh(x, y);
System.out.println("Result (unsigned): " + resultUnsigned);
// using jOOU
ULong ux = ulong(234253490223L);
ULong uy = ulong(-565951223449L);
System.out.println();
System.out.println("Unsigned x: " + ux + " long value: " + ux.longValue());
System.out.println("Unsigned y: " + uy + " long value: " + uy.longValue());
System.out.println();
long uResultSigned = Math.multiplyHigh(ux.longValue(), uy.longValue());
System.out.println("jOOU Result (signed): " + uResultSigned);
long uResultUnsigned = Math.unsignedMultiplyHigh(ux.longValue(), uy.longValue());
System.out.println("jOOU Result (unsigned): " + uResultUnsigned);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P35_InfiniteStreamOfRndGenerators/src/main/java/modern/challenge/Main.java | Chapter01/P35_InfiniteStreamOfRndGenerators/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Supplier;
import java.util.random.RandomGenerator.JumpableGenerator;
import java.util.random.RandomGenerator.LeapableGenerator;
import java.util.random.RandomGenerator.StreamableGenerator;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) throws NoSuchAlgorithmException {
// doubles between 0.0 and 0.5
Supplier<Double> doubles = Math::random;
double[] arrOfDoubles = Stream.generate(doubles) // or, Stream.generate(Math::random)
.takeWhile(t -> t < 0.5d) // without this condition the stream will be infinite
.mapToDouble(i -> i)
.toArray();
System.out.println("Doubles: " + Arrays.toString(arrOfDoubles));
// 10 integers via Random
Random rnd = new Random();
int[] arrOfInts = rnd.ints(10) // if we use the ints() alternative then the stream will be infinite
.toArray();
// or, shortly: int[] arrOfInts = new Random().ints(10).toArray();
System.out.println("Integers: " + Arrays.toString(arrOfInts));
// 10 integers via SecureRandom
SecureRandom secureRnd = SecureRandom.getInstanceStrong();
int[] arrOfSecInts = secureRnd.ints(10) // if we use the ints() alternative then the stream will be infinite
.toArray();
// or, shortly: int[] arrOfSecInts = SecureRandom.getInstanceStrong().ints(10).toArray();
System.out.println("Integers (via SecureRandom): " + Arrays.toString(arrOfSecInts));
ThreadLocalRandom tlRnd = ThreadLocalRandom.current();
int[] arrOfTlInts = tlRnd.ints(10) // if we use the ints() alternative then the stream will be infinite
.toArray();
// or, shortly: int[] arrOfTlInts = ThreadLocalRandom.current().ints(10).toArray();
System.out.println("Integers (via ThreadLocalRandom): " + Arrays.toString(arrOfTlInts));
// using StreamableGenerator
StreamableGenerator streamableRnd = StreamableGenerator.of("L128X1024MixRandom");
// 10 integers via StreamableGenerator
int[] arrOfStRndInts = streamableRnd.ints(10)
.toArray();
// or, shortly StreamableGenerator.of("L128X1024MixRandom").ints(10).toArray();
System.out.println("Integers (via StreamableGenerator): " + Arrays.toString(arrOfStRndInts));
System.out.println();
System.out.println("StreamableGenerator generators:");
streamableRnd.rngs(5) // generate 5 objects, each of which implements the RandomGenerator interface
// if we use rngs() then the stream is infinite
.forEach(System.out::println);
// each of the 5 generators generates 10 integers in an array
List<int[]> listOfArrOfIntsSG = streamableRnd.rngs(5) // obtain 5 generators
.map(r -> r.ints(10)) // each generator generates 10 integers
.map(r -> r.toArray()) // every 10 integers are mapped into an array
.collect(Collectors.toList()); // all 5 arrays are collected into a list
System.out.println();
System.out.println("List of arrays:");
for (int i = 0; i < listOfArrOfIntsSG.size(); i++) {
System.out.println("Array " + i + ": " + Arrays.toString(listOfArrOfIntsSG.get(i)));
}
// using JumpableGenerator
System.out.println();
JumpableGenerator jumpableRnd = JumpableGenerator.of("Xoshiro256PlusPlus");
// 10 integers via JumpableGenerator
int[] arrOfJpRndInts = jumpableRnd.ints(10)
.toArray();
// or, shortly JumpableGenerator.of("Xoshiro256PlusPlus").ints(10).toArray();
System.out.println("Integers (via JumpableGenerator): " + Arrays.toString(arrOfJpRndInts));
System.out.println();
System.out.println("JumpableGenerator generators:");
jumpableRnd.jumps(5) // generate 5 objects, each of which implements the RandomGenerator interface
// if we use jumps()/rngs() then the stream is infinite
.forEach(System.out::println);
// each of the 5 generators generates 10 integers in an array
List<int[]> listOfArrOfIntsJG = jumpableRnd.jumps(5) // obtain 5 generators
.map(r -> {
JumpableGenerator jg = (JumpableGenerator) r;
int[] ints = new int[10];
for (int i = 0; i < 10; i++) {
ints[i] = jg.nextInt();
jg.jump();
}
return ints;
}) // each generator generates 10 integers
.collect(Collectors.toList()); // all 5 arrays are collected into a list
System.out.println();
System.out.println("List of arrays:");
for (int i = 0; i < listOfArrOfIntsJG.size(); i++) {
System.out.println("Array " + i + ": " + Arrays.toString(listOfArrOfIntsJG.get(i)));
}
// using LeapableGenerator
System.out.println();
LeapableGenerator leapableRnd = LeapableGenerator.of("Xoshiro256PlusPlus");
// 10 integers via LeapableGenerator
int[] arrOfLpRndInts = leapableRnd.ints(10)
.toArray();
// or, shortly LeapableGenerator.of("Xoshiro256PlusPlus").ints(10).toArray();
System.out.println("Integers (via LeapableGenerator): " + Arrays.toString(arrOfLpRndInts));
System.out.println();
System.out.println("LeapableGenerator generators:");
leapableRnd.leaps(5) // generate 5 objects, each of which implements the RandomGenerator interface
// if we use leaps()/rngs() then the stream is infinite
.forEach(System.out::println);
// each of the 5 generators generates 10 integers in an array
List<int[]> listOfArrOfIntsLG = leapableRnd.leaps(5) // obtain 5 generators
.map(r -> {
LeapableGenerator lg = (LeapableGenerator) r;
int[] ints = new int[10];
for (int i = 0; i < 10; i++) {
ints[i] = lg.nextInt();
lg.leap();
}
return ints;
}) // each generator generates 10 integers
.collect(Collectors.toList()); // all 5 arrays are collected into a list
System.out.println();
System.out.println("List of arrays:");
for (int i = 0; i < listOfArrOfIntsLG.size(); i++) {
System.out.println("Array " + i + ": " + Arrays.toString(listOfArrOfIntsLG.get(i)));
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P20_MathAbsoluteValueOperationOverflow/src/main/java/modern/challenge/Main.java | Chapter01/P20_MathAbsoluteValueOperationOverflow/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.function.IntUnaryOperator;
import java.util.function.LongUnaryOperator;
public class Main {
public static void main(String[] args) {
int x = Integer.MIN_VALUE;
long y = Long.MIN_VALUE;
long absofx = Math.abs(x);
long absofy = Math.abs(y);
System.out.println("The mathematical absolute value of " + x + " via abs() is: " + absofx);
System.out.println("The mathematical absolute value of " + y + " via abs() is: " + absofy);
// throw ArithmeticException
int absofxExact = Math.absExact(x);
long absofyExact = Math.absExact(y);
System.out.println("The mathematical absolute value of " + x + " via absExact() is: " + absofxExact);
System.out.println("The mathematical absolute value of " + y + " via absExact() is: " + absofyExact);
// throw ArithmeticException
IntUnaryOperator operatorInt = Math::absExact;
LongUnaryOperator operatorLong = Math::absExact;
int absofxExactUo = operatorInt.applyAsInt(x);
long absofyExactUo = operatorLong.applyAsLong(y);
System.out.println("The mathematical absolute value of " + x + " via IntUnaryOperator is: " + absofxExactUo);
System.out.println("The mathematical absolute value of " + y + " via LongUnaryOperator is: " + absofyExactUo);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor4/src/main/java/modern/challenge/Main.java | Chapter01/P16_CustomTemplateProcessor4/src/main/java/modern/challenge/Main.java | package modern.challenge;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.util.regex.Pattern;
public class Main {
private static final Pattern PHONE_PATTERN = Pattern.compile(
"\\d{10}|(?:\\d{3}-){2}\\d{4}|\\(\\d{3}\\)\\d{3}-?\\d{4}");
public static void main(String[] args) throws IOException {
StringTemplate.Processor<JsonNode, IllegalArgumentException> pp
= (StringTemplate st) -> {
var values = st.values().stream()
.map(value -> {
if (!PHONE_PATTERN.matcher((CharSequence) value).matches()) {
return "Invalid phone number";
}
return value;
}).toList();
ObjectMapper mapper = new ObjectMapper();
try {
return mapper.readTree(StringTemplate.interpolate(
st.fragments(), values));
} catch (IOException ex) {
throw new RuntimeException(ex);
}
};
String workPhone = "072-825-90095"; // not valid
String homePhone = "(040)234-9670";
JsonNode jsonMessage = pp.
"""
{ "contact": {
"work": "\{workPhone}",
"home": "\{homePhone}"
}
}
""";
System.out.println(jsonMessage);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P03_TextBlockIndentation/src/main/java/modern/challenge/Main.java | Chapter01/P03_TextBlockIndentation/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
System.out.println("\nThe opening and closing delimiters are aligned:");
String json1 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}""";
System.out.println(json1);
System.out.println("\nThe closing delimiter is at the end of the content and "
+ "shifted-right with the content:");
String json2 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}""";
System.out.println(json2);
System.out.println("\nAdding more meaningful (or essential) white spaces"
+ " by shifting-right the content:");
String json3 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json3);
System.out.println("\nAdding more meaningful (or essential) white spaces"
+ " by shifting-left the closing delimiter:");
String json4 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json4);
System.out.println("\nAdding more meaningful (or essential) white spaces"
+ " by adjusting the content's lines:");
String json5 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}""";
System.out.println(json5);
System.out.println("\nAdding essential white spaces via String#indent():");
String json6 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}""".indent(8);
System.out.println(json6);
System.out.println("\nIndent a block of text having lines "
+ "placed at the same level of indentation (using JDK 14, \\, escape sequence):");
String poem1 = """
I would want to establish strength; root-like,
anchored in the hopes of solidity.
Forsake the contamination of instability.
Prove I’m the poet of each line of prose.\
""";
System.out.println(poem1);
System.out.println("\nIndent a block of text having lines "
+ "placed at the same level of indentation (before JDK 11):");
String poem2 = """
I would want to establish strength; root-like,
anchored in the hopes of solidity.
Forsake the contamination of instability.
Prove I’m the poet of each line of prose.
""".replaceFirst("\\s++$", "");
System.out.println(poem2);
System.out.println("\nIndent a block of text having lines "
+ "placed at the same level of indentation (starting with JDK 11):");
String poem3 = """
I would want to establish strength; root-like,
anchored in the hopes of solidity.
Forsake the contamination of instability.
Prove I’m the poet of each line of prose.
""".stripTrailing();
System.out.println(poem3);
System.out.println("\nIndent a block of text having lines "
+ "placed at the same level of indentation (starting with JDK 12):");
String poem4 = """
I would want to establish strength; root-like,
anchored in the hopes of solidity.
Forsake the contamination of instability.
Prove I’m the poet of each line of prose."""
.indent(6)
.stripTrailing();
System.out.println(poem4);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P33_PRNGSelectViaOf/src/main/java/modern/challenge/Main.java | Chapter01/P33_PRNGSelectViaOf/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.random.RandomGenerator;
import java.util.random.RandomGenerator.JumpableGenerator;
import java.util.random.RandomGenerator.LeapableGenerator;
import java.util.random.RandomGenerator.SplittableGenerator;
import java.util.random.RandomGenerator.StreamableGenerator;
import java.util.random.RandomGeneratorFactory;
public class Main {
public static void main(String[] args) {
// get the default random generator
RandomGenerator defaultGenerator = RandomGenerator.getDefault();
System.out.println("Default generator: " + defaultGenerator);
// using RandomGenerator.of()
RandomGenerator generator1 = RandomGenerator.of("L128X256MixRandom");
// using RandomGeneratorFactory.of()
RandomGenerator generator2 = RandomGeneratorFactory.of("Xoroshiro128PlusPlus")
.create();
// create a splittable generator ('L128X256MixRandom' is splittable)
RandomGenerator.SplittableGenerator splittableGenerator1 = RandomGeneratorFactory
.<RandomGenerator.SplittableGenerator>of("L128X256MixRandom")
.create();
// or, like this
SplittableGenerator splittableGenerator2 = RandomGeneratorFactory
.<SplittableGenerator>of("L128X256MixRandom")
.create();
// or, like this
RandomGenerator.SplittableGenerator splittableGenerator3 =
RandomGenerator.SplittableGenerator.of("L128X256MixRandom");
// or, like this
SplittableGenerator splittableGenerator4 = SplittableGenerator.of("L128X256MixRandom");
// or, like this:
java.util.SplittableRandom splittableGenerator5 = new java.util.SplittableRandom();
// create a streamable generator ('L64X128MixRandom' is streamable)
RandomGenerator.StreamableGenerator streamableGenerator1 = RandomGeneratorFactory
.<RandomGenerator.StreamableGenerator>of("L64X128MixRandom")
.create();
// or, like this
StreamableGenerator streamableGenerator2 = RandomGeneratorFactory
.<StreamableGenerator>of("L64X128MixRandom")
.create();
// or, like this
RandomGenerator.StreamableGenerator streamableGenerator3 =
RandomGenerator.StreamableGenerator.of("L64X128MixRandom");
// or, like this
StreamableGenerator streamableGenerator4 = StreamableGenerator.of("L64X128MixRandom");
// create a leapable generator ('Xoshiro256PlusPlus' is leapable)
RandomGenerator.LeapableGenerator leapableGenerator1 = RandomGeneratorFactory
.<RandomGenerator.LeapableGenerator>of("Xoshiro256PlusPlus")
.create();
// or, like this
LeapableGenerator leapableGenerator2 = RandomGeneratorFactory
.<LeapableGenerator>of("Xoshiro256PlusPlus")
.create();
// or, like this
RandomGenerator.LeapableGenerator leapableGenerator3 =
RandomGenerator.LeapableGenerator.of("Xoshiro256PlusPlus");
// or, like this
LeapableGenerator leapableGenerator4 = LeapableGenerator.of("Xoshiro256PlusPlus");
// create a jumpable generator ('Xoshiro256PlusPlus' is jumpable)
RandomGenerator.JumpableGenerator jumpableGenerator1 = RandomGeneratorFactory
.<RandomGenerator.JumpableGenerator>of("Xoshiro256PlusPlus")
.create();
// or, like this
JumpableGenerator jumpableGenerator2 = RandomGeneratorFactory
.<JumpableGenerator>of("Xoshiro256PlusPlus")
.create();
// or, like this
RandomGenerator.JumpableGenerator jumpableGenerator3 =
RandomGenerator.JumpableGenerator.of("Xoshiro256PlusPlus");
// or, like this
JumpableGenerator jumpableGenerator4 = JumpableGenerator.of("Xoshiro256PlusPlus");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P30_ClampingBetweenMinMax/src/main/java/modern/challenge/PressureRegulator.java | Chapter01/P30_ClampingBetweenMinMax/src/main/java/modern/challenge/PressureRegulator.java | package modern.challenge;
public final class PressureRegulator {
private static final int MIN_PRESSURE = 10;
private static final int MAX_PRESSURE = 50;
private PressureRegulator() {
throw new AssertionError("Cannot be instantiated");
}
public static int adjustV1(int pressure) {
if (pressure < MIN_PRESSURE) {
return MIN_PRESSURE;
}
if (pressure > MAX_PRESSURE) {
return MAX_PRESSURE;
}
return pressure;
}
public static int adjustV2(int pressure) {
return Math.clamp(pressure, MIN_PRESSURE, MAX_PRESSURE);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P30_ClampingBetweenMinMax/src/main/java/modern/challenge/Main.java | Chapter01/P30_ClampingBetweenMinMax/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
int lowPressure = 7;
int normalPressure = 23;
int highPressure = 55;
int adjustLowPressureV1 = PressureRegulator.adjustV1(lowPressure);
int adjustHighPressureV1 = PressureRegulator.adjustV1(highPressure);
int adjustNormalPressureV1 = PressureRegulator.adjustV1(normalPressure);
System.out.println("Adjust low pressure(V1): " + adjustLowPressureV1);
System.out.println("Adjust high pressure (V1): " + adjustHighPressureV1);
System.out.println("Adjust normal pressure (V1): " + adjustNormalPressureV1);
int adjustLowPressureV2 = PressureRegulator.adjustV2(lowPressure);
int adjustHighPressureV2 = PressureRegulator.adjustV2(highPressure);
int adjustNormalPressureV2 = PressureRegulator.adjustV2(normalPressure);
System.out.println("Adjust low pressure(V2): " + adjustLowPressureV2);
System.out.println("Adjust high pressure (V2): " + adjustHighPressureV2);
System.out.println("Adjust normal pressure (V2): " + adjustNormalPressureV2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P24_DoubleIsIntegerBenchmark/src/main/java/modern/challenge/Main.java | Chapter01/P24_DoubleIsIntegerBenchmark/src/main/java/modern/challenge/Main.java | package modern.challenge;
import com.google.common.math.DoubleMath;
import java.io.IOException;
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.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, warmups = 0)
@Measurement(iterations = 10, time = 1)
@State(Scope.Benchmark)
public class Main {
@Param({"23.11", "23"})
private double v;
@Benchmark
public boolean isDoubleIntegerV1() {
return v == (int) v;
}
@Benchmark
public boolean isDoubleIntegerV2() {
return v % 1 == 0;
}
@Benchmark
public boolean isDoubleIntegerV3() {
return ((Math.floor(v) == v) && Double.isFinite(v));
}
@Benchmark
public boolean isDoubleIntegerV4() {
return (Math.floor(v) == Math.ceil(v) && Double.isFinite(v));
}
@Benchmark
public boolean isDoubleIntegerV5() {
return ((Math.rint(v) == v) && Double.isFinite(v));
}
@Benchmark
public boolean isDoubleIntegerV6() {
return DoubleMath.isMathematicalInteger(v);
}
public static void main(String[] args) throws IOException {
org.openjdk.jmh.Main.main(args);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK11Benchmark/src/main/java/modern/challenge/Main.java | Chapter01/P13_StringConcatJDK11Benchmark/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
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.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, warmups = 0)
@Measurement(iterations = 90, time = 1)
@State(Scope.Benchmark)
public class Main {
private static String str1;
private static String str2;
private static String str3;
private static String str4;
private static List<String> strs;
@Setup
public void setup() {
str1 = "hello";
str2 = "my";
str3 = "dear";
str4 = "friend";
strs = Arrays.asList("hello", "my", "dear", "friend");
}
@Benchmark
public static String concatViaPlus() {
return str1 + str2 + str3 + str4;
}
@Benchmark
public static String concatViaStringBuilder() {
StringBuilder sb = new StringBuilder();
sb.append(str1)
.append(str2)
.append(str3)
.append(str4);
return sb.toString();
}
@Benchmark
public static String concatListViaPlus() {
String result = "";
for (String str : strs) {
result = result + str;
}
return result;
}
@Benchmark
public static String concatListViaStringBuilder() {
StringBuilder result = new StringBuilder();
for (String str : strs) {
result.append(str);
}
return result.toString();
}
public static void main(String[] args) throws IOException {
org.openjdk.jmh.Main.main(args);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P15_BuiltinStringTemplate/src/main/java/modern/challenge/Main.java | Chapter01/P15_BuiltinStringTemplate/src/main/java/modern/challenge/Main.java | package modern.challenge;
import static java.lang.StringTemplate.RAW;
import static java.lang.StringTemplate.STR;
import java.time.LocalDate;
import static java.util.FormatProcessor.FMT;
import java.util.List;
public class Main {
public static void main(String[] args) {
LocalDate fiscalDate = LocalDate.now();
double value = 4552.2367;
String employeeCode = "RN4555";
String jsonText = "{\"sale\": {\n"
+ " \"id\": 1,\n"
+ " \"details\": {\n"
+ " \"fiscal_year\": %d,\n".formatted(fiscalDate.getYear())
+ " \"employee_nr\": \"%s\",\n".formatted(employeeCode)
+ " \"value\": %.2f \n".formatted(value)
+ " }\n"
+ "}";
String jsonBlock = """
{"sale": {
"id": 1,
"details": {
"fiscal_year": %d,
"employee_nr": "%s",
"value": %.2f
}
}
""".formatted(fiscalDate.getYear(), employeeCode, value);
String jsonTextStr = "{\"sale\": {\n"
+ " \"id\": 1,\n"
+ " \"details\": {\n"
+ STR." \"fiscal_year\": \{fiscalDate.getYear()},\n"
+ STR." \"employee_nr\": \"\{employeeCode}\",\n"
+ STR.
" \"value\": \{value} \n"
+ " }\n"
+"}";
String jsonBlockStr = STR."""
{"sale": {
"id": 1,
"details": {
"fiscal_year": \{fiscalDate.getYear()},
"employee_nr": "\{employeeCode}",
"value": \{value}
}
}
""";
String jsonBlockFmt = FMT."""
{"sale": {
"id": 1,
"details": {
"fiscal_year": \{fiscalDate.getYear()},
"employee_nr": "\{employeeCode}",
"value": %.2f\{value}
}
}
""";
LocalDate fiscalDate1 = LocalDate.of(2023, 2, 4);
LocalDate fiscalDate2 = LocalDate.of(2024, 3, 12);
double value1 = 343.23;
double value2 = 1244.33;
StringTemplate templateRaw = RAW."""
"employee_nr": "\{employeeCode}",
""";
String jsonBlockRaw = STR."""
{"sale": {
"id": 1,
"details": {
"fiscal_year": \{fiscalDate1.getYear()},
\{templateRaw.interpolate()}\
"value": \{value1}
}
},
{"sale": {
"id": 2,
"details": {
"fiscal_year": \{fiscalDate2.getYear()},
\{templateRaw.interpolate()}\
"value": \{value2}
}
}
""";
System.out.println("Simple JSON and formatted():");
System.out.println(jsonText);
System.out.println("\nJSON text-block and formatted():");
System.out.println(jsonBlock);
System.out.println("Simple JSON and STR:");
System.out.println(jsonTextStr);
System.out.println("\nJSON text-block and STR:");
System.out.println(jsonBlockStr);
System.out.println("\nJSON text-block and FMT:");
System.out.println(jsonBlockFmt);
System.out.println("\nJSON text-block and RAW :");
System.out.println(jsonBlockRaw);
String employeeCodeString = templateRaw.interpolate();
System.out.println("\nEmployee code :");
System.out.println(employeeCodeString);
List<String> trFragments = templateRaw.fragments();
System.out.println("Fragments:\n" + trFragments);
List<Object> trValues = templateRaw.values();
System.out.println("Values:\n" + trValues);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P22_ValueNextAlgebraicQuotient/src/main/java/modern/challenge/Main.java | Chapter01/P22_ValueNextAlgebraicQuotient/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.function.BinaryOperator;
public class Main {
public static void main(String[] args) {
int x = Integer.MIN_VALUE;
int resultFloor = Math.floorDiv(x, -1);
System.out.println("Result via floorDiv(): " + resultFloor);
int resultCeil = Math.ceilDiv(x, -1);
System.out.println("Result via ceilDiv(): " + resultCeil);
// throw ArtihmeticException
int resultFloorExact = Math.floorDivExact(x, -1);
System.out.println("Result via floorDivExact(): " + resultFloorExact);
// throw ArithmeticException
BinaryOperator<Integer> operatorf = Math::floorDivExact;
int floorExactBo = operatorf.apply(x, -1);
System.out.println("Result via BinaryOperator: " + floorExactBo);
// throw ArtihmeticException
int resultCeilExact = Math.ceilDivExact(x, -1);
System.out.println("Result via ceilDivExact(): " + resultCeilExact);
// throw ArtihmeticException
BinaryOperator<Integer> operatorc = Math::ceilDivExact;
int ceilExactBo = operatorc.apply(x, -1);
System.out.println("Result via BinaryOperator: " + ceilExactBo);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P18_LocaleCurrency/src/main/java/modern/challenge/Main.java | Chapter01/P18_LocaleCurrency/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.text.NumberFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.ThreadLocalRandom;
public class Main {
public static void main(String[] args) {
// just a list of locales to randomly choose from
List<Locale> myLocales = List.of(Locale.GERMANY, Locale.ITALY,
Locale.JAPAN, Locale.TAIWAN, Locale.US);
int rnd = ThreadLocalRandom.current().nextInt(0, myLocales.size() - 1);
Locale.setDefault(myLocales.get(rnd));
// prepare the date for display
String date = LocalDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
// prepare the royalty for display
NumberFormat format = NumberFormat.getCurrencyInstance(myLocales.get(rnd));
format.setMaximumFractionDigits(format.getCurrency().getDefaultFractionDigits());
String royalty = format.format(122005.9565);
System.out.println("Locale: " + myLocales.get(rnd));
System.out.println("Date: " + date);
System.out.println("Royalty: " + royalty);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK8/src/main/java/modern/challenge/Main.java | Chapter01/P13_StringConcatJDK8/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.bcel.Repository;
import org.apache.bcel.classfile.JavaClass;
public class Main {
public static void main(String[] args) {
System.out.println("JDK 8 bytecode of Strings#concatViaPlus()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatViaPlus", String.class, String.class, String.class, String.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 8 bytecode of Strings#concatViaStringBuilder()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatViaStringBuilder", String.class, String.class, String.class, String.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 8 bytecode of Strings#concatListViaPlus()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatListViaPlus", List.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 8 bytecode of Strings#concatListViaStringBuilder()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatListViaStringBuilder", List.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK8/src/main/java/modern/challenge/Strings.java | Chapter01/P13_StringConcatJDK8/src/main/java/modern/challenge/Strings.java | package modern.challenge;
import java.util.List;
public class Strings {
private Strings() {
throw new AssertionError("Cannot be instantiated");
}
public static String concatViaPlus(String str1, String str2, String str3, String str4) {
return str1 + str2 + str3 + str4;
}
public static String concatViaStringBuilder(String str1, String str2, String str3, String str4) {
StringBuilder sb = new StringBuilder();
sb.append(str1)
.append(str2)
.append(str3)
.append(str4);
return sb.toString();
}
public static String concatListViaPlus(List<String> strs) {
String result = "";
for(String str: strs) {
result = result + str;
}
return result;
}
public static String concatListViaStringBuilder(List<String> strs) {
StringBuilder result = new StringBuilder();
for(String str: strs) {
result.append(str);
}
return result.toString();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor3/src/main/java/modern/challenge/PhoneProcessor.java | Chapter01/P16_CustomTemplateProcessor3/src/main/java/modern/challenge/PhoneProcessor.java | package modern.challenge;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.IOException;
import java.lang.StringTemplate.Processor;
import java.util.regex.Pattern;
public class PhoneProcessor implements Processor<JsonNode, IllegalArgumentException> {
private static final Pattern PHONE_PATTERN = Pattern.compile(
"\\d{10}|(?:\\d{3}-){2}\\d{4}|\\(\\d{3}\\)\\d{3}-?\\d{4}");
@Override
public JsonNode process(StringTemplate stringTemplate) throws IllegalArgumentException {
for (Object value : stringTemplate.values()) {
if (!PHONE_PATTERN.matcher((CharSequence) value).matches()) {
throw new IllegalArgumentException(
"This is not a valid phone number");
}
}
ObjectMapper mapper = new ObjectMapper();
try {
return mapper.readTree(StringTemplate.interpolate(
stringTemplate.fragments(), stringTemplate.values()));
} catch (IOException ex) {
throw new RuntimeException(ex);
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor3/src/main/java/modern/challenge/Main.java | Chapter01/P16_CustomTemplateProcessor3/src/main/java/modern/challenge/Main.java | package modern.challenge;
import com.fasterxml.jackson.databind.JsonNode;
public class Main {
public static void main(String[] args) {
PhoneProcessor pp = new PhoneProcessor();
String workPhone = "072-825-9009";
String homePhone = "(040)234-9670";
JsonNode jsonMessage = pp."""
{ "contact": {
"work": "\{workPhone}",
"home": "\{homePhone}"
}
}
""";
System.out.println(jsonMessage);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P10_TextBlockStringLiteralIntermix/src/main/java/modern/challenge/Main.java | Chapter01/P10_TextBlockStringLiteralIntermix/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
String str = "I love Java!";
String txt = """
I love Java!""";
System.out.println("Is 'str' (string literal) equal to 'txt' (text block) via '==': "
+ (str == txt));
System.out.println("Is 'str' (string literal) equal to 'txt' (text block) via 'equals': "
+ str.equals(txt));
System.out.println();
String tom = "Tom";
String jerry = """
Jerry""";
System.out.println(tom + " and " + jerry);
System.out.println();
System.out.println(tom.toUpperCase() + " AND " + jerry.toUpperCase());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor5/src/main/java/modern/challenge/PhoneProcessor.java | Chapter01/P16_CustomTemplateProcessor5/src/main/java/modern/challenge/PhoneProcessor.java | package modern.challenge;
import java.lang.StringTemplate.Processor;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;
public class PhoneProcessor implements Processor<String, IllegalArgumentException> {
private static final Pattern PHONE_PATTERN = Pattern.compile(
"\\d{10}|(?:\\d{3}-){2}\\d{4}|\\(\\d{3}\\)\\d{3}-?\\d{4}");
@Override
public String process(StringTemplate stringTemplate) throws IllegalArgumentException {
List<Object> newValues = new ArrayList<>();
List<Object> values = stringTemplate.values();
List<String> fragments = stringTemplate.fragments();
for (int i = 0; i < values.size(); i++) {
if (fragments.get(i).contains("<phone>")
&& !PHONE_PATTERN.matcher((CharSequence) values.get(i)).matches()) {
newValues.add("098-788-0000");
} else {
newValues.add(values.get(i));
}
}
return StringTemplate.interpolate(fragments, newValues);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor5/src/main/java/modern/challenge/Main.java | Chapter01/P16_CustomTemplateProcessor5/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
public class Main {
public static void main(String[] args) {
PhoneProcessor pp = new PhoneProcessor();
List<String> names = List.of("Arita Ion", "Mark Jurg", "Paul Istrate");
List<String> phones= List.of("244-815-0089", "0721-825-8892", "(045)655-9230");
StringBuilder xmlMessage = new StringBuilder();
for (int i = 0; i < names.size(); i++) {
xmlMessage.append(pp."""
<name>\{names.get(i)}</name>
<phone>\{phones.get(i)}</phone>
""");
}
System.out.println(xmlMessage);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P08_TextBlockEmbeddedExpressions/src/main/java/modern/challenge/Main.java | Chapter01/P08_TextBlockEmbeddedExpressions/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.text.MessageFormat;
public class Main {
public static void main(String[] args) {
// Ordinary string concatenation
System.out.println("\n Using ordinary string concatenation (+):\n");
String fn = "Jo";
String ln = "Kym";
String str1 = "<user><firstName>" + fn + "</firstName><lastName>" + ln + "</lastName></user>";
System.out.println("String literal:\n" + str1);
String xml1 = """
<user>
<firstName>\
"""
+ fn
+ """
</firstName>
<lastName>\
"""
+ ln
+ """
</lastName>
</user>
""";
System.out.println();
System.out.println("Text block:\n" + xml1);
String xml2 = """
<user>
<firstName>
"""
+ fn.indent(4)
+ """
</firstName>
<lastName>
"""
+ ln.indent(4)
+ """
</lastName>
</user>
""";
System.out.println();
System.out.println("Text block:\n" + xml2);
// StringBuilder(Buffer)
System.out.println("\n Using StringBuilder(Buffer):\n");
StringBuilder sbStr = new StringBuilder();
sbStr.append("<user><firstName>")
.append(fn)
.append("</firstName><lastName>")
.append(ln)
.append("</lastName></user>");
System.out.println("String literal:\n" + sbStr.toString());
StringBuilder sbXml1 = new StringBuilder();
sbXml1.append("""
<user>
<firstName>""")
.append(fn)
.append("""
</firstName>
<lastName>""")
.append(ln)
.append("""
</lastName>
</user>""");
System.out.println();
System.out.println("Text block:\n" + sbXml1.toString());
StringBuilder sbXml2 = new StringBuilder();
sbXml2.append("""
<user>
<firstName>
""")
.append(fn.indent(4))
.append("""
</firstName>
<lastName>
""")
.append(ln.indent(4))
.append("""
</lastName>
</user>
""");
System.out.println();
System.out.println("Text block:\n" + sbXml2.toString());
// Java 1.4, MessageFormat.format()
System.out.println("\n Using Java 1.4, MessageFormat.format():\n");
String str2 = MessageFormat.format("<user><firstName>{0}</firstName><lastName>{1}</lastName></user>", fn, ln);
System.out.println("String literal:\n" + str2);
String xml3 = MessageFormat.format("""
<user>
<firstName>{0}</firstName>
<lastName>{1}</lastName>
</user>
""", fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml3);
String xml4 = MessageFormat.format("""
<user>
<firstName>
{0}
</firstName>
<lastName>
{1}
</lastName>
</user>
""", fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml4);
// Java 5, String.format()
System.out.println("\n Using Java 5, String.format():\n");
String str3 = String.format("<user><firstName>%s</firstName><lastName>%s</lastName></user>", fn, ln);
System.out.println("String literal:\n" + str3);
String xml5 = String.format("""
<user>
<firstName>%s</firstName>
<lastName>%s</lastName>
</user>
""", fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml5);
String xml6 = String.format("""
<user>
<firstName>
%s
</firstName>
<lastName>
%s
</lastName>
</user>
""", fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml6);
// Java 15, String.formatted()
System.out.println("\n Using Java 15, String.formatted() - instance version of String.format():\n");
String str4 = "<user><firstName>%s</firstName><lastName>%s</lastName></user>".formatted(fn, ln);
System.out.println("String literal:\n" + str4);
String xml7 = """
<user>
<firstName>%s</firstName>
<lastName>%s</lastName>
</user>
""".formatted(fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml7);
String xml8 = """
<user>
<firstName>
%s
</firstName>
<lastName>
%s
</lastName>
</user>
""".formatted(fn, ln);
System.out.println();
System.out.println("Text block:\n" + xml8);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P27_CountPrimeNumbers/src/main/java/modern/challenge/Primes.java | Chapter01/P27_CountPrimeNumbers/src/main/java/modern/challenge/Primes.java | package modern.challenge;
import java.util.BitSet;
public final class Primes {
private Primes() {
throw new AssertionError("Cannot be instantiated");
}
public static int count(int v) {
if (v <= 2) {
return 0;
}
BitSet bs = new BitSet();
v = v - 1;
int sq = (int) Math.sqrt(v);
int cnt = v;
for (int i = 2; i <= sq; i++) {
if (!bs.get(i)) {
for (int j = 2; (i * j) <= v; j++) {
if (!bs.get(i * j)) {
cnt--;
bs.set(i * j);
}
}
}
}
return cnt - 1;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P27_CountPrimeNumbers/src/main/java/modern/challenge/Main.java | Chapter01/P27_CountPrimeNumbers/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
int v = 13;
int result = Primes.count(v);
System.out.println("Count: " + result);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P17_LocaleOf/src/main/java/modern/challenge/Main.java | Chapter01/P17_LocaleOf/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.text.DateFormat;
import java.util.Date;
import java.util.List;
import java.util.Locale;
public class Main {
public static void main(String[] args) {
// before JDK 19
Locale roDep = new Locale("ro", "RO");
Locale deDep = new Locale("de", "DE"); // or, Locale de = Locale.GERMANY;
System.out.println("roDep: " + roDep);
System.out.println("deDep: " + deDep);
// via Locale.Builder
Locale aLocale = new Locale.Builder().setLanguage("ro").setRegion("RO").build();
System.out.println("Locale via Locale.Builder: " + aLocale);
// via Locale#forLanguageTag()
Locale bLocale = Locale.forLanguageTag("zh-cmn-Hans-CN");
System.out.println("Locale via Locale#forLanguageTag(): " + bLocale);
// creating language ranges
Locale.LanguageRange lr1 = new Locale.LanguageRange("de-*", 1.0);
Locale.LanguageRange lr2 = new Locale.LanguageRange("ro-RO", 0.5);
Locale.LanguageRange lr3 = new Locale.LanguageRange("en-*", 0.0);
System.out.println("Language range (1): " + lr1);
System.out.println("Language range (2): " + lr2);
System.out.println("Language range (3): " + lr3);
// creating priority list
String rangeString = "es-ES;q=1.0,es-MX;q=0.5,pt-BR;q=0.0";
List<Locale.LanguageRange> priorityList = Locale.LanguageRange.parse(rangeString);
System.out.println("Priority list: " + priorityList);
// JDK 19+, creating a Locale via of()
Locale ro = Locale.of("ro", "RO");
Locale de = Locale.of("de", "DE"); // or, Locale de = Locale.GERMANY;
DateFormat rodf = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, ro);
DateFormat dedf = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, de);
System.out.println("Locale:" + ro + " Date:" + rodf.format(new Date()));
System.out.println("Locale:" + de + " Date:" + dedf.format(new Date()));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor1/src/main/java/modern/challenge/PhoneProcessor.java | Chapter01/P16_CustomTemplateProcessor1/src/main/java/modern/challenge/PhoneProcessor.java | package modern.challenge;
import java.lang.StringTemplate.Processor;
import java.util.Iterator;
import java.util.regex.Pattern;
public class PhoneProcessor implements Processor<String, IllegalArgumentException> {
private static final Pattern PHONE_PATTERN = Pattern.compile(
"\\d{10}|(?:\\d{3}-){2}\\d{4}|\\(\\d{3}\\)\\d{3}-?\\d{4}");
@Override
public String process(StringTemplate stringTemplate) throws IllegalArgumentException {
StringBuilder sb = new StringBuilder();
Iterator<String> fragmentsIter = stringTemplate.fragments().iterator();
for (Object value : stringTemplate.values()) {
sb.append(fragmentsIter.next());
if (!PHONE_PATTERN.matcher((CharSequence) value).matches()) {
throw new IllegalArgumentException(
"This is not a valid phone number");
}
sb.append(value);
}
sb.append(fragmentsIter.next());
return sb.toString();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor1/src/main/java/modern/challenge/Main.java | Chapter01/P16_CustomTemplateProcessor1/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
PhoneProcessor pp = new PhoneProcessor();
String workPhone = "072-825-9009";
String homePhone = "(040)234-9670";
String message = pp."""
You can contact me at work at \{workPhone}
or at home at \{homePhone}.
""";
System.out.println(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P26_FloorCeilModulus/src/main/java/modern/challenge/Main.java | Chapter01/P26_FloorCeilModulus/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
int dividend = 162;
int divisor = 42;
System.out.println("Floor modulus:");
int fd = Math.floorDiv(dividend, divisor);
int fmodJDK8_1 = dividend - (fd * divisor);
int fmodJDK8_2 = Math.floorMod(dividend, divisor);
System.out.println("Modulus: " + (dividend % divisor)
+ " Floor modulus: " + fmodJDK8_1 + " = " + fmodJDK8_2);
System.out.println();
System.out.println("Ceil modulus:");
int cd = Math.ceilDiv(dividend, divisor);
int cmodJDK18_1 = dividend - (cd * divisor);
int cmodJDK18_2 = Math.ceilMod(dividend, divisor);
System.out.println("Modulus: " + (dividend % divisor)
+ " Ceil modululs: " + cmodJDK18_1 + " = " + cmodJDK18_2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P12_TextBlockIsomorphic/src/main/java/modern/challenge/Main.java | Chapter01/P12_TextBlockIsomorphic/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
String s1 = """
abbcdd
baaaad
ccddaa
""";
String s2 = """
qwwerr
wqqqqr
eerrqq
""";
boolean result = Strings.isIsomorphic(s1, s2);
System.out.println("Is ismoporphic ? " + result);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P12_TextBlockIsomorphic/src/main/java/modern/challenge/Strings.java | Chapter01/P12_TextBlockIsomorphic/src/main/java/modern/challenge/Strings.java | package modern.challenge;
import java.util.HashMap;
import java.util.Map;
public final class Strings {
private Strings() {
throw new AssertionError("Cannot be instantiated");
}
public static boolean isIsomorphic(String s1, String s2) {
if (s1 == null || s2 == null
|| s1.length() != s2.length()) {
return false;
}
Map<Character, Character> map = new HashMap<>();
for (int i = 0; i < s1.length(); i++) {
char chs1 = s1.charAt(i);
char chs2 = s2.charAt(i);
if (map.containsKey(chs1)) {
if (map.get(chs1) != chs2) {
return false;
}
} else {
if (map.containsValue(chs2)) {
return false;
}
map.put(chs1, chs2);
}
}
return true;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P11_RegexNamedGroups/src/main/java/modern/challenge/Main.java | Chapter01/P11_RegexNamedGroups/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) {
String nameAndAddress = "Mark Janson;243 West Main St;Louisville;40202;USA";
Pattern pattern = Pattern.compile("""
(?<name>[ a-zA-Z]+);\
(?<address>[ 0-9a-zA-Z]+);\
(?<city>[ a-zA-Z]+);\
(?<zip>[\\d]+);\
(?<country>[ a-zA-Z]+)$""");
Matcher matcher = pattern.matcher(nameAndAddress);
matcher.matches();
if (matcher.hasMatch()) {
System.out.println(matcher.namedGroups());
String name = matcher.group("name");
String address = matcher.group("address");
String city = matcher.group("city");
String zip = matcher.group("zip");
String country = matcher.group("country");
System.out.println(name);
System.out.println(address);
System.out.println(city);
System.out.println(zip);
System.out.println(country);
}
String[] result = Pattern.compile(";+").splitWithDelimiters(nameAndAddress, 0);
System.out.println(Arrays.toString(result));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpInterface/src/main/java/modern/challenge/Rectangle.java | Chapter01/P19_UsingStrictfpInterface/src/main/java/modern/challenge/Rectangle.java | package modern.challenge;
// strictfp is not required starting with Java 17
public strictfp interface Rectangle {
default double area(double length, double width) {
return length * width;
}
double diagonal(double length, double width);
public class Trigonometry {
public static double smallAngleOfDiagonals(double length, double width) {
double delta = Math.atan(length / width);
double alfa = Math.PI - 2.0d * delta;
return alfa * 180.0d / Math.PI;
}
public static double bigAngleOfDiagonals(double length, double width) {
double delta = Math.atan(width / length);
double beta = Math.PI - 2.0d * delta;
return beta * 180.0d / Math.PI;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpInterface/src/main/java/modern/challenge/Main.java | Chapter01/P19_UsingStrictfpInterface/src/main/java/modern/challenge/Main.java | package modern.challenge;
// strictfp is not required starting with Java 17
@SuppressWarnings("unchecked")
public class Main implements Rectangle {
public static void main(String[] args) {
double alfa = Rectangle.Trigonometry.smallAngleOfDiagonals(10, 5);
double beta = Rectangle.Trigonometry.bigAngleOfDiagonals(10, 5);
System.out.println("Small angle (alfa): " + alfa + " degree");
System.out.println("Big angle (beta): " + beta + " degree");
}
@Override
strictfp public double diagonal(double length, double width) {
return Math.sqrt((length * length) + (width * width));
}
strictfp public double perimeter(double length, double width) {
return 2.0d * length + 2.0d * width;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P33_PRNGFindByProperty/src/main/java/modern/challenge/Main.java | Chapter01/P33_PRNGFindByProperty/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;
public class Main {
public static void main(String[] args) {
RandomGenerator generator = RandomGeneratorFactory.all()
.filter(RandomGeneratorFactory::isLeapable)
.filter(RandomGeneratorFactory::isStatistical)
.findFirst()
.map(RandomGeneratorFactory::create)
.orElseThrow(() -> new RuntimeException("Cannot find this kind of generator"));
System.out.println("Leapable generator: " + generator);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P27_PrimeFactors/src/main/java/modern/challenge/Primes.java | Chapter01/P27_PrimeFactors/src/main/java/modern/challenge/Primes.java | package modern.challenge;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public final class Primes {
private Primes() {
throw new AssertionError("Cannot be instantiated");
}
public static List<Integer> factorsV1(int v) {
if (v <= 1) {
// for negatives please consider reading:
// https://primes.utm.edu/notes/faq/negative_primes.html
return Collections.emptyList();
}
List<Integer> factorsList = new ArrayList<>();
int s = 2;
while (v > 1) {
// each perfect division give us a prime factor
if (v % s == 0) {
factorsList.add(s);
v = v / s;
} else {
s++;
}
}
return factorsList;
}
public static List<Integer> factorsV2(int v) {
if (v <= 1) {
// for negatives please consider reading:
// https://primes.utm.edu/notes/faq/negative_primes.html
return Collections.emptyList();
}
List<Integer> factorsList = new ArrayList<>();
// compute v % 2, 3, ..., v-1
for (int i = 2; i < v; i++) {
// each perfect division give us a prime factor
while (v % i == 0) {
factorsList.add(i);
v = v / i;
}
}
// collect the last prime factor when 'v' is a prime number greater than 2
if (v > 2) {
factorsList.add(v);
}
return factorsList;
}
public static List<Integer> factorsV3(int v) {
if (v <= 1) {
// for negatives please consider reading:
// https://primes.utm.edu/notes/faq/negative_primes.html
return Collections.emptyList();
}
List<Integer> factorsList = new ArrayList<>();
// compute v % 2 as long as modulus return 0 and collect prime factors (2)
while (v % 2 == 0) {
factorsList.add(2);
v = v / 2;
}
// now, 'v' should be odd
// so, skip one element
for (int i = 3; i <= Math.sqrt(v); i += 2) {
// While 'i' divides 'v', collect 'i' as a prime factor and continue division
while (v % i == 0) {
factorsList.add(i);
v = v / i;
}
}
// collect the last prime factor when 'v' is a prime number greater than 2
if (v > 2) {
factorsList.add(v);
}
return factorsList;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P27_PrimeFactors/src/main/java/modern/challenge/Main.java | Chapter01/P27_PrimeFactors/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
public class Main {
public static void main(String[] args) {
int v = 90;
List<Integer> primeFactors1 = Primes.factorsV1(v);
List<Integer> primeFactors2 = Primes.factorsV2(v);
List<Integer> primeFactors3 = Primes.factorsV3(v);
System.out.println("Prime factors (V1): " + primeFactors1);
System.out.println("Prime factors (V2): " + primeFactors2);
System.out.println("Prime factors (V3): " + primeFactors3);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P24_DoubleIsInteger/src/main/java/modern/challenge/Numbers.java | Chapter01/P24_DoubleIsInteger/src/main/java/modern/challenge/Numbers.java | package modern.challenge;
import com.google.common.math.DoubleMath;
public final class Numbers {
private Numbers() {
throw new AssertionError("Cannot be instantiated");
}
public static boolean isDoubleIntegerV1(double v) {
return v == (int) v;
}
public static boolean isDoubleIntegerV2(double v) {
return v % 1 == 0;
}
public static boolean isDoubleIntegerV3(double v) {
return ((Math.floor(v) == v) && Double.isFinite(v));
}
public static boolean isDoubleIntegerV4(double v) {
return (Math.floor(v) == Math.ceil(v) && Double.isFinite(v));
}
public static boolean isDoubleIntegerV5(double v) {
return ((Math.rint(v) == v) && Double.isFinite(v));
}
// using Guava implementation
public static boolean isDoubleIntegerV6(double v) {
return DoubleMath.isMathematicalInteger(v);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P24_DoubleIsInteger/src/main/java/modern/challenge/Main.java | Chapter01/P24_DoubleIsInteger/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
double v1 = 23.11;
double v2 = 23;
double v3 = 23.0;
double v4 = Double.NaN;
double v5 = Double.NEGATIVE_INFINITY;
double v6 = Double.POSITIVE_INFINITY;
System.out.println("-------------------------------------------------");
System.out.println("USING CAST:");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV1(v6));
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("USING MODULO (%):");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV2(v6));
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("USING Math.floor() AND Double.isFinite():");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV3(v6));
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("USING Math.floor(), Math.ceil() AND Double.isFinite():");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV4(v6));
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("USING Math.rint() AND Double.isFinite():");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV5(v6));
System.out.println("-------------------------------------------------");
System.out.println();
System.out.println("-------------------------------------------------");
System.out.println("USING GUAVA:");
System.out.println("-------------------------------------------------");
System.out.println("'v1 (23.11)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v1));
System.out.println("'v2 (23)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v2));
System.out.println("'v3 (23.0)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v3));
System.out.println("'v4 (NaN)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v4));
System.out.println("'v5 (NEGATIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v5));
System.out.println("'v6 (POSITIVE_INFINITY)' is integer ?: "
+ Numbers.isDoubleIntegerV6(v6));
System.out.println("-------------------------------------------------");
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK11/src/main/java/modern/challenge/Main.java | Chapter01/P13_StringConcatJDK11/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.bcel.Repository;
import org.apache.bcel.classfile.JavaClass;
public class Main {
public static void main(String[] args) {
System.out.println("JDK 11 bytecode of Strings#concatViaPlus()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatViaPlus", String.class, String.class, String.class, String.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 11 bytecode of Strings#concatViaStringBuilder()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatViaStringBuilder", String.class, String.class, String.class, String.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 11 bytecode of Strings#concatListViaPlus()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatListViaPlus", List.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
System.out.println();
System.out.println("JDK 11 bytecode of Strings#concatListViaStringBuilder()");
System.out.println("-----------------------------------------------------------");
try {
JavaClass objectClazz = Repository.lookupClass("modern.challenge.Strings");
System.out.println(objectClazz.getMethod(Strings.class.getMethod(
"concatListViaStringBuilder", List.class)).getCode());
} catch (ClassNotFoundException | NoSuchMethodException | SecurityException ex) {
Logger.getLogger(Main.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println("-----------------------------------------------------------");
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK11/src/main/java/modern/challenge/Strings.java | Chapter01/P13_StringConcatJDK11/src/main/java/modern/challenge/Strings.java | package modern.challenge;
import java.util.List;
public class Strings {
private Strings() {
throw new AssertionError("Cannot be instantiated");
}
public static String concatViaPlus(String str1, String str2, String str3, String str4) {
return str1 + str2 + str3 + str4;
}
public static String concatViaStringBuilder(String str1, String str2, String str3, String str4) {
StringBuilder sb = new StringBuilder();
sb.append(str1)
.append(str2)
.append(str3)
.append(str4);
return sb.toString();
}
public static String concatListViaPlus(List<String> strs) {
String result = "";
for(String str: strs) {
result = result + str;
}
return result;
}
public static String concatListViaStringBuilder(List<String> strs) {
StringBuilder result = new StringBuilder();
for(String str: strs) {
result.append(str);
}
return result.toString();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpInterfaceReflection/src/main/java/modern/challenge/Rectangle.java | Chapter01/P19_UsingStrictfpInterfaceReflection/src/main/java/modern/challenge/Rectangle.java | package modern.challenge;
// strictfp is not required starting with Java 17
public strictfp interface Rectangle {
default double area(double length, double width) {
return length * width;
}
double diagonal(double length, double width);
public class Trigonometry {
public static double smallAngleOfDiagonals(double length, double width) {
double delta = Math.atan(length / width);
double alfa = Math.PI - 2.0d * delta;
return alfa * 180.0d / Math.PI;
}
public static double bigAngleOfDiagonals(double length, double width) {
double delta = Math.atan(width / length);
double beta = Math.PI - 2.0d * delta;
return beta * 180.0d / Math.PI;
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpInterfaceReflection/src/main/java/modern/challenge/Main.java | Chapter01/P19_UsingStrictfpInterfaceReflection/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.lang.reflect.Modifier;
// strictfp is not required starting with Java 17
@SuppressWarnings("unchecked")
public class Main implements Rectangle {
public static void main(String[] args) {
displayModifiers(Main.class, "diagonal");
displayModifiers(Main.class, "perimeter");
displayModifiers(Main.class.getInterfaces()[0], "diagonal");
displayModifiers(Main.class.getInterfaces()[0], "area");
displayModifiers(Rectangle.Trigonometry.class, "smallAngleOfDiagonals");
displayModifiers(Rectangle.Trigonometry.class, "bigAngleOfDiagonals");
}
@Override
public double diagonal(double length, double width) { // needs explicit strictfp
return Math.sqrt((length * length) + (width * width));
}
public double perimeter(double length, double width) { // needs explicit strictfp
return 2.0d * length + 2.0d * width;
}
public static void displayModifiers(Class clazz, String member) {
try {
int modifiers = clazz.getDeclaredMethod(member, double.class, double.class).getModifiers();
System.out.println(member + " has the following modifiers: " + Modifier.toString(modifiers));
} catch (NoSuchMethodException | SecurityException e) {
e.printStackTrace(System.out);
}
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P06_TextBlockEscaping/src/main/java/modern/challenge/Main.java | Chapter01/P06_TextBlockEscaping/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
System.out.println("\n Escaping \" explicitly can be done "
+ "but is not necessary (DON'T DO THIS!):");
String txt11 = """
She told me
\"I have no idea what's going on\"
""";
System.out.println(txt11);
System.out.println();
System.out.println("\n Escaping \" is done out of the box:");
String txt12 = """
She told me
"I have no idea what's going on"
""";
System.out.println(txt12);
System.out.println();
System.out.println("\n Escaping \"\" explicitly can be done "
+ "but is not necessary (DON'T DO THIS!):");
String txt21 = """
She told me
\"\"I have no idea what's going on\"\"
""";
System.out.println(txt21);
System.out.println();
System.out.println("\n Escaping \"\" is done out of the box:");
String txt22 = """
She told me
""I have no idea what's going on""
""";
System.out.println(txt22);
System.out.println();
System.out.println("\n Escaping \"\"\" can be done as following:");
String txt1 = """
She told me
\"""I have no idea what's going on\"""
""";
System.out.println(txt1);
System.out.println();
System.out.println("\n Escaping \\n can be done explicitly "
+ "but is not necessary (DON'T DO THIS UNLESS YOU REALLY NEED IT!):");
String sql1 = """
SELECT "public"."employee"."first_name",\n
"public"."employee"."last_name", ?\n
FROM "public"."employee"\n
WHERE "public"."employee"."job_title" = ?
""";
System.out.println(sql1);
System.out.println();
System.out.println("\n Escaping \\n is done out of the box:");
String sql2 = """
SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?
""";
System.out.println(sql2);
System.out.println();
System.out.println("\n Using \\b, \\t, \\r, \\n, \\f can be done as usual "
+ "(however, think twice if you really need to use escape sequences):");
String txt2 = """
\b\bShe told me\n
\t""I have no idea what's going on""
""";
System.out.println(txt2);
System.out.println();
String txt3 = """
She told me
""I have no idea what's going on""
""";
System.out.println(txt3);
System.out.println();
System.out.println("\n Embedding \\\" (or any other escape sequence) can be done as usual:");
String sql3 = """
SELECT \\"public\\".\\"employee\\".\\"first_name\\", \\"public\\".\\"employee\\".\\"last_name\\", ?
FROM \\"public\\".\\"employee\\"
WHERE \\"public\\".\\"employee\\".\\"job_title\\" = ?
""";
System.out.println(sql3);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P23_GetDoubleParts/src/main/java/modern/challenge/Main.java | Chapter01/P23_GetDoubleParts/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.math.BigDecimal;
public class Main {
public static void main(String[] args) {
double value = -9.33543545;
// simple approach
double fractionalPart1 = value % 1;
double integralPart1 = value - fractionalPart1;
System.out.println("Fractional part (1): " + fractionalPart1);
System.out.println("Integral part (1): " + integralPart1);
// alternatively, using BigDecimal
BigDecimal bd = BigDecimal.valueOf(value);
int integralPart2 = bd.intValue();
double fractionalPart2 = bd.subtract(
BigDecimal.valueOf(integralPart2)).doubleValue();
System.out.println("Fractional part (2): " + fractionalPart2);
System.out.println("Integral part (2): " + integralPart2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P36_LegacyRndFromRandomGenerator/src/main/java/modern/challenge/Main.java | Chapter01/P36_LegacyRndFromRandomGenerator/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.security.SecureRandom;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;
import java.util.random.RandomGenerator;
import java.util.random.RandomGeneratorFactory;
public class Main {
public static void main(String[] args) {
Random legacyRnd1 = Random.from(RandomGenerator.of("L128X256MixRandom"));
Random legacyRnd2 = Random.from(RandomGeneratorFactory.
of("Xoroshiro128PlusPlus").create());
Random legacyRnd3 = Random.from(RandomGeneratorFactory
.<RandomGenerator.SplittableGenerator>of("L128X256MixRandom")
.create());
Random legacyRnd4 = SecureRandom.from(RandomGenerator.of("L128X256MixRandom"));
Random legacyRnd5 = SecureRandom.from(RandomGeneratorFactory.
of("Xoroshiro128PlusPlus").create());
Random legacyRnd6 = SecureRandom.from(RandomGeneratorFactory
.<RandomGenerator.SplittableGenerator>of("L128X256MixRandom")
.create());
Random legacyRnd7 = ThreadLocalRandom.from(RandomGenerator.of("L128X256MixRandom"));
Random legacyRnd8 = ThreadLocalRandom.from(RandomGeneratorFactory.
of("Xoroshiro128PlusPlus").create());
Random legacyRnd9 = ThreadLocalRandom.from(RandomGeneratorFactory
.<RandomGenerator.SplittableGenerator>of("L128X256MixRandom")
.create());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P37_ThreadSafeRandomGenerator/src/main/java/modern/challenge/Main.java | Chapter01/P37_ThreadSafeRandomGenerator/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;
import java.util.random.RandomGenerator.SplittableGenerator;
import java.util.random.RandomGeneratorFactory;
public class Main {
private static final Logger logger = Logger.getLogger(Main.class.getName());
public static void main(String[] args) {
List<Integer> listOfInts = new CopyOnWriteArrayList<>();
ExecutorService executorService = Executors.newCachedThreadPool();
SplittableGenerator splittableGenerator = RandomGeneratorFactory
.<SplittableGenerator>of("L128X256MixRandom")
.create();
splittableGenerator.splits(10)
.forEach((anotherSplittableGenerator) -> {
executorService.submit(() -> {
int nextInt = anotherSplittableGenerator.nextInt(1_000);
logger.info(() -> "Added in list " + nextInt
+ " by generator " + anotherSplittableGenerator.hashCode()
+ " running in thread" + Thread.currentThread().getName());
listOfInts.add(nextInt);
});
});
shutdownExecutor(executorService);
}
private static boolean shutdownExecutor(ExecutorService executor) {
executor.shutdown();
try {
if (!executor.awaitTermination(1_000, TimeUnit.MILLISECONDS)) {
executor.shutdownNow();
return executor.awaitTermination(1_000, TimeUnit.MILLISECONDS);
}
return true;
} catch (InterruptedException ex) {
executor.shutdownNow();
Thread.currentThread().interrupt();
logger.severe(() -> "Exception: " + ex);
}
return false;
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P07_TextBlockTranslateEscapes/src/main/java/modern/challenge/Main.java | Chapter01/P07_TextBlockTranslateEscapes/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
// Quick test
String newline = "\\n".translateEscapes();
System.out.println(("\n".equals(newline)) ? "yes" : "no");
System.out.println();
// An example
String address = """
JASON MILLER (\\"BIGBOY\\")\\n
\\tMOUNT INC\\n
\\t104 SEAL AVE\\n
\\tMIAMI FL 55334 1200\\n
\\tUSA
""";
String translatedAddress = address.translateEscapes();
Strings.printAddressOnEnvelope(address);
Strings.printAddressOnEnvelope(translatedAddress);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P07_TextBlockTranslateEscapes/src/main/java/modern/challenge/Strings.java | Chapter01/P07_TextBlockTranslateEscapes/src/main/java/modern/challenge/Strings.java | package modern.challenge;
public final class Strings {
private Strings() {
throw new AssertionError("Cannot be instantiated");
}
// we need to pass here the unescaped version of address
public static void printAddressOnEnvelope(String address) {
// the code needed to print the address on envelope
System.out.println("The printed address looks as follows:\n");
System.out.println(address);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor2/src/main/java/modern/challenge/PhoneProcessor.java | Chapter01/P16_CustomTemplateProcessor2/src/main/java/modern/challenge/PhoneProcessor.java | package modern.challenge;
import java.lang.StringTemplate.Processor;
import java.util.regex.Pattern;
public class PhoneProcessor implements Processor<String, IllegalArgumentException> {
private static final Pattern PHONE_PATTERN = Pattern.compile(
"\\d{10}|(?:\\d{3}-){2}\\d{4}|\\(\\d{3}\\)\\d{3}-?\\d{4}");
@Override
public String process(StringTemplate stringTemplate) throws IllegalArgumentException {
for (Object value : stringTemplate.values()) {
if (!PHONE_PATTERN.matcher((CharSequence) value).matches()) {
throw new IllegalArgumentException(
"This is not a valid phone number");
}
}
return StringTemplate.interpolate(
stringTemplate.fragments(), stringTemplate.values());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P16_CustomTemplateProcessor2/src/main/java/modern/challenge/Main.java | Chapter01/P16_CustomTemplateProcessor2/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
PhoneProcessor pp = new PhoneProcessor();
String workPhone = "072-825-9009";
String homePhone = "(040)234-9670";
String message = pp."""
You can contact me at work at \{workPhone}
or at home at \{homePhone}.
""";
System.out.println(message);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P14_IntegerToStringBenchmark/src/main/java/modern/challenge/Main.java | Chapter01/P14_IntegerToStringBenchmark/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
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.Measurement;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, warmups = 0)
@Measurement(iterations = 20, time = 1)
@State(Scope.Benchmark)
public class Main {
private int v;
private Integer vo;
@Setup
public void setup() {
v = 948822;
vo = Integer.valueOf(948822);
}
@Benchmark
public String intToStringV1() {
return Integer.toString(v);
}
@Benchmark
public String intToStringV2() {
return "" + v;
}
@Benchmark
public String intToStringV3() {
return String.valueOf(v);
}
@Benchmark
public String intToStringV4() {
return String.format("%d", v);
}
@Benchmark
public String integerToStringV1() {
return Integer.toString(vo);
}
@Benchmark
public String integerToStringV2() {
return "" + vo;
}
@Benchmark
public String integerToStringV3() {
return String.valueOf(vo);
}
@Benchmark
public String integerToStringV4() {
return String.format("%d", vo);
}
public static void main(String[] args) throws IOException {
org.openjdk.jmh.Main.main(args);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P13_StringConcatJDK8Benchmark/src/main/java/modern/challenge/Main.java | Chapter01/P13_StringConcatJDK8Benchmark/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;
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.Measurement;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, warmups = 0)
@Measurement(iterations = 90, time = 1)
@State(Scope.Benchmark)
public class Main {
private static String str1;
private static String str2;
private static String str3;
private static String str4;
private static List<String> strs;
@Setup
public static void setup() {
str1 = "hello";
str2 = "my";
str3 = "dear";
str4 = "friend";
strs = Arrays.asList("hello", "my", "dear", "friend");
}
@Benchmark
public static String concatViaPlus() {
return str1 + str2 + str3 + str4;
}
@Benchmark
public static String concatViaStringBuilder() {
StringBuilder sb = new StringBuilder();
sb.append(str1)
.append(str2)
.append(str3)
.append(str4);
return sb.toString();
}
@Benchmark
public static String concatListViaPlus() {
String result = "";
for (String str : strs) {
result = result + str;
}
return result;
}
@Benchmark
public static String concatListViaStringBuilder() {
StringBuilder result = new StringBuilder();
for (String str : strs) {
result.append(str);
}
return result.toString();
}
public static void main(String[] args) throws IOException {
org.openjdk.jmh.Main.main(args);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P21_MathQuotientOperationOverflow/src/main/java/modern/challenge/Main.java | Chapter01/P21_MathQuotientOperationOverflow/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.function.BinaryOperator;
public class Main {
public static void main(String[] args) {
int x = Integer.MIN_VALUE;
int quotient = x/-1;
System.out.println("The quotient is " + quotient);
// throw ArithmeticException
int quotientExact = Math.divideExact(x, -1);
System.out.println("The quotient is " + quotientExact);
// throw ArithmeticException
BinaryOperator<Integer> operator = Math::divideExact;
int quotientExactBo = operator.apply(x, -1);
System.out.println("The quotient is " + quotientExactBo);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P08_TextBlockEmbeddedExpressionsBenchmark/src/main/java/modern/challenge/Main.java | Chapter01/P08_TextBlockEmbeddedExpressionsBenchmark/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.text.MessageFormat;
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.infra.Blackhole;
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@BenchmarkMode(Mode.AverageTime)
@Fork(value = 1, warmups = 0)
public class Main {
@Benchmark
public void messageFormat(Blackhole blackhole) {
String txt = MessageFormat.format(
"""
Sweet {0} of {1} and of {2},
delightful {3} of {4} wantonness,
{5} in {6} and in beauty {7}
and in {8} virtue {9} hold {10} dear ...
""", "rose", "virtue", "gentleness", "lily", "youthful", "richest", "bounty", "clear", "every", "men", "most"
);
blackhole.consume(txt);
}
@Benchmark
public void stringFormat(Blackhole blackhole) {
String txt = String.format(
"""
Sweet %s of %s and of %s,
delightful %s of %s wantonness,
%s in %s and in beauty %s
and in %s virtue %s hold %s dear ...
""", "rose", "virtue", "gentleness", "lily", "youthful", "richest", "bounty", "clear", "every", "men", "most"
);
blackhole.consume(txt);
}
@Benchmark
public void stringFormatted(Blackhole blackhole) {
String txt = """
Sweet %s of %s and of %s,
delightful %s of %s wantonness,
%s in %s and in beauty %s
and in %s virtue %s hold %s dear ...
""".formatted("rose", "virtue", "gentleness", "lily", "youthful", "richest", "bounty", "clear", "every", "men", "most");
blackhole.consume(txt);
}
@Benchmark
public void concatenation(Blackhole blackhole) {
String txt = """
Sweet""" + " rose "
+ """
of""" + " virtue "
+ """
and of""" + " gentleness "
+ """
delightful""" + " lily "
+ """
of""" + " youthful "
+ """
wantonness,""" + " richest "
+ """
in""" + " bounty "
+ """
and in beauty""" + " clear "
+ """
and in""" + " every "
+ """
virtue""" + " men "
+ """
hold""" + " most "
+ """
dear ...""";
blackhole.consume(txt);
}
@Benchmark
public void stringBuilder(Blackhole blackhole) {
StringBuilder sb = new StringBuilder();
String txt = sb.append("""
Sweet""")
.append(" rose ")
.append("""
of""")
.append(" virtue ")
.append("""
and of""")
.append(" gentleness ")
.append("""
delightful""")
.append(" lily ")
.append("""
of""")
.append(" youthful ")
.append("""
wantonness,""")
.append(" richest ")
.append("""
in""")
.append(" bounty ")
.append("""
and in beauty""")
.append(" clear ")
.append("""
and in""")
.append(" every ")
.append("""
virtue""")
.append(" men ")
.append("""
hold""")
.append(" most ")
.append("""
dear ...""").toString();
blackhole.consume(txt);
blackhole.consume(sb);
}
public static void main(String[] args) throws Exception {
org.openjdk.jmh.Main.main(args);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P18_LocaleOfLocalizedDate/src/main/java/modern/challenge/Main.java | Chapter01/P18_LocaleOfLocalizedDate/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.OffsetTime;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.util.Locale;
public class Main {
public static void main(String[] args) {
// yyyy-MM-dd
LocalDate localDate = LocalDate.now();
// HH:mm:ss
LocalTime localTime = LocalTime.now();
// yyyy-MM-dd HH:mm:ss
LocalDateTime localDateTime = LocalDateTime.now();
// E MMM yyyy HH:mm:ss.SSSZ
ZonedDateTime zonedDateTime = ZonedDateTime.now();
// E MMM yyyy HH:mm:ss.SSSZ
OffsetDateTime offsetDateTime = OffsetDateTime.now();
// HH:mm:ss,Z
OffsetTime offsetTime = OffsetTime.now();
DateTimeFormatter formatterLocalDate =
DateTimeFormatter.ofPattern("yyyy-MM-dd");
DateTimeFormatter formatterLocalTime =
DateTimeFormatter.ofPattern("HH:mm:ss");
DateTimeFormatter formatterLocalDateTime =
DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
DateTimeFormatter formatterZonedDateTime =
DateTimeFormatter.ofPattern("E MMM yyyy HH:mm:ss.SSSZ");
DateTimeFormatter formatterOffsetDateTime =
DateTimeFormatter.ofPattern("E MMM yyyy HH:mm:ss.SSSZ");
DateTimeFormatter formatterOffsetTime =
DateTimeFormatter.ofPattern("HH:mm:ss,Z");
String ld1 = formatterLocalDate.format(localDate);
String lt1 = formatterLocalTime.format(localTime);
String ldt1 = formatterLocalDateTime.format(localDateTime);
String zdt1 = formatterZonedDateTime.format(zonedDateTime);
String odt1 = formatterOffsetDateTime.format(offsetDateTime);
String ot1 = formatterOffsetTime.format(offsetTime);
// or shortly
String ld2 = LocalDate.now()
.format(DateTimeFormatter.ofPattern("y-MM-dd"));
String lt2 = LocalTime.now()
.format(DateTimeFormatter.ofPattern("HH:mm:ss"));
String ldt2 = LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("y-MM-dd HH:mm:ss"));
String zdt2 = ZonedDateTime.now()
.format(DateTimeFormatter.ofPattern("E MMM yyyy HH:mm:ss.SSSZ"));
String odt2 = OffsetDateTime.now()
.format(DateTimeFormatter.ofPattern("E MMM yyyy HH:mm:ss.SSSZ"));
String ot2 = OffsetTime.now()
.format(DateTimeFormatter.ofPattern("HH:mm:ss,Z"));
System.out.println(ld1);
System.out.println(ld2);
System.out.println(lt1);
System.out.println(lt2);
System.out.println(ldt1);
System.out.println(ldt2);
System.out.println(zdt1);
System.out.println(zdt2);
System.out.println(odt1);
System.out.println(odt2);
System.out.println(ot1);
System.out.println(ot2);
System.out.println();
// change current locale
Locale.setDefault(Locale.GERMANY);
// localized date
String ld3 = LocalDate.now()
.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG));
String ld4 = LocalDate.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMM"));
String lt3 = LocalTime.now()
.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT));
String lt4 = LocalTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("Hm"));
String ldt3 = LocalDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
String ldt4 = LocalDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHm"));
String zdt3 = ZonedDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL));
String zdt4 = ZonedDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHmsv"));
String odt3 = OffsetDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
String odt4 = OffsetDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHms"));
String ot3 = OffsetTime.now()
.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM));
String ot4 = OffsetTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("Hms"));
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized date):" + ld3);
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized pattern):" + ld4);
System.out.println("Locale:" + Locale.getDefault()
+ " Time (localized time):" + lt3);
System.out.println("Locale:" + Locale.getDefault()
+ " Time (localized pattern):" + lt4);
System.out.println("Locale:" + Locale.getDefault()
+ " Date/Time (localized date/time):" + ldt3);
System.out.println("Locale:" + Locale.getDefault()
+ " Date/Time (localized pattern):" + ldt4);
System.out.println("Locale:" + Locale.getDefault()
+ " Zoned Date/Time (localized date/time):" + zdt3);
System.out.println("Locale:" + Locale.getDefault()
+ " Zoned Date/Time (localized pattern):" + zdt4);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Date/Time (localized date/time):" + odt3);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Date/Time (localized pattern):" + odt4);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Time (localized time):" + ot3);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Time (localized pattern):" + ot4);
// change current locale
Locale.setDefault(Locale.of("ro", "RO"));
String ld5 = LocalDate.now()
.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG));
String ld6 = LocalDate.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMM"));
String lt5 = LocalTime.now()
.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.SHORT));
String lt6 = LocalTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("Hm"));
String ldt5 = LocalDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
String ldt6 = LocalDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHm"));
String zdt5 = ZonedDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL));
String zdt6 = ZonedDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHmsv"));
String odt5 = OffsetDateTime.now()
.format(DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM));
String odt6 = OffsetDateTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("yMMHms"));
String ot5 = OffsetTime.now()
.format(DateTimeFormatter.ofLocalizedTime(FormatStyle.MEDIUM));
String ot6 = OffsetTime.now()
.format(DateTimeFormatter.ofLocalizedPattern("Hms"));
System.out.println();
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized date):" + ld5);
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized pattern):" + ld6);
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized time):" + lt5);
System.out.println("Locale:" + Locale.getDefault()
+ " Date (localized pattern):" + lt6);
System.out.println("Locale:" + Locale.getDefault()
+ " Date/Time (localized date/time):" + ldt5);
System.out.println("Locale:" + Locale.getDefault()
+ " Date/Time (localized pattern):" + ldt6);
System.out.println("Locale:" + Locale.getDefault()
+ " Zoned Date/Time (localized date/time):" + zdt5);
System.out.println("Locale:" + Locale.getDefault()
+ " Zoned Date/Time (localized pattern):" + zdt6);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Date/Time (localized date/time):" + odt5);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Date/Time (localized pattern):" + odt6);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Time (localized time):" + ot5);
System.out.println("Locale:" + Locale.getDefault()
+ " Offset Time (localized pattern):" + ot6);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P02_TextBlockDelimiters/src/main/java/modern/challenge/Main.java | Chapter01/P02_TextBlockDelimiters/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
System.out.println("The common usage of text block delimiters:\n");
String sql1 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql1);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nKeep the opening delimiter and the content on the "
+ "same line is not accepted (does not compile)\n");
/*
String not_compile = """UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?""";
*/
System.out.println("\nShift-left the content has no effect:\n");
String sql2 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql2);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nShift-right the opening/closing delimiter has no effect:\n");
String sql3 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ? """;
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql3);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nMoving the closing delimiter on its own line (1):\n");
String sql4 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?
""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql4);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nMoving the closing delimiter on its own line (2):\n");
String sql5 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?
""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql5);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nMoving on its own line and shift-left the closing delimiter:\n");
String sql6 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?
""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql6);
System.out.println("-- AFTER TEXT BLOCK --");
System.out.println("\nMoving on its own line and shift-right the closing delimiter:\n");
String sql7 = """
UPDATE "public"."office"
SET ("address_first", "address_second", "phone") =
(SELECT "public"."employee"."first_name",
"public"."employee"."last_name", ?
FROM "public"."employee"
WHERE "public"."employee"."job_title" = ?
""";
System.out.println("-- BEFORE TEXT BLOCK --");
System.out.println(sql7);
System.out.println("-- AFTER TEXT BLOCK --");
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P31_MulitplyTwoIntegers/src/main/java/modern/challenge/Numbers.java | Chapter01/P31_MulitplyTwoIntegers/src/main/java/modern/challenge/Numbers.java | package modern.challenge;
public final class Numbers {
private Numbers() {
throw new AssertionError("Cannot be instantiated");
}
public static int multiplyV1(int p, int q) {
// p * 0 = 0
if (q == 0) {
return 0;
}
// adding 'p' one-by-one
if (q > 0) {
return (p + multiplyV1(p, q - 1));
}
// if 'q' is negative
if (q < 0) {
return -multiplyV1(p, -q);
}
return -1;
}
public static int multiplyV2(int p, int q) {
// p * 0 = 0, 0 * q = 0
if (p == 0 || q == 0) {
return 0;
}
int pqSquare = (int) Math.pow(p + q, 2);
int pSquare = (int) Math.pow(p, 2);
int qSquare = (int) Math.pow(q, 2);
int squareResult = pqSquare - pSquare - qSquare;
int result;
if (squareResult >= 0) {
result = divideByTwo(squareResult);
} else {
result = 0 - divideByTwo(Math.abs(squareResult));
}
return result;
}
// recursion used to divide a number by 2
private static int divideByTwo(int d) {
if (d < 2) {
return 0;
}
return 1 + divideByTwo(d - 2);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P31_MulitplyTwoIntegers/src/main/java/modern/challenge/Main.java | Chapter01/P31_MulitplyTwoIntegers/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
int p = 5;
int q = -4;
int r1 = Numbers.multiplyV1(p, q);
int r2 = Numbers.multiplyV2(p, q);
System.out.println("V1: " + p + " * " + q + " = " + r1);
System.out.println("V2: " + p + " * " + q + " = " + r2);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P34_FillArrayRandomData/src/main/java/modern/challenge/Main.java | Chapter01/P34_FillArrayRandomData/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.io.IOException;
import java.util.Arrays;
import java.util.SplittableRandom;
import java.util.random.RandomGenerator.SplittableGenerator;
import java.util.random.RandomGeneratorFactory;
public class Main {
public static void main(String[] args) throws IOException {
SplittableRandom splittableRandom = new SplittableRandom();
SplittableGenerator splittableRndL64X256 = RandomGeneratorFactory
.<SplittableGenerator>of("L64X256MixRandom")
.create();
long[] arr = new long[100_000_000];
Arrays.parallelSetAll(arr, x -> splittableRndL64X256.nextLong());
Arrays.parallelSetAll(arr, x -> splittableRandom.nextLong());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P05_TextBlockJustForReadability/src/main/java/modern/challenge/Main.java | Chapter01/P05_TextBlockJustForReadability/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
System.out.println("\n This whole SQL string is just on one line:");
String sql1 = """
SELECT "public"."employee"."first_name" \
FROM "public"."employee" \
WHERE "public"."employee"."job_title" = ?\
""";
System.out.println("SQL 1: \n" + sql1);
System.out.println();
String sql2 = """
UPDATE "public"."office" \
SET ("address_first", "address_second", "phone") = \
(SELECT "public"."employee"."first_name", \
"public"."employee"."last_name", ? \
FROM "public"."employee" \
WHERE "public"."employee"."job_title" = ?\
""";
// eliminate extra white spaces
System.out.println("SQL 2:\n" + sql2);
System.out.println("SQL 2:\n" + sql2.trim().replaceAll(" +", " "));
System.out.println();
String poem1 = """
An old silent pond...
A frog jumps into the pond,
splash!! Silence again.
""";
System.out.println("POEM 1\n" + poem1);
System.out.println();
String poem2 = """
An old silent pond...\s\s\s
A frog jumps into the pond,
splash!! Silence again.\s\s
""";
System.out.println("POEM 2\n" + poem2);
String poem3 = """
An old silent pond... \s
A frog jumps into the pond,
splash!! Silence again. \s
""";
System.out.println("POEM 3\n" + poem3);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpClass/src/main/java/modern/challenge/Main.java | Chapter01/P19_UsingStrictfpClass/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
double x = 0.8793331;
double y = 12.22933;
double z = 901.98334884433;
double a1 = (x + y) + z;
double a2 = (x + (y + z));
double m1 = (x * y) * z;
double m2 = (x * (y * z));
System.out.println("Associativity of addition: " + a1 + " = " + a2);
System.out.println("Associativity of addition: " + (a1 == a2));
System.out.println("Associativity of multiplication: " + m1 + " = " + m2);
System.out.println("Associativity of multiplication: " + (m1 == m2));
double mresult = ScientificCalculator.multiply(11e+09, 7e+06);
double dresult = ScientificCalculator.division(11e+09, 7e+06);
System.out.println("Multiply result: " + mresult);
System.out.println("Division result: " + dresult);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P19_UsingStrictfpClass/src/main/java/modern/challenge/ScientificCalculator.java | Chapter01/P19_UsingStrictfpClass/src/main/java/modern/challenge/ScientificCalculator.java | package modern.challenge;
// strictfp is not required starting with Java 17
public strictfp final class ScientificCalculator {
private ScientificCalculator() {
throw new AssertionError("Cannot be instantiated");
}
public static double multiply(final double v1, final double v2) {
return v1 * v2;
}
public static double division(final double v1, final double v2) {
return v1 / v2;
}
// more computational methods
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter01/P04_TextBlockRemovingIncidentalWhiteSpace/src/main/java/modern/challenge/Main.java | Chapter01/P04_TextBlockRemovingIncidentalWhiteSpace/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
System.out.println("\nRemoving incidental white spaces (1):");
String json1 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json1);
System.out.println("\nRemoving incidental white spaces (2):");
String json2 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json2);
System.out.println("\nRemoving incidental white spaces (3):");
String json3 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json3);
System.out.println("\nRemoving incidental white spaces (4):");
String json4 = """
{
"widget": {
"debug": "on",
"window": {
"title": "Sample Widget 1",
"name": "back_window"
},
"image": {
"src": "images\\sw.png"
},
"text": {
"data": "Click Me",
"size": 39
}
}
}
""";
System.out.println(json4);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P199_StreamComparators/src/main/java/modern/challenge/Car.java | Chapter09/P199_StreamComparators/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car { // implements Comparable<Car> {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
/*
@Override
public int compareTo(Car c) {
return this.getHorsepower() > c.getHorsepower()
? 1 : this.getHorsepower() < c.getHorsepower() ? -1 : 0;
}
*/
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P199_StreamComparators/src/main/java/modern/challenge/Main.java | Chapter09/P199_StreamComparators/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.ArrayList;
import java.util.Comparator;
import static java.util.Comparator.comparing;
import static java.util.Comparator.nullsLast;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> nrs = new ArrayList<>();
nrs.add(1); nrs.add(6); nrs.add(3); nrs.add(8); nrs.add(2); nrs.add(3); nrs.add(0);
List<String> strs = new ArrayList<>();
strs.add("book"); strs.add("old"); strs.add("new"); strs.add("quiz"); strs.add("around"); strs.add("tick");
List<Car> cars = List.of(
new Car("Dacia", "diesel", 100),
new Car("Lexus", "gasoline", 300),
new Car("Chevrolet", "electric", 150),
new Car("Mercedes", null, 150),
new Car("Chevrolet", "diesel", 250),
new Car("Ford", "electric", 80),
new Car("Chevrolet", "diesel", 450),
new Car("Mercedes", "electric", 200),
new Car("Chevrolet", null, 350),
new Car("Lexus", "diesel", 300)
);
System.out.println("Natural order:");
System.out.println();
nrs.stream()
.sorted()
.forEach(System.out::println);
System.out.println();
strs.stream()
.sorted()
.forEach(System.out::println);
System.out.println();
nrs.stream()
.sorted((n1, n2) -> n1.compareTo(n2))
.forEach(System.out::println);
System.out.println();
strs.stream()
.sorted((s1, s2) -> s1.compareTo(s2))
.forEach(System.out::println);
System.out.println();
nrs.stream()
.sorted(Comparator.naturalOrder())
.forEach(System.out::println);
System.out.println();
strs.stream()
.sorted(Comparator.naturalOrder())
.forEach(System.out::println);
System.out.println();
System.out.println("Reverse natural order:");
System.out.println();
nrs.stream()
.sorted(Comparator.reverseOrder())
.forEach(System.out::println);
System.out.println();
strs.stream()
.sorted(Comparator.reverseOrder())
.forEach(System.out::println);
System.out.println();
System.out.println("Null first:");
System.out.println();
nrs.add(null);
/* - NPE
nrs.stream()
.sorted()
.forEach(System.out::println);
*/
System.out.println();
nrs.stream()
.sorted(Comparator.nullsFirst(Comparator.naturalOrder()))
.forEach(System.out::println);
System.out.println();
nrs.stream()
.sorted(Comparator.nullsLast(Comparator.naturalOrder()))
.forEach(System.out::println);
System.out.println();
nrs.stream()
.sorted(Comparator.nullsFirst(Comparator.reverseOrder()))
.forEach(System.out::println);
System.out.println();
System.out.println("Custom comparator:");
System.out.println();
strs.stream()
.sorted((s1, s2) -> Character.compare(s1.charAt(s1.length() - 1),
s2.charAt(s2.length() - 1)))
.forEach(System.out::println);
System.out.println();
/* - we need to implement java.lang.Comparable
cars.stream()
.sorted()
.forEach(System.out::println);
*/
cars.stream()
.sorted(Comparator.comparingInt(Car::getHorsepower))
.forEach(System.out::println);
System.out.println();
cars.stream()
.sorted(Comparator.comparingInt(Car::getHorsepower).reversed())
.forEach(System.out::println);
System.out.println();
cars.stream()
.sorted(Comparator.comparing(Car::getFuel,
Comparator.nullsLast(Comparator.naturalOrder())))
.forEach(System.out::println);
System.out.println();
cars.stream()
.sorted(Comparator.comparing(Car::getFuel,
Comparator.nullsLast(
(s1, s2) -> Character.compare(s1.charAt(s1.length() - 1),
s2.charAt(s2.length() - 1)))))
.forEach(System.out::println);
System.out.println();
// same result as the previous example but more readable
Comparator<String> byCharAt = nullsLast(
(s1, s2) -> Character.compare(s1.charAt(s1.length() - 1),
s2.charAt(s2.length() - 1)));
Comparator<Car> byFuelAndCharAt = comparing(Car::getFuel, byCharAt);
cars.stream()
.sorted(byFuelAndCharAt)
.forEach(System.out::println);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/ApplicationDependency.java | Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/ApplicationDependency.java | package modern.challenge;
public class ApplicationDependency {
private final long id;
private final String name;
private String dependencies;
public ApplicationDependency(long id, String name) {
this.id = id;
this.name = name;
}
public long getId() {
return id;
}
public String getName() {
return name;
}
public String getDependencies() {
return dependencies;
}
private void downloadDependencies() {
dependencies = "list of dependencies downloaded from repository " + Math.random();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/DependencyManager.java | Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/DependencyManager.java | package modern.challenge;
import java.util.HashMap;
import java.util.Map;
public class DependencyManager {
private Map<Long,String> apps = new HashMap<>();
public void processDependencies(ApplicationDependency appd){
System.out.println();
System.out.println("Processing app: " + appd.getName());
System.out.println("Dependencies: " + appd.getDependencies());
apps.put(appd.getId(),appd.getDependencies());
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/Main.java | Chapter09/P189_LambdaLazinessDysfunctional/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
ApplicationDependency app1 = new ApplicationDependency(1, "app-1");
ApplicationDependency app2 = new ApplicationDependency(2, "app-2");
DependencyManager dm = new DependencyManager();
dm.processDependencies(app1);
dm.processDependencies(app2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Streams.java | Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Streams.java | package modern.challenge;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;
import java.util.stream.Collectors;
public final class Streams {
private Streams() {
throw new AssertionError("Cannot be instantiated");
}
public static <K, T> Collector<T, ?, Map<K, T>> distinctByKeyV1(
Function<? super T, ? extends K> function) {
return Collectors.toMap(function, Function.identity(), (t1, t2) -> t1);
}
public static <T> Predicate<T> distinctByKeyV2(Function<? super T, ?> function) {
Map<Object, Boolean> seen = new ConcurrentHashMap<>();
return t -> seen.putIfAbsent(function.apply(t), Boolean.TRUE) == null;
}
public static <T> Predicate<T> distinctByKeyV3(Function<? super T, ?> function) {
Set<Object> seen = ConcurrentHashMap.newKeySet();
return t -> seen.add(function.apply(t));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Car.java | Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Main.java | Chapter09/P204_StreamDistinctBy/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Car> cars = List.of(
new Car("Chevrolet", "diesel", 350),
new Car("Dacia", "diesel", 100),
new Car("Lexus", "gasoline", 300),
new Car("Chevrolet", "electric", 150),
new Car("Mercedes", "electric", 150),
new Car("Chevrolet", "diesel", 250),
new Car("Lexus", "gasoline", 300),
new Car("Ford", "electric", 80),
new Car("Chevrolet", "diesel", 450),
new Car("Mercedes", "electric", 200),
new Car("Chevrolet", "gasoline", 350),
new Car("Lexus", "diesel", 300)
);
// typical distinct (based on equals()
cars.stream()
.distinct()
.forEach(System.out::println);
System.out.println();
cars.stream()
.collect(Collectors.toMap(Car::getBrand, Function.identity(), (c1, c2) -> c1))
.values()
.forEach(System.out::println);
System.out.println();
// works with nulls a well
cars.stream()
.collect(Streams.distinctByKeyV1(Car::getBrand))
.values()
.forEach(System.out::println);
System.out.println();
cars.stream()
.collect(Streams.distinctByKeyV1(Car::getFuel))
.values()
.forEach(System.out::println);
System.out.println();
// doesn't work for nulls
cars.stream()
.filter(Streams.distinctByKeyV2(Car::getBrand))
.forEach(System.out::println);
System.out.println();
// // doesn't work for nulls
cars.stream()
.filter(Streams.distinctByKeyV3(Car::getFuel))
.forEach(System.out::println);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Streams.java | Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Streams.java | package modern.challenge;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.Spliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.Function;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.LongConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
@SuppressWarnings("unchecked")
public interface Streams<T> extends Stream<T> {
default Streams<T> remove(T item) {
return removeAll(item);
}
default Streams<T> removeAll(T... items) {
return removeAll(Stream.of(items));
}
default Streams<T> removeAll(List<? extends T> items) {
return removeAll(items.stream());
}
default Streams<T> removeAll(Stream<? extends T> items) {
Set<? extends T> set = toSet(items);
if (set.isEmpty()) {
return this;
}
return filter(item -> !set.contains(item))
.onClose(items::close);
}
default Streams<T> retainAll(T... items) {
return retainAll(Stream.of(items));
}
default Streams<T> retainAll(List<? extends T> items) {
return retainAll(items.stream());
}
default Streams<T> retainAll(Stream<? extends T> items) {
Set<? extends T> set = toSet(items);
if (set.isEmpty()) {
return from(Stream.empty());
}
return filter(item -> set.contains(item))
.onClose(items::close);
}
static <T> Streams<T> from(Stream<? extends T> stream) {
if (stream == null) {
return from(Stream.empty());
}
if (stream instanceof Streams) {
return (Streams<T>) stream;
}
return new StreamsWrapper<>(stream);
}
static <T> Set<T> toSet(Stream<? extends T> stream) {
return stream.collect(Collectors.toSet());
}
@Override
public Streams<T> filter(Predicate<? super T> predicate);
@Override
public <R> Streams<R> map(Function<? super T, ? extends R> mapper);
@Override
public IntStream mapToInt(ToIntFunction<? super T> mapper);
@Override
public LongStream mapToLong(ToLongFunction<? super T> mapper);
@Override
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper);
@Override
public <R> Streams<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);
@Override
public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper);
@Override
public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper);
@Override
public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper);
@Override
public Streams<T> distinct();
@Override
public Streams<T> sorted();
@Override
public Streams<T> sorted(Comparator<? super T> comparator);
@Override
public Streams<T> peek(Consumer<? super T> action);
@Override
public Streams<T> limit(long maxSize);
@Override
public Streams<T> skip(long n);
@Override
public void forEach(Consumer<? super T> action);
@Override
public void forEachOrdered(Consumer<? super T> action);
@Override
public Object[] toArray();
@Override
public <A> A[] toArray(IntFunction<A[]> generator);
@Override
public T reduce(T identity, BinaryOperator<T> accumulator);
@Override
public Optional<T> reduce(BinaryOperator<T> accumulator);
@Override
public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner);
@Override
public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner);
@Override
public <R, A> R collect(Collector<? super T, A, R> collector);
@Override
public Optional<T> min(Comparator<? super T> comparator);
@Override
public Optional<T> max(Comparator<? super T> comparator);
@Override
public long count();
@Override
public boolean anyMatch(Predicate<? super T> predicate);
@Override
public boolean allMatch(Predicate<? super T> predicate);
@Override
public boolean noneMatch(Predicate<? super T> predicate);
@Override
public Optional<T> findFirst();
@Override
public List<T> toList();
@Override
public Streams<T> dropWhile(Predicate<? super T> predicate);
@Override
public Streams<T> takeWhile(Predicate<? super T> predicate);
@Override
public DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper);
@Override
public LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper);
@Override
public IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper);
@Override
public <R> Streams<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper);
@Override
public Optional<T> findAny();
@Override
public Iterator<T> iterator();
@Override
public Spliterator<T> spliterator();
@Override
public Streams<T> onClose(Runnable closeHandler);
@Override
public void close();
@Override
default boolean isParallel() {
return false;
}
@Override
default Streams<T> parallel() {
throw new UnsupportedOperationException("Not supported yet."); // or, return this
}
@Override
default Streams<T> unordered() {
throw new UnsupportedOperationException("Not supported yet."); // or, return this
}
@Override
default Streams<T> sequential() {
return this;
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Car.java | Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Main.java | Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Arrays;
import java.util.List;
@SuppressWarnings("unchecked")
public class Main {
public static void main(String[] args) {
List<Car> cars = Arrays.asList(new Car("Dacia", "diesel", 100),
new Car("Lexus", "gasoline", 300), new Car("Chevrolet", "electric", 150),
new Car("Mercedes", "gasoline", 150), new Car("Chevrolet", "diesel", 250),
new Car("Ford", "electric", 80), new Car("Chevrolet", "diesel", 450),
new Car("Mercedes", "electric", 200), new Car("Chevrolet", "gasoline", 350),
new Car("Lexus", "diesel", 300), new Car("Ford", "electric", 200)
);
Car car1 = new Car("Lexus", "diesel", 300);
Car car2 = new Car("Ford", "electric", 80);
Car car3 = new Car("Chevrolet", "electric", 150);
List<Car> cars123 = List.of(car1, car2, car3);
Streams.from(cars.stream()).forEach(System.out::println);
System.out.println();
Streams.from(cars.stream())
.remove(car1)
.forEach(System.out::println);
System.out.println();
Streams.from(cars.stream())
.distinct()
.retainAll(car1, car2, car3)
.filter(car -> car.getFuel().equals("electric"))
.removeAll(car2)
.forEach(System.out::println);
System.out.println();
Streams.from(cars.stream())
.retainAll(cars123)
.forEach(System.out::println);
System.out.println();
Streams.from(cars.stream()).retainAll(cars123)
.removeAll(car1, car3).forEach(System.out::println);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/StreamsWrapper.java | Chapter09/P198_ImplementingRemoveRetainAll1/src/main/java/modern/challenge/StreamsWrapper.java | package modern.challenge;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Optional;
import java.util.Spliterator;
import java.util.function.BiConsumer;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.DoubleConsumer;
import java.util.function.Function;
import java.util.function.IntConsumer;
import java.util.function.IntFunction;
import java.util.function.LongConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToDoubleFunction;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.DoubleStream;
import java.util.stream.IntStream;
import java.util.stream.LongStream;
import java.util.stream.Stream;
@SuppressWarnings("unchecked")
public class StreamsWrapper<T> implements Streams<T> {
private final Stream<? extends T> delegator;
public StreamsWrapper(Stream<? extends T> delegator) {
this.delegator = delegator.sequential();
}
@Override
public Streams<T> filter(Predicate<? super T> predicate) {
return Streams.from(delegator.filter(predicate));
}
@Override
public <R> Streams<R> map(Function<? super T, ? extends R> mapper) {
return Streams.from(delegator.map(mapper));
}
@Override
public IntStream mapToInt(ToIntFunction<? super T> mapper) {
return delegator.mapToInt(mapper);
}
@Override
public LongStream mapToLong(ToLongFunction<? super T> mapper) {
return delegator.mapToLong(mapper);
}
@Override
public DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper) {
return delegator.mapToDouble(mapper);
}
@Override
public <R> Streams<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper) {
return Streams.from(delegator.flatMap(mapper));
}
@Override
public IntStream flatMapToInt(Function<? super T, ? extends IntStream> mapper) {
return delegator.flatMapToInt(mapper);
}
@Override
public LongStream flatMapToLong(Function<? super T, ? extends LongStream> mapper) {
return delegator.flatMapToLong(mapper);
}
@Override
public DoubleStream flatMapToDouble(Function<? super T, ? extends DoubleStream> mapper) {
return delegator.flatMapToDouble(mapper);
}
@Override
public Streams<T> distinct() {
return Streams.from(delegator.distinct());
}
@Override
public Streams<T> sorted() {
return Streams.from(delegator.sorted());
}
@Override
public Streams<T> sorted(Comparator<? super T> comparator) {
return Streams.from(delegator.sorted(comparator));
}
@Override
public Streams<T> peek(Consumer<? super T> action) {
return Streams.from(delegator.peek(action));
}
@Override
public Streams<T> limit(long maxSize) {
return Streams.from(delegator.limit(maxSize));
}
@Override
public Streams<T> skip(long n) {
return Streams.from(delegator.skip(n));
}
@Override
public void forEach(Consumer<? super T> action) {
delegator.forEach(action);
}
@Override
public void forEachOrdered(Consumer<? super T> action) {
delegator.forEachOrdered(action);
}
@Override
public Object[] toArray() {
return delegator.toArray();
}
@Override
public <A> A[] toArray(IntFunction<A[]> generator) {
return delegator.toArray(generator);
}
@Override
public T reduce(T identity, BinaryOperator<T> accumulator) {
return ((Stream<T>) delegator).reduce(identity, accumulator);
}
@Override
public Optional<T> reduce(BinaryOperator<T> accumulator) {
return ((Stream<T>) delegator).reduce(accumulator);
}
@Override
public <U> U reduce(U identity, BiFunction<U, ? super T, U> accumulator, BinaryOperator<U> combiner) {
return delegator.reduce(identity, accumulator, combiner);
}
@Override
public <R> R collect(Supplier<R> supplier, BiConsumer<R, ? super T> accumulator, BiConsumer<R, R> combiner) {
return delegator.collect(supplier, accumulator, combiner);
}
@Override
public <R, A> R collect(Collector<? super T, A, R> collector) {
return delegator.collect(collector);
}
@Override
public Optional<T> min(Comparator<? super T> comparator) {
return ((Stream<T>) delegator).min(comparator);
}
@Override
public Optional<T> max(Comparator<? super T> comparator) {
return ((Stream<T>) delegator).max(comparator);
}
@Override
public long count() {
return delegator.count();
}
@Override
public boolean anyMatch(Predicate<? super T> predicate) {
return delegator.anyMatch(predicate);
}
@Override
public boolean allMatch(Predicate<? super T> predicate) {
return delegator.allMatch(predicate);
}
@Override
public boolean noneMatch(Predicate<? super T> predicate) {
return delegator.noneMatch(predicate);
}
@Override
public Optional<T> findFirst() {
return ((Stream<T>) delegator).findFirst();
}
@Override
public Optional<T> findAny() {
return ((Stream<T>) delegator).findAny();
}
@Override
public List<T> toList() {
return delegator.collect(Collectors.toList());
}
@Override
public Streams<T> dropWhile(Predicate<? super T> predicate) {
return Streams.from(delegator.dropWhile(predicate));
}
@Override
public Streams<T> takeWhile(Predicate<? super T> predicate) {
return Streams.from(delegator.takeWhile(predicate));
}
@Override
public DoubleStream mapMultiToDouble(BiConsumer<? super T, ? super DoubleConsumer> mapper) {
return delegator.mapMultiToDouble(mapper);
}
@Override
public LongStream mapMultiToLong(BiConsumer<? super T, ? super LongConsumer> mapper) {
return delegator.mapMultiToLong(mapper);
}
@Override
public IntStream mapMultiToInt(BiConsumer<? super T, ? super IntConsumer> mapper) {
return delegator.mapMultiToInt(mapper);
}
@Override
public <R> Streams<R> mapMulti(BiConsumer<? super T, ? super Consumer<R>> mapper) {
return Streams.from(delegator.mapMulti(mapper));
}
@Override
public Iterator<T> iterator() {
return ((Stream<T>) delegator).iterator();
}
@Override
public Spliterator<T> spliterator() {
return ((Stream<T>) delegator).spliterator();
}
@Override
public Streams<T> onClose(Runnable closeHandler) {
return Streams.from(delegator.onClose(closeHandler));
}
@Override
public void close() {
delegator.close();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/Logistics.java | Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/Logistics.java | package modern.challenge;
public final class Logistics {
private Logistics() {
throw new AssertionError("Cannot be instantiated");
}
public static void pl4(Double a, Double b, Double c, Double d, Double x) {
System.out.println(d + ((a - d) / (1 + (Math.pow(x / c, b)))));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/Main.java | Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/Main.java | package modern.challenge;
public class Main {
public static void main(String[] args) {
FiveConsumer<Double, Double, Double, Double, Double> pl4c = (a, b, c, d, x) ->
Logistics.pl4(a, b, c, d, x);
pl4c.accept(4.19, -1.10, 12.65, 0.03, 40.3);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/FiveConsumer.java | Chapter09/P207_ConsumerWith5Args/src/main/java/modern/challenge/FiveConsumer.java | package modern.challenge;
@FunctionalInterface
public interface FiveConsumer <T1, T2, T3, T4, T5> {
void accept (T1 t1, T2 t2, T3 t3, T4 t4, T5 t5);
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/MyCollectors.java | Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/MyCollectors.java | package modern.challenge;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collector;
public final class MyCollectors {
private MyCollectors() {
throw new AssertionError("Cannot be instantiated");
}
public static <T> Collector<T, List<T>, List<T>> toUnmodifiableListKeep(int max) {
return Collector.of(ArrayList::new,
(list, value) -> {
if (list.size() < max) {
list.add(value);
}
},
(left, right) -> {
left.addAll(right);
return left;
},
Collections::unmodifiableList);
}
public static <T> Collector<T, List<T>, List<T>> toUnmodifiableListSkip(int index) {
return Collector.of(ArrayList::new,
(list, value) -> {
if (list.size() >= index) {
list.add(value);
} else {
list.add(null);
}
},
(left, right) -> {
left.addAll(right);
return left;
},
list -> Collections.unmodifiableList(list.subList(index, list.size())));
}
public static <T> Collector<T, ?, List<T>> toUnmodifiableListSkipOptimized(int index) {
class Sublist {
int index;
List<T> list = new ArrayList<>();
}
return Collector.of(Sublist::new,
(sublist, value) -> {
if (sublist.index >= index) {
sublist.list.add(value);
} else {
sublist.index++;
}
},
(left, right) -> {
left.list.addAll(right.list);
left.index = left.index + right.index;
return left;
},
sublist -> Collections.unmodifiableList(sublist.list));
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/Car.java | Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/Main.java | Chapter09/P205_CollectorSkipKeepItems/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
List<Car> cars = List.of(
new Car("Chevrolet", "diesel", 350),
new Car("Dacia", "diesel", 100),
new Car("Lexus", "gasoline", 300),
new Car("Chevrolet", "electric", 150),
new Car("Mercedes", "electric", 150),
new Car("Chevrolet", "diesel", 250),
new Car("Lexus", "gasoline", 300),
new Car("Ford", "electric", 80),
new Car("Chevrolet", "diesel", 450),
new Car("Mercedes", "electric", 200),
new Car("Chevrolet", "gasoline", 350),
new Car("Lexus", "diesel", 300)
);
List<Car> first5CarsLimit = cars.stream()
.limit(5)
.collect(Collectors.toList());
System.out.println("\nFirst 5 cars: " + first5CarsLimit);
List<Car> first5Cars = cars.stream()
.collect(MyCollectors.toUnmodifiableListKeep(5));
System.out.println("\nFirst 5 cars: " + first5Cars);
List<Car> last5CarsSkip = cars.stream()
.skip(5)
.collect(Collectors.toList());
System.out.println("\nLast 5 cars: " + last5CarsSkip);
List<Car> last5Cars1 = cars.stream()
.collect(MyCollectors.toUnmodifiableListSkip(5));
System.out.println("\nLast 5 cars: " + last5Cars1);
List<Car> last5Cars2 = cars.stream()
.collect(MyCollectors.toUnmodifiableListSkipOptimized(5));
System.out.println("\nLast 5 cars: " + last5Cars2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Book.java | Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Book.java | package modern.challenge;
import java.time.LocalDate;
import java.util.Objects;
public class Book {
private final String title;
private final LocalDate published;
public Book(String title, LocalDate published) {
this.title = title;
this.published = published;
}
public String getTitle() {
return title;
}
public LocalDate getPublished() {
return published;
}
@Override
public int hashCode() {
int hash = 3;
hash = 29 * hash + Objects.hashCode(this.title);
hash = 29 * hash + Objects.hashCode(this.published);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Book other = (Book) obj;
if (!Objects.equals(this.title, other.title)) {
return false;
}
return Objects.equals(this.published, other.published);
}
@Override
public String toString() {
return "Book{" + "title=" + title + ", published=" + published + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Main.java | Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
Book b1 = new Book("Book1", LocalDate.of(2000, 3, 12));
Book b2 = new Book("Book2", LocalDate.of(2002, 3, 11));
Book b3 = new Book("Book3", LocalDate.of(2004, 11, 24));
Book b4 = new Book("Book4", LocalDate.of(2002, 6, 10));
Book b5 = new Book("Book5", LocalDate.of(2009, 5, 7));
Book b6 = new Book("Book6", LocalDate.of(2007, 2, 17));
Book b7 = new Book("Book7", LocalDate.of(1995, 10, 27));
Book b8 = new Book("Book8", LocalDate.of(2001, 10, 17));
Book b9 = new Book("Book9", LocalDate.of(2004, 8, 10));
Book b10 = new Book("Book10", LocalDate.of(2008, 1, 4));
Author a1 = new Author("Joana Nimar", List.of(b1, b2, b3));
Author a2 = new Author("Olivia Goy", List.of(b4, b5));
Author a3 = new Author("Marcel Joel", List.of(b6));
Author a4 = new Author("Alexender Tohn", List.of(b7, b8, b9, b10));
List<Author> authors = new ArrayList<>();
authors.add(a1);
authors.add(a2);
authors.add(a3);
authors.add(a4);
/* find books published in 2002 */
// using flatMap
List<Book> book2002fm = authors.stream()
.flatMap(author -> author.getBooks().stream())
.filter(book -> book.getPublished().getYear() == 2002)
.collect(Collectors.toList());
System.out.println(book2002fm);
System.out.println();
// using mapMulti
List<Book> book2002mm = authors.stream()
.<Book>mapMulti((author, consumer) -> {
for (Book book : author.getBooks()) {
if (book.getPublished().getYear() == 2002) {
consumer.accept(book);
}
}
})
.collect(Collectors.toList());
System.out.println(book2002mm);
System.out.println();
/* find authors having book published in 2002 */
// using anyMatch
List<Author> authors2002am = authors.stream()
.filter(
author -> author.getBooks().stream()
.anyMatch(book -> book.getPublished().getYear() == 2002)
)
.collect(Collectors.toList());
System.out.println(authors2002am);
System.out.println();
// using mapMulti
List<Author> author2002mm = authors.stream()
.<Author>mapMulti((author, consumer) -> {
for (Book book : author.getBooks()) {
if (book.getPublished().getYear() == 2002) {
consumer.accept(author);
break;
}
}
})
.collect(Collectors.toList());
System.out.println(author2002mm);
System.out.println();
// using removeif (altering the original list)
authors.removeIf(author -> author.getBooks().stream()
.noneMatch(book -> book.getPublished().getYear() == 2002));
System.out.println(authors);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Author.java | Chapter09/P192_FilterNestedCollection/src/main/java/modern/challenge/Author.java | package modern.challenge;
import java.util.List;
import java.util.Objects;
public class Author {
private final String name;
private final List<Book> books;
public Author(String name, List<Book> books) {
this.name = name;
this.books = books;
}
public String getName() {
return name;
}
public List<Book> getBooks() {
return books;
}
@Override
public int hashCode() {
int hash = 7;
hash = 67 * hash + Objects.hashCode(this.name);
hash = 67 * hash + Objects.hashCode(this.books);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Author other = (Author) obj;
if (!Objects.equals(this.name, other.name)) {
return false;
}
return Objects.equals(this.books, other.books);
}
@Override
public String toString() {
return "Author{" + "name=" + name + ", books=" + books + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P193_UsingBiPredicate/src/main/java/modern/challenge/Car.java | Chapter09/P193_UsingBiPredicate/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P193_UsingBiPredicate/src/main/java/modern/challenge/Main.java | Chapter09/P193_UsingBiPredicate/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
public class Main {
public static void main(String[] args) {
List<Car> cars = Arrays.asList(new Car("Dacia", "diesel", 100),
new Car("Lexus", "gasoline", 300), new Car("Chevrolet", "electric", 150),
new Car("Mercedes", "gasoline", 150), new Car("Chevrolet", "diesel", 250),
new Car("Ford", "electric", 80), new Car("Chevrolet", "diesel", 450),
new Car("Mercedes", "electric", 200), new Car("Chevrolet", "gasoline", 350),
new Car("Lexus", "diesel", 300), new Car("Ford", "electric", 200)
);
Car car = new Car("Ford", "electric", 80);
Predicate<Car> predicate = cars::contains;
System.out.println(predicate.test(car));
System.out.println(cars.stream().anyMatch(p -> p.equals(car)));
BiPredicate<List<Car>, Car> biPredicate = List::contains;
System.out.println(biPredicate.test(cars, car));
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/MyCollectors.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/MyCollectors.java | package modern.challenge;
import java.util.Collection;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collector;
public final class MyCollectors {
private MyCollectors() {
throw new AssertionError("Cannot be instantiated");
}
public static <T> Collector<T, TreeSet<T>, TreeSet<T>> toTreeSet() {
return Collector.of(TreeSet::new, TreeSet::add,
(left, right) -> {
left.addAll(right);
return left;
}, Collector.Characteristics.IDENTITY_FINISH);
}
public static <T> Collector<T, LinkedHashSet<T>, LinkedHashSet<T>> toLinkedHashSet() {
return Collector.of(LinkedHashSet::new, HashSet::add,
(left, right) -> {
left.addAll(right);
return left;
}, Collector.Characteristics.IDENTITY_FINISH);
}
public static <T, A, R> Collector<T, A, R> exclude(
Predicate<T> predicate, Collector<T, A, R> collector) {
return Collector.of(
collector.supplier(),
(l, r) -> {
if (predicate.negate().test(r)) {
collector.accumulator().accept(l, r);
}
},
collector.combiner(),
collector.finisher(),
collector.characteristics().toArray(Collector.Characteristics[]::new)
);
}
public static <T, A extends T, R extends Collection<A>> Collector<T, ?, R>
toType(Class<A> type, Supplier<R> supplier) {
return Collector.of(supplier,
(R r, T t) -> {
if (type.isInstance(t)) {
r.add(type.cast(t));
}
},
(R left, R right) -> {
left.addAll(right);
return left;
},
Collector.Characteristics.IDENTITY_FINISH
);
}
public static Collector<Integer, SplayTree, SplayTree> toSplayTree() {
return Collector.of(SplayTree::new, SplayTree::insert,
(left, right) -> {
left.insertAll(right);
return left;
}, Collector.Characteristics.IDENTITY_FINISH);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Submersible.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Submersible.java | package modern.challenge;
import java.util.Objects;
public class Submersible implements Vehicle {
private final String type;
private final double maxdepth;
public Submersible(String type, double maxdepth) {
this.type = type;
this.maxdepth = maxdepth;
}
public String getType() {
return type;
}
public double getMaxdepth() {
return maxdepth;
}
@Override
public int hashCode() {
int hash = 7;
hash = 43 * hash + Objects.hashCode(this.type);
hash = 43 * hash + (int) (Double.doubleToLongBits(this.maxdepth) ^ (Double.doubleToLongBits(this.maxdepth) >>> 32));
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Submersible other = (Submersible) obj;
if (Double.doubleToLongBits(this.maxdepth) != Double.doubleToLongBits(other.maxdepth)) {
return false;
}
return Objects.equals(this.type, other.type);
}
@Override
public String toString() {
return "Submersible{" + "type=" + type + ", maxdepth=" + maxdepth + '}';
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/SplayTree.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/SplayTree.java | package modern.challenge;
import java.util.ArrayDeque;
import java.util.Queue;
class SplayTree {
private Node root;
private int count;
private final class Node {
private Node left;
private Node right;
private Node parent;
private int data;
public Node() {
this(0, null, null, null);
}
public Node(int data) {
this(data, null, null, null);
}
public Node(int data, Node left, Node right, Node parent) {
this.left = left;
this.right = right;
this.parent = parent;
this.data = data;
}
}
public SplayTree() {
root = null;
}
public void insert(int data) {
Node xNode = root;
Node yNode = null;
while (xNode != null) {
yNode = xNode;
if (data > yNode.data) {
xNode = xNode.right;
} else {
xNode = xNode.left;
}
}
xNode = new Node();
xNode.data = data;
xNode.parent = yNode;
if (yNode == null) {
root = xNode;
} else if (data > yNode.data) {
yNode.right = xNode;
} else {
yNode.left = xNode;
}
splay(xNode);
count++;
}
public void insertAll(SplayTree other) {
insertAll(other.root);
}
private void insertAll(Node node) {
if (node != null) {
insertAll(node.left);
insert(node.data);
insertAll(node.right);
}
}
private void splay(Node node) {
while (node.parent != null) {
Node parentNode = node.parent;
Node grandpaNode = parentNode.parent;
if (grandpaNode == null) {
if (node == parentNode.left) {
leftChildToParent(node, parentNode);
} else {
rightChildToParent(node, parentNode);
}
} else {
if (node == parentNode.left) {
if (parentNode == grandpaNode.left) {
leftChildToParent(parentNode, grandpaNode);
leftChildToParent(node, parentNode);
} else {
leftChildToParent(node, node.parent);
rightChildToParent(node, node.parent);
}
} else {
if (parentNode == grandpaNode.left) {
rightChildToParent(node, node.parent);
leftChildToParent(node, node.parent);
} else {
rightChildToParent(parentNode, grandpaNode);
rightChildToParent(node, parentNode);
}
}
}
}
root = node;
}
private void leftChildToParent(Node xNode, Node yNode) {
if (xNode == null || yNode == null || yNode.left != xNode || xNode.parent != yNode) {
throw new IllegalStateException("Something is not working properly while transforming the left child into parent");
}
if (yNode.parent != null) {
if (yNode == yNode.parent.left) {
yNode.parent.left = xNode;
} else {
yNode.parent.right = xNode;
}
}
if (xNode.right != null) {
xNode.right.parent = yNode;
}
xNode.parent = yNode.parent;
yNode.parent = xNode;
yNode.left = xNode.right;
xNode.right = yNode;
}
private void rightChildToParent(Node xNode, Node yNode) {
if ((xNode == null) || (yNode == null) || (yNode.right != xNode) || (xNode.parent != yNode)) {
throw new IllegalStateException("Something is not working properly while transforming the right child into parent");
}
if (yNode.parent != null) {
if (yNode == yNode.parent.left) {
yNode.parent.left = xNode;
} else {
yNode.parent.right = xNode;
}
}
if (xNode.left != null) {
xNode.left.parent = yNode;
}
xNode.parent = yNode.parent;
yNode.parent = xNode;
yNode.right = xNode.left;
xNode.left = yNode;
}
public boolean search(int data) {
return searchNode(data) != null;
}
private Node searchNode(int data) {
Node previousNode = null;
Node rootNode = root;
while (rootNode != null) {
previousNode = rootNode;
if (data > rootNode.data) {
rootNode = rootNode.right;
} else if (data < rootNode.data) {
rootNode = rootNode.left;
} else if (data == rootNode.data) {
splay(rootNode);
return rootNode;
}
}
if (previousNode != null) {
splay(previousNode);
return null;
}
return null;
}
public void delete(int data) {
Node node = searchNode(data);
delete(node);
}
private void delete(Node node) {
if (node == null) {
return;
}
splay(node);
if ((node.left != null) && (node.right != null)) {
Node min = node.left;
while (min.right != null) {
min = min.right;
}
min.right = node.right;
node.right.parent = min;
node.left.parent = null;
root = node.left;
} else if (node.right != null) {
node.right.parent = null;
root = node.right;
} else if (node.left != null) {
node.left.parent = null;
root = node.left;
} else {
root = null;
}
node.parent = null;
node.left = null;
node.right = null;
node = null;
count--;
}
public boolean isEmpty() {
return root == null;
}
public int count() {
return count;
}
public void clear() {
root = null;
count = 0;
}
public enum TraversalOrder {
PRE,
IN,
POST,
LEVEL
}
public void print(TraversalOrder to) {
if (isEmpty()) {
System.out.println("empty");
return;
}
switch (to) {
// DFS
case IN ->
printInOrder(root);
case PRE ->
printPreOrder(root);
case POST ->
printPostOrder(root);
// BFS
case LEVEL ->
printLevelOrder(root);
}
}
private void printInOrder(Node node) {
if (node != null) {
printInOrder(node.left);
System.out.print(" " + node.data);
printInOrder(node.right);
}
}
private void printPreOrder(Node node) {
if (node != null) {
System.out.print(" " + node.data);
printPreOrder(node.left);
printPreOrder(node.right);
}
}
private void printPostOrder(Node node) {
if (node != null) {
printPostOrder(node.left);
printPostOrder(node.right);
System.out.print(" " + node.data);
}
}
private void printLevelOrder(Node node) {
Queue<Node> queue = new ArrayDeque<>();
queue.add(node);
while (!queue.isEmpty()) {
Node current = queue.poll();
System.out.print(" " + current.data);
if (current.left != null) {
queue.add(current.left);
}
if (current.right != null) {
queue.add(current.right);
}
}
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Vehicle.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Vehicle.java | package modern.challenge;
public interface Vehicle {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Car.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Car.java | package modern.challenge;
import java.util.Objects;
public class Car implements Vehicle {
private final String brand;
private final String fuel;
private final int horsepower;
public Car(String brand, String fuel, int horsepower) {
this.brand = brand;
this.fuel = fuel;
this.horsepower = horsepower;
}
public String getBrand() {
return brand;
}
public String getFuel() {
return fuel;
}
public int getHorsepower() {
return horsepower;
}
@Override
public int hashCode() {
int hash = 5;
hash = 17 * hash + Objects.hashCode(this.brand);
hash = 17 * hash + Objects.hashCode(this.fuel);
hash = 17 * hash + this.horsepower;
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Car other = (Car) obj;
if (this.horsepower != other.horsepower) {
return false;
}
if (!Objects.equals(this.brand, other.brand)) {
return false;
}
return Objects.equals(this.fuel, other.fuel);
}
@Override
public String toString() {
return "Car{" + "brand=" + brand + ", fuel=" + fuel + ", horsepower=" + horsepower + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Main.java | Chapter09/P202_CustomCollectorOf/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
public class Main {
public static void main(String[] args) {
Map<Integer, Car> cars = Map.of(
1, new Car("Dacia", "diesel", 100),
2, new Car("Lexus", "gasoline", 300),
3, new Car("Chevrolet", "electric", 150),
4, new Car("Mercedes", "gasoline", 150),
5, new Car("Chevrolet", "diesel", 250),
6, new Car("Ford", "electric", 80),
7, new Car("Chevrolet", "diesel", 450),
8, new Car("Mercedes", "electric", 200),
9, new Car("Chevrolet", "gasoline", 350),
10, new Car("Lexus", "diesel", 300)
);
TreeSet<String> electricBrands = cars.values().stream()
.filter(c -> "electric".equals(c.getFuel()))
.map(c -> c.getBrand())
.collect(MyCollectors.toTreeSet());
System.out.println("Electric brands: " + electricBrands);
LinkedHashSet<Integer> hpSorted = cars.values().stream()
.map(c -> c.getHorsepower())
.sorted()
.collect(MyCollectors.toLinkedHashSet());
System.out.println("Sorted horsepower: " + hpSorted);
LinkedHashSet<Integer> excludeHp200 = cars.values().stream()
.map(c -> c.getHorsepower())
.sorted()
.collect(MyCollectors.exclude(c -> c > 200, MyCollectors.toLinkedHashSet()));
System.out.println("Sorted horsepower less than 200: " + excludeHp200);
Vehicle mazda = new Car("Mazda", "diesel", 155);
Vehicle ferrari = new Car("Ferrari", "gasoline", 500);
Vehicle hov = new Submersible("HOV", 3000);
Vehicle rov = new Submersible("ROV", 7000);
List<Vehicle> vehicles = List.of(mazda, hov, ferrari, rov);
List<Car> onlyCars = vehicles.stream()
.collect(MyCollectors.toType(Car.class, ArrayList::new));
Set<Submersible> onlySubmersible = vehicles.stream()
.collect(MyCollectors.toType(Submersible.class, HashSet::new));
System.out.println("Only cars:" + onlyCars);
System.out.println("Only submersible:" + onlySubmersible);
SplayTree st = cars.values().stream()
.map(c -> c.getHorsepower())
.collect(MyCollectors.toSplayTree());
System.out.println("SplayTree:");
st.print(SplayTree.TraversalOrder.IN);
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Book.java | Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Book.java | package modern.challenge;
import java.time.LocalDate;
import java.util.Objects;
public class Book {
private final String title;
private final LocalDate published;
public Book(String title, LocalDate published) {
this.title = title;
this.published = published;
}
public String getTitle() {
return title;
}
public LocalDate getPublished() {
return published;
}
@Override
public int hashCode() {
int hash = 3;
hash = 29 * hash + Objects.hashCode(this.title);
hash = 29 * hash + Objects.hashCode(this.published);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Book other = (Book) obj;
if (!Objects.equals(this.title, other.title)) {
return false;
}
return Objects.equals(this.published, other.published);
}
@Override
public String toString() {
return "Book{" + "title=" + title + ", published=" + published + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Bookshelf.java | Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Bookshelf.java | package modern.challenge;
public class Bookshelf {
private final String author;
private final String book;
public Bookshelf(String author, String book) {
this.author = author;
this.book = book;
}
public String getAuthor() {
return author;
}
public String getBook() {
return book;
}
@Override
public String toString() {
return "Shelf{" + "author=" + author + ", book=" + book + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Main.java | Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Main.java | package modern.challenge;
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
Book b1 = new Book("Book1", LocalDate.of(2000, 3, 12));
Book b2 = new Book("Book2", LocalDate.of(2002, 3, 11));
Book b3 = new Book("Book3", LocalDate.of(2004, 11, 24));
Book b4 = new Book("Book4", LocalDate.of(2002, 6, 10));
Book b5 = new Book("Book5", LocalDate.of(2009, 5, 7));
Book b6 = new Book("Book6", LocalDate.of(2007, 2, 17));
Book b7 = new Book("Book7", LocalDate.of(1995, 10, 27));
Book b8 = new Book("Book8", LocalDate.of(2001, 10, 17));
Book b9 = new Book("Book9", LocalDate.of(2004, 8, 10));
Book b10 = new Book("Book10", LocalDate.of(2008, 1, 4));
Author a1 = new Author("Joana Nimar", List.of(b1, b2, b3));
Author a2 = new Author("Olivia Goy", List.of(b4, b5));
Author a3 = new Author("Marcel Joel", List.of(b6));
Author a4 = new Author("Alexender Tohn", List.of(b7, b8, b9, b10));
List<Author> authors = new ArrayList<>();
authors.add(a1);
authors.add(a2);
authors.add(a3);
authors.add(a4);
List<Bookshelf> bookshelfClassic = authors.stream()
.flatMap(
author -> author.getBooks()
.stream()
.map(book -> new Bookshelf(author.getName(), book.getTitle()))
)
.collect(Collectors.toList());
System.out.println(bookshelfClassic);
System.out.println();
List<Bookshelf> bookshelfMM = authors.stream()
.<Bookshelf>mapMulti((author, consumer) -> {
for (Book book : author.getBooks()) {
consumer.accept(new Bookshelf(author.getName(), book.getTitle()));
}
})
.collect(Collectors.toList());
System.out.println(bookshelfMM);
System.out.println();
/* Case 1: mapMulti() is useful when replacing each stream
element with a small (possibly zero) number of elements */
List<Bookshelf> bookshelfGt2005Classic = authors.stream()
.flatMap(
author -> author.getBooks()
.stream()
.filter(book -> book.getPublished().getYear() > 2005)
.map(book -> new Bookshelf(author.getName(), book.getTitle()))
)
.collect(Collectors.toList());
System.out.println();
System.out.println(bookshelfGt2005Classic);
List<Bookshelf> bookshelfGt2005MM1 = authors.stream()
.<Bookshelf>mapMulti((author, consumer) -> {
for (Book book : author.getBooks()) {
if (book.getPublished().getYear() > 2005) {
consumer.accept(new Bookshelf(author.getName(), book.getTitle()));
}
}
})
.collect(Collectors.toList());
System.out.println();
System.out.println(bookshelfGt2005MM1);
/* Case 2: mapMulti() is useful when it is easier to use an imperative approach
for generating result elements than it is to return them in the form of a Stream */
List<Bookshelf> bookshelfGt2005MM2 = authors.stream()
.<Bookshelf>mapMulti(Author::bookshelfGt2005)
.collect(Collectors.toList());
System.out.println();
System.out.println(bookshelfGt2005MM2);
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Author.java | Chapter09/P185_MapMulti2/src/main/java/modern/challenge/Author.java | package modern.challenge;
import java.util.List;
import java.util.Objects;
import java.util.function.Consumer;
public class Author {
private final String name;
private final List<Book> books;
public Author(String name, List<Book> books) {
this.name = name;
this.books = books;
}
public void bookshelfGt2005(Consumer<Bookshelf> consumer) {
for (Book book : this.getBooks()) {
if (book.getPublished().getYear() > 2005) {
consumer.accept(new Bookshelf(this.getName(), book.getTitle()));
}
}
}
public String getName() {
return name;
}
public List<Book> getBooks() {
return books;
}
@Override
public int hashCode() {
int hash = 7;
hash = 67 * hash + Objects.hashCode(this.name);
hash = 67 * hash + Objects.hashCode(this.books);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Author other = (Author) obj;
if (!Objects.equals(this.name, other.name)) {
return false;
}
return Objects.equals(this.books, other.books);
}
@Override
public String toString() {
return "Author{" + "name=" + name + ", books=" + books + '}';
}
}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/FSupplier.java | Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/FSupplier.java | package modern.challenge;
import java.util.function.Supplier;
@FunctionalInterface
public interface FSupplier<R> extends Supplier<R> {}
| java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/ApplicationDependency.java | Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/ApplicationDependency.java | package modern.challenge;
import java.util.function.Supplier;
public class ApplicationDependency {
private final long id;
private final String name;
private final Supplier<String> dependencies
= Memoize.supplier(this::downloadDependencies);
public ApplicationDependency(long id, String name) {
this.id = id;
this.name = name;
}
public long getId() {
return id;
}
public String getName() {
return name;
}
public String getDependencies() {
return dependencies.get();
}
private String downloadDependencies() {
return "list of dependencies downloaded from repository " + Math.random();
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/DependencyManager.java | Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/DependencyManager.java | package modern.challenge;
import java.util.HashMap;
import java.util.Map;
public class DependencyManager {
private Map<Long,String> apps = new HashMap<>();
public void processDependencies(ApplicationDependency appd){
System.out.println();
System.out.println("Processing app: " + appd.getName());
System.out.println("Dependencies: " + appd.getDependencies());
apps.put(appd.getId(),appd.getDependencies());
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
PacktPublishing/Java-Coding-Problems-Second-Edition | https://github.com/PacktPublishing/Java-Coding-Problems-Second-Edition/blob/47b7c834407a607580baf8e3a23c1c24c24b8bc0/Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/Memoize.java | Chapter09/P189_LambdaLazinessFunctional/src/main/java/modern/challenge/Memoize.java | package modern.challenge;
import java.util.concurrent.atomic.AtomicReference;
import java.util.function.Supplier;
@SuppressWarnings("unchecked")
public class Memoize {
private final static Object UNDEFINED = new Object();
public static <T> FSupplier<T> supplier(final Supplier<T> supplier) {
AtomicReference cache = new AtomicReference<>(UNDEFINED);
return () -> {
Object value = cache.get();
if (value == UNDEFINED) {
synchronized (cache) {
if (cache.get() == UNDEFINED) {
System.out.println("Caching: " + supplier.get());
value = supplier.get();
cache.set(value);
}
}
}
return (T) value;
};
}
} | java | MIT | 47b7c834407a607580baf8e3a23c1c24c24b8bc0 | 2026-01-05T02:37:06.170961Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.