我需要String在 Java 中连接两个数组。
void f(String[] first, String[] second) {
String[] both = ???
}
最简单的方法是什么？
Antti Sykäri
问问题
1249334 次
64 回答
1220
我从旧的 Apache Commons Lang 库中找到了一个单行解决方案。
ArrayUtils.addAll(T[], T...)
代码：
String[] both = ArrayUtils.addAll(first, second);
于 2008-09-17T06:34:37.023 回答
787
这是一个简单的方法，它将连接两个数组并返回结果：
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 }));
于 2008-09-17T06:20:25.543 回答
547
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));
于 2014-04-20T23:52:12.923 回答
491
可以编写一个完全通用的版本，甚至可以扩展为连接任意数量的数组。这个版本需要 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;
}
于 2009-04-24T07:28:01.373 回答
200
或与心爱的番石榴：
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)
于 2011-03-09T15:19:39.390 回答
140
您可以在两行代码中附加两个数组。
String[] both = Arrays.copyOf(first, first.length + second.length);
System.arraycopy(second, 0, both, first.length, second.length);
这是一个快速有效的解决方案，适用于原始类型以及所涉及的两种方法被重载。
您应该避免涉及 ArrayLists、流等的解决方案，因为这些将需要分配临时内存而没有任何用处。
您应该避免for大型数组的循环，因为它们效率不高。内置方法使用速度极快的块复制功能。
于 2018-04-11T10:17:49.983 回答
59
使用 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()]);
}
于 2008-09-18T20:59:06.157 回答
43
一个100% 旧的 java解决方案，没有 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;
}
于 2011-10-11T10:54:01.030 回答
34
我最近解决了过度记忆旋转的问题。如果已知 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;
}
编辑：这篇文章的前一个版本指出，这样的数组重用应该被清楚地记录下来。正如 Maarten 在评论中指出的那样，通常最好只删除 if 语句，从而避免需要文档。但话又说回来，那些 if 语句首先是这个特定优化的重点。我会在这里留下这个答案，但要小心！
于 2008-09-17T16:52:36.210 回答
27
Functional Java库有一个数组包装类，它为数组配备了方便的方法，如连接。
import static fj.data.Array.array;
...接着
Array<String> both = array(first).append(array(second));
要取出未包装的数组，请调用
String[] s = both.array();
于 2008-09-17T06:52:12.080 回答
27
ArrayList<String> both = new ArrayList(Arrays.asList(first));
both.addAll(Arrays.asList(second));
both.toArray(new String[0]);
于 2013-08-21T06:27:09.633 回答
19
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);
}
于 2016-02-10T12:48:08.893 回答
17
这是对 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 解决方案的回答。它不仅消除了警告；它也更短、更高效、更易于阅读！
于 2008-09-17T16:47:47.547 回答
13
如果您使用这种方式，那么您无需导入任何第三方类。
如果你想连接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));
}
}
我们也可以使用这种方式。
于 2017-02-13T10:17:06.880 回答
13
您可以尝试将其转换为 Arraylist 并使用 addAll 方法，然后再转换回数组。
List list = new ArrayList(Arrays.asList(first));
list.addAll(Arrays.asList(second));
String[] both = list.toArray();
于 2015-11-14T18:45:36.427 回答
11
请原谅我在这个已经很长的列表中添加另一个版本。我查看了每个答案，并决定我真的想要一个签名中只有一个参数的版本。我还添加了一些参数检查，以便在意外输入的情况下从早期失败中受益，并提供合理的信息。
@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;
}
于 2012-07-13T12:08:42.240 回答
10
使用 Java 8+ 流，您可以编写以下函数：
private static String[] concatArrays(final String[]... arrays) {
return Arrays.stream(arrays)
.flatMap(Arrays::stream)
.toArray(String[]::new);
}
于 2018-10-23T13:29:08.810 回答
8
这应该是单行的。
public String [] concatenate (final String array1[], final String array2[])
{
return Stream.concat(Stream.of(array1), Stream.of(array2)).toArray(String[]::new);
}
于 2018-10-27T18:52:33.340 回答
7
这里是由 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]);
}
}
于 2012-01-04T14:35:54.947 回答
6
这可行，但您需要插入自己的错误检查。
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 以外的任何东西。
于 2009-04-24T07:12:41.193 回答
6
哇！这里有很多复杂的答案，包括一些依赖于外部依赖的简单答案。这样做怎么样：
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]);
于 2012-10-28T20:23:12.990 回答
6
使用高性能 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;
}
于 2018-11-06T23:02:54.220 回答
5
允许连接多个数组的简单变体：
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()]);
}
于 2009-06-18T12:07:45.397 回答
5
这是字符串数组的转换函数：
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;
}
于 2011-06-11T19:59:56.370 回答
5
简单点怎么样
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属于同一类型，这将为您提供另一个包含两个数组的相同类型的数组。
于 2011-10-12T00:15:35.327 回答
4
怎么样 ：
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()]);
}
于 2015-02-11T23:35:38.973 回答
4
这是我稍微改进的 Joachim Sauer 的 concatAll 版本。它可以在 Java 5 或 6 上运行，如果它在运行时可用，则使用 Java 6 的 System.arraycopy。此方法（恕我直言）非常适合 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;
}
于 2011-06-09T15:48:05.237 回答
4
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;
}
于 2010-12-29T07:29:11.063 回答
4
另一种思考问题的方式。要连接两个或多个数组，必须列出每个数组的所有元素，然后构建一个新数组。这听起来像是创建一个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. 不过我觉得这个有它自己的美。
于 2013-02-27T03:03:56.277 回答
4
这可能是唯一通用且类型安全的方法：
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
于 2019-03-24T04:22:43.697 回答
4
这是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"]
于 2016-11-28T23:20:24.503 回答
3
与类型无关的变体（已更新 - 感谢 Volley 实例化 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()));
}
于 2009-06-18T12:13:48.207 回答
3
一种简单但低效的方法（不包括泛型）：
ArrayList baseArray = new ArrayList(Arrays.asList(array1));
baseArray.addAll(Arrays.asList(array2));
String concatenated[] = (String []) baseArray.toArray(new String[baseArray.size()]);
于 2009-04-24T15:52:46.060 回答
3
仅使用 Java 自己的 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[]（甚至是零数组）。
于 2008-09-17T08:02:41.100 回答
3
String [] both = new ArrayList<String>(){{addAll(Arrays.asList(first)); addAll(Arrays.asList(second));}}.toArray(new String[0]);
于 2013-06-21T12:59:12.240 回答
3
我发现我必须处理数组可以为空的情况......
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;
}
于 2012-04-30T10:55:35.063 回答
3
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()]);
}
于 2016-02-26T05:18:45.123 回答
3
每个答案都是复制数据并创建一个新数组。这不是绝对必要的，如果您的数组相当大，这绝对不是您想要做的。Java 的创建者已经知道数组复制是浪费的，这就是为什么他们提供给我们 System.arrayCopy() 来在我们必须的时候在 Java 之外做这些事情。
与其复制您的数据，不如考虑将其留在原处并从中提取数据。仅仅因为程序员想要组织它们而复制数据位置并不总是明智的。
// 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
}
于 2016-09-04T22:54:10.360 回答
2
另一个基于 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;
}
于 2011-01-01T16:27:38.667 回答
2
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
您可以用您喜欢的类型/类替换字符串
我相信这可以做得更短更好，但它有效，我懒得进一步整理......
于 2011-07-14T10:30:44.890 回答
2
如果您想在解决方案中使用 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()]);
}
于 2008-09-25T18:57:51.993 回答
2
我认为使用泛型的最佳解决方案是：
/* 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;
}
于 2014-07-29T23:03:01.180 回答
1
非 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;
}
于 2018-09-17T21:02:38.047 回答
1
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;
}
于 2015-10-08T14:27:34.980 回答
0
你可以试试这个
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;
}
你可以输入你的数组！
于 2011-07-21T13:58:19.600 回答
0
我测试了下面的代码并且工作正常
我也在使用库：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]);
}
}
}
问候
于 2009-04-01T22:15:50.170 回答
0
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];
于 2011-03-31T09:12:01.283 回答
0
这个只适用于 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];
}
于 2014-01-03T12:21:08.857 回答
0
我能找到的最简单的方法如下：
List allFiltersList = Arrays.asList(regularFilters);
allFiltersList.addAll(Arrays.asList(preFiltersArray));
Filter[] mergedFilterArray = (Filter[]) allFiltersList.toArray();
于 2011-06-10T04:14:31.870 回答
0
在 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));
}
于 2018-04-12T09:53:37.620 回答
0
使用 Java 集合
好吧，Java 没有提供连接数组的辅助方法。但是，从 Java 5 开始，Collections 实用程序类引入了 addAll(Collection<? super T> c, T... elements) 方法。
我们可以创建一个 List 对象，然后调用该方法两次，将两个数组添加到列表中。最后，我们将生成的 List 转换回数组：
static <T> T[] concatWithCollection(T[] array1, T[] array2) {
List<T> resultList = new ArrayList<>(array1.length + array2.length);
Collections.addAll(resultList, array1);
Collections.addAll(resultList, array2);
@SuppressWarnings("unchecked")
//the type cast is safe as the array1 has the type T[]
T[] resultArray = (T[]) Array.newInstance(array1.getClass().getComponentType(), 0);
return resultList.toArray(resultArray);
}
测试
@Test
public void givenTwoStringArrays_whenConcatWithList_thenGetExpectedResult() {
String[] result = ArrayConcatUtil.concatWithCollection(strArray1, strArray2);
assertThat(result).isEqualTo(expectedStringArray);
}
于 2021-09-13T04:54:32.607 回答
0
您可以尝试这种连接多个数组的方法：
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;
}
于 2017-10-27T10:16:04.387 回答
0
我使用下一个方法使用 java 8 连接任意数量的相同类型的数组：
public static <G> G[] concatenate(IntFunction<G[]> generator, G[] ... arrays) {
int len = arrays.length;
if (len == 0) {
return generator.apply(0);
} else if (len == 1) {
return arrays[0];
}
int pos = 0;
Stream<G> result = Stream.concat(Arrays.stream(arrays[pos]), Arrays.stream(arrays[++pos]));
while (pos < len - 1) {
result = Stream.concat(result, Arrays.stream(arrays[++pos]));
}
return result.toArray(generator);
}
用法：
concatenate(String[]::new, new String[]{"one"}, new String[]{"two"}, new String[]{"three"})
或者
concatenate(Integer[]::new, new Integer[]{1}, new Integer[]{2}, new Integer[]{3})
于 2020-12-28T20:58:29.683 回答
0
算法爱好者的另一个答案：
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]
于 2017-10-03T10:31:41.723 回答
0
只是想添加，您也可以使用System.arraycopy：
import static java.lang.System.out;
import static java.lang.System.arraycopy;
import java.lang.reflect.Array;
class Playground {
@SuppressWarnings("unchecked")
public static <T>T[] combineArrays(T[] a1, T[] a2) {
T[] result = (T[]) Array.newInstance(a1.getClass().getComponentType(), a1.length+a2.length);
arraycopy(a1,0,result,0,a1.length);
arraycopy(a2,0,result,a1.length,a2.length);
return result;
}
public static void main(String[ ] args) {
String monthsString = "JANFEBMARAPRMAYJUNJULAUGSEPOCTNOVDEC";
String[] months = monthsString.split("(?<=\\G.{3})");
String daysString = "SUNMONTUEWEDTHUFRISAT";
String[] days = daysString.split("(?<=\\G.{3})");
for (String m : months) {
out.println(m);
}
out.println("===");
for (String d : days) {
out.println(d);
}
out.println("===");
String[] results = combineArrays(months, days);
for (String r : results) {
out.println(r);
}
out.println("===");
}
}
于 2020-02-01T13:52:40.363 回答
0
刚发现这个问题，不好意思很晚，看到很多答案太远了，使用某些库，使用将数据从数组转换为流再返回数组的特性等等。但是，我们可以只使用一个简单的循环，问题就解决了
public String[] concat(String[] firstArr,String[] secondArr){
//if both is empty just return
if(firstArr.length==0 && secondArr.length==0)return new String[0];
String[] res = new String[firstArr.length+secondArr.length];
int idxFromFirst=0;
//loop over firstArr, idxFromFirst will be used as starting offset for secondArr
for(int i=0;i<firstArr.length;i++){
res[i] = firstArr[i];
idxFromFirst++;
}
//loop over secondArr, with starting offset idxFromFirst (the offset track from first array)
for(int i=0;i<secondArr.length;i++){
res[idxFromFirst+i]=secondArr[i];
}
return res;
}
就是这样，对吧？他没有说他关心订单或任何事情。这应该是最简单的方法。
于 2021-01-14T21:50:44.533 回答
0
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;
于 2016-07-19T01:55:15.637 回答
0
使用 lambda 连接一系列紧凑、快速且类型安全的数组
@SafeVarargs
public static <T> T[] concat( T[]... arrays ) {
return( Stream.of( arrays ).reduce( ( arr1, arr2 ) -> {
T[] rslt = Arrays.copyOf( arr1, arr1.length + arr2.length );
System.arraycopy( arr2, 0, rslt, arr1.length, arr2.length );
return( rslt );
} ).orElse( null ) );
};
null不带参数调用时返回
例如。带有 3 个数组的示例：
String[] a = new String[] { "a", "b", "c", "d" };
String[] b = new String[] { "e", "f", "g", "h" };
String[] c = new String[] { "i", "j", "k", "l" };
concat( a, b, c ); // [a, b, c, d, e, f, g, h, i, j, k, l]
“……可能是唯一通用且类型安全的方式” ——改编：
Number[] array1 = { 1, 2, 3 };
Number[] array2 = { 4.0, 5.0, 6.0 };
Number[] array = concat( array1, array2 ); // [1, 2, 3, 4.0, 5.0, 6.0]
于 2019-10-28T08:15:27.703 回答
-1
在 Haskell 中，您可以执行类似的操作[a, b, c] ++ [d, e]来获取[a, b, c, d, e]. 这些是串联的 Haskell 列表，但很高兴在 Java 中看到类似的数组运算符。你不这么认为吗？这是优雅、简单、通用的，实现起来并不难。
如果你愿意，我建议你看看 Alexander Hristov 在他的Hacking the OpenJDK compiler中的工作。他解释了如何修改 javac 源代码以创建新的运算符。他的示例包括定义一个 '**' 运算符 where i ** j = Math.pow(i, j)。可以举这个例子来实现一个连接两个相同类型数组的运算符。
一旦你这样做了，你就会绑定到你定制的 javac 来编译你的代码，但是生成的字节码将被任何 JVM 理解。
当然，您可以在源代码级别实现自己的数组连接方法，其他答案中有很多关于如何做到这一点的示例！
有很多有用的运算符可以添加，这个就是其中之一。
于 2012-03-01T08:18:31.960 回答
-1
看看这个优雅的解决方案（如果您需要 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;
}
}
您可以连接每个数组。
于 2012-04-07T17:50:13.927 回答
-1
应该做的伎俩。这是假设 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()]);
于 2013-10-29T19:00:10.117 回答
-1
我有一个简单的方法。您不想浪费时间研究复杂的 java 函数或库。但返回类型应该是字符串。
String[] f(String[] first, String[] second) {
// Variable declaration part
int len1 = first.length;
int len2 = second.length;
int lenNew = len1 + len2;
String[] both = new String[len1+len2];
// For loop to fill the array "both"
for (int i=0 ; i<lenNew ; i++){
if (i<len1) {
both[i] = first[i];
} else {
both[i] = second[i-len1];
}
}
return both;
}
很简单...
于 2021-06-13T16:22:52.950 回答
-1
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];
}
这个可以在不了解任何其他类/库等的情况下工作。它适用于任何数据类型。只需用,或String之类的东西替换。它的工作效率很高。intdoublechar
于 2016-12-06T08:39:26.943 回答
-2
这对我有用：
String[] data=null;
String[] data2=null;
ArrayList<String> data1 = new ArrayList<String>();
for(int i=0; i<2;i++) {
data2 = input.readLine().split(",");
data1.addAll(Arrays.asList(data2));
data= data1.toArray(new String[data1.size()]);
}
于 2020-02-12T12:54:26.737 回答