Ich lerne Java 8-Streams. Sagen Sie mir bitte, wie kann ich eine sortArray
Methode kompakter schreiben ?
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import static org.junit.Assert.assertArrayEquals;
public class TestStream {
/*
* Sort numbers in an array without changing even numbers position
*/
@Test
public void test_1() {
int[] nonSorted = new int[]{3, 4, 5, 2, 1, 6, 9, 8, 7, 0};
int[] expected = new int[]{1, 4, 3, 2, 5, 6, 7, 8, 9, 0};
Integer[] arr = sortArray(nonSorted);
int[] sorted = new int[arr.length];
for (int i = 0; i < arr.length; i++) {
sorted[i] = arr[i];
}
assertArrayEquals(expected, sorted);
}
private Integer[] sortArray(int[] array) {
Map<Integer, Integer> even = extractEven(array);
Integer[] withoutEvens = removeEven(array);
int length = even.size() + withoutEvens.length;
Integer[] result = new Integer[length];
Arrays.sort(withoutEvens);
for (int i = 0; i < withoutEvens.length; i++) {
result[i] = withoutEvens[i];
}
even.forEach((k, v) -> {
System.arraycopy(result, k, result, k + 1, length - k - 1);
result[k] = v;
});
return result;
}
private Map<Integer, Integer> extractEven(int[] array) {
Map<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < array.length; i++) {
if (array[i] % 2 == 0) {
map.put(i, array[i]);
}
}
return map;
}
private Integer[] removeEven(int[] array) {
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < array.length; i++) {
if (array[i] % 2 != 0) {
list.add(array[i]);
}
}
Integer[] a = new Integer[list.size()];
return list.toArray(a);
}
}
quelle
Die Idee, eine sortierte zu verwenden, hat mir sehr gut gefallen
Stack
, hat , aber sie ist nicht leicht parallelisierbar und hat mich neugierig gemacht, wie ich das lösen kann.Meine Idee ist es, Indizes von ungeraden Elementen zu sortieren. Abhängig von der Position des Index können wir bei der Erstellung des Ergebnisarrays unterscheiden, ob eine Zahl gerade ist oder nicht.
quelle
Ich glaube, was Sie unter Java-8 verstehen, ist die Verwendung von
Stream
s und anderen APIs, die seit dieser Version eingeführt wurden. Meiner Meinung nach haben Sie jedoch bereits einen sehr leistungsfähigen Code. Ich könnte mir vorstellen, das Problem wie folgt zu lösen:Finden Sie die ungeraden und geraden Zahlen und ihre Zuordnungen zu den aktuellen Indizes. So dass auch Werte mit ihren Indizes fest bleiben würden.
Ordnen Sie die ungeraden Zahlen und ihre Indizes den Werten zu, indem Sie sie auf natürliche Weise sortieren.
Sobald dies alles erledigt ist, führen Sie diese geteilten ungeraden-geraden Karten basierend auf den Indizes zusammen.
Rufen Sie die Werte aus diesem zusammengeführten Ergebnis ab.
Die Gesamtimplementierung würde ungefähr so aussehen -
quelle
Dies ist ein Einfügesortierversuch mit Streams. Das
nonSorted
Array wird gestreamt und zu a gesammeltnew int[]
. Wenn der Wert aus demnonSorted
Array gerade ist, wird er nur kopiert. Wenn er ungerade ist, wird eine Einfügesortierung nur für ungerade Werte ausgeführt, die bereits im Ergebnis vorhanden sind.quelle