mindol1004/spring-boot-rest
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[JAVA-616] core-java-arrays-sorting

Browse Source 
* Creation

* Moved code from https://www.baeldung.com/java-sorting-arrays

* Moved code from https://www.baeldung.com/java-check-sorted-array

* Moved code from https://www.baeldung.com/java-invert-array

* Moved code from https://www.baeldung.com/java-arrays-sort-vs-parallelsort
This commit is contained in:
dupirefr
2020-04-09 08:24:04 +02:00
parent d2c03ec301
commit 91a2ac8ddd
13 changed files with 146 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core-java-modules/core-java-arrays-2/README.md
View File

@@ -13,5 +13,4 @@ This module contains articles about Java arrays
- [Removing an Element from an Array in Java](https://www.baeldung.com/java-array-remove-element)
- [Removing the First Element of an Array](https://www.baeldung.com/java-array-remove-first-element)
- [Adding an Element to a Java Array vs an ArrayList](https://www.baeldung.com/java-add-element-to-array-vs-list)
- [Arrays.sort vs Arrays.parallelSort](https://www.baeldung.com/java-arrays-sort-vs-parallelsort)
- [[<-- Prev]](/core-java-modules/core-java-arrays)

72
core-java-modules/core-java-arrays-2/src/main/java/com/baeldung/arraysort/ArraySortingBenchmark.java
View File

@@ -1,72 +0,0 @@
package com.baeldung.arraysort;
import java.util.Arrays;
import java.util.Random;
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.Level;
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.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
import org.openjdk.jmh.infra.Blackhole;
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 5)
@Measurement(iterations = 10)
@Fork(2)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
public class ArraySortingBenchmark {
@State(Scope.Benchmark)
public static class ArrayContainer {
@Param({ "1000", "10000", "100000", "1000000" })
int arraySize;
// initial unsorted array
int[] unsortedArray;
//cloned array to sort
int[] arrayToSort;
@Setup(Level.Trial)
public void createUnSortedArray() {
unsortedArray = new int[arraySize];
for (int i = 0; i < arraySize; i++) {
unsortedArray[i] = new Random().nextInt(1000);
}
}
@Setup(Level.Invocation)
public void createUnSortedArrayCopy() {
arrayToSort = unsortedArray.clone();
}
int[] getArrayToSort() {
return arrayToSort;
}
}
@Benchmark
public void benchmark_arrays_parallel_sort(ArrayContainer d, Blackhole b) {
int[] arr = d.getArrayToSort();
Arrays.parallelSort(arr);
b.consume(arr);
}
@Benchmark
public void benchmark_arrays_sort(ArrayContainer d, Blackhole b) {
int[] arr = d.getArrayToSort();
Arrays.sort(arr);
b.consume(arr);
}
}

185
core-java-modules/core-java-arrays-2/src/test/java/com/baeldung/arraysort/SortComparisonUnitTest.java
View File

@@ -1,185 +0,0 @@
package com.baeldung.arraysort;
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import java.util.Arrays;
import java.util.Random;
import org.junit.After;
import org.junit.Before;
import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;
/**
* Time taken by JUnit test cases can be seen in JUnit Runner
* @author rchaudhary23
*
*/
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class SortComparisonUnitTest {
private int[] sizeOfArrays = { 1000, 10000, 100000, 1000000 };
private int[] _1000_elements_array;
private int[] _10000_elements_array;
private int[] _100000_elements_array;
private int[] _1000000_elements_array;
@Before
public void setUp() throws Exception {
_1000_elements_array = new int[sizeOfArrays[0]];
_10000_elements_array = new int[sizeOfArrays[1]];
_100000_elements_array = new int[sizeOfArrays[2]];
_1000000_elements_array = new int[sizeOfArrays[3]];
Random random = new Random();
for (int i = 0; i < sizeOfArrays[0]; i++) {
_1000_elements_array[i] = random.nextInt(sizeOfArrays[0]) + random.nextInt(sizeOfArrays[0]);
}
for (int i = 0; i < sizeOfArrays[1]; i++) {
_10000_elements_array[i] = random.nextInt(sizeOfArrays[1]) + random.nextInt(sizeOfArrays[1]);
}
for (int i = 0; i < sizeOfArrays[2]; i++) {
_100000_elements_array[i] = random.nextInt(sizeOfArrays[2]) + random.nextInt(sizeOfArrays[2]);
}
for (int i = 0; i < sizeOfArrays[3]; i++) {
_1000000_elements_array[i] = random.nextInt(sizeOfArrays[3]) + random.nextInt(sizeOfArrays[3]);
}
}
@Test
public void givenArrayOfIntegers_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Arrays.sort(array);
assertArrayEquals(expected, array);
}
@Test
public void givenArrayOfIntegers_whenUsingArraysSortWithRange_thenSortRangeOfArrayAsc() {
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
Arrays.sort(array, 2, 8);
assertArrayEquals(expected, array);
}
@Test
public void givenArrayOfIntegers_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
int[] expected = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
Arrays.parallelSort(array);
assertArrayEquals(expected, array);
}
@Test
public void givenArrayOfIntegers_whenUsingArraysParallelSortWithRange_thenSortRangeOfArrayAsc() {
int[] array = { 10, 4, 6, 2, 1, 9, 7, 8, 3, 5 };
int[] expected = { 10, 4, 1, 2, 6, 7, 8, 9, 3, 5 };
Arrays.parallelSort(array, 2, 8);
assertArrayEquals(expected, array);
}
@Test
public void givenIntegerArrayOf1000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
int[] sequentialDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
Arrays.sort(sequentialDataSet);
assertNotNull(sequentialDataSet);
assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), sequentialDataSet);
}
@Test
public void givenIntegerArrayOf1000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
int[] parallelDataSet = Arrays.copyOf(_1000_elements_array, _1000_elements_array.length);
Arrays.parallelSort(parallelDataSet);
assertNotNull(parallelDataSet);
assertNotSame(Arrays.copyOf(_1000_elements_array, _1000_elements_array.length), parallelDataSet);
}
@Test
public void givenIntegerArrayOf10000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
int[] sequentialDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
Arrays.sort(sequentialDataSet);
assertNotNull(sequentialDataSet);
assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), sequentialDataSet);
}
@Test
public void givenIntegerArrayOf10000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
int[] parallelDataSet = Arrays.copyOf(_10000_elements_array, _10000_elements_array.length);
Arrays.parallelSort(parallelDataSet);
assertNotNull(parallelDataSet);
assertNotSame(Arrays.copyOf(_10000_elements_array, _10000_elements_array.length), parallelDataSet);
}
@Test
public void givenIntegerArrayOf100000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
int[] sequentialDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
Arrays.sort(sequentialDataSet);
assertNotNull(sequentialDataSet);
assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), sequentialDataSet);
}
@Test
public void givenIntegerArrayOf100000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
int[] parallelDataSet = Arrays.copyOf(_100000_elements_array, _100000_elements_array.length);
Arrays.parallelSort(parallelDataSet);
assertNotNull(parallelDataSet);
assertNotSame(Arrays.copyOf(_100000_elements_array, _100000_elements_array.length), parallelDataSet);
}
@Test
public void givenIntegerArrayOf1000000Elements_whenUsingArraysSortMethod_thenSortFullArrayInAscendingOrder() {
int[] sequentialDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
Arrays.sort(sequentialDataSet);
assertNotNull(sequentialDataSet);
assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), sequentialDataSet);
}
@Test
public void givenIntegerArrayOf1000000Elements_whenUsingArraysParallelSortMethod_thenSortFullArrayInAscendingOrder() {
int[] parallelDataSet = Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length);
Arrays.parallelSort(parallelDataSet);
assertNotNull(parallelDataSet);
assertNotSame(Arrays.copyOf(_1000000_elements_array, _1000000_elements_array.length), parallelDataSet);
}
@After
public void tearDown() throws Exception {
sizeOfArrays = null;
_1000_elements_array = null;
_10000_elements_array = null;
_100000_elements_array = null;
_1000000_elements_array = null;
}
}