it-swarm-tr.com

Java'da iki diziyi nasıl birleştirebilirim?

Java'da iki String diziyi birleştirmem gerekiyor.

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

Bunu yapmanın en kolay yolu nedir?

1202
Antti Kissaniemi

Eski Apache Commons Lang kütüphanesinden tek satırlık bir çözüm buldum.
ArrayUtils.addAll(T[], T...)

Kod:

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

İşte iki diziyi birleştirecek ve sonucu döndürecek basit bir yöntem:

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;
}

İlkel veri türleriyle, yalnızca nesne türleriyle çalışmayacağını unutmayın.

Aşağıdaki biraz daha karmaşık sürüm, hem nesne hem de ilkel dizilerle çalışır. Bunu, argüman türü olarak T[] yerine T kullanarak yapar.

Ayrıca, sonucun bileşen türü olarak en genel türü seçerek iki farklı türden dizileri birleştirmeyi mümkün kılar.

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;
}

İşte bir örnek:

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

Herhangi bir dizi diziyi birleştirmek için genişletilebilecek, tamamen genel bir sürüm yazmak mümkündür. Bu sürümler Java 6 kullanmaktadır, çünkü Arrays.copyOf()

Her iki sürüm de herhangi bir ara List nesnesi oluşturmaktan kaçınır ve büyük dizilerin kopyalanmasının mümkün olduğunca hızlı olmasını sağlamak için System.arraycopy() öğesini kullanır.

İki dizi için şöyle görünür:

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;
}

Ve rastgele bir dizi için (> = 1) şöyle görünür:

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

Java 8'de bir astar:

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

Veya:

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

Veya sevgili Guava ile :

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

Ayrıca, ilkel diziler için sürümler vardır:

  • 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

Java API'sini kullanma:

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

Bir çözüm% 100 eski Java veSystem.arraycopy'suz (örneğin GWT istemcisinde mevcut değil):

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

İki diziyi iki kod satırına ekleyebilirsiniz.

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

Bu hızlı ve etkili bir çözümdür ve ilkel türler için çalışacaktır, ayrıca iki yöntem aşırı yüklenmiştir.

ArrayLists, stream, vb. İçeren çözümlerden kaçınmalısınız, çünkü bunlar geçici bir bellek kullanmaya gerek kalmadan ihtiyaç duyarlar.

Bunlar verimli olmadığı için büyük diziler için for döngülerinden kaçınmalısınız. Yerleşik yöntemler, son derece hızlı olan blok kopyalama işlevlerini kullanır.

37
rghome

Son zamanlarda aşırı bellek rotasyonu ile ilgili sorunlar yaşadım. A ve/veya b'nin genel olarak boş olduğu biliniyorsa, silvertab'ın kodunun başka bir uyarlaması (aynı zamanda oluşturulmuş):

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;
}

(Her iki durumda da, dizi yeniden kullanım davranışı açıkça JavaDoced olacaktır!)

31
volley

Functional Java library, dizileri birleştirme gibi kullanışlı yöntemlerle donatan bir dizi sarmalayıcı sınıfına sahiptir.

import static fj.data.Array.array;

...ve sonra

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

Sarılmamış diziyi geri almak için

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

Stream kullanarak Java8 ile başka bir yol

  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

İşte silvertab çözümünün bir uyarlaması, jenerikler güçlendirilmiş olarak:

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;
}

NOT: Bkz. Joachim'in cevabı bir Java 6 çözümü için. Sadece uyarıyı ortadan kaldırmakla kalmaz; Ayrıca daha kısa, daha verimli ve okuması daha kolay!

17
volley

Bu şekilde kullanıyorsanız, herhangi bir üçüncü taraf sınıfını almanıza gerek yoktur.

Birleştirmek istiyorsanız String

İki tane dize dizisi için örnek kod

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;
    }

Birleştirmek istiyorsanız Int

İki adet tamsayı dizisi için örnek kod

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;
    }

İşte Ana yöntem

    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));

        }
    }  

Bu şekilde de kullanabiliriz.

12
Raj S. Rusia

Bu zaten uzun bir listeye başka bir sürüm eklediğim için lütfen beni affet. Her cevaba baktım ve imzada sadece bir parametreli bir versiyon istediğime karar verdim. Beklenmeyen bir giriş durumunda, mantıklı bilgiyle erken başarısızlıktan yararlanmak için bazı argüman kontrollerini de ekledim.

@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

Bir Arraylist'e dönüştürmeyi deneyebilir ve addAll yöntemini kullanarak tekrar bir diziye dönüştürebilirsiniz.

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

Burada silvertab tarafından yazılmış sözde kod çözümünün çalışma kodunda olası bir uygulama. 

Silvertab'a teşekkürler!

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;
   }
}

Bundan sonraki üretici arayüzü. 

Not: Bir oluşturucu gereklidir, çünkü Java'da bunu yapmak mümkün değildir. 

new T[size] 

genel tür silme nedeniyle:

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

Burada bir Integer dizisi oluşturarak arabirimi uygulayan bir beton oluşturucu:

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

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

Ve son olarak uygulama/test:

@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

Vaov! Dış bağımlılıklara bağlı basit cevaplar da dahil olmak üzere birçok karmaşık cevap. Bu şekilde yapmaya ne dersin:

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

Bu işe yarar, ancak kendi hata kontrolünüzü eklemeniz gerekir.

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();
    }
}

Muhtemelen en verimli değil, fakat Java'nın kendi API'sinden başka bir şeye güvenmiyor.

6
glue

Bu, bir String dizisi için dönüştürülmüş bir işlevdir:

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

Basitçe nasıl 

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());
    }
}

Ve sadece Array.concat(arr1, arr2) yapın. arr1 ve arr2 aynı tip olduğu sürece, bu size her iki diziyi içeren aynı türden başka bir dizi verecektir. 

5
Ephraim

Birden fazla dizinin birleştirilmesine izin veren basit bir değişiklik

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

İşte Joachim Sauer’ın concatAll’ının biraz geliştirilmiş versiyonum. Çalışma zamanında mevcutsa, Java 6'nın System.arraycopy'sini kullanarak Java 5 veya 6'da çalışabilir. Bu yöntem (IMHO) Android için mükemmeldir çünkü Android <9'da çalışır (System.arraycopy'ye sahip değildir), ancak mümkünse daha hızlı yöntemi kullanır.

  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

Bu bir astar olmalı.

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

Soru hakkında düşünmenin başka bir yolu. İki veya daha fazla diziyi birleştirmek için yapılması gereken, her dizinin tüm öğelerini listelemek ve sonra yeni bir dizi oluşturmaktır. Bu bir List<T> oluşturun ve sonra üzerine toArray çağırır. Diğer bazı cevaplar ArrayList kullanır ve bu iyidir. Ama kendimizinkini uygulamaya ne dersiniz? Zor değil:

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);
}

Yukarıdakilerin System.arraycopy kullanan çözümlere eşdeğer olduğuna inanıyorum. Ancak bunun kendi güzelliğine sahip olduğunu düşünüyorum. 

4
Earth Engine

Peki ya:

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
clément francomme

Bunu yapmanın kolay, ancak verimsiz bir yolu (jenerikler dahil değildir):

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

Yalnızca Javas'ın kendi API'sini kullanarak:


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]);
}

Şimdi, bu kod en verimli değil, ancak yalnızca standart Java sınıflarına dayanıyor ve anlaşılması kolaydır. Herhangi bir String [] (sıfır dizilerde bile) için çalışır.

3
Kiwi

Java 8+ akışlarını kullanarak aşağıdaki işlevi yazabilirsiniz:

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

Bağımsız bir değişkenlik (UPDATED - T örneği için Voleybolu sayesinde):

@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

Her bir cevap veriyi kopyalamak ve yeni bir dizi oluşturmaktır. Bu kesinlikle gerekli değildir ve dizileriniz makul derecede büyükse kesinlikle ne yapmak istediğinizi DEĞİLDİR. Java yaratıcıları zaten dizi kopyalarının boşuna olduğunu biliyorlardı ve bu yüzden bize gerektiğinde Java dışındakileri yapmak için System.arrayCopy () uygulamasını sağladılar.

Verilerinizi kopyalamak yerine, yerinde bırakarak düşünün ve bulunduğu yerden çekin. Veri konumlarını sadece programcının düzenlemek istediği için kopyalamak her zaman mantıklı değildir.

// 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

Çözümdeki ArrayLists ile çalışmak istiyorsanız, şunu deneyebilirsiniz:

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

Dizilerin boş olabileceği dava ile uğraşmak zorunda kaldım.

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

String'i beğeninize göre bir Tip/Sınıf ile değiştirebilirsiniz.

Bunun daha kısa ve daha iyi hale getirilebileceğinden eminim, ama işe yarıyor ve daha da ilerletmek için tembel olmak ...

2
Jeroen

@SuppressWarnings ek açıklaması gerektirmeden yüksek performanslı System.arraycopy kullanan genel statik sürüm:

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

Bence jenerikle ilgili en iyi çözüm şöyle olurdu:

/* 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

Birden çok diziyi birleştiren bu yöntemi deneyebilirsiniz:

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

Bunu deneyebilirsiniz

 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;
}

U, dizinizi cast yazabilir !!!

1
Sushim

İşte kod - 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

Java 8'de 

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

Bulabildiğim en kolay yol şöyle:


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

SilverTab'ın önerisine dayanan, ancak x sayısı argümanını desteklemek için yapılmış ve Java 6 gerektirmeyen bir tane daha. Ayrıca, genel değil, ancak genel olabileceğinden eminim.

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

Bunun için ArrayList koleksiyonunu kullanabilirsiniz. Uygulamasının anlaşılması çok kolaydır, başlangıçta ArrayList'te bağımsız değişkenlerde sağlanan String dizilerini saklamak zorundasınız ve bundan sonra sadece ArrayList'i toArray () yöntemiyle String dizisine dönüştürün, işte uygulama:

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

Haskell'de [a, b, c] ++ [d, e] almak için [a, b, c, d, e] gibi bir şey yapabilirsiniz. Bunlar birleştirilmiş Haskell listeleri ama diziler için Java'da benzer bir operatör görmek çok güzeldi. Öyle düşünmüyor musun Bu zarif, basit, genel ve uygulanması o kadar da zor değil.

İsterseniz, Alexander Hristov'un çalışmalarına OpenJDK derleyicisini kırma bölümüne bir göz atmanızı öneririm. Yeni bir işleç oluşturmak için javac kaynağının nasıl değiştirileceğini açıklar. Örneği i ** j = Math.pow(i, j) olan bir '**' işleci tanımlamaktan ibarettir. Bu örneği, aynı türde iki diziyi birleştiren bir işleç uygulamak için bir örnek alabilir.

Bunu yaptığınızda, kodunuzu derlemek için özelleştirilmiş javacınıza bağlanırsınız ancak oluşturulan bayt kodu herhangi bir JVM tarafından anlaşılır. 

Elbette, kendi dizi eşleştirme yönteminizi kaynak seviyenizde uygulayabilirsiniz, diğer cevaplarda nasıl yapılacağına dair birçok örnek var!

Eklenebilecek çok sayıda operatör var, bunlardan biri olabilir.

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];
}

Bu, başka herhangi bir sınıf/kütüphane vb. Bilgisiz çalışır. Sadece String yerine int, double veya char..__ gibi bir şeyle değiştirin.

0
Yashovardhan99

Java 8 olmayan çözüm:

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

Muhtemelen tek ve genel güvenli yol budur:

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;
    }
}

Ve kullanımı oldukça kısa:

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

(statik ithalat gerektirir)

Geçersiz dizi türleri reddedildi:

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

Bu sadece int ile çalışır ancak fikir geneldir

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

Şu şık çözüme bakın (char'dan başka bir tipe ihtiyacınız varsa değiştirin)

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;
    }
}

Her dizi dizisini bir araya getirebilirsiniz.

0
filosofem

Bu muhtemelen tek genel ve güvenli tip yoldur:

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;
    }
}

Ve kullanımı oldukça kısa:

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

(statik ithalat gerektirir)

Geçersiz dizi türleri reddedildi:

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

Algoritma sevenler için başka bir cevap:

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;

Kullanımı:

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));

Sonuç:

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

Hile yapmalı. Bu, String [] first ve String [] second olduğunu varsaymaktadır.

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

Aşağıdaki kodu test ettim ve çalıştı

Ayrıca kütüphane kullanıyorum: 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]);
        }
    }
}

Saygılarımızla

0
bhektor