it-swarm-eu.dev

Jak mohu spojit dvě pole v jazyce Java?

Potřebuji zřetězit dvě pole String v Javě.

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

Jaký je nejjednodušší způsob, jak toho dosáhnout?

1202
Antti Kissaniemi

Našel jsem jednořádkové řešení od staré dobré knihovny Apache Commons Lang.
ArrayUtils.addAll(T[], T...)

Kód:

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

Zde je jednoduchá metoda, která spojí dvě pole a vrátí výsledek:

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

Všimněte si, že nebude pracovat s primitivními datovými typy, pouze s typy objektů.

Následující poněkud složitější verze pracuje s objektovými i primitivními poli. To dělá pomocí T místo T[] jako typ argumentu.

To také umožňuje spojit pole dvou různých typů výběrem nejobecnější typ jako typ komponenty výsledek.

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

Zde je příklad:

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

Je možné napsat plně obecnou verzi, která může být rozšířena na zřetězení libovolného počtu polí. Tyto verze vyžadují Javu 6, protože používají Arrays.copyOf()

Obě verze se vyhýbají vytváření jakýchkoli zprostředkovatelných List objektů a používají System.arraycopy() k zajištění toho, aby kopírování velkých polí bylo co nejrychlejší.

Pro dvě pole to vypadá takto:

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

A pro libovolný počet polí (> = 1) to vypadá takto:

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 v Javě 8:

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

Nebo:

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

Nebo s milovanou Guavou :

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

Existují také verze pro primitivní pole:

  • 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

Použití rozhraní 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

Řešení 100% stará Java a bez System.arraycopy (například v klientovi GWT není k dispozici):

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

Dvě pole můžete připojit do dvou řádků kódu.

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

Jedná se o rychlé a efektivní řešení a bude pracovat pro primitivní typy, stejně jako dvě metody jsou přetíženy.

Měli byste se vyhnout řešením zahrnujícím ArrayLists, streamy, atd., Protože budou muset přidělit dočasnou paměť pro žádný užitečný účel.

Měli byste se vyhnout for smyčky pro velká pole, protože nejsou efektivní. Vestavěné metody používají funkce blokové kopie, které jsou velmi rychlé.

37
rghome

Nedávno jsem bojoval s problémy s nadměrnou rotací paměti. Je-li známo, že a a/nebo b jsou obyčejně prázdné, je zde další přizpůsobení kódu Silvertab (generováno také):

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

(V každém případě musí být chování při opětovném použití pole jasně JavaDoced!)

31
volley

Funkční Java knihovna má třídu wrapperů matic, která vybavuje matice praktickými metodami, jako je zřetězení.

import static fj.data.Array.array;

...a pak

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

Chcete-li vrátit nerozbalené pole zpět, zavolejte

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

Další způsob, jak s Java8 používat 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

Zde je adaptace řešení Silvertab, s generickými úpravami:

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

POZNÁMKA: Viz Joachimova odpověď pro řešení Java 6. Nejenže toto varování odstraní; je také kratší, efektivnější a lépe čitelný!

17
volley

Pokud používáte tímto způsobem, takže nemusíte importovat žádné třetí strany třídy.

Chcete-li spojit String

Ukázkový kód pro concate dva 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;
    }

Chcete-li spojit Int

Ukázkový kód pro konvertovat dvě 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;
    }

Zde je hlavní metoda

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

        }
    }  

Můžeme použít i tímto způsobem.

12
Raj S. Rusia

Promiňte, prosím, že přidávám další verzi do tohoto již dlouhého seznamu. Podíval jsem se na každou odpověď a rozhodl jsem se, že opravdu chci verzi s jedním parametrem v podpisu. Také jsem přidal kontrolu některých argumentů, abych využil včasného selhání s rozumnými informacemi v případě neočekávaného vstupu.

@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

Můžete to zkusit převést na Arraylist a použít metodu addAll a poté převést zpět na pole.

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

Zde je možná implementace v pracovním kódu pseudo-kódového řešení napsaného silvertab. 

Díky 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;
   }
}

Dále následuje stavitelské rozhraní. 

Poznámka: Tvůrce je nutný, protože v Javě není možné 

new T[size] 

kvůli smazání generického typu:

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

Zde konkrétní stavitel implementující rozhraní, sestavující pole Integer:

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

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

A konečně aplikace/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

Wow! mnoho složitých odpovědí včetně jednoduchých, které závisí na vnějších závislostech. jak to udělat takto:

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

To funguje, ale je třeba vložit vlastní kontrolu chyb.

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

Pravděpodobně to není nejúčinnější, ale nespoléhá se na nic jiného než na vlastní API jazyka Java.

6
glue

Toto je převedená funkce pro pole 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

Co takhle jednoduše 

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

A prostě Array.concat(arr1, arr2). Pokud jsou arr1 a arr2 stejného typu, získáte další pole stejného typu obsahující obě pole. 

5
Ephraim

Jednoduchá variace umožňující spojení více než jednoho pole:

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

Tady je moje mírně vylepšená verze concatAll od Joachima Sauera. Může pracovat na platformě Java 5 nebo 6, pokud je k dispozici za běhu. Tato metoda (IMHO) je ideální pro Android, protože pracuje na Androidu <9 (který nemá System.arraycopy), ale pokud je to možné, použije rychlejší metodu.

  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

To by mělo být jednořadé.

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

Další způsob, jak přemýšlet o otázce. Chcete-li zřetězit dvě nebo více polí, je třeba provést seznam všech prvků každého pole a poté vytvořit nové pole. To zní jako vytvoření List<T> a pak na něj zavolá toArray. Některé další odpovědi používají ArrayList a to je v pořádku. Ale co takhle realizovat naše vlastní? Není to těžké:

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

Domnívám se, že výše uvedené je ekvivalentní řešení, která používají System.arraycopy. Myslím si však, že tento má svou vlastní krásu. 

4
Earth Engine

Co takhle :

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

Snadný, ale neefektivní způsob, jak toho dosáhnout (generika nejsou zahrnuty):

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

Použití pouze vlastního Javas API:


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

Nyní tento kód není nejefektivnější, ale spoléhá pouze na standardní třídy Java a je snadno pochopitelný. Pracuje pro libovolný počet String [] (i nulových polí).

3
Kiwi

Pomocí streamů Java 8+ můžete napsat následující funkci:

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

Nezávislá varianta typu A (UPDATED - díky volley pro instanci 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

Každá jednotlivá odpověď kopíruje data a vytváří nové pole. To není nezbytně nutné a rozhodně NENÍ to, co chcete dělat, pokud jsou vaše pole přiměřeně velká. Tvůrci jazyka Java již věděli, že maticové kopie jsou plýtvání a proto nám poskytli System.arrayCopy () k tomu, aby to dělali mimo Javu.

Namísto kopírování dat kolem, zvažte ponechání na místě a čerpat z toho, kde leží. Kopírování umístění dat jen proto, že by je programátor chtěl organizovat, není vždy rozumné.

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

Pokud chcete v řešení pracovat s ArrayLists, můžete to zkusit takto:

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

Našel jsem, že jsem se musel zabývat případem, kdy pole mohou být null ...

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

Můžete nahradit řetězec podle typu/třídy podle vašich představ

Im jistý, že to může být kratší a lepší, ale funguje to a im líný, aby to vyřešit další ...

2
Jeroen

Obecná statická verze, která používá vysoce výkonnou System.arraycopy bez použití anotace @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

Myslím, že nejlepším řešením s generiky by bylo:

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

Můžete vyzkoušet tuto metodu, která spojuje více polí:

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

Můžete to zkusit

 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 můžete psát své pole !!!

1
Sushim

Zde je kód 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

V jazyce Java 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

Nejjednodušší způsob, jak bych mohl najít, je následující:


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

Další na základě návrhu SilverTabu, ale na podporu x počet argumentů a nevyžadují Javu 6. Není to také obecné, ale jsem si jistý, že by to mohlo být generické.

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

K tomu můžete použít kolekci ArrayList. jeho implementace je velmi snadno pochopitelná, zpočátku musíte ukládat jak pole String, která jsou uvedena v argumentech v ArrayList, tak po té převést ArrayList do pole String s metodou toArray (), zde je implementace:

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

V Haskellu můžete udělat něco jako [a, b, c] ++ [d, e] a získat [a, b, c, d, e]. To jsou Haskell seznamy zřetězené, ale to by velmi pěkné vidět podobný operátor v Javě pro pole. Nemyslíte si to? To je elegantní, jednoduché, obecné a není to tak těžké implementovat.

Pokud chcete, navrhuji, abyste se podívali na práci Alexandra Hristova v jeho Hackingovém OpenJDK kompilátoru . Vysvětluje, jak upravit zdroj javac pro vytvoření nového operátora. Jeho příklad spočívá v definování operátoru '**', kde i ** j = Math.pow(i, j). Jeden by mohl vzít takový příklad implementovat operátora, který spojí dvě pole stejného typu.

Jakmile to uděláte, jste vázáni na svůj přizpůsobený javac pro kompilaci kódu, ale vygenerovaný bytecode bude pochopen jakýmkoliv JVM. 

Samozřejmě můžete na své zdrojové úrovni implementovat vlastní metodu spojování matic, existuje mnoho příkladů, jak to udělat v ostatních odpovědích!

Existuje tolik užitečných operátorů, které by mohly být přidány.

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

Toto funguje bez znalosti jakýchkoliv jiných tříd/knihoven atd. Pracuje pro jakýkoli typ dat. Stačí nahradit String s čímkoliv, jako int, double nebo char. Funguje to docela efektivně.

0
Yashovardhan99

Řešení jiné než 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

Toto je pravděpodobně jediný obecný a typově bezpečný způsob:

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

Použití je velmi stručné:

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

(vyžaduje statický import)

Neplatné typy polí jsou odmítnuty:

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

Toto funguje pouze s int, ale myšlenka je obecná

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

Podívejte se na toto elegantní řešení (pokud potřebujete jiný typ než char, změňte jej):

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

Můžete zřetězit každý počet polí.

0
filosofem

Toto je pravděpodobně jediný obecný a typově bezpečný způsob:

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

Použití je velmi stručné:

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

(vyžaduje statický import)

Neplatné typy polí jsou odmítnuty:

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

Další odpověď pro milovníky algoritmů:

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;

Používání:

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

Výsledek:

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

Měl by to udělat trik. Toto předpokládá String [] první a String [] sekundu

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

Testoval jsem níže uvedený kód a pracoval jsem v pořádku

Také používám knihovnu: 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]);
        }
    }
}

Pozdravy

0
bhektor