Concatenar arrays

Programação Java
#1

Qual a melhor maneira de concatenar arrays de inteiros?

Por exemplo:
int[] arr1 = new int[500];
int[] arr2 = new int[500];
int[] arr3 = new int[500];

Quero deixar esses 3, 4, 5… o quanto for em ordem, exemplo:
int[] arrTotal = new int[1500];
ae dentro dele armazenar os 3 em ordem.

Sei la, sem fazer loops, existe alguma classe?
Pois se fazer com loop da, mas é muito empenho!

#2

Use System.arraycopy e um pouco de paciência (acho que o mais difícil é acertar os parâmetros).

#3

O problema deste é fazer dinamicamente, como vou saber o próximo “SRC” lá? se vai ser dinâmico?
Não existe outra classe?

Se eu fizer algo como: Array.append?

#4

Leia o javadoc e pare de atirar para tudo que é lado. Use System.arraycopy e crie um método.

System.arraycopy
java.util.Arrays

#5

System.arraycopy é traduzida internamente pelo Java para uma instrução de cópia de memória do próprio processador, portanto não é possível fazer uma cópia mais rápida que System.arraycopy.

#6

thingol:
Obrigado pela força, e valeu ai pelo puchão de orelha ai, vou parar de abrir tópico pra tudo que tenho dúvida.

#7

topico já tá velho mas vou responder pra quem pesquisa no google

import org.apache.commons.lang.ArrayUtils;
...
Object[] array = ArrayUtils.addAll(array1,array2);

mas precisa da lib commons-lang.jar
http://commons.apache.org/lang/

eu sinceramente gosto de usar os commons da apache

#8 
import java.util.*;

class ConcatenarArrays {
    // Versão genérica, usar com quaisquer arrays de objetos (têm de ser do mesmo tipo)
    public static <T> T[] concat (Class<T> klass, T[]... arrays) {
        int length = 0;
        for (T[] array : arrays) { length += array.length; }

        @SuppressWarnings ("unchecked") 
            T[] ret = (T[]) java.lang.reflect.Array.newInstance (klass, length);
        int destPos = 0;
        for (T[] array : arrays) {
            System.arraycopy (array, 0, ret, destPos, array.length);
            destPos += array.length;
        }
        return ret;
    }
    // Versão especializada para o tipo primitivo int
    public static int[] concat (int[]... arrays) {
        int length = 0;
        for (int[] array : arrays) { length += array.length; }

        int[] ret = new int[length];
        int destPos = 0;
        for (int[] array : arrays) {
            System.arraycopy (array, 0, ret, destPos, array.length);
            destPos += array.length;
        }
        return ret;
    }
    // Versão especializada para o tipo primitivo double
    public static double[] concat (double[]... arrays) {
        int length = 0;
        for (double[] array : arrays) { length += array.length; }

        double[] ret = new double[length];
        int destPos = 0;
        for (double[] array : arrays) {
            System.arraycopy (array, 0, ret, destPos, array.length);
            destPos += array.length;
        }
        return ret;
    }

    public static void main (String[] args) {
        Integer[] arr1 = new Integer[10]; 
        for (int i = 0; i < arr1.length; ++i) arr1[i] = i;
        Integer[] arr2 = new Integer[15];
        for (int i = 0; i < arr2.length; ++i) arr2[i] = i + 100;
        Integer[] arr3 = new Integer[30];
        for (int i = 0; i < arr3.length; ++i) arr3[i] = i + 1000;
        Integer[] arr = ConcatenarArrays.concat (Integer.class, arr1, arr2, arr3);
        System.out.println (arr.length);
        System.out.println (Arrays.asList (arr));
        int[] intArr = ConcatenarArrays.concat (new int[10], new int[15], new int[30]);
        System.out.println (intArr.length);
    }
}
1 curtida
#9