как я могу объединить два массива в java?

<p>мне нужно объединить два массива <code>string</code> в java.</p><pre><code>void f(string[] first, string[] second) { string[] both = ??? } </code></pre><p>какой самый простой способ сделать это?</p>

<p>я нашел однострочное решение из старой доброй библиотеки apache commons lang.<br> <a href="http://commons.apache.org/proper/commons-lang/javadocs/api-3.1/org/apache/commons/lang3/arrayutils.html#addall%28t%5b%5d,%20t...%29"><code>arrayutils.addall(t[], t...)</code></a> </p><p>код:</p><pre><code>string[] both = (string[])arrayutils.addall(first, second); </code></pre>

<p>вот простой метод, который объединит два массива и вернет результат:</p><pre><code>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; } </code></pre><p>обратите внимание, что он не будет работать с примитивными типами данных, только с типами объектов.</p><p>следующая немного более сложная версия работает как с объектными, так и с примитивными массивами. это делается с помощью <code>t</code> вместо <code>t[]</code> в качестве типа аргумента.</p><p>это также позволяет объединять массивы двух разных типов, выбирая наиболее общий тип в качестве типа компонента результата.</p><pre><code>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; } </code></pre><p>вот пример:</p><pre><code>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 })); </code></pre>

<p>можно написать полностью общую версию, которая может быть расширена для объединения любого числа массивов. эти версии требуют java 6, так как они используют <a href="http://java.sun.com/javase/6/docs/api/java/util/arrays.html#copyof%28t[],%20int%29"><code>arrays.copyof()</code></a> </p><p>обе версии избегают создания каких-либо промежуточных объектов <code>list</code> и используют <code>system.arraycopy()</code>, чтобы обеспечить максимально быстрое копирование больших массивов.</p><p>для двух массивов это выглядит так:</p><pre><code>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; } </code></pre><p>а для произвольного числа массивов (> = 1) это выглядит так:</p><pre><code>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; } </code></pre>

<p>однострочник в java 8:</p><pre><code>string[] both = stream.concat(arrays.stream(a), arrays.stream(b)) .toarray(string[]::new); </code></pre><p>или же:</p><pre><code>string[] both = stream.of(a, b).flatmap(stream::of) .toarray(string[]::new); </code></pre>

<p>или с любимым <a href="https://google.github.io/guava/releases/19.0/api/docs/com/google/common/collect/objectarrays.html#concat(t%5b%5d,%20t%5b%5d,%20java.lang.class)">гуава</a> :</p><pre><code>string[] both = objectarrays.concat(first, second, string.class); </code></pre><p>также есть версии для примитивных массивов:</p><ul> <li><code>booleans.concat(first, second)</code></li> <li><code>bytes.concat(first, second)</code></li> <li><code>chars.concat(first, second)</code></li> <li><code>doubles.concat(first, second)</code></li> <li><code>shorts.concat(first, second)</code></li> <li><code>ints.concat(first, second)</code></li> <li><code>longs.concat(first, second)</code></li> <li><code>floats.concat(first, second)</code></li> </ul>

<p>использование java api:</p><pre><code>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()]); } </code></pre>

<p>решение<strong> 100% старая java </strong>и<strong> без </strong><code>system.arraycopy</code> (например, недоступно в gwt-клиенте):</p><pre><code>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; } </code></pre>

<p>вы можете добавить два массива в две строки кода.</p><pre><code>string[] both = arrays.copyof(first, first.length + second.length); system.arraycopy(second, 0, both, first.length, second.length); </code></pre><p>это быстрое и эффективное решение, которое будет работать для примитивных типов, так как оба метода перегружены.</p><p>вам следует избегать решений, включающих arraylists, потоки и т.д., так как они должны будут выделять временную память без какой-либо полезной цели.</p><p>вы должны избегать циклов <code>for</code> для больших массивов, так как они не эффективны. встроенные методы используют функции блочного копирования, которые чрезвычайно быстры.</p>

<p>я недавно боролся с проблемами с чрезмерным вращением памяти. если известно, что a и/или b обычно пустые, вот еще одна адаптация кода silvertab (также генерируется):</p><pre><code>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; } </code></pre><p>(в любом случае поведение повторного использования массива должно быть явно javadoced!)</p>

<p> <a href="http://functionaljava.org">функциональная библиотека java</a> имеет класс-оболочку для массива, который оснащает массивы такими удобными методами, как конкатенация.</p><pre><code>import static fj.data.array.array; </code></pre><p>...а потом</p><pre><code>array<string> both = array(first).append(array(second)); </code></pre><p>чтобы вернуть развернутый массив, вызовите</p><pre><code>string[] s = both.array(); </code></pre>

<pre><code>arraylist<string> both = new arraylist(arrays.aslist(first)); both.addall(arrays.aslist(second)); both.toarray(new string[0]); </code></pre>

<p>другой способ с java8 с использованием stream</p><pre><code> 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); } </code></pre>

<p>вот адаптация решения silvertab с модифицированными дженериками:</p><pre><code>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; } </code></pre><p>примечание: см. <a href="https://stackoverflow.com/questions/80476/how-to-concatenate-two-arrays-in-java/784842#784842">ответ иоахима</a> для решения java 6. это не только устраняет предупреждение; это также короче, более эффективно и легче читать!</p>

<p>если вы используете этот способ, вам не нужно импортировать какие-либо сторонние классы.</p><p>если вы хотите объединить <code>string</code></p><p><strong> пример кода для конкатенации двух string array </strong></p><pre><code>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; } </code></pre><p>если вы хотите объединить <code>int</code></p><p><strong> пример кода для объединения двух целочисленных массивов </strong></p><pre><code>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; } </code></pre><p><strong> вот основной метод </strong></p><pre><code> 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)); } } </code></pre><p>мы можем использовать этот способ также.</p>

<p>пожалуйста, прости меня за добавление еще одной версии в этот уже длинный список. я посмотрел на каждый ответ и решил, что мне действительно нужна версия с одним параметром в подписи. я также добавил некоторую проверку аргументов, чтобы извлечь выгоду из раннего сбоя с разумной информацией в случае неожиданного ввода.</p><pre><code>@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; } </code></pre>

<p>вы можете попробовать преобразовать его в arraylist и использовать метод addall, а затем преобразовать обратно в массив.</p><pre><code>list list = new arraylist(arrays.aslist(first)); list.addall(arrays.aslist(second)); string[] both = list.toarray(); </code></pre>

<p>здесь возможна реализация в рабочем коде решения псевдокода, написанного silvertab. </p><p>спасибо silvertab!</p><pre class="lang-java prettyprint-override"><code>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; } } </code></pre><p>далее следует интерфейс строителя. </p><p>примечание: сборщик необходим, потому что в java это невозможно сделать </p><p><code>new t[size]</code> </p><p>из-за стирания универсального типа:</p><pre class="lang-java prettyprint-override"><code>public interface arraybuilderi<t> { public t[] build(int size); } </code></pre><p>вот конкретный конструктор, реализующий интерфейс, создающий массив <code>integer</code>:</p><pre class="lang-java prettyprint-override"><code>public class integerarraybuilder implements arraybuilderi<integer> { @override public integer[] build(int size) { return new integer[size]; } } </code></pre><p>и, наконец, приложение/тест:</p><pre class="lang-java prettyprint-override"><code>@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]); } } </code></pre>

<p>вот это да! здесь много сложных ответов, в том числе несколько простых, которые зависят от внешних зависимостей. как насчет этого:</p><pre><code>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]); </code></pre>

<p>это работает, но вам нужно вставить свою собственную проверку ошибок.</p><pre><code>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(); } } </code></pre><p> вероятно, он не самый эффективный, но он не зависит ни от чего, кроме собственного api java.</p>

<p>это преобразованная функция для массива string:</p><pre><code>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; } </code></pre>

<p>как насчет просто </p><pre><code>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()); } } </code></pre><p>и просто сделайте <code>array.concat(arr1, arr2)</code>. поскольку <code>arr1</code> и <code>arr2</code> одного типа, это даст вам другой массив того же типа, содержащий оба массива. </p>

<p>простой вариант, позволяющий объединять несколько массивов:</p><pre><code>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()]); } </code></pre>

<p>вот моя слегка улучшенная версия concatall йоахима зауэра. он может работать на java 5 или 6, используя java 6 system.arraycopy, если он доступен во время выполнения. этот метод (imho) идеально подходит для android, так как он работает на android <9 (у которого нет system.arraycopy), но будет по возможности использовать более быстрый метод.</p><pre><code> 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; } </code></pre>

<p>это должно быть однострочно.</p><pre><code>public string [] concatenate (final string array1[], final string array2[]) { return stream.concat(stream.of(array1), stream.of(array2)).toarray(string[]::new); } </code></pre>

<p>еще один способ задуматься над вопросом. чтобы объединить два или более массивов, нужно составить список всех элементов каждого массива, а затем построить новый массив. это звучит как создание <code>list<t></code> и затем вызывает <code>toarray</code> для него. некоторые другие ответы используют <code>arraylist</code>, и это нормально. но как насчет реализации нашего? это не сложно</p><pre><code>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); } </code></pre><p>я считаю, что вышесказанное эквивалентно решениям, которые используют <code>system.arraycopy</code>. однако я думаю, что у этого есть своя собственная красота. </p>

<p>как насчет :</p><pre><code>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()]); } </code></pre>

<p>простой, но неэффективный способ сделать это (дженерики не включены):</p><pre><code>arraylist basearray = new arraylist(arrays.aslist(array1)); basearray.addall(arrays.aslist(array2)); string concatenated[] = (string []) basearray.toarray(new string[basearray.size()]); </code></pre>

<p>используя только собственный api javas:</p><pre><code> 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]); } </code></pre><p>теперь этот код не самый эффективный, но он опирается только на стандартные классы java и прост для понимания. это работает для любого числа string [] (даже нулевых массивов).</p>

<p>используя потоки java 8+, вы можете написать следующую функцию:</p><pre><code>private static string[] concatarrays(final string[]... arrays) { return arrays.stream(arrays) .flatmap(arrays::stream) .toarray(string[]::new); } </code></pre>

<p>вариант, независимый от типа (обновлено - спасибо volley за создание экземпляра t):</p><pre><code>@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())); } </code></pre>

<pre><code>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; } </code></pre>

<pre><code>string [] both = new arraylist<string>(){{addall(arrays.aslist(first)); addall(arrays.aslist(second));}}.toarray(new string[0]); </code></pre>

<p>каждый ответ копирует данные и создает новый массив. это не является строго необходимым и определенно не то, что вы хотите делать, если ваши массивы достаточно велики. создатели java уже знали, что копии массивов расточительны, и именно поэтому они предоставили нам system.arraycopy () для выполнения тех операций вне java, когда это необходимо.</p><p>вместо того, чтобы копировать ваши данные, подумайте о том, чтобы оставить их на месте и взять их там, где они лежат. копирование местоположений данных только потому, что программист хотел бы организовать их, не всегда целесообразно.</p><pre><code>// 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 } </code></pre>

<p>если вы хотите работать с arraylists в решении, вы можете попробовать это:</p><pre><code>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()]); } </code></pre>

<pre><code>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()]); } </code></pre>

<p>я обнаружил, что имел дело со случаем, когда массивы могут быть нулевыми ...</p><pre><code>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; } </code></pre>

<pre><code>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 </code></pre><p>вы можете заменить string типом/классом по своему вкусу</p><p>я уверен, что это можно сделать короче и лучше, но это работает, и мне лень разбираться с этим дальше ...</p>

<p>универсальная статическая версия, которая использует высокопроизводительную system.arraycopy, не требуя аннотации @suppresswarnings:</p><pre><code>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; } </code></pre>

<pre><code>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; </code></pre>

<pre><code>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; } </code></pre>

<p>я думаю, что лучшее решение с дженериками было бы:</p><pre><code>/* 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; } </code></pre>

<p>вы можете попробовать этот метод, который объединяет несколько массивов:</p><pre><code>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; } </code></pre>

<p><strong> вы можете попробовать это </strong></p><pre><code> 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; } </code></pre><p>вы можете напечатать ваш массив !!!</p>

<p>вот код от <a href="https://github.com/landawn/abacusutil">abacusutil</a> .</p><pre><code>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"] </code></pre>

<p>в java 8 </p><pre><code>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)); } </code></pre>

<p>самый простой способ, который я мог найти, заключается в следующем:</p><pre> <code> list allfilterslist = arrays.aslist(regularfilters); allfilterslist.addall(arrays.aslist(prefiltersarray)); filter[] mergedfilterarray = (filter[]) allfilterslist.toarray(); </code> </pre>

<pre><code>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]; </code></pre>

<p>еще один, основанный на предложении silvertab, но созданный для поддержки x количества аргументов и не требующий java 6. он также не является универсальным, но я уверен, что его можно сделать универсальным.</p><pre><code>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; } </code></pre>

<p>вы можете использовать коллекцию arraylist для этого. его реализация очень проста для понимания, сначала вы должны хранить оба массива string, которые представлены в аргументах в arraylist, а после этого просто конвертировать этот arraylist в массив string с помощью метода toarray (), вот реализация:</p><pre><code>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()); } </code></pre>

<p>в haskell вы можете сделать что-то подобное <code>[a, b, c] ++ [d, e]</code>, чтобы получить <code>[a, b, c, d, e]</code>. это сцепленные списки на haskell, но было бы очень приятно увидеть подобный оператор в java для массивов. тебе так не кажется? это элегантно, просто, универсально и не так сложно для реализации.</p><p>если вы хотите, я предлагаю вам взглянуть на работу александра христова в его <a href="http://www.ahristov.com/tutoriales/java-compiler/duplicating-lexer.html">взлом компилятора openjdk</a> . он объясняет, как изменить исходный код javac для создания нового оператора. его пример состоит в определении оператора **, где <code>i ** j = math.pow(i, j)</code>. можно взять этот пример для реализации оператора, который объединяет два массива одного типа.<br></p><p>как только вы это сделаете, вы будете привязаны к вашему настроенному javac для компиляции вашего кода, но сгенерированный байт-код будет понят любой jvm. <br><br>конечно, вы можете реализовать свой собственный метод конкатенации массивов на уровне источника, в других ответах есть много примеров того, как это сделать!<br> <br> есть так много полезных операторов, которые могут быть добавлены, и это один из них.</p>

<pre><code> 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]; } </code></pre><p>этот работает без знания каких-либо других классов/библиотек и т.д он работает для любого типа данных. просто замените <code>string</code> на что-нибудь вроде <code>int</code>, <code>double</code> или <code>char</code>. это работает довольно эффективно.</p>

<p>решение не на java 8:</p><pre><code>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; } </code></pre>

<p>вероятно, это единственный общий и безопасный для типов способ:</p><pre><code>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; } } </code></pre><p>и использование довольно кратко:</p><pre><code>integer[] array1 = { 1, 2, 3 }; double[] array2 = { 4.0, 5.0, 6.0 }; number[] array = concat(number[]::new).apply(array1, array2); </code></pre><p>(требуется статический импорт)</p><p>неверные типы массивов отклоняются:</p><pre><code>concat(string[]::new).apply(array1, array2); // error concat(integer[]::new).apply(array1, array2); // error </code></pre>

<p>этот работает только с int, но идея является общей</p><pre><code>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]; } </code></pre>

<p>посмотрите на это элегантное решение (если вам нужен другой тип, кроме char, измените его):</p><pre><code>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; } } </code></pre><p>вы можете объединить каждый массив массивов.</p>

<p>вероятно, это единственный общий и безопасный для типов способ:</p><pre><code>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; } } </code></pre><p>и использование довольно кратко:</p><pre><code>integer[] array1 = { 1, 2, 3 }; double[] array2 = { 4.0, 5.0, 6.0 }; number[] array = concat(number[]::new).apply(array1, array2); </code></pre><p>(требуется статический импорт)</p><p>неверные типы массивов отклоняются:</p><pre><code>concat(string[]::new).apply(array1, array2); // error concat(integer[]::new).apply(array1, array2); // error </code></pre>

<p>еще один ответ для любителей алгоритма:</p><pre><code>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; </code></pre><p>использование:</p><pre><code>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)); </code></pre><p>результат:</p><pre><code>[a, b, c, d, e, f, g, h, i] </code></pre>

<p>должен сделать свое дело. предполагается, что string [] first и string [] second</p><pre><code>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()]); </code></pre>

<p>я тестировал приведенный ниже код и работал нормально</p><p>также я использую библиотеку: org.apache.commons.lang.arrayutils</p><pre><code>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]); } } } </code></pre><p>с уважением</p>