w tym poście omówimy, jak scalić wiele tablic w Javie w jedną nową tablicę. Nowa tablica powinna zachować pierwotną kolejność elementów w poszczególnych tablicach.
Java 8
w Javie 8 i nowszych możemy użyć Stream API do scalania wielu tablic. Można to zrobić na różne sposoby –
.of ()
możemy otrzymać strumień składający się ze wszystkich elementów z każdej tablicy używając statycznej metody fabrycznej Stream.of (). Gdy już mamy strumień, możemy go spłaścić za pomocą metody flatMap (), a następnie przekonwertować z powrotem na tablicę za pomocą metody toArray ().
|
1
2
3
4
5
6
7
|
// funkcja scalania wielu tablic w Javie 8 i nowszych
public static String merge (String …tablice)
{
return Stream.of (arrays)
.flatMap (Stream::of) // lub użyj Arrays:: stream
.toArray (String:: new);
}
|
⮚ strumień.concat ()
Stream ma metodę concat (), która pobiera dwa strumienie jako wejście i tworzy z nich leniwie połączony strumień. Możemy go użyć do scalania wielu tablic, jak pokazano poniżej:
|
1
2
3
4
5
6
7
8
9
|
// funkcja scalania wielu tablic w Javie 8 i nowszych
public static String merge (String …tablice)
{
Stream< String> stream = Stream.of ();
for (String s: arrays)
stream = Stream.concat (strumień, Tablice.stream (s));
return stream.toArray(String:: new);
}
|
System.arraycopy()
zaczynamy od alokacji wystarczającej ilości pamięci do nowej tablicy, aby pomieścić wszystkie elementy obecne we wszystkich tablicach za pomocą tablic.copyOf (). Wtedy użyjemy systemu.arraycopy (), aby skopiować podane tablice do nowej tablicy, jak pokazano poniżej:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// funkcja scalania wielu tablic w Javie
public static String merge (String… tablice)
{
int finalLength = 0;
for (String array : arrays) {
finalLength += array.długość;
}
String dest = null;
int destPos = 0;
for (String array: tablice)
{
if (dest = = null) {
Dest = Tablice.copyOf (array, finalLength);
destPos = array.length;
} else {
System.arraycopy(array, 0, dest, destPos, array.length);
destPos += array.długość;
}
}
return dest;
}
|
oto wersja, która działa z generykami:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
// Ogólna funkcja scalająca wiele tablic tego samego typu w Javie
public static <T> t merge(T… tablice)
{
int finalLength = 0;
for (T array : arrays) {
finalLength += array.długość;
}
T dest = null;
int destPos = 0;
for (T array: tablice)
{
if (dest = = null) {
Dest = Tablice.copyOf (array, finalLength);
destPos = array.length;
} else {
System.arraycopy(array, 0, dest, destPos, array.length);
destPos += array.długość;
}
}
return dest;
}
|
List
możemy również użyć listy do scalania wielu tablic w Javie, jak pokazano poniżej. Takie podejście nie jest zalecane, ponieważ polega na utworzeniu obiektu listy pośredniczącej.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
// funkcja scalania wielu tablic w Javie 8 i nowszych
public static String merge (String… tablice)
{
List< String > result = new ArrayList<>();
strumień.of (arrays)
.flatMap (Stream::of)
.map (x – > (String)x)
.forEach (result::add);
zwraca wynik.toArray (nowy ciąg);
}
|
dla Javy 7 i wcześniejszych możemy użyć metody Collections.addAll() :
|
1
2
3
4
5
6
7
8
9
10
|
// funkcja scalania wielu tablic w Javie
public static String merge (String… tablice)
{
List< String > list = new ArrayList<>();
for (String array : arrays)
Collections.addAll (list, array);
return list.toArray (nowy ciąg);
}
|