it-swarm-vi.tech

Làm thế nào tôi có thể nối hai mảng trong Java?

Tôi cần nối hai mảng String trong Java.

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

Cách dễ nhất để làm điều này là gì?

1202
Antti Kissaniemi

Tôi đã tìm thấy một giải pháp một dòng từ thư viện Apache Commons Lang cũ.
[.__.] ArrayUtils.addAll(T[], T...)

Mã số:

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

Đây là một phương pháp đơn giản sẽ ghép hai mảng và trả về kết quả:

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

Lưu ý rằng nó sẽ không hoạt động với các kiểu dữ liệu nguyên thủy, chỉ với các kiểu đối tượng.

Phiên bản phức tạp hơn một chút sau đây hoạt động với cả mảng đối tượng và mảng nguyên thủy. Nó thực hiện điều này bằng cách sử dụng T thay vì T[] làm kiểu đối số.

Nó cũng cho phép ghép các mảng của hai loại khác nhau bằng cách chọn loại chung nhất làm loại thành phần của kết quả.

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

Đây là một ví dụ:

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

Có thể viết một phiên bản hoàn toàn chung thậm chí có thể được mở rộng để nối bất kỳ số lượng mảng nào. Các phiên bản này yêu cầu Java 6, vì chúng sử dụng Arrays.copyOf()

Cả hai phiên bản đều tránh tạo bất kỳ đối tượng List trung gian nào và sử dụng System.arraycopy() để đảm bảo sao chép mảng lớn càng nhanh càng tốt.

Đối với hai mảng, nó trông như thế này:

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

Và đối với số lượng mảng tùy ý (> = 1), nó trông như thế này:

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

Một lớp lót trong Java 8:

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

Hoặc là:

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

Hoặc với người yêu dấu ổi :

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

Ngoài ra, có các phiên bản cho mảng nguyên thủy:

  • 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)
183
KARASZI István

Sử dụng API Java:

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

Một giải pháp 100% Java cũ không có System.arraycopy (chẳng hạn trong ứng dụng khách GWT):

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

Bạn có thể nối hai mảng trong hai dòng mã.

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

Đây là một giải pháp nhanh chóng và hiệu quả và sẽ hoạt động cho các loại nguyên thủy cũng như hai phương pháp liên quan bị quá tải.

Bạn nên tránh các giải pháp liên quan đến ArrayLists, luồng, v.v. vì những giải pháp này sẽ cần phân bổ bộ nhớ tạm thời cho mục đích hữu ích.

Bạn nên tránh các vòng lặp for cho các mảng lớn vì chúng không hiệu quả. Các phương thức tích hợp sử dụng các hàm sao chép khối cực kỳ nhanh.

37
rghome

Gần đây tôi đã chiến đấu với các vấn đề với vòng quay bộ nhớ quá mức. Nếu a và/hoặc b được biết là thường trống, thì đây là một sự thích ứng khác của mã silvertab (cũng được tạo ra)

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

(Trong cả hai trường hợp, hành vi sử dụng lại mảng sẽ rõ ràng là JavaDoced!)

31
volley

Thư viện Functional Java có một lớp trình bao bọc mảng trang bị cho các mảng với các phương thức tiện dụng như nối.

import static fj.data.Array.array;

...và sau đó

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

Để lấy lại mảng chưa mở, hãy gọi

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

Một cách khác với Java8 bằng cách sử dụng 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

Đây là một bản phóng tác của giải pháp silvertab, với thuốc generic được trang bị thêm:

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

LƯU Ý: Xem Câu trả lời của Joachim cho giải pháp Java 6. Nó không chỉ loại bỏ cảnh báo; Nó cũng ngắn hơn, hiệu quả hơn và dễ đọc hơn!

17
volley

Nếu bạn sử dụng cách này để bạn không cần phải nhập bất kỳ lớp bên thứ ba nào.

Nếu bạn muốn nối String

Mã mẫu để nối hai chuỗi String

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

Nếu bạn muốn nối Int

Mã mẫu để nối hai mảng Integer

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

Đây là phương thức chính

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

        }
    }  

Chúng ta cũng có thể sử dụng cách này.

12
Raj S. Rusia

Xin vui lòng tha thứ cho tôi vì đã thêm một phiên bản khác vào danh sách đã dài này. Tôi đã xem xét mọi câu trả lời và quyết định rằng tôi thực sự muốn có một phiên bản chỉ có một tham số trong chữ ký. Tôi cũng đã thêm một số kiểm tra đối số để hưởng lợi từ thất bại sớm với thông tin hợp lý trong trường hợp đầu vào bất ngờ.

@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

Bạn có thể thử chuyển đổi nó thành một Arraylist và sử dụng phương thức addAll sau đó chuyển đổi trở lại thành một mảng.

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

Đây là một triển khai có thể có trong mã làm việc của giải pháp mã giả được viết bởi silvertab. 

Cảm ơn 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;
   }
}

Tiếp theo là giao diện xây dựng. 

Lưu ý: Trình xây dựng là cần thiết vì trong Java không thể thực hiện được 

new T[size] 

do loại chung chung xóa:

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

Ở đây, một người xây dựng cụ thể thực hiện giao diện, xây dựng một mảng Integer:

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

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

Và cuối cùng là ứng dụng/kiểm tra:

@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

Ồ rất nhiều câu trả lời phức tạp ở đây bao gồm một số câu trả lời đơn giản phụ thuộc vào sự phụ thuộc bên ngoài. làm thế nào để làm điều đó như thế này:

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

Điều này hoạt động, nhưng bạn cần chèn kiểm tra lỗi của riêng bạn.

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

,.

6
glue

Đây là một hàm được chuyển đổi cho một mảng 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

Đơn giản thế nào 

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

Và chỉ cần làm Array.concat(arr1, arr2). Miễn là arr1arr2 cùng loại, điều này sẽ cung cấp cho bạn một mảng khác cùng loại chứa cả hai mảng. 

5
Ephraim

Một biến thể đơn giản cho phép nối nhiều hơn một mảng:

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

Đây là phiên bản cải tiến của Joachimerer của tôi. Nó có thể hoạt động trên Java 5 hoặc 6, sử dụng System.arraycopy của Java 6 nếu nó có sẵn trong thời gian chạy. Phương pháp này (IMHO) hoàn hảo cho Android, vì nó hoạt động trên Android <9 (không có System.arraycopy) nhưng sẽ sử dụng phương pháp nhanh hơn nếu có thể.

  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

Điều này nên là một lót.

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

Một cách khác để suy nghĩ về câu hỏi. Để nối hai hoặc nhiều mảng, người ta phải làm là liệt kê tất cả các phần tử của mỗi mảng, sau đó xây dựng một mảng mới. Điều này nghe có vẻ như tạo một List<T> và sau đó gọi toArray trên đó. Một số câu trả lời khác sử dụng ArrayList, và điều đó tốt. Nhưng làm thế nào về việc thực hiện của chúng ta? Nó không khó:

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

Tôi tin rằng ở trên tương đương với các giải pháp sử dụng System.arraycopy. Tuy nhiên tôi nghĩ cái này có vẻ đẹp riêng của nó. 

4
Earth Engine

Làm thế nào về :

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

Một cách dễ dàng, nhưng không hiệu quả, để làm điều này (không bao gồm thuốc generic):

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

Chỉ sử dụng API riêng của Javas:


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

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

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

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

Bây giờ, mã này không phải là hiệu quả nhất, nhưng nó chỉ dựa trên các lớp Java tiêu chuẩn và rất dễ hiểu. Nó hoạt động với bất kỳ số lượng Chuỗi [] (thậm chí là mảng 0).

3
Kiwi

Sử dụng luồng Java 8+, bạn có thể viết hàm sau:

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

Một biến thể độc lập loại (CẬP NHẬT - nhờ Volley để khởi tạo 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

Mỗi câu trả lời là sao chép dữ liệu và tạo một mảng mới. Điều này không thực sự cần thiết và chắc chắn KHÔNG phải là những gì bạn muốn làm nếu mảng của bạn lớn một cách hợp lý. Những người tạo Java đã biết rằng các bản sao mảng là lãng phí và đó là lý do tại sao họ cung cấp cho chúng tôi System.arrayCopy () để thực hiện những điều đó bên ngoài Java khi chúng ta phải làm.

Thay vì sao chép dữ liệu của bạn xung quanh, hãy cân nhắc để nó tại chỗ và rút ra từ nơi nó nằm. Sao chép vị trí dữ liệu chỉ vì lập trình viên muốn tổ chức chúng không phải lúc nào cũng hợp lý.

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

Nếu bạn muốn làm việc với ArrayLists trong giải pháp, bạn có thể thử điều này:

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
Kamil Tomasz Jarmusik

Tôi thấy rằng tôi đã phải đối phó với trường hợp các mảng có thể là 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

Bạn có thể thay thế Chuỗi bằng Loại/Lớp theo ý thích của bạn

Tôi chắc chắn rằng điều này có thể được thực hiện ngắn hơn và tốt hơn, nhưng nó hoạt động và tôi lười biếng để sắp xếp nó ra xa hơn ...

2
Jeroen

Một phiên bản tĩnh chung sử dụng System.arraycopy hiệu suất cao mà không yêu cầu chú thích @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

Tôi nghĩ rằng giải pháp tốt nhất với thuốc generic sẽ là:

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

Bạn có thể thử phương pháp này nối nhiều mảng:

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

Bạn có thể thử cái này

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

Bạn có thể gõ cast mảng của bạn !!!

1
Sushim

Đây là mã của 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

Trong 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

Cách dễ nhất tôi có thể tìm thấy là như sau:


List allFiltersList = Arrays.asList(regularFilters);
allFiltersList.addAll(Arrays.asList(preFiltersArray));
Filter[] mergedFilterArray = (Filter[]) allFiltersList.toArray();
1
Muhammad Haris Altaf
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

Một số khác dựa trên đề xuất của SilverTab, nhưng được thực hiện để hỗ trợ x số lượng đối số và không yêu cầu Java 6. Nó cũng không chung chung, nhưng tôi chắc chắn rằng nó có thể được tạo thành chung chung.

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

Bạn có thể sử dụng bộ sưu tập ArrayList cho việc này. Cách thực hiện của nó rất dễ hiểu, ban đầu bạn phải lưu trữ cả hai mảng String được cung cấp trong các đối số trong ArrayList và sau đó chỉ cần chuyển đổi ArrayList đó thành mảng String bằng phương thức toArray (), đây là cách thực hiện:

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

Trong Haskell, bạn có thể làm một cái gì đó như thế [a, b, c] ++ [d, e] để nhận [a, b, c, d, e]. Đây là các danh sách Haskell được nối nhưng thật tuyệt khi thấy một toán tử tương tự trong Java cho các mảng. Bạn không nghĩ vậy sao? Điều đó thanh lịch, đơn giản, chung chung và không khó để thực hiện.

Nếu bạn muốn, tôi khuyên bạn nên xem công việc của Alexander Hristov trong Hack trình biên dịch OpenJDK . Ông giải thích cách sửa đổi nguồn javac để tạo một toán tử mới. Ví dụ của anh ấy bao gồm việc xác định toán tử '**' trong đó i ** j = Math.pow(i, j). Người ta có thể lấy ví dụ đó để thực hiện một toán tử nối hai mảng cùng loại.

Khi bạn làm điều đó, bạn bị ràng buộc với javac tùy chỉnh của bạn để biên dịch mã của bạn nhưng mã byte được tạo sẽ được hiểu bởi bất kỳ JVM nào. 

Tất nhiên, bạn có thể thực hiện phương pháp nối mảng của riêng bạn ở cấp nguồn của bạn, có nhiều ví dụ về cách thực hiện trong các câu trả lời khác!

Có rất nhiều toán tử hữu ích có thể được thêm vào, cái này sẽ là một trong số chúng.

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

Cái này hoạt động mà không có kiến ​​thức về bất kỳ lớp/thư viện nào khác, vv . Nó hoạt động cho bất kỳ loại dữ liệu nào. Chỉ cần thay thế String bằng bất cứ thứ gì như int, double hoặc char. Nó hoạt động khá hiệu quả.

0
Yashovardhan99

Giải pháp phi 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

Đây có lẽ là cách duy nhất chung và loại an toàn:

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

Và cách sử dụng khá súc tích:

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

(yêu cầu nhập tĩnh)

Các kiểu mảng không hợp lệ bị từ chối:

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

Cái này chỉ hoạt động với int nhưng ý tưởng là chung chung

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

Nhìn vào giải pháp tao nhã này (nếu bạn cần loại khác ngoài char, hãy thay đổi nó):

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

Bạn có thể nối một số lượng các mảng.

0
filosofem

Đây có lẽ là cách duy nhất chung chung và loại an toàn:

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

Và cách sử dụng khá súc tích:

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

(yêu cầu nhập tĩnh)

Các kiểu mảng không hợp lệ bị từ chối:

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

Một câu trả lời khác cho những người yêu thích thuật toán:

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;

Sử dụng:

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

Kết quả:

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

Nên làm thủ thuật. Đây là giả sử Chuỗi [] đầu tiên và Chuỗi [] thứ hai

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

Tôi đã thử nghiệm dưới đây mã và làm việc ok

Ngoài ra tôi đang sử dụng thư viện: 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]);
        }
    }
}

Trân trọng

0
bhektor