Skip to content

Commit 2731096

Browse files
lor6lor6
authored
Merge branch 'master' into master
2 parents 128e391 + 54aee18 commit 2731096

162 files changed

Lines changed: 4745 additions & 504 deletions

File tree

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

‎algorithms-modules/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -29,13 +29,13 @@ void add(int num) {
2929
}
3030

3131
double getMedian() {
32-
int median;
32+
double median;
3333
if (minHeap.size() < maxHeap.size()) {
3434
median = maxHeap.peek();
3535
} else if (minHeap.size() > maxHeap.size()) {
3636
median = minHeap.peek();
3737
} else {
38-
median = (minHeap.peek() + maxHeap.peek()) / 2;
38+
median = (minHeap.peek() + maxHeap.peek()) / 2.0;
3939
}
4040
return median;
4141
}

‎algorithms-modules/algorithms-miscellaneous-5/src/main/java/com/baeldung/algorithms/integerstreammedian/MedianOfIntegerStream2.java‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -25,11 +25,11 @@ void add(int num) {
2525
}
2626

2727
double getMedian() {
28-
int median;
28+
double median;
2929
if (minHeap.size() > maxHeap.size()) {
3030
median = minHeap.peek();
3131
} else {
32-
median = (minHeap.peek() + maxHeap.peek()) / 2;
32+
median = (minHeap.peek() + maxHeap.peek()) / 2.0;
3333
}
3434
return median;
3535
}

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

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -13,4 +13,12 @@
1313
<version>0.0.1-SNAPSHOT</version>
1414
</parent>
1515

16+
<dependencies>
17+
<dependency>
18+
<groupId>org.apache.commons</groupId>
19+
<artifactId>commons-lang3</artifactId>
20+
<version>3.14.0</version>
21+
</dependency>
22+
</dependencies>
23+
1624
</project>

‎core-java-modules/core-java-arrays-operations-basic-2/src/test/java/com/baeldung/array/flatarray/FlatArrayUnitTest.java‎

Lines changed: 130 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,130 @@
1+
package com.baeldung.array.flatarray;
2+
3+
import static org.assertj.core.api.Assertions.assertThat;
4+
5+
import java.util.ArrayList;
6+
import java.util.Arrays;
7+
import java.util.List;
8+
import java.util.stream.Collectors;
9+
import java.util.stream.Stream;
10+
import org.junit.jupiter.params.ParameterizedTest;
11+
import org.junit.jupiter.params.provider.Arguments;
12+
import org.junit.jupiter.params.provider.MethodSource;
13+
14+
class FlatArrayUnitTest {
15+
16+
@ParameterizedTest
17+
@MethodSource("arrayProvider")
18+
void giveTwoDimensionalArray_whenFlatWithStream_thenGetCorrectResult(int[][] initialArray,
19+
int[] expected) {
20+
int[] actual = Arrays.stream(initialArray).flatMapToInt(Arrays::stream).toArray();
21+
assertThat(actual).containsExactly(expected);
22+
}
23+
24+
@ParameterizedTest
25+
@MethodSource("arrayProvider")
26+
void giveTwoDimensionalArray_whenFlatWithForLoopAndAdditionalList_thenGetCorrectResult(int[][] initialArray,
27+
int[] intArray) {
28+
List<Integer> expected = Arrays.stream(intArray).boxed().collect(Collectors.toList());
29+
List<Integer> actual = new ArrayList<>();
30+
for (int[] numbers : initialArray) {
31+
for (int number : numbers) {
32+
actual.add(number);
33+
}
34+
}
35+
assertThat(actual).isEqualTo(expected);
36+
}
37+
38+
@ParameterizedTest
39+
@MethodSource("arrayProvider")
40+
void giveTwoDimensionalArray_whenFlatWithForLoopAndLists_thenGetCorrectResult(int[][] initialArray,
41+
int[] intArray) {
42+
List<Integer> expected = Arrays.stream(intArray).boxed().collect(Collectors.toList());
43+
List<Integer> actual = new ArrayList<>();
44+
for (int[] numbers : initialArray) {
45+
List<Integer> listOfNumbers = Arrays.stream(numbers).boxed().collect(Collectors.toList());
46+
actual.addAll(listOfNumbers);
47+
}
48+
assertThat(actual).isEqualTo(expected);
49+
}
50+
51+
@ParameterizedTest
52+
@MethodSource("arrayProvider")
53+
void giveTwoDimensionalArray_whenFlatWithArrayCopy_thenGetCorrectResult(int[][] initialArray,
54+
int[] expected) {
55+
int[] actual = new int[]{};
56+
int position = 0;
57+
for (int[] numbers : initialArray) {
58+
if (actual.length < position + numbers.length) {
59+
int[] newArray = new int[actual.length + numbers.length];
60+
System.arraycopy(actual, 0, newArray, 0, actual.length);
61+
actual = newArray;
62+
}
63+
System.arraycopy(numbers, 0, actual, position, numbers.length);
64+
position += numbers.length;
65+
}
66+
assertThat(actual).isEqualTo(expected);
67+
}
68+
69+
@ParameterizedTest
70+
@MethodSource("arrayProvider")
71+
void giveTwoDimensionalArray_whenFlatWithArrayCopyAndTotalNumberOfElements_thenGetCorrectResult(int[][] initialArray,
72+
int[] expected) {
73+
int totalNumberOfElements = 0;
74+
for (int[] numbers : initialArray) {
75+
totalNumberOfElements += numbers.length;
76+
}
77+
int[] actual = new int[totalNumberOfElements];
78+
int position = 0;
79+
for (int[] numbers : initialArray) {
80+
System.arraycopy(numbers, 0, actual, position, numbers.length);
81+
position += numbers.length;
82+
}
83+
assertThat(actual).isEqualTo(expected);
84+
}
85+
86+
@ParameterizedTest
87+
@MethodSource("arrayProvider")
88+
void giveTwoDimensionalArray_whenFlatWithForLoopAndTotalNumberOfElements_thenGetCorrectResult(int[][] initialArray,
89+
int[] expected) {
90+
int totalNumberOfElements = 0;
91+
for (int[] numbers : initialArray) {
92+
totalNumberOfElements += numbers.length;
93+
}
94+
int[] actual = new int[totalNumberOfElements];
95+
int position = 0;
96+
for (int[] numbers : initialArray) {
97+
for (int number : numbers) {
98+
actual[position] = number;
99+
++position;
100+
}
101+
}
102+
assertThat(actual).isEqualTo(expected);
103+
}
104+
105+
106+
static Stream<Arguments> arrayProvider() {
107+
return Stream.of(
108+
Arguments.of(
109+
new int[][]{
110+
{805, 902, 259, 162, 775},
111+
{278, 216, 0, 72, 663},
112+
{185, 390, 537, 909, 918},
113+
{150, 782, 282, 482, 401},
114+
{244, 685, 643, 364, 307},
115+
{483, 939, 750, 190, 424},
116+
{44, 160, 290, 963, 881}
117+
},
118+
new int[]{
119+
805, 902, 259, 162, 775,
120+
278, 216, 0, 72, 663,
121+
185, 390, 537, 909, 918,
122+
150, 782, 282, 482, 401,
123+
244, 685, 643, 364, 307,
124+
483, 939, 750, 190, 424,
125+
44, 160, 290, 963, 881
126+
}
127+
)
128+
);
129+
}
130+
}

‎core-java-modules/core-java-arrays-operations-basic-2/src/test/java/com/baeldung/array/smallestindex/SmallestElementIndexUnitTest.java‎

Lines changed: 132 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,132 @@
1+
package com.baeldung.array.smallestindex;
2+
3+
import static org.assertj.core.api.Assertions.assertThat;
4+
5+
import java.util.Arrays;
6+
import java.util.List;
7+
import java.util.stream.Collectors;
8+
import java.util.stream.IntStream;
9+
import java.util.stream.Stream;
10+
import org.apache.commons.lang3.ArrayUtils;
11+
import org.junit.jupiter.params.ParameterizedTest;
12+
import org.junit.jupiter.params.provider.Arguments;
13+
import org.junit.jupiter.params.provider.MethodSource;
14+
15+
class SmallestElementIndexUnitTest {
16+
17+
@ParameterizedTest
18+
@MethodSource("primitiveProvider")
19+
void givenArray_whenUsingForLoop_thenGetCorrectResult(int[] array, int expectedIndex) {
20+
int minValue = Integer.MAX_VALUE;
21+
int minIndex = -1;
22+
for (int i = 0; i < array.length; i++) {
23+
if (array[i] < minValue) {
24+
minValue = array[i];
25+
minIndex = i;
26+
}
27+
}
28+
assertThat(minIndex).isEqualTo(expectedIndex);
29+
}
30+
31+
@ParameterizedTest
32+
@MethodSource("primitiveProvider")
33+
void givenArray_whenUsingForLoopAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
34+
int minValue = Integer.MAX_VALUE;
35+
for (int number : array) {
36+
if (number < minValue) {
37+
minValue = number;
38+
}
39+
}
40+
int minIndex = -1;
41+
for (int i = 0; i < array.length; i++) {
42+
if (array[i] == minValue) {
43+
minIndex = i;
44+
break;
45+
}
46+
}
47+
assertThat(minIndex).isEqualTo(expectedIndex);
48+
}
49+
50+
@ParameterizedTest
51+
@MethodSource("primitiveProvider")
52+
void givenArray_whenUsingIntStreamAndLookForIndex_thenGetCorrectResult(int[] array, int expectedIndex) {
53+
int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
54+
int minIndex = -1;
55+
for (int i = 0; i < array.length; i++) {
56+
if (array[i] == minValue) {
57+
minIndex = i;
58+
break;
59+
}
60+
}
61+
assertThat(minIndex).isEqualTo(expectedIndex);
62+
}
63+
64+
@ParameterizedTest
65+
@MethodSource("primitiveProvider")
66+
void givenArray_whenUsingIntStreamAndLookForIndexWithIntStream_thenGetCorrectResult(int[] array, int expectedIndex) {
67+
int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
68+
int minIndex = IntStream.range(0, array.length)
69+
.filter(index -> array[index] == minValue)
70+
.findFirst().orElse(-1);
71+
assertThat(minIndex).isEqualTo(expectedIndex);
72+
}
73+
74+
@ParameterizedTest
75+
@MethodSource("primitiveProvider")
76+
void givenArray_whenUsingIntStreamAndLookForIndexWithArrayUtils_thenGetCorrectResult(int[] array, int expectedIndex) {
77+
int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
78+
int minIndex = ArrayUtils.indexOf(array, minValue);
79+
assertThat(minIndex).isEqualTo(expectedIndex);
80+
}
81+
82+
@ParameterizedTest
83+
@MethodSource("referenceTypesProvider")
84+
void givenArray_whenUsingReduce_thenGetCorrectResult(Integer[] array, int expectedIndex) {
85+
int minValue = Arrays.stream(array).reduce(Integer.MAX_VALUE, Integer::min);
86+
int minIndex = ArrayUtils.indexOf(array, minValue);
87+
assertThat(minIndex).isEqualTo(expectedIndex);
88+
}
89+
90+
@ParameterizedTest
91+
@MethodSource("referenceTypesProvider")
92+
void givenArray_whenUsingReduceAndList_thenGetCorrectResult(Integer[] array, int expectedIndex) {
93+
List<Integer> list = Arrays.asList(array);
94+
int minValue = list.stream().reduce(Integer.MAX_VALUE, Integer::min);
95+
int index = list.indexOf(minValue);
96+
assertThat(index).isEqualTo(expectedIndex);
97+
}
98+
99+
@ParameterizedTest
100+
@MethodSource("primitiveProvider")
101+
void givenArray_whenUsingReduceWithRange_thenGetCorrectResult(int[] array, int expectedIndex) {
102+
int index = IntStream.range(0, array.length)
103+
.reduce((a, b) -> array[a] <= array[b] ? a : b)
104+
.orElse(-1);
105+
assertThat(index).isEqualTo(expectedIndex);
106+
}
107+
108+
@ParameterizedTest
109+
@MethodSource("primitiveProvider")
110+
void givenArray_whenUsingPrimitiveStreams_thenGetCorrectResult(int[] array, int expectedIndex) {
111+
List<Integer> list = Arrays.stream(array).boxed().collect(Collectors.toList());
112+
int minValue = Arrays.stream(array).min().orElse(Integer.MAX_VALUE);
113+
int index = list.indexOf(minValue);
114+
assertThat(index).isEqualTo(expectedIndex);
115+
}
116+
117+
static Stream<Arguments> primitiveProvider() {
118+
return Stream.of(
119+
Arguments.of(new int[]{585, 190, 201, 82, 332}, 3),
120+
Arguments.of(new int[]{1, 1, 1}, 0),
121+
Arguments.of(new int[]{}, -1)
122+
);
123+
}
124+
125+
static Stream<Arguments> referenceTypesProvider() {
126+
return Stream.of(
127+
Arguments.of(new Integer[]{585, 190, 201, 82, 332}, 3),
128+
Arguments.of(new Integer[]{1, 1, 1}, 0),
129+
Arguments.of(new Integer[]{}, -1)
130+
);
131+
}
132+
}

‎core-java-modules/core-java-collections-5/README.md‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,10 +7,8 @@
77
- [Creating Custom Iterator in Java](https://www.baeldung.com/java-creating-custom-iterator)
88
- [Difference Between Arrays.sort() and Collections.sort()](https://www.baeldung.com/java-arrays-collections-sort-methods)
99
- [Skipping the First Iteration in Java](https://www.baeldung.com/java-skip-first-iteration)
10-
- [Remove Elements From a Queue Using Loop](https://www.baeldung.com/java-remove-elements-queue)
1110
- [Intro to Vector Class in Java](https://www.baeldung.com/java-vector-guide)
1211
- [Time Complexity of Java Collections Sort in Java](https://www.baeldung.com/java-time-complexity-collections-sort)
13-
- [Check if List Contains at Least One Enum](https://www.baeldung.com/java-list-check-enum-presence)
1412
- [Comparison of for Loops and Iterators](https://www.baeldung.com/java-for-loops-vs-iterators)
1513
- [PriorityQueue iterator() Method in Java](https://www.baeldung.com/java-priorityqueue-iterator)
1614
- [Immutable vs Unmodifiable Collection in Java](https://www.baeldung.com/java-collection-immutable-unmodifiable-differences)

‎core-java-modules/core-java-collections-6/README.md‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,4 +5,7 @@
55
### Relevant Articles:
66
- [Iterator vs forEach() in Java](https://www.baeldung.com/java-iterator-vs-foreach)
77
- [Adding Elements to a Collection During Iteration](https://www.baeldung.com/java-add-elements-collection)
8+
- [Remove Elements From a Queue Using Loop](https://www.baeldung.com/java-remove-elements-queue)
9+
- [Check if List Contains at Least One Enum](https://www.baeldung.com/java-list-check-enum-presence)
10+
811
- More articles: [[<-- prev]](/core-java-modules/core-java-collections-5)

0 commit comments

Comments
 (0)