现在要处理字符串二维两数组的数据，把它们合并成一个，大家没有高效果的方法，希望给点意见，谢谢
[b]问题补充：[/b]
呵呵 谢谢 楼上的几位大哥。。。
比较大的字符串的[color=red]二维数组[/color]，大家都是一维的，不过还谢谢大家，我现在的处理方法是bohemia 的方式。
是比较慢。。。。。

如果不需要去重的话

[code="java"]
String[] a = new String[3];
a[0] = "0";
a[1] = "1";
a[2] = "2";

        String[] b = new String[3];
        b[0] = "0";
        b[1] = "1";
        b[2] = "2";

        String[] c = new String[a.length + b.length];

        for (int j = 0; j < a.length; ++j) {
            c[j] = a[j];
        }

        for (int j = 0; j < b.length; ++j) {
            c[a.length + j] = b[j];
        }

[/code]

比上面的效率要高很多。

需要去重不？

[code="java"] String[] srcStrings1 = new String[4];
srcStrings1[0] = "0";
srcStrings1[1] = "1";
srcStrings1[2] = "2";
srcStrings1[3] = "3";
String[] srcStrings2 = new String[5];
srcStrings2[0] = "4";
srcStrings2[1] = "5";
srcStrings2[2] = "6";
srcStrings2[3] = "7";
srcStrings2[4] = "8";
String[] destStrings = new String[srcStrings1.length + srcStrings2.length];
System.arraycopy(srcStrings1, 0, destStrings, 0, srcStrings1.length);
System.arraycopy(srcStrings2, 0, destStrings, srcStrings1.length, srcStrings2.length);
for (String str:destStrings){
System.out.println(str);
}
[/code]

感觉做多了程序,要注重效率,就减少间接,直接操作; 类似taopian的;
如果要注重可读性,就增加间接,例如OO;

呵呵. 都是在权衡适合的方法..

还是我这个方案最快，哈哈。

是这个样子的，你交给Java的类库去干，估计他加了很多额外的操作。

如果python的话:

a = ['1','2','3'];
b = ['1','2','3'];
c = a+b; //得到结果
c = set(a)|set(b) //去重.

呵呵.

[quote]是这个样子的，你交给Java的类库去干，估计他加了很多额外的操作。[/quote]
请查一查Java API的System.arraycopy，可是用native方法的哟！Java操作和native那个快？

这个你就错了吧，Java可恶的就是，无论啥都去用native，你仔细想想，调用native肯定效率没有java自己搞定的快的。

你可以测试一下我的方法，和你的方法，我的比你快三倍左右。

我循环了100000次，你可以测试一下。

你可以测试一下我的方法，和你的方法，我的比你快三倍左右。
我循环了100000次，你可以测试一下。
请将两个数组的length调整到10000，再试试看结果。采用System.arraycopy和直接操作的，在我的机器上：124596/596165。
[quote]这个你就错了吧，Java可恶的就是，无论啥都去用native，你仔细想想，调用native肯定效率没有java自己搞定的快的[/quote]
SUN采用此方法是一种设计决策。在涉及到效率问题的时候，一般采用这种策略，譬如zip算法，密码学等等。

构建二叉树！

构建二叉树或者链表，随便你用java方法还是native方法

System.arraycopy(srcStrings1, 0, destStrings, 0, srcStrings1.length);

System.arraycopy(srcStrings2, 0, destStrings, srcStrings1.length, srcStrings2.length);

是最高效的了， native code 完成的， 你可以去看看代码。

楼主， 可以结贴咯。

public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);

java如何把两个二维数组合并成一个二位数组?

如果要效率.就字符直接复制,ArrayCopy都是高效的;

[code="java"] String[] a = new String[3];
a[0] = "0";
a[1] = "1";
a[2] = "2";

    String[] b = new String[3];
    b[0] = "0";
    b[1] = "1";
    b[2] = "2";

    List aL = Arrays.asList(a);
    List bL = Arrays.asList(b);

    System.out.println(aL); 
    System.out.println(bL); 


    List resultList = new ArrayList();
    resultList.addAll(aL);
    resultList.addAll(bL);

    Object[] result = resultList.toArray();[/code]