ජාවා හි අරා දෙකක් සංයුක්ත කරන්නේ කෙසේද?

මට Stringජාවාහි අරා දෙකක් සංයුක්ත කිරීමට අවශ්‍යයි .

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

මෙය කිරීමට පහසුම ක්‍රමය කුමක්ද?

හොඳ පැරණි අපාචේ කොමන්ස් ලැන්ග් පුස්තකාලයෙන් මට එක පේළියේ විසඳුමක් හමු විය.
ArrayUtils.addAll(T[], T...)

කේතය:

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

අරා දෙකක් සමපාත කර ප්‍රති result ලය ලබා දෙන සරල ක්‍රමයක් මෙන්න:

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[].

ප්‍රති .ලයේ සං type ටක වර්ගය ලෙස වඩාත් සාමාන්‍ය වර්ගය තෝරා ගැනීමෙන් විවිධ වර්ග දෙකක අරා සංයුක්ත කිරීමට ද එය සමත් වේ.

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

ඕනෑම අරා ගණනක් සංයුක්ත කිරීම සඳහා පවා දීර් can කළ හැකි පූර්ණ ජනක අනුවාදයක් ලිවිය හැකිය. මෙම අනුවාදයන් භාවිතා කරන පරිදි ජාවා 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ජාවා 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);

මෙය වේගවත් හා කාර්යක්ෂම විසඳුමක් වන අතර එය ප්‍රාථමික වර්ග සඳහා ක්‍රියා කරනු ඇති අතර ඊට සම්බන්ධ ක්‍රම දෙක අධික ලෙස පටවා ඇත.

අරා ලැයිස්තු, ධාරා යනාදිය සම්බන්ධ විසඳුම් වලින් ඔබ වැළකී සිටිය යුතුය.

forමේවා කාර්යක්ෂම නොවන බැවින් විශාල අරා සඳහා ලූප වළක්වා ගත යුතුය . ගොඩනංවන ලද ක්‍රම අතිශයින්ම වේගවත් බ්ලොක්-පිටපත් කාර්යයන් භාවිතා කරයි.

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

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 සාමාන්‍යයෙන් හිස් බව දන්නා නම්, මෙන්න සිල්වර්ටැබ් කේතයේ තවත් අනුවර්තනයක් (සාමාන්‍යකරණය කරන ලද):

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

සංස්කරණය කරන්න: මෙම ලිපියේ පෙර අනුවාදයක සඳහන් වූයේ මෙවැනි අරා නැවත භාවිතා කිරීම පැහැදිලිව ලේඛනගත කළ යුතු බවයි. මාර්ටන් අදහස් දැක්වීමේදී පෙන්වා දෙන පරිදි, සාමාන්‍යයෙන් නම් ප්‍රකාශ ඉවත් කිරීම වඩා හොඳ වනු ඇත. නමුත් නැවතත්, ප්‍රකාශයන් නම් මෙම විශේෂිත ප්‍රශස්තිකරණයේ මුලික ලක්ෂ්‍යයයි. මම මෙම පිළිතුර මෙහි තබමි, නමුත් ප්‍රවේශම් වන්න!

මෙම ක්රියාකාරී ජාවා පුස්තකාල අකාර වැනි ප්රයෝජනවත් ක්රම සමග පෙලගැස්මක් සූදානම් කරවන මාලාවක් දවටනය පන්තියේ ඇත.

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

ධාරාව භාවිතා කරමින් ජාවා 8 සමඟ තවත් ක්‍රමයක්

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

මෙන්න සිල්වර්ටැබ්ගේ විසඳුමේ අනුවර්තනයක්, ජනක විද්‍යාව නැවත සකස් කර ඇත:

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

සටහන: ජාවා 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

සමෝධානික අරා දෙකක නියැදි කේතය

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

        }
    }  

අපට මේ ආකාරයෙන්ද භාවිතා කළ හැකිය.

ඔබට එය අරා ලැයිස්තුවක් බවට පරිවර්තනය කර addAll ක්‍රමය භාවිතා කර නැවත අරාවකට පරිවර්තනය කළ හැකිය.

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

දැනටමත් දිගු ලැයිස්තුවට තවත් සංස්කරණයක් එක් කිරීම ගැන කරුණාකර මට සමාව දෙන්න. මම සෑම පිළිතුරක්ම බැලූ අතර අත්සනෙහි එක් පරාමිතියක් සහිත අනුවාදයක් මට අවශ්‍ය බව තීරණය කළෙමි. අනපේක්ෂිත ආදානයකදී සංවේදී තොරතුරු සමඟ මුල් අසමත් වීමෙන් ප්‍රයෝජන ලබා ගැනීම සඳහා මම යම් තර්ක පරීක්‍ෂණයක් එකතු කළෙමි.

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

ජාවා 8+ ධාරාවන් භාවිතා කිරීමෙන් ඔබට පහත ශ්‍රිතය ලිවිය හැකිය:

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

සිල්වර්ටැබ් විසින් ලියන ලද ව්‍යාජ කේත විසඳුමේ ක්‍රියාකාරී කේතයේ ක්‍රියාත්මක කිරීමක් මෙහි දැක්වේ.

ස්තූතියි සිල්වර්ටැබ්!

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

එය බොහෝ විට වඩාත්ම කාර්යක්ෂම නොවේ, නමුත් එය ජාවාගේම ඒපීඅයි හැර වෙනත් කිසිවක් මත රඳා නොපවතී.

මෙය සංගීත අරා සඳහා පරිවර්තනය කළ ශ්‍රිතයකි:

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පවතින තාක් කල් , මෙය ඔබට අරා දෙකම අඩංගු එකම වර්ගයේ තවත් පෙළක් ලබා දෙනු ඇත.

UppSuppressWarnings විවරණයකින් තොරව ඉහළ ක්‍රියාකාරී 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;
}

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

මෙන්න මගේ තරමක් වැඩිදියුණු කළ ජොකිම් සෝවර්ගේ කොන්කාට් ඇල්. එය ජාවා 5 හෝ 6 මත වැඩ කළ හැකි අතර, ජාවා 6 හි System.arraycopy භාවිතා කර එය ක්‍රියාත්මක වේලාවේ තිබේ නම්. මෙම ක්‍රමය (IMHO) ඇන්ඩ්‍රොයිඩ් සඳහා පරිපූර්ණයි, එය ඇන්ඩ්‍රොයිඩ් <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 පමණක් භාවිතා කිරීම:

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

දැන්, මෙම කේතය වඩාත්ම කාර්යක්ෂම නොවේ, නමුත් එය රඳා පවතින්නේ සම්මත ජාවා පන්ති මත පමණක් වන අතර එය තේරුම් ගැනීමට පහසුය. එය ඕනෑම සංගීත සංඛ්‍යාවක් සඳහා ක්‍රියා කරයි [] (ශුන්‍ය අරා පවා).