it-swarm-id.com

Bagaimana saya bisa menggabungkan dua array di Jawa?

Saya perlu menggabungkan dua array String di Jawa.

void f(String[] first, String[] second) {
    String[] both = ???
}

Apa cara termudah untuk melakukan ini?

1202
Antti Kissaniemi

Saya menemukan solusi satu-baris dari perpustakaan lama Apache Commons Lang.
ArrayUtils.addAll(T[], T...)

Kode:

String[] both = (String[])ArrayUtils.addAll(first, second);
962
Antti Kissaniemi

Berikut adalah metode sederhana yang akan menggabungkan dua array dan mengembalikan hasilnya:

public <T> T[] concatenate(T[] a, T[] b) {
    int aLen = a.length;
    int bLen = b.length;

    @SuppressWarnings("unchecked")
    T[] c = (T[]) Array.newInstance(a.getClass().getComponentType(), aLen + bLen);
    System.arraycopy(a, 0, c, 0, aLen);
    System.arraycopy(b, 0, c, aLen, bLen);

    return c;
}

Perhatikan bahwa itu tidak akan berfungsi dengan tipe data primitif, hanya dengan tipe objek.

Versi yang sedikit lebih rumit berikut ini berfungsi dengan array objek dan primitif. Itu melakukan ini dengan menggunakan T bukan T[] sebagai jenis argumen.

Hal ini juga memungkinkan untuk menggabungkan array dari dua tipe yang berbeda dengan memilih tipe yang paling umum sebagai tipe komponen dari hasilnya.

public static <T> T concatenate(T a, T b) {
    if (!a.getClass().isArray() || !b.getClass().isArray()) {
        throw new IllegalArgumentException();
    }

    Class<?> resCompType;
    Class<?> aCompType = a.getClass().getComponentType();
    Class<?> bCompType = b.getClass().getComponentType();

    if (aCompType.isAssignableFrom(bCompType)) {
        resCompType = aCompType;
    } else if (bCompType.isAssignableFrom(aCompType)) {
        resCompType = bCompType;
    } else {
        throw new IllegalArgumentException();
    }

    int aLen = Array.getLength(a);
    int bLen = Array.getLength(b);

    @SuppressWarnings("unchecked")
    T result = (T) Array.newInstance(resCompType, aLen + bLen);
    System.arraycopy(a, 0, result, 0, aLen);
    System.arraycopy(b, 0, result, aLen, bLen);        

    return result;
}

Berikut ini sebuah contoh:

Assert.assertArrayEquals(new int[] { 1, 2, 3 }, concatenate(new int[] { 1, 2 }, new int[] { 3 }));
Assert.assertArrayEquals(new Number[] { 1, 2, 3f }, concatenate(new Integer[] { 1, 2 }, new Number[] { 3f }));
734
jeannicolas

Dimungkinkan untuk menulis versi yang sepenuhnya generik yang bahkan dapat diperluas untuk menggabungkan sejumlah array. Versi ini memerlukan Java 6, karena menggunakan Arrays.copyOf()

Kedua versi menghindari membuat objek List perantara dan menggunakan System.arraycopy() untuk memastikan bahwa menyalin array besar secepat mungkin.

Untuk dua array terlihat seperti ini:

public static <T> T[] concat(T[] first, T[] second) {
  T[] result = Arrays.copyOf(first, first.length + second.length);
  System.arraycopy(second, 0, result, first.length, second.length);
  return result;
}

Dan untuk sejumlah array yang arbitrer (> = 1) terlihat seperti ini:

public static <T> T[] concatAll(T[] first, T[]... rest) {
  int totalLength = first.length;
  for (T[] array : rest) {
    totalLength += array.length;
  }
  T[] result = Arrays.copyOf(first, totalLength);
  int offset = first.length;
  for (T[] array : rest) {
    System.arraycopy(array, 0, result, offset, array.length);
    offset += array.length;
  }
  return result;
}
448
Joachim Sauer

One-liner di Java 8:

String[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b))
                      .toArray(String[]::new);

Atau:

String[] both = Stream.of(a, b).flatMap(Stream::of)
                      .toArray(String[]::new);
374

Atau dengan Jambu tercinta :

String[] both = ObjectArrays.concat(first, second, String.class);

Juga, ada versi untuk array primitif:

  • Booleans.concat(first, second)
  • Bytes.concat(first, second)
  • Chars.concat(first, second)
  • Doubles.concat(first, second)
  • Shorts.concat(first, second)
  • Ints.concat(first, second)
  • Longs.concat(first, second)
  • Floats.concat(first, second)
175
KARASZI István

Menggunakan Java API:

String[] f(String[] first, String[] second) {
    List<String> both = new ArrayList<String>(first.length + second.length);
    Collections.addAll(both, first);
    Collections.addAll(both, second);
    return both.toArray(new String[both.size()]);
}
56
Fabian Steeg

Solusi Java 100% lama dan tanpa System.arraycopy (tidak tersedia di klien GWT misalnya):

static String[] concat(String[]... arrays) {
    int length = 0;
    for (String[] array : arrays) {
        length += array.length;
    }
    String[] result = new String[length];
    int pos = 0;
    for (String[] array : arrays) {
        for (String element : array) {
            result[pos] = element;
            pos++;
        }
    }
    return result;
}
39
francois

Anda dapat menambahkan dua array dalam dua baris kode.

String[] both = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, both, first.length, second.length);

Ini adalah solusi cepat dan efisien dan akan bekerja untuk tipe primitif serta dua metode yang terlibat kelebihan beban.

Anda harus menghindari solusi yang melibatkan ArrayLists, stream, dll karena ini akan perlu mengalokasikan memori sementara tanpa tujuan yang bermanfaat.

Anda harus menghindari loop for untuk array besar karena ini tidak efisien. Metode bawaan menggunakan fungsi blok-salin yang sangat cepat.

37
rghome

Saya baru-baru ini menghadapi masalah dengan rotasi memori yang berlebihan. Jika a dan/atau b diketahui umumnya kosong, berikut ini adalah adaptasi lain dari kode silvertab (dibuat juga):

private static <T> T[] concat(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    if (alen == 0) {
        return b;
    }
    if (blen == 0) {
        return a;
    }
    final T[] result = (T[]) Java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}

(Dalam kedua kasus ini, perilaku penggunaan ulang array harus dengan jelas JavaDoced!)

31
volley

Fungsional Java library memiliki kelas pembungkus array yang melengkapi array dengan metode praktis seperti penggabungan.

import static fj.data.Array.array;

...lalu

Array<String> both = array(first).append(array(second));

Untuk mendapatkan kembali array yang terbuka, panggil

String[] s = both.array();
27
Apocalisp
ArrayList<String> both = new ArrayList(Arrays.asList(first));
both.addAll(Arrays.asList(second));

both.toArray(new String[0]);
26
nick-s

Cara lain dengan Java8 menggunakan Stream

  public String[] concatString(String[] a, String[] b){ 
    Stream<String> streamA = Arrays.stream(a);
    Stream<String> streamB = Arrays.stream(b);
    return Stream.concat(streamA, streamB).toArray(String[]::new); 
  }
17
Vaseph

Berikut ini adalah adaptasi dari solusi silvertab, dengan obat generik yang dilengkapi:

static <T> T[] concat(T[] a, T[] b) {
    final int alen = a.length;
    final int blen = b.length;
    final T[] result = (T[]) Java.lang.reflect.Array.
            newInstance(a.getClass().getComponentType(), alen + blen);
    System.arraycopy(a, 0, result, 0, alen);
    System.arraycopy(b, 0, result, alen, blen);
    return result;
}

CATATAN: Lihat Jawaban Joachim untuk solusi Java 6. Tidak hanya menghilangkan peringatan; juga lebih pendek, lebih efisien, dan lebih mudah dibaca!

17
volley

Jika Anda menggunakan cara ini, maka Anda tidak perlu mengimpor kelas pihak ketiga mana pun.

Jika Anda ingin menyatukan String

Contoh kode untuk dua String Array

public static String[] combineString(String[] first, String[] second){
        int length = first.length + second.length;
        String[] result = new String[length];
        System.arraycopy(first, 0, result, 0, first.length);
        System.arraycopy(second, 0, result, first.length, second.length);
        return result;
    }

Jika Anda ingin menyatukan Int

Contoh kode untuk dua array Integer array

public static int[] combineInt(int[] a, int[] b){
        int length = a.length + b.length;
        int[] result = new int[length];
        System.arraycopy(a, 0, result, 0, a.length);
        System.arraycopy(b, 0, result, a.length, b.length);
        return result;
    }

Inilah metode Utama

    public static void main(String[] args) {

            String [] first = {"a", "b", "c"};
            String [] second = {"d", "e"};

            String [] joined = combineString(first, second);
            System.out.println("concatenated String array : " + Arrays.toString(joined));

            int[] array1 = {101,102,103,104};
            int[] array2 = {105,106,107,108};
            int[] concatenateInt = combineInt(array1, array2);

            System.out.println("concatenated Int array : " + Arrays.toString(concatenateInt));

        }
    }  

Kita bisa menggunakan cara ini juga.

12
Raj S. Rusia

Maafkan saya karena menambahkan versi lain ke daftar yang sudah lama ini. Saya melihat setiap jawaban dan memutuskan bahwa saya benar-benar menginginkan versi dengan hanya satu parameter di tanda tangan. Saya juga menambahkan beberapa pemeriksaan argumen untuk mendapatkan manfaat dari kegagalan awal dengan info yang masuk akal jika input tidak terduga.

@SuppressWarnings("unchecked")
public static <T> T[] concat(T[]... inputArrays) {
  if(inputArrays.length < 2) {
    throw new IllegalArgumentException("inputArrays must contain at least 2 arrays");
  }

  for(int i = 0; i < inputArrays.length; i++) {
    if(inputArrays[i] == null) {
      throw new IllegalArgumentException("inputArrays[" + i + "] is null");
    }
  }

  int totalLength = 0;

  for(T[] array : inputArrays) {
    totalLength += array.length;
  }

  T[] result = (T[]) Array.newInstance(inputArrays[0].getClass().getComponentType(), totalLength);

  int offset = 0;

  for(T[] array : inputArrays) {
    System.arraycopy(array, 0, result, offset, array.length);

    offset += array.length;
  }

  return result;
}
11
Reto Höhener

Anda dapat mencoba mengubahnya menjadi Arraylist dan menggunakan metode addAll kemudian mengonversi kembali ke array.

List list = new ArrayList(Arrays.asList(first));
  list.addAll(Arrays.asList(second));
  String[] both = list.toArray();
10
Paul

Di sini kemungkinan implementasi dalam kode kerja dari solusi kode semu ditulis oleh silvertab. 

Terima kasih silvertab!

public class Array {

   public static <T> T[] concat(T[] a, T[] b, ArrayBuilderI<T> builder) {
      T[] c = builder.build(a.length + b.length);
      System.arraycopy(a, 0, c, 0, a.length);
      System.arraycopy(b, 0, c, a.length, b.length);
      return c;
   }
}

Mengikuti selanjutnya adalah antarmuka pembangun. 

Catatan: Pembangun diperlukan karena di Jawa tidak mungkin dilakukan 

new T[size] 

karena penghapusan tipe generik:

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

Di sini pembuat beton yang mengimplementasikan antarmuka, membangun array Integer:

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

   @Override
   public Integer[] build(int size) {
      return new Integer[size];
   }
}

Dan akhirnya aplikasi/tes:

@Test
public class ArrayTest {

   public void array_concatenation() {
      Integer a[] = new Integer[]{0,1};
      Integer b[] = new Integer[]{2,3};
      Integer c[] = Array.concat(a, b, new IntegerArrayBuilder());
      assertEquals(4, c.length);
      assertEquals(0, (int)c[0]);
      assertEquals(1, (int)c[1]);
      assertEquals(2, (int)c[2]);
      assertEquals(3, (int)c[3]);
   }
}
7
hpgisler

Wow! banyak jawaban kompleks di sini termasuk beberapa jawaban sederhana yang bergantung pada ketergantungan eksternal. bagaimana kalau melakukannya seperti ini:

String [] arg1 = new String{"a","b","c"};
String [] arg2 = new String{"x","y","z"};

ArrayList<String> temp = new ArrayList<String>();
temp.addAll(Arrays.asList(arg1));
temp.addAll(Arrays.asList(arg2));
String [] concatedArgs = temp.toArray(new String[arg1.length+arg2.length]);
6
doles

Ini berfungsi, tetapi Anda harus memasukkan pemeriksaan kesalahan Anda sendiri.

public class StringConcatenate {

    public static void main(String[] args){

        // Create two arrays to concatenate and one array to hold both
        String[] arr1 = new String[]{"s","t","r","i","n","g"};
        String[] arr2 = new String[]{"s","t","r","i","n","g"};
        String[] arrBoth = new String[arr1.length+arr2.length];

        // Copy elements from first array into first part of new array
        for(int i = 0; i < arr1.length; i++){
            arrBoth[i] = arr1[i];
        }

        // Copy elements from second array into last part of new array
        for(int j = arr1.length;j < arrBoth.length;j++){
            arrBoth[j] = arr2[j-arr1.length];
        }

        // Print result
        for(int k = 0; k < arrBoth.length; k++){
            System.out.print(arrBoth[k]);
        }

        // Additional line to make your terminal look better at completion!
        System.out.println();
    }
}

Mungkin ini bukan yang paling efisien, tetapi tidak bergantung pada apa pun selain API milik Java.

6
glue

Ini adalah fungsi yang dikonversi untuk array String:

public String[] mergeArrays(String[] mainArray, String[] addArray) {
    String[] finalArray = new String[mainArray.length + addArray.length];
    System.arraycopy(mainArray, 0, finalArray, 0, mainArray.length);
    System.arraycopy(addArray, 0, finalArray, mainArray.length, addArray.length);

    return finalArray;
}
5
Oritm

Bagaimana dengan sederhana 

public static class Array {

    public static <T> T[] concat(T[]... arrays) {
        ArrayList<T> al = new ArrayList<T>();
        for (T[] one : arrays)
            Collections.addAll(al, one);
        return (T[]) al.toArray(arrays[0].clone());
    }
}

Dan lakukan saja Array.concat(arr1, arr2). Selama arr1 dan arr2 memiliki tipe yang sama, ini akan memberi Anda array lain dari tipe yang sama yang mengandung kedua array. 

5
Ephraim

Variasi sederhana yang memungkinkan penggabungan lebih dari satu array:

public static String[] join(String[]...arrays) {

    final List<String> output = new ArrayList<String>();

    for(String[] array : arrays) {
        output.addAll(Arrays.asList(array));
    }

    return output.toArray(new String[output.size()]);
}
4
Damo

Ini adalah versi saya yang sedikit lebih baik dari concatAll Joachim Sauer. Ini dapat bekerja pada Java 5 atau 6, menggunakan System.arraycopy Java 6 jika tersedia saat runtime. Metode ini (IMHO) sangat cocok untuk Android, karena bekerja pada Android <9 (yang tidak memiliki System.arraycopy) tetapi akan menggunakan metode yang lebih cepat jika memungkinkan.

  public static <T> T[] concatAll(T[] first, T[]... rest) {
    int totalLength = first.length;
    for (T[] array : rest) {
      totalLength += array.length;
    }
    T[] result;
    try {
      Method arraysCopyOf = Arrays.class.getMethod("copyOf", Object[].class, int.class);
      result = (T[]) arraysCopyOf.invoke(null, first, totalLength);
    } catch (Exception e){
      //Java 6 / Android >= 9 way didn't work, so use the "traditional" approach
      result = (T[]) Java.lang.reflect.Array.newInstance(first.getClass().getComponentType(), totalLength);
      System.arraycopy(first, 0, result, 0, first.length);
    }
    int offset = first.length;
    for (T[] array : rest) {
      System.arraycopy(array, 0, result, offset, array.length);
      offset += array.length;
    }
    return result;
  }
4
candrews

Ini harus satu baris.

public String [] concatenate (final String array1[], final String array2[])
{
    return Stream.concat(Stream.of(array1), Stream.of(array2)).toArray(String[]::new);
}
4
avigaild

Cara lain untuk memikirkan pertanyaan itu. Untuk menggabungkan dua array atau lebih, yang harus dilakukan adalah membuat daftar semua elemen dari setiap array, dan kemudian membangun sebuah array baru. Ini terdengar seperti membuat List<T> dan kemudian memanggil toArray di atasnya. Beberapa jawaban lain menggunakan ArrayList, dan itu bagus. Tetapi bagaimana dengan mengimplementasikan kita sendiri? Itu tidak sulit:

private static <T> T[] addAll(final T[] f, final T...o){
    return new AbstractList<T>(){

        @Override
        public T get(int i) {
            return i>=f.length ? o[i - f.length] : f[i];
        }

        @Override
        public int size() {
            return f.length + o.length;
        }

    }.toArray(f);
}

Saya percaya hal di atas setara dengan solusi yang menggunakan System.arraycopy. Namun saya pikir yang ini memiliki keindahannya sendiri. 

4
Earth Engine

Bagaimana tentang :

public String[] combineArray (String[] ... strings) {
    List<String> tmpList = new ArrayList<String>();
    for (int i = 0; i < strings.length; i++)
        tmpList.addAll(Arrays.asList(strings[i]));
    return tmpList.toArray(new String[tmpList.size()]);
}
4

Cara mudah, tetapi tidak efisien, untuk melakukan ini (obat generik tidak termasuk):

ArrayList baseArray = new ArrayList(Arrays.asList(array1));
baseArray.addAll(Arrays.asList(array2));
String concatenated[] = (String []) baseArray.toArray(new String[baseArray.size()]);
3
MetroidFan2002

Hanya menggunakan API milik Javas:


String[] join(String[]... arrays) {
  // calculate size of target array
  int size = 0;
  for (String[] array : arrays) {
    size += array.length;
  }

  // create list of appropriate size
  Java.util.List list = new Java.util.ArrayList(size);

  // add arrays
  for (String[] array : arrays) {
    list.addAll(Java.util.Arrays.asList(array));
  }

  // create and return final array
  return list.toArray(new String[size]);
}

Sekarang, kode ini bukan yang paling efisien, tetapi hanya bergantung pada kelas Java standar dan mudah dimengerti. Ini berfungsi untuk sejumlah String [] (bahkan nol array).

3
Kiwi

Menggunakan aliran Java 8+ Anda dapat menulis fungsi berikut:

private static String[] concatArrays(final String[]... arrays) {
    return Arrays.stream(arrays)
         .flatMap(Arrays::stream)
         .toArray(String[]::new);
}
3
keisar

Jenis variasi independen (DIPERBARUI - terima kasih kepada Volley untuk instantiating T):

@SuppressWarnings("unchecked")
public static <T> T[] join(T[]...arrays) {

    final List<T> output = new ArrayList<T>();

    for(T[] array : arrays) {
        output.addAll(Arrays.asList(array));
    }

    return output.toArray((T[])Array.newInstance(
        arrays[0].getClass().getComponentType(), output.size()));
}
3
Damo
public String[] concat(String[]... arrays)
{
    int length = 0;
    for (String[] array : arrays) {
        length += array.length;
    }
    String[] result = new String[length];
    int destPos = 0;
    for (String[] array : arrays) {
        System.arraycopy(array, 0, result, destPos, array.length);
        destPos += array.length;
    }
    return result;
}
3
Sujay
String [] both = new ArrayList<String>(){{addAll(Arrays.asList(first)); addAll(Arrays.asList(second));}}.toArray(new String[0]);
3
Frimousse

Setiap jawaban tunggal adalah menyalin data dan membuat array baru. Ini tidak sepenuhnya diperlukan dan jelas BUKAN apa yang ingin Anda lakukan jika array Anda cukup besar. Pembuat Java sudah tahu bahwa salinan array boros dan itulah sebabnya mereka memberi kami System.arrayCopy () untuk melakukan hal-hal di luar Jawa ketika kami harus.

Alih-alih menyalin data Anda di sekitar, pertimbangkan untuk membiarkannya di tempat dan menarik dari tempat data itu berada. Menyalin lokasi data hanya karena programmer ingin mengaturnya tidak selalu masuk akal.

// I have arrayA and arrayB; would like to treat them as concatenated
// but leave my damn bytes where they are!
Object accessElement ( int index ) {
     if ( index < 0 ) throw new ArrayIndexOutOfBoundsException(...);
     // is reading from the head part?
     if ( index < arrayA.length )
          return arrayA[ index ];
     // is reading from the tail part?
     if ( index < ( arrayA.length + arrayB.length ) )
          return arrayB[ index - arrayA.length ];
     throw new ArrayIndexOutOfBoundsException(...); // index too large
}
2
Douglas Held

Jika Anda ingin bekerja dengan ArrayLists dalam solusi, Anda dapat mencoba ini:

public final String [] f(final String [] first, final String [] second) {
    // Assuming non-null for brevity.
    final ArrayList<String> resultList = new ArrayList<String>(Arrays.asList(first));
    resultList.addAll(new ArrayList<String>(Arrays.asList(second)));
    return resultList.toArray(new String [resultList.size()]);
}
2
Bob Cross
public static String[] toArray(String[]... object){
    List<String> list=new ArrayList<>();
    for (String[] i : object) {
        list.addAll(Arrays.asList(i));
    }
    return list.toArray(new String[list.size()]);
}
2

Saya menemukan saya harus berurusan dengan kasus di mana array dapat menjadi nol ...

private double[] concat  (double[]a,double[]b){
    if (a == null) return b;
    if (b == null) return a;
    double[] r = new double[a.length+b.length];
    System.arraycopy(a, 0, r, 0, a.length);
    System.arraycopy(b, 0, r, a.length, b.length);
    return r;

}
private double[] copyRest (double[]a, int start){
    if (a == null) return null;
    if (start > a.length)return null;
    double[]r = new double[a.length-start];
    System.arraycopy(a,start,r,0,a.length-start); 
    return r;
}
2
user462990
Import Java.util.*;

String array1[] = {"bla","bla"};
String array2[] = {"bla","bla"};

ArrayList<String> tempArray = new ArrayList<String>(Arrays.asList(array1));
tempArray.addAll(Arrays.asList(array2));
String array3[] = films.toArray(new String[1]); // size will be overwritten if needed

Anda dapat mengganti String dengan Jenis/Kelas sesuai keinginan Anda

Saya yakin ini bisa dibuat lebih pendek dan lebih baik, tetapi bekerja dan im untuk malas mengatasinya lebih lanjut ...

2
Jeroen

Versi statis umum yang menggunakan System.arraycopy berkinerja tinggi tanpa memerlukan penjelasan @SuppressWarnings:

public static <T> T[] arrayConcat(T[] a, T[] b) {
    T[] both = Arrays.copyOf(a, a.length + b.length);
    System.arraycopy(b, 0, both, a.length, b.length);
    return both;
}
2
beaudet
Object[] mixArray(String[] a, String[] b)
String[] s1 = a;
String[] s2 = b;
Object[] result;
List<String> input = new ArrayList<String>();
for (int i = 0; i < s1.length; i++)
{
    input.add(s1[i]);
}
for (int i = 0; i < s2.length; i++)
{
    input.add(s2[i]);
}
result = input.toArray();
return result;
1
obwan02
public int[] mergeArrays(int [] a, int [] b) {
    int [] merged = new int[a.length + b.length];
    int i = 0, k = 0, l = a.length;
    int j = a.length > b.length ? a.length : b.length;
    while(i < j) {
        if(k < a.length) {
            merged[k] = a[k];
            k++;
        }
        if((l - a.length) < b.length) {
            merged[l] = b[l - a.length];
            l++;
        }
        i++;
    }
    return merged;
}
1
George

Saya pikir solusi terbaik dengan obat generik adalah:

/* This for non primitive types */
public static <T> T[] concatenate (T[]... elements) {

    T[] C = null;
    for (T[] element: elements) {
        if (element==null) continue;
        if (C==null) C = (T[]) Array.newInstance(element.getClass().getComponentType(), element.length);
        else C = resizeArray(C, C.length+element.length);

        System.arraycopy(element, 0, C, C.length-element.length, element.length);
    }

    return C;
}

/**
 * as far as i know, primitive types do not accept generics 
 * http://stackoverflow.com/questions/2721546/why-dont-Java-generics-support-primitive-types
 * for primitive types we could do something like this:
 * */
public static int[] concatenate (int[]... elements){
    int[] C = null;
    for (int[] element: elements) {
        if (element==null) continue;
        if (C==null) C = new int[element.length];
        else C = resizeArray(C, C.length+element.length);

        System.arraycopy(element, 0, C, C.length-element.length, element.length);
    }
    return C;
}

private static <T> T resizeArray (T array, int newSize) {
    int oldSize =
            Java.lang.reflect.Array.getLength(array);
    Class elementType =
            array.getClass().getComponentType();
    Object newArray =
            Java.lang.reflect.Array.newInstance(
                    elementType, newSize);
    int preserveLength = Math.min(oldSize, newSize);
    if (preserveLength > 0)
        System.arraycopy(array, 0,
                newArray, 0, preserveLength);
    return (T) newArray;
}
1
spacebiker

Anda dapat mencoba metode ini yang menggabungkan beberapa array:

public static <T> T[] concatMultipleArrays(T[]... arrays)
{
   int length = 0;
   for (T[] array : arrays)
   {
      length += array.length;
   }
   T[] result = (T[]) Array.newInstance(arrays.getClass().getComponentType(), length) ;

   length = 0;
   for (int i = 0; i < arrays.length; i++)
   {
      System.arraycopy(arrays[i], 0, result, length, arrays[i].length);
      length += arrays[i].length;
   }

   return result;
}
1
Hakim

Anda dapat mencoba ini

 public static Object[] addTwoArray(Object[] objArr1, Object[] objArr2){
    int arr1Length = objArr1!=null && objArr1.length>0?objArr1.length:0;
    int arr2Length = objArr2!=null && objArr2.length>0?objArr2.length:0;
    Object[] resutlentArray = new Object[arr1Length+arr2Length]; 
    for(int i=0,j=0;i<resutlentArray.length;i++){
        if(i+1<=arr1Length){
            resutlentArray[i]=objArr1[i];
        }else{
            resutlentArray[i]=objArr2[j];
            j++;
        }
    }

    return resutlentArray;
}

Anda dapat mengetikkan larik array Anda !!!

1
Sushim

Ini adalah kode dari AbacusUtil .

String[] a = {"a", "b", "c"};
String[] b = {"1", "2", "3"};
String[] c = N.concat(a, b); // c = ["a", "b", "c", "1", "2", "3"]

// N.concat(...) is null-safety.
a = null;
c = N.concat(a, b); // c = ["1", "2", "3"]
1
user_3380739

Di Jawa 8 

public String[] concat(String[] arr1, String[] arr2){
    Stream<String> stream1 = Stream.of(arr1);
    Stream<String> stream2 = Stream.of(arr2);
    Stream<String> stream = Stream.concat(stream1, stream2);
    return Arrays.toString(stream.toArray(String[]::new));
}
1
Basil Battikhi

Cara termudah yang bisa saya temukan adalah sebagai berikut:


List allFiltersList = Arrays.asList(regularFilters);
allFiltersList.addAll(Arrays.asList(preFiltersArray));
Filter[] mergedFilterArray = (Filter[]) allFiltersList.toArray();
1
Object[] obj = {"hi","there"};
Object[] obj2 ={"im","fine","what abt u"};
Object[] obj3 = new Object[obj.length+obj2.length];

for(int i =0;i<obj3.length;i++)
    obj3[i] = (i<obj.length)?obj[i]:obj2[i-obj.length];
1
Adham

Satu lagi berdasarkan saran SilverTab, tetapi dibuat untuk mendukung sejumlah x argumen dan tidak memerlukan Java 6. Ini juga tidak generik, tapi saya yakin itu bisa dibuat generik.

private byte[] concat(byte[]... args)
{
    int fulllength = 0;
    for (byte[] arrItem : args)
    {
        fulllength += arrItem.length;
    }
    byte[] retArray = new byte[fulllength];
    int start = 0;
    for (byte[] arrItem : args)
    {
        System.arraycopy(arrItem, 0, retArray, start, arrItem.length);
        start += arrItem.length;
    }
    return retArray;
}
1
Doug

Anda dapat menggunakan koleksi ArrayList untuk ini. implementasinya sangat mudah dimengerti, awalnya Anda harus menyimpan kedua array String yang disediakan dalam argumen di ArrayList dan setelah itu baru saja mengkonversi ArrayList itu menjadi String array dengan metode toArray (), berikut ini implementasinya:

public static void f(String[] first, String[] second) {
            ArrayList<String> list = new ArrayList<>();

            for(String s: first){
                list.add(s);
            }
            for(String s: second){
                list.add(s);
            }

            String[] both = list.toArray(new String[list.size()]);
            System.out.println(list.toString());

        }
0
Ketan Ramteke

Di Haskell Anda dapat melakukan sesuatu seperti itu [a, b, c] ++ [d, e] untuk mendapatkan [a, b, c, d, e]. Ini adalah daftar Haskell yang digabungkan tetapi itu sangat bagus untuk melihat operator serupa di Jawa untuk array. Bukankah begitu? Itu elegan, sederhana, generik dan tidak sulit untuk diimplementasikan.

Jika Anda mau, saya sarankan Anda melihat karya Alexander Hristov di Meretas kompiler OpenJDK . Dia menjelaskan cara memodifikasi sumber javac untuk membuat operator baru. Contohnya adalah mendefinisikan operator '**' di mana i ** j = Math.pow(i, j). Orang bisa mengambil contoh itu untuk mengimplementasikan operator yang menggabungkan dua array dengan tipe yang sama.

Setelah Anda melakukannya, Anda terikat ke javac khusus Anda untuk mengkompilasi kode Anda tetapi bytecode yang dihasilkan akan dipahami oleh JVM. 

Tentu saja, Anda dapat menerapkan metode penggabungan array Anda sendiri di tingkat sumber Anda, ada banyak contoh tentang bagaimana melakukannya di jawaban lain!

Ada banyak operator yang bermanfaat yang dapat ditambahkan, yang ini akan menjadi salah satunya.

0
Jerome
    void f(String[] first, String[] second) {
    String[] both = new String[first.length+second.length];
    for(int i=0;i<first.length;i++)
        both[i] = first[i];
    for(int i=0;i<second.length;i++)
        both[first.length + i] = second[i];
}

Yang ini bekerja tanpa sepengetahuan kelas/perpustakaan lain dll . Ini berfungsi untuk semua tipe data. Ganti saja String dengan yang seperti int, double atau char. Ia bekerja dengan cukup efisien.

0
Yashovardhan99

Solusi Non Java 8:

public static int[] combineArrays(int[] a, int[] b) {
        int[] c = new int[a.length + b.length];

        for (int i = 0; i < a.length; i++) {
            c[i] = a[i];
        }

        for (int j = 0, k = a.length; j < b.length; j++, k++) {
            c[k] = b[j];
        }

        return c;
    }
0
rhel.user

Ini mungkin satu-satunya cara umum dan jenis-aman:

public class ArrayConcatenator<T> {
    private final IntFunction<T[]> generator;

    private ArrayConcatenator(IntFunction<T[]> generator) {
        this.generator = generator;
    }

    public static <T> ArrayConcatenator<T> concat(IntFunction<T[]> generator) {
        return new ArrayConcatenator<>(generator);
    }

    public T[] apply(T[] array1, T[] array2) {
        T[] array = generator.apply(array1.length + array2.length);
        System.arraycopy(array1, 0, array, 0, array1.length);
        System.arraycopy(array2, 0, array, array1.length, array2.length);
        return array;
    }
}

Dan penggunaannya cukup ringkas:

Integer[] array1 = { 1, 2, 3 };
Double[] array2 = { 4.0, 5.0, 6.0 };
Number[] array = concat(Number[]::new).apply(array1, array2);

(membutuhkan impor statis)

Jenis array yang tidak valid ditolak:

concat(String[]::new).apply(array1, array2); // error
concat(Integer[]::new).apply(array1, array2); // error
0
ZhekaKozlov

Yang ini hanya bekerja dengan int tetapi idenya generik

public static int[] junta(int[] v, int[] w) {

int[] junta = new int[v.length + w.length];

for (int i = 0; i < v.length; i++) {            
    junta[i] = v[i];
}

for (int j = v.length; j < junta.length; j++) {
    junta[j] = w[j - v.length];
}
0
Ricardo Vallejo

Lihatlah solusi elegan ini (jika Anda membutuhkan tipe selain char, ubahlah):

private static void concatArrays(char[] destination, char[]... sources) {
    int currPos = 0;
    for (char[] source : sources) {
        int length = source.length;
        System.arraycopy(source, 0, destination, currPos, length);
        currPos += length;
    }
}

Anda dapat menggabungkan setiap hitungan array.

0
filosofem

Ini mungkin satu-satunya cara umum dan jenis-aman:

public class ArrayConcatenator<T> {
    private final IntFunction<T[]> generator;

    private ArrayConcatenator(IntFunction<T[]> generator) {
        this.generator = generator;
    }

    public static <T> ArrayConcatenator<T> concat(IntFunction<T[]> generator) {
        return new ArrayConcatenator<>(generator);
    }

    public T[] apply(T[] array1, T[] array2) {
        T[] array = generator.apply(array1.length + array2.length);
        System.arraycopy(array1, 0, array, 0, array1.length);
        System.arraycopy(array2, 0, array, array1.length, array2.length);
        return array;
    }
}

Dan penggunaannya cukup ringkas:

Integer[] array1 = { 1, 2, 3 };
Double[] array2 = { 4.0, 5.0, 6.0 };
Number[] array = concat(Number[]::new).apply(array1, array2);

(membutuhkan impor statis)

Jenis array yang tidak valid ditolak:

concat(String[]::new).apply(array1, array2); // error
concat(Integer[]::new).apply(array1, array2); // error
0
ZhekaKozlov

Namun jawaban lain untuk pecinta algoritma:

public static String[] mergeArrays(String[] array1, String[] array2) {
    int totalSize = array1.length + array2.length; // Get total size
    String[] merged = new String[totalSize]; // Create new array
    // Loop over the total size
    for (int i = 0; i < totalSize; i++) {
        if (i < array1.length) // If the current position is less than the length of the first array, take value from first array
            merged[i] = array1[i]; // Position in first array is the current position

        else // If current position is equal or greater than the first array, take value from second array.
            merged[i] = array2[i - array1.length]; // Position in second array is current position minus length of first array.
    }

    return merged;

Pemakaian:

String[] array1str = new String[]{"a", "b", "c", "d"}; 
String[] array2str = new String[]{"e", "f", "g", "h", "i"};
String[] listTotalstr = mergeArrays(array1str, array2str);
System.out.println(Arrays.toString(listTotalstr));

Hasil:

[a, b, c, d, e, f, g, h, i]
0
c-chavez

Sebaiknya lakukan triknya. Ini mengasumsikan String [] pertama dan String [] kedua

List<String> myList = new ArrayList<String>(Arrays.asList(first));
myList.addAll(new ArrayList<String>(Arrays.asList(second)));
String[] both = myList.toArray(new String[myList.size()]);
0
SuperCamp

Saya menguji kode di bawah ini dan bekerja dengan baik

Saya juga menggunakan library: org.Apache.commons.lang.ArrayUtils

public void testConcatArrayString(){
    String[] a = null;
    String[] b = null;
    String[] c = null;
    a = new String[] {"1","2","3","4","5"};
    b = new String[] {"A","B","C","D","E"};

    c = (String[]) ArrayUtils.addAll(a, b);
    if(c!=null){
        for(int i=0; i<c.length; i++){
            System.out.println("c[" + (i+1) + "] = " + c[i]);
        }
    }
}

Salam

0
bhektor