it-swarm-ko.tech

Java로 두 배열을 연결하려면 어떻게해야합니까?

Java에서 두 개의 String 배열을 연결해야합니다.

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

가장 쉬운 방법은 무엇입니까?

1236
Antti Kissaniemi

좋은 오래된 Apache Commons Lang 라이브러리에서 한 줄짜리 해결책을 찾았습니다.
ArrayUtils.addAll(T[], T...)

암호:

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

다음은 두 배열을 연결하고 결과를 반환하는 간단한 메서드입니다.

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

원시 데이터 유형에는 사용할 수 없으며 객체 유형에만 사용할 수 있습니다.

다음의 좀 더 복잡한 버전은 객체와 프리미티브 배열 모두에서 작동합니다. 인수 유형으로 T[] 대신 T을 사용하여이 작업을 수행합니다.

또한 가장 일반적인 유형을 결과의 구성 요소 유형으로 선택하여 두 가지 유형의 h 열을 연결할 수 있습니다.

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

다음은 그 예입니다.

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

임의의 수의 배열을 연결하기 위해 확장 될 수있는 완전한 제네릭 버전을 작성할 수 있습니다. 이 버전에서는 Java 6이 필요합니다. Arrays.copyOf()

두 버전 모두 중개 List 객체를 만들지 않고 System.arraycopy()을 사용하여 대용량 배열을 최대한 빨리 복사 할 수 있습니다.

두 배열의 경우 다음과 같습니다.

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

임의의 수의 배열 (> = 1)의 경우, 다음과 같이됩니다 :

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

자바 8의 한 - 라이너 :

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

또는:

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

또는 사랑하는 구아바 와 함께 :

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

또한 프리미티브 배열에 대한 버전이 있습니다.

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

Java API 사용 :

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

100 % 오래된 JavawithoutSystem.arraycopy (예 : 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

두 줄을 두 줄의 코드로 추가 할 수 있습니다.

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

이것은 빠르고 효율적인 솔루션이며 원시 타입에 대해 작동 할뿐만 아니라 관련된 두 메소드가 오버로드됩니다.

당신은 유용한 목적을 위해 임시 메모리를 할당해야하므로 ArrayList, 스트림 등을 포함하는 솔루션을 피해야합니다.

대형 어레이의 경우 for 루프는 효율적이지 않으므로이를 피해야합니다. 내장 된 메서드는 매우 빠른 블록 복사 기능을 사용합니다.

37
rghome

나는 최근 과도한 메모리 교체로 문제를 싸웠다. a 및/또는 b가 일반적으로 비어있는 것으로 알려진 경우 다음은 silvertab 코드의 또 다른 적용입니다 (generized도 해당).

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

(두 경우 모두 배열 재사용 동작이 명확하게 JavaDoced되어야합니다!)

31
volley

Functional Java 라이브러리에는 배열과 같은 편리한 메소드를 사용하는 배열 래퍼 클래스가 있습니다.

import static fj.data.Array.array;

...그리고

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

래핑되지 않은 배열을 다시 가져 오려면

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

스트림을 사용하는 Java8의 또 다른 방법

  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

다음은 개조 된 제네릭과 함께 silvertab의 솔루션을 적용한 것입니다.

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

참고 : Joachim의 답변 Java 6 솔루션을 참조하십시오. 그것은 경고를 제거 할뿐만 아니라, 또한 더 짧고 효율적이며 읽기 쉽습니다!

17
volley

이 방법을 사용하면 제 3 자 클래스를 가져올 필요가 없습니다.

String을 연결하려는 경우

concate 2의 샘플 코드 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;
    }

Int을 연결하려는 경우

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

기본 방법은 다음과 같습니다.

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

        }
    }  

우리는 또한이 방법을 사용할 수 있습니다.

12
Raj S. Rusia

이미 긴 목록에 다른 버전을 추가해 주셔서 저를 용서해주십시오. 모든 대답을 살펴본 후 서명에 하나의 매개 변수 만있는 버전을 정말로 필요로한다고 결정했습니다. 또한 예상치 못한 입력이있을 경우에 합리적인 정보로 초기 실패로부터 이익을 얻는 몇 가지 인수 검사를 추가했습니다.

@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

Arraylist로 변환하고 addAll 메서드를 사용하여 배열로 다시 변환 할 수 있습니다.

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

Silvertab이 작성한 유사 코드 솔루션의 작업 코드에서 가능한 구현입니다. 

감사합니다 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;
   }
}

다음은 빌더 인터페이스입니다. 

참고 : Java에서는 수행 할 수 없기 때문에 빌더가 필요합니다. 

new T[size] 

제네릭 형식 삭제로 인해 :

public interface ArrayBuilderI<T> {

   public T[] build(int size);
}

여기에 인터페이스를 구현하고 Integer 배열을 빌드하는 구체적인 빌더가 있습니다.

public class IntegerArrayBuilder implements ArrayBuilderI<Integer> {

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

마지막으로 응용 프로그램/테스트 :

@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

와우! 외부 의존성에 의존하는 간단한 것들을 포함하여 여기에 복잡한 대답이 많습니다. 방법에 대해 이렇게 :

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

이 방법은 작동하지만 사용자 자신의 오류 검사를 삽입해야합니다.

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

아마도 가장 효율적인 것은 아니지만 Java 자체 API 이외의 다른 것에 의존하지는 않습니다.

6
glue

문자열 배열의 변환 된 함수입니다.

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

어때요? 

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

그리고 Array.concat(arr1, arr2)을 수행하십시오. arr1arr2가 같은 유형 인 한이 배열을 포함하는 동일한 유형의 다른 배열을 제공합니다. 

5
Ephraim

둘 이상의 배열을 결합 할 수있는 간단한 변형 :

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

Joachim Sauer의 concatAll을 약간 개선 한 버전입니다. 런타임시 Java 6의 System.arraycopy를 사용할 수 있으면 Java 5 또는 6에서 작동합니다. 이 방법 (IMHO)은 Android <9 (System.arraycopy가없는)에서 작동하지만 가능한 경우 더 빠른 방법을 사용하므로 Android에 적합합니다.

  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

이것은 하나의 라이너 여야합니다.

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

질문에 대해 생각하는 또 다른 방법. 둘 이상의 배열을 연결하려면 각 배열의 모든 요소를 ​​나열한 다음 새 배열을 작성해야합니다. 이것은 List<T>를 만든 다음 toArray을 호출하는 것처럼 들립니다. 다른 답변은 ArrayList을 사용하며 괜찮습니다. 그러나 우리 자신을 구현하는 것은 어떨까요? 어렵지 않다.

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

위의 내용은 System.arraycopy를 사용하는 솔루션과 동일하다고 생각합니다. 그러나 나는 이것이 자신의 아름다움을 가지고 있다고 생각한다. 

4
Earth Engine

어때?

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

쉽지만 비효율적 인 방법 (제네릭 포함되지 않음) :

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

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

이제는이 코드가 가장 효율적이지는 않지만 표준 Java 클래스에만 의존하므로 이해하기 쉽습니다. 그것은 임의의 수의 String [] (제로 배열)에서도 작동합니다.

3
Kiwi

Java 8+ 스트림을 사용하면 다음과 같은 함수를 작성할 수 있습니다.

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

유형 독립적 변형 (업데이트 됨 - T를 인스턴스화 한 Volley 덕분) :

@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

모든 대답은 데이터를 복사하고 새로운 배열을 만드는 것입니다. 이것은 꼭 필요한 것은 아니며, 배열이 상당히 큰 경우에는 원하는 것이 아닙니다. 자바 제작자는 이미 배열 복사본이 낭비 적이라는 것을 이미 알고 있었고, 그래서 우리가해야 할 때 Java 외부의 작업을 수행하기 위해 System.arrayCopy ()를 제공 한 것입니다.

데이터를 복사하는 대신, 제 위치에두고 데이터가있는 곳에 그려주십시오. 프로그래머가 구성하려고하기 때문에 데이터 위치를 복사하는 것이 항상 의미있는 것은 아닙니다.

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

솔루션에서 ArrayLists로 작업하고 싶다면 다음을 시도해보십시오 :

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

배열이 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

원하는 String 유형/클래스로 대체 할 수 있습니다.

나는 이것이 더 짧고 더 좋게 만들 수 있음을 확신하지만, 그것을 더 일종의 게으름으로 작동시킨다.

2
Jeroen

@SuppressWarnings 주석을 사용하지 않고 고성능 System.arraycopy를 사용하는 일반 정적 버전입니다.

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

제네릭을 사용하는 최상의 솔루션은 다음과 같을 것이라고 생각합니다.

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

여러 배열을 연결하는이 메서드를 사용할 수 있습니다.

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

너도해볼 수있어

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

당신의 배열을 캐스팅 할 수 있습니다!

1
Sushim

다음은 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

자바 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

내가 찾을 수있는 가장 쉬운 방법은 다음과 같습니다.


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

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

또 다른 하나는 SilverTab의 제안에 기반을두고 있지만 x 개의 인수를 지원하고 Java 6이 필요하지 않습니다. 또한 일반적인 것도 아니지만 일반화 할 수 있다고 확신합니다.

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

이를 위해 ArrayList 컬렉션을 사용할 수 있습니다. 그것의 구현은 이해하기 쉽습니다. 처음에는 ArrayList에 인수로 제공되는 문자열 배열을 모두 저장해야합니다. 그리고 그 ArrayList를 toArray () 메서드를 사용하여 String 배열로 변환하면 다음과 같이 구현됩니다.

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

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

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

        }
0
Ketan Ramteke

Haskell에서는 [a, b, c] ++ [d, e]를 얻기 위해 [a, b, c, d, e]와 같은 것을 할 수 있습니다. 이것들은 연결된 Haskell 목록이지만 배열에 대해 Java에서 비슷한 연산자를 보는 것이 매우 좋습니다. 그렇게 생각하지 않습니까? 우아하고 단순하며 일반적이며 구현하기가 어렵지 않습니다.

원한다면 Alexander Hristov의 작업을 OpenJDK 컴파일러 해킹 에서 살펴 보는 것이 좋습니다. 그는 새 연산자를 작성하기 위해 javac 소스를 수정하는 방법을 설명합니다. 그의 예는 i ** j = Math.pow(i, j) 인 '**'연산자를 정의하는 것으로 구성됩니다. 예를 들어 동일한 유형의 두 배열을 연결하는 연산자를 구현할 수 있습니다.

일단 그렇게하면 코드를 컴파일하기 위해 사용자 정의 된 javac에 바인딩되지만 생성 된 바이트 코드는 모든 JVM에서 이해할 수 있습니다.

물론, 소스 레벨에서 자신 만의 배열 연결 메소드를 구현할 수 있습니다. 다른 답변에서이를 수행하는 방법에 대한 예가 많이 있습니다!

추가 할 수있는 유용한 연산자가 너무 많습니다.이 연산자는 그 중 하나입니다.

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

이 클래스는 다른 클래스/라이브러리 등의 지식 없이도 작동합니다. 모든 데이터 유형에서 작동합니다. Stringint, double 또는 char과 같이 바꿉니다. 매우 효율적으로 작동합니다.

0
Yashovardhan99

비 자바 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

이것은 아마도 유일한 범용 및 유형 안전 방식입니다.

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

사용법은 매우 간결합니다.

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

(정적 가져 오기 필요)

유효하지 않은 배열 유형이 거부되었습니다.

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

이것은 int로만 작동하지만 아이디어는 일반적인 것입니다.

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

이 우아한 솔루션을 살펴보십시오 (char가 아닌 다른 유형이 필요한 경우 변경하십시오).

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

모든 배열 수를 연결할 수 있습니다.

0
filosofem

이것은 아마도 유일한 범용 및 유형 안전 방식입니다.

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

사용법은 매우 간결합니다.

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

(정적 가져 오기 필요)

유효하지 않은 배열 유형이 거부되었습니다.

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

알고리즘 애호가를위한 또 다른 대답은 다음과 같습니다.

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;

용법:

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

결과:

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

속임수를 써야 해. 이것은 String []을 먼저 가정하고 String []을 두 번째로 가정합니다.

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

나는 코드 아래에서 테스트를하고 ok 작업을했다.

또한 라이브러리를 사용하고 있습니다 : 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]);
        }
    }
}

문안 인사

0
bhektor