重複の可能性:
Javaで2つの配列を連結する方法は?
私は2つのオブジェクトを持っています
HealthMessage[] healthMessages1;
HealthMessage[] healthMessages2;
HealthMessage[] healthMessagesAll;
healthMessages1 = x.getHealth( );
healthMessages2 = y.getHealth( );
2 つのオブジェクトを結合して、1 つだけを返すにはどうすればよいですか。
return healthMessagesAll;
おすすめの方法は？
Apache CommonsCollectionsAPIを使用するのは良い方法です。
healthMessagesAll = ArrayUtils.addAll(healthMessages1,healthMessages2);
全長がhealthMessages1andの配列を割り当て、その内容をコピーするために1つまたは2つのループをhealthMessages2使用します。これがサンプルです：System.arraycopyforSystem.arraycopy
public class HelloWorld {
public static void main(String []args) {
int[] a = new int[] { 1, 2, 3};
int[] b = new int[] { 3, 4, 5};
int[] r = new int[a.length + b.length];
System.arraycopy(a, 0, r, 0, a.length);
System.arraycopy(b, 0, r, a.length, b.length);
// prints 1, 2, 3, 4, 5 on sep. lines
for(int x : r) {
System.out.println(x);
}
}
}
これはより直感的に記述でき、配列インデックスを扱う必要はありません。
Collection<HealthMessage> collection = new ArrayList<HealthMessage>();
collection.addAll(Arrays.asList(healthMessages1));
collection.addAll(Arrays.asList(healthMessages2));
HealthMessage[] healthMessagesAll = collection.toArray(new HealthMessage[] {});
..しかし、それとは対照的に、そのパフォーマンスについて私に尋ねないでくださいSystem.arraycopy。
私は一緒に行きますSystem.arraycopy
private static HealthMessage[] join(HealthMessage[] healthMessages1, HealthMessage[] healthMessages2)
{
HealthMessage[] healthMessagesAll = new HealthMessage[healthMessages1.length + healthMessages2.length];
System.arraycopy(healthMessages1, 0, healthMessagesAll, 0, healthMessages1.length);
System.arraycopy(healthMessages2, 0, healthMessagesAll, healthMessages1.length, healthMessages2.length);
return healthMessagesAll;
}
そして、最も複雑でメモリへの負荷が最も少ないソリューションの場合、それらをオブジェクトにラップすることができます。これは、Iterator<T>すべてのアイテムとcopyTo、新しい配列にコピーする方法を提供します。ゲッターとセッターを提供するために簡単に拡張できます。
public class JoinedArray<T> implements Iterable<T> {
final List<T[]> joined;
// Pass all arrays to be joined as constructor parameters.
public JoinedArray(T[]... arrays) {
joined = Arrays.asList(arrays);
}
// Iterate across all entries in all arrays (in sequence).
public Iterator<T> iterator() {
return new JoinedIterator<T>(joined);
}
private class JoinedIterator<T> implements Iterator<T> {
// The iterator across the arrays.
Iterator<T[]> i;
// The array I am working on. Equivalent to i.next without the hassle.
T[] a;
// Where we are in it.
int ai;
// The next T to return.
T next = null;
private JoinedIterator(List<T[]> joined) {
i = joined.iterator();
a = nextArray();
}
private T[] nextArray () {
ai = 0;
return i.hasNext() ? i.next() : null;
}
public boolean hasNext() {
if (next == null) {
// a goes to null at the end of i.
if (a != null) {
// End of a?
if (ai >= a.length) {
// Yes! Next i.
a = nextArray();
}
if (a != null) {
next = a[ai++];
}
}
}
return next != null;
}
public T next() {
T n = null;
if (hasNext()) {
// Give it to them.
n = next;
next = null;
} else {
// Not there!!
throw new NoSuchElementException();
}
return n;
}
public void remove() {
throw new UnsupportedOperationException("Not supported.");
}
}
public int copyTo(T[] to, int offset, int length) {
int copied = 0;
// Walk each of my arrays.
for (T[] a : joined) {
// All done if nothing left to copy.
if (length <= 0) {
break;
}
if (offset < a.length) {
// Copy up to the end or to the limit, whichever is the first.
int n = Math.min(a.length - offset, length);
System.arraycopy(a, offset, to, copied, n);
offset = 0;
copied += n;
length -= n;
} else {
// Skip this array completely.
offset -= a.length;
}
}
return copied;
}
public int copyTo(T[] to, int offset) {
return copyTo(to, offset, to.length);
}
public int copyTo(T[] to) {
return copyTo(to, 0);
}
@Override
public String toString() {
StringBuilder s = new StringBuilder();
Separator comma = new Separator(",");
for (T[] a : joined) {
s.append(comma.sep()).append(Arrays.toString(a));
}
return s.toString();
}
public static void main(String[] args) {
JoinedArray<String> a = new JoinedArray<String>(
new String[]{
"One"
},
new String[]{
"Two",
"Three",
"Four",
"Five"
},
new String[]{
"Six",
"Seven",
"Eight",
"Nine"
});
for (String s : a) {
System.out.println(s);
}
String[] four = new String[4];
int copied = a.copyTo(four, 3, 4);
System.out.println("Copied " + copied + " = " + Arrays.toString(four));
}
}
配列は固定長であるため、さまざまな選択肢があります。ここにいくつかあります：
a) 他のサイズの新しい配列を作成し、すべての要素を手動でコピーします。
healthMessagesAll = new HealthMessage[healthMessages1.length + healthMessages2.length];
int i = 0;
for (HealthMessage msg : healthMessases1)
{
healthMessagesAll[i] = msg;
i++;
}
for (HealthMessage msg : healthMessages2)
{
healthMessagesAll[i] = msg;
i++;
}
b) Arraysクラスによって提供されるメソッドを使用します。配列をリストに変換したり、要素をまとめてコピーしたりできます。提供される機能を見て、自分に合ったものを選択してください。
アップデート
重複についてのコメントを参照してください。Set一意性を保証するにすべてを入れたいと思うかもしれません。同じ要素を 2 回追加すると、2 回目は追加されません。独自のtoArray()メソッドを持つ配列が明示的に必要な場合は、Set を配列に戻すことができます。
他の回答者が示唆しているように、System.arraycopy()は要素の内容をコピーするのにも役立つため、上記の代替 (a) の短いバージョンです。
この道に沿って何かはどうですか：
List<String> l1 = Arrays.asList(healthMessages1);
l1.addAll(Arrays.asList(healthMessages2));
HealthMessage[] result = l1.toArray();
（少し一般化する必要があります... :)