ฉันจะต่อสองอาร์เรย์ใน Java ได้อย่างไร

ฉันต้องต่อสองStringอาร์เรย์ใน Java

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

วิธีที่ง่ายที่สุดในการทำเช่นนี้คืออะไร?

ฉันพบโซลูชันบรรทัดเดียวจากห้องสมุด Apache Commons Lang เก่าที่ดี
ArrayUtils.addAll(T[], T...)

รหัส:

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

ต่อไปนี้เป็นวิธีการง่ายๆที่จะต่อกันสองอาร์เรย์และส่งคืนผลลัพธ์:

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[]ประเภทอาร์กิวเมนต์

นอกจากนี้ยังทำให้สามารถเชื่อมต่ออาร์เรย์ของสองประเภทที่แตกต่างกันได้โดยเลือกประเภททั่วไปมากที่สุดเป็นประเภทส่วนประกอบของผลลัพธ์

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

เป็นไปได้ที่จะเขียนเวอร์ชันทั่วไปอย่างสมบูรณ์ที่สามารถขยายเพื่อต่อเชื่อมอาร์เรย์จำนวนเท่าใดก็ได้ รุ่นนี้ต้องการ 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;
}

ใช้Streamใน Java 8:

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

หรือเช่นนี้โดยใช้flatMap:

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

ในการทำเช่นนี้สำหรับประเภททั่วไปคุณต้องใช้การสะท้อนภาพ:

@SuppressWarnings("unchecked")
T[] both = Stream.concat(Arrays.stream(a), Arrays.stream(b)).toArray(
    size -> (T[]) Array.newInstance(a.getClass().getComponentType(), size));

หรือกับฝรั่งที่รัก:

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)

คุณสามารถผนวกสองอาร์เรย์ในโค้ดสองบรรทัด

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

นี่เป็นวิธีแก้ปัญหาที่รวดเร็วและมีประสิทธิภาพและจะทำงานสำหรับประเภทดั้งเดิมรวมถึงวิธีการสองวิธีที่เกี่ยวข้องกับการโอเวอร์โหลด

คุณควรหลีกเลี่ยงการแก้ปัญหาที่เกี่ยวข้องกับ ArrayLists, สตรีม, ฯลฯ เนื่องจากสิ่งเหล่านี้จะต้องจัดสรรหน่วยความจำชั่วคราวสำหรับจุดประสงค์ที่ไม่มีประโยชน์

คุณควรหลีกเลี่ยงการforวนซ้ำสำหรับอาร์เรย์ขนาดใหญ่เนื่องจากสิ่งเหล่านี้ไม่มีประสิทธิภาพ วิธีการในตัวใช้ฟังก์ชั่นการคัดลอกบล็อกที่รวดเร็วมาก

ใช้ 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()]);
}

วิธีแก้ปัญหาjava เก่าและไม่มี 100%System.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;
}

ฉันเพิ่งต่อสู้กับปัญหาการหมุนหน่วยความจำมากเกินไป หาก a และ / หรือ b เป็นที่รู้กันทั่วไปว่าว่างเปล่านี่คือการดัดแปลงรหัสของ silvertab (สร้างขึ้นด้วย):

private static <T> T[] concatOrReturnSame(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;
}

แก้ไข: เวอร์ชันก่อนหน้าของโพสต์นี้ระบุว่าการใช้อาร์เรย์ซ้ำเช่นนี้จะต้องมีการบันทึกไว้อย่างชัดเจน เมื่อมาร์เท่นชี้ให้เห็นในความคิดเห็นโดยทั่วไปแล้วจะเป็นการดีกว่าที่จะลบคำสั่ง if ออกดังนั้นจึงจำเป็นต้องมีเอกสารประกอบ แต่จากนั้นอีกครั้งข้อความเหล่านั้นถ้าเป็นจุดรวมของการเพิ่มประสิทธิภาพเฉพาะนี้ตั้งแต่แรก ฉันจะทิ้งคำตอบไว้ที่นี่ แต่ระวัง!

Java ทำงานห้องสมุดมีระดับอาร์เรย์เสื้อคลุมที่สวมใส่อาร์เรย์ด้วยวิธีการที่มีประโยชน์เช่นการเรียงต่อกัน

import static fj.data.Array.array;

... แล้ว

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

หากต้องการดึงอาเรย์ที่ยังไม่ได้เปิดออกให้โทรออก

String[] s = both.array();

ArrayList<String> both = new ArrayList(Arrays.asList(first));
both.addAll(Arrays.asList(second));

both.toArray(new String[0]);

อีกวิธีหนึ่งกับ Java8 โดยใช้ 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); 
  }

นี่คือการปรับเปลี่ยนโซลูชันของ 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 ไม่เพียงกำจัดคำเตือนเท่านั้น มันสั้นกว่ามีประสิทธิภาพกว่าและอ่านง่ายกว่า!

หากคุณใช้วิธีนี้คุณจึงไม่จำเป็นต้องนำเข้าคลาสบุคคลที่สามใด ๆ

หากคุณต้องการเชื่อมต่อ 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;
    }

หากคุณต้องการเชื่อมต่อ Int

โค้ดตัวอย่างสำหรับการต่อสอง 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));

        }
    }  

เราสามารถใช้วิธีนี้ได้เช่นกัน

โปรดยกโทษให้ฉันสำหรับการเพิ่มรุ่นอื่นลงในรายการที่มีความยาวแล้ว ฉันดูทุกคำตอบและตัดสินใจว่าฉันต้องการรุ่นที่มีพารามิเตอร์เพียงตัวเดียวในลายเซ็น ฉันยังเพิ่มการตรวจสอบข้อโต้แย้งบางอย่างเพื่อรับประโยชน์จากความล้มเหลวในช่วงต้นด้วยข้อมูลที่สมเหตุสมผลในกรณีที่มีการป้อนข้อมูลที่ไม่คาดคิด

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

คุณสามารถลองแปลงมันเป็น Arraylist และใช้เมธอด addAll จากนั้นแปลงกลับเป็นอาร์เรย์

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

การใช้ Java 8+ สตรีมคุณสามารถเขียนฟังก์ชันต่อไปนี้:

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

นี่คือการใช้งานที่เป็นไปได้ในรหัสการทำงานของโซลูชันรหัสเทียมที่เขียนโดย 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;
   }
}

ถัดไปคืออินเทอร์เฟซผู้สร้าง

หมายเหตุ: ตัวสร้างจำเป็นเพราะในจาวาไม่สามารถทำได้

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

นี่ควรเป็นหนึ่งซับ

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

ว้าว! มีคำตอบที่ซับซ้อนมากมายที่นี่รวมถึงคำตอบง่ายๆที่ขึ้นอยู่กับการอ้างอิงภายนอก วิธีทำแบบนี้:

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

ใช้งานได้ แต่คุณต้องแทรกการตรวจสอบข้อผิดพลาดของคุณเอง

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

มันอาจจะไม่ได้มีประสิทธิภาพมากที่สุด แต่ก็ไม่ได้พึ่งพา API ของ Java เอง

นี่คือฟังก์ชั่นที่แปลงแล้วสำหรับอาร์เรย์ 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;
}

วิธีการเกี่ยวกับเพียงแค่

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)และเพียงแค่ทำ ตราบใดที่arr1และarr2เป็นประเภทเดียวกันสิ่งนี้จะทำให้คุณได้อาร์เรย์ประเภทเดียวกันที่มีทั้งสองอาร์เรย์

เวอร์ชันสแตติกทั่วไปที่ใช้ System.arraycopy ที่มีประสิทธิภาพสูงโดยไม่ต้องการคำอธิบายประกอบ @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;
}

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

นี่คือ concatAll ของ Joachim Sauer ที่ได้รับการปรับปรุงเล็กน้อยของฉัน สามารถทำงานกับ Java 5 หรือ 6 ได้โดยใช้ System.arraycopy ของ Java 6 หากมีให้ใช้งานขณะใช้งานจริง วิธีนี้ (IMHO) เหมาะสำหรับ Android เพราะมันทำงานบน Android <9 (ซึ่งไม่มี System.arraycopy) แต่จะใช้วิธีที่เร็วกว่าถ้าเป็นไปได้

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

อีกวิธีในการคิดถึงคำถาม ในการเชื่อมต่อสองแถวหรือมากกว่าเข้าด้วยกันสิ่งที่ต้องทำคือรายการองค์ประกอบทั้งหมดของแต่ละอาร์เรย์จากนั้นสร้างอาร์เรย์ใหม่ ดูเหมือนว่าจะสร้าง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ผมเชื่อดังกล่าวข้างต้นจะเทียบเท่ากับการแก้ปัญหาที่ใช้ อย่างไรก็ตามฉันคิดว่าอันนี้มีความงามของตัวเอง

เกี่ยวกับ :

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

ชุดรูปแบบที่เรียบง่ายช่วยให้สามารถรวมอาร์เรย์ได้มากกว่าหนึ่งชุด:

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

ใช้ API ของ 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]);
}

ตอนนี้รหัสนี้ไม่ได้มีประสิทธิภาพมากที่สุด แต่มันอาศัยเฉพาะคลาส Java มาตรฐานและเข้าใจง่าย มันใช้งานได้กับจำนวนของ String [] (แม้จะมีอาร์เรย์เป็นศูนย์)