Dadas dos arrays del mismo tipo, deben fusionarse en una nueva array de objetos. La tarea es fusionar las dos arrays del mismo tipo en una array de objetos de modo que los elementos de la array mantengan su orden original en la array recién fusionada y los elementos de la primera array precedan a los elementos de la segunda array en la array de objetos fusionados.
Esta fusión se puede realizar en muchos métodos en Java, como Java8, System.arrraycopy() y Java Collections.
Diferentes métodos para fusionar arreglos en un nuevo objeto
- Uso de Stream API en Java 8 con los métodos Stream.of(), flatMap() y toArray()
- Usando el método concat() Clase de flujo
- Usando el método arraycopyOf() de la clase System
- Uso de colecciones de Java para Java 8 y versiones posteriores
- Uso de colecciones de Java para Java 7
Analicemos estos métodos en detalle, que son los siguientes:
Método 1: Uso de la API Stream en Java8 con los métodos Stream.of(), flatMap() y toArray()
La jerarquía de clases de Stream es la siguiente:
java.lang.Object ↳ java.util.stream
| Método | Acción realizada |
|---|---|
| de(T… valores) | Devuelve un flujo ordenado secuencial cuyos elementos son los valores especificados. |
| flatMap(Función<? super T,? extiende Stream<? extiende R%gt;> mapeador) | Devuelve un flujo de objetos después de aplicar la función de mapeo en cada elemento y luego aplana el resultado. |
| aArray() | Devuelve una array que contiene los elementos de esta secuencia. |
Ilustración:
Input : a[] = {1, 2, 3}
b[] = {4, 5, 6}
Output : {1, 2, 3, 4, 5, 6}
Salida Explicación: Stream.of(a, b) obtiene las arrays y las canaliza en una sola secuencia. Luego, el método flatMap() devuelve una secuencia de objetos después de aplicar la función de mapeo en cada elemento de Stream.of() y luego aplana el resultado. Al final, toArray() convierte los elementos de flujo en una array y devuelve la array formada.
Ejemplo:
Java
// Java program to merge two arrays of
// same type into an Object array.
import java.util.stream.Stream;
import java.util.Arrays;
import java.io.*;
class GFG {
public static <T> Object[] concatenate(T[] a, T[] b)
{
// Function to merge two arrays of
// same type
return Stream.of(a, b)
.flatMap(Stream::of)
.toArray();
// Arrays::stream can also be used in place
// of Stream::of in the flatMap() above.
}
public static void main (String[] args)
{
Integer[] a = new Integer[]{1,2,3};
Integer[] b = new Integer[]{4,5,6};
Object[] c = concatenate(a,b);
System.out.println("Merged object array : "
+ Arrays.toString(c));
}
}
Producción:
Merged object array : [1, 2, 3, 4, 5, 6]
Método 2: usar los métodos Stream.concat(), Arrays.stream() y toArray()
| Método | Acción realizada |
|---|---|
| concat(Stream<? extiende T> a, Stream<? extiende T> b) | Crea una secuencia concatenada de forma diferida cuyos elementos son todos los elementos de la primera secuencia seguidos de todos los elementos de la segunda secuencia. |
Ilustración:
Input : a[] = {1, 2, 3}
b[] = {4, 5, 6}
Output : {1, 2, 3, 4, 5, 6}
Salida Explicación: Stream.concat() crea una secuencia fusionada en la que los elementos en el orden en que están en el parámetro. Aquí, Stream.concat() crea un flujo concatenado cuyos elementos son todos los elementos del flujo convertidos desde el arreglo ‘a’ seguidos por todos los elementos del flujo convertidos desde el arreglo ‘b’. El flujo concatenado luego se convierte a la array y se devuelve.
Ejemplo:
Java
// Java program to merge two arrays of
// same type into an Object array.
import java.util.stream.Stream;
import java.util.Arrays;
import java.io.*;
class GFG {
public static <T> Object[] concatenate(T[] a, T[] b)
{
// Function to merge two arrays of
// same type
return Stream.concat(Arrays.stream(a),
Arrays.stream(b))
.toArray();
}
public static void main (String[] args)
{
Integer[] a = new Integer[]{1,2,3};
Integer[] b = new Integer[]{4,5,6};
Object[] c = concatenate(a,b);
System.out.println("Merged object array : "
+ Arrays.toString(c));
}
}
Producción :
Merged object array : [1, 2, 3, 4, 5, 6]
Método 3: Usando el método arraycopy() de la clase System
El método arraycopy() de la clase System ha estado presente dentro del paquete java.lang copia una array de origen desde una posición de inicio específica a la array de destino desde la posición mencionada. El número de argumentos a copiar se decide por el argumento len.
Los componentes en source_Position a source_Position + longitud – 1 se copian en la array de destino desde Destination_Position a Destination_Position + longitud – 1.
Sintaxis: declaración de clase
public final class System extends Object
Sintaxis: Declaración de método
public static void arraycopy(Object source_arr, int sourcePos,
Object dest_arr, int destPos, int len)
Ilustración:
Input : a[] = {1, 2, 3}
b[] = {4, 5, 6}
Output : {1, 2, 3, 4, 5, 6}
Ejemplo:
Java
// Java program to merge two arrays of
// same type into an Object array.
import java.util.stream.Stream;
import java.util.Arrays;
import java.io.*;
class GFG {
// Function to merge two arrays of same type
public static <T> Object[] concatenate(T[] a, T[] b)
{
// Create an empty Object array of the combined
// size of the array a and array b
Object[] n=new Object[a.length + b.length];
// Copy the array a into n
System.arraycopy(a, 0, n, 0, a.length);
// Copy the array b into n
System.arraycopy(b, 0, n, a.length, b.length);
return n;
}
public static void main (String[] args)
{
Integer[] a = new Integer[]{1,2,3};
Integer[] b = new Integer[]{4,5,6};
Object[] c = concatenate(a,b);
System.out.println("Merged object array : "
+ Arrays.toString(c));
}
}
Producción:
Merged object array : [1, 2, 3, 4, 5, 6]
Método 4: uso de colecciones de Java en Java 8
Una colección es un grupo de objetos individuales representados como una sola unidad. Java proporciona un Framework de colección que define varias clases e interfaces para representar un grupo de objetos como una sola unidad.
Ilustración: uso de colecciones de Java para Java 8 Stream
Input : a[] = {1, 2, 3}
b[] = {4, 5, 6}
Output : {1, 2, 3, 4, 5, 6}
Ejemplo:
Java
// Java program to merge two arrays of
// same type into an Object array.
import java.util.stream.*;
import java.util.Arrays;
import java.io.*;
class GFG {
// Function to merge two arrays of same type
public static <T> Object[] concatenate(T[] a, T[] b)
{
// Create an empty List of type Object
List<Object> n = new ArrayList<>();
// Add arrays to list
Stream.of(a, b)
.flatMap(Stream::of)
.forEach(n::add);
// Convert list to array and return
return n.toArray();
}
public static void main (String[] args)
{
Integer[] a = new Integer[]{1,2,3};
Integer[] b = new Integer[]{4,5,6};
Object[] c = concatenate(a,b);
System.out.println("Merged object array : "
+ Arrays.toString(c));
}
}
Producción:
Merged object array : [1, 2, 3, 4, 5, 6]
Método 5: usar colecciones de Java para Java 7 usando Collections.addAll()
Ilustración:
Input : a[] = {1, 2, 3}
b[] = {4, 5, 6}
Output : {1, 2, 3, 4, 5, 6}
Ejemplo:
Java
// Java program to merge two arrays of
// same type into an Object array.
import java.util.*;
import java.io.*;
class GFG {
// Function to merge two arrays of same type
public static <T> List<Object> concatenate(T[] a, T[] b)
{
// Create an empty List of type Object
List<Object> n = new ArrayList<>();
// Add the array a into n
Collections.addAll(n, a);
// Add the array b into n
Collections.addAll(n, b);
return n;
}
public static void main (String[] args)
{
Integer[] a = new Integer[]{1,2,3};
Integer[] b = new Integer[]{4,5,6};
List<Object> c = concatenate(a,b);
System.out.println("Merged object array : "
+ c);
}
}
Producción:
Merged object array : [1, 2, 3, 4, 5, 6]
Publicación traducida automáticamente
Artículo escrito por RishabhPrabhu y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA