blocks|key|3634569|text|use+System.arrayCopy(src,src+start+index,destn,destn+start+index,destn+length)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|3634570|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>use System.arrayCopy(src,src start index,destn,destn start index,destn length)
</code></pre>

blocks|key|3634572|text|尝试使用ArrayUtils。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3634573|int+m[]+=+(int+[])ArrayUtils.addAll(x,y);|code-block|syntax|javascript|3634574|entityMap^0|4|A|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Try using ArrayUtils .

<pre><code>int m[] = (int [])ArrayUtils.addAll(x,y);
</code></pre>

blocks|key|3634601|text|一定要使用本机System.arraycopy。它具有O(n)复杂度，但由于处理器级对此类操作的支持，它的工作速度非常快。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3634602|java.util.Arrays.copyOf也会做得很好--它是使用System.arraycopy实现的。|3634603|entityMap^0|7|G|0|0|N|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

Use native System.arraycopy for sure. It has O(n) complexity, but works really fast due to processor-level support of such operation.

java.util.Arrays.copyOf will do as well - it's implemented using System.arraycopy.

blocks|key|3662437|text|我不认为你能找到一个O(1)算法这个任务。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3662438|我几乎肯定你的复杂性将是O(n)。|3662439|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

I do not think that you can find an O(1) algorithm this task. 

I am almost sure that your complexity will be O(n).

blocks|key|3634625|text|如果您需要一个密集矩阵，那么就更容易分配一大块大小为can的array[]，并将其封装在一个矩阵类中，该类可以将矩阵(r，c)转换为array[r*C+%2B+c]。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3634626|这样，您将只对内部array[]执行一个数组复制操作。|3634627|就像这样：|3634628|编辑：使用System.arraycopy()添加行主矩阵连接|BOLD|3634629|package+example;

import+java.util.Arrays;
import+java.util.Random;

public+class+Matrix+{
++++private+double[]+array;
++++int+R;
++++int+C;

++++Matrix(int+R,+int+C)+{
++++++++this.R+=+R;
++++++++this.C+=+C;
++++++++this.array+=+new+double[R+*+C];
++++}

++++Matrix(double[]+array,+int+R,+int+C)+{
++++++++this.R+=+R;
++++++++this.C+=+C;
++++++++this.array+=+array;
++++}

++++Matrix(Matrix+that)+{
++++++++this.R+=+that.R;
++++++++this.C+=+that.C;
++++++++array+=+Arrays.copyOf(that.array,+that.array.length);
++++}

++++public+void+set(int+r,+int+c,+double+value)+{
++++++++assert+(r+>=+0+&&+r+<+R);
++++++++assert+(c+>=+0+&&+c+<+C);
++++++++array[C+*+r+%2B+c]+=+value;
++++}

++++public+double+get(int+r,+int+c)+{
++++++++assert+(r+>=+0+&&+r+<+R);
++++++++assert+(c+>=+0+&&+c+<+C);
++++++++return+array[C+*+r+%2B+c];
++++}

++++public+static+Matrix+concatRows(Matrix+m1,+Matrix+m2)+{
++++++++double[]+array+=+concat(m1.array,+m2.array);
++++++++Matrix+m+=+new+Matrix(array,+m1.R+%2B+m2.R,+m1.C);
++++++++return+m;
++++}

++++private+static+double[]+concat(double[]+array2,+double[]+array3)+{
++++++++int+aLen+=+array2.length;
++++++++int+bLen+=+array3.length;
++++++++double[]+C+=+new+double[aLen+%2B+bLen];
++++++++System.arraycopy(array2,+0,+C,+0,+aLen);
++++++++System.arraycopy(array3,+0,+C,+aLen,+bLen);
++++++++return+C;
++++}

++++public+void+print()+{
++++++++for+(int+r+=+0;+r+<+R;+r%2B%2B)+{
++++++++++++for+(int+c+=+0;+c+<+C;+c%2B%2B)+{
++++++++++++++++double+v+=+get(r,+c);
++++++++++++++++System.out.print(String.format("%25.3f+",+v));
++++++++++++}
++++++++++++System.out.println();
++++++++}
++++++++System.out.println();
++++}

++++public+static+void+main(String[]+args)+{
++++++++double[]+a1+=+{+1,+2,+3,+4,+5,+6,+7,+8,+9+};
++++++++Matrix+m1+=+new+Matrix(a1,+3,+3);
++++++++m1.print();

++++++++double[]+a2+=+{+3,+2,+1,+6,+5,+4+};
++++++++Matrix+m2+=+new+Matrix(a2,+2,+3);
++++++++m2.print();

++++++++Matrix+m3+=+Matrix.concatRows(m1,+m2);
++++++++m3.print();
++++}
}|code-block|syntax|javascript|3634630|输出|3634631|1.000+2.000+3.000+
4.000+5.000+6.000+
7.000+8.000+9.000+

3.000+2.000+1.000+
6.000+5.000+4.000+

1.000+2.000+3.000+
4.000+5.000+6.000+
7.000+8.000+9.000+
3.000+2.000+1.000+
6.000+5.000+4.000+|3634632|基本上，除非你能确保这个矩阵是不可变的，否则你只能使用整个矩阵的深拷贝。因此，这个阶仍然是矩阵的O(N)，其中N+=+ROWS+*+COLS。|3634633|entityMap^0|U|7|1U|E|0|9|7|0|0|0|2|5|I|0|0|0|2|0|0|1C|4|1J|F|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|14|8|@$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|18|8|@$9|19|A|1A|B|L]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|M|3|N|5|O|7|1D|8|@]|D|@]|E|$P|Q]]|$1|R|3|S|5|6|7|1E|8|@$9|1F|A|1G|B|L]]|D|@]|E|$]]|$1|T|3|U|5|O|7|1H|8|@]|D|@]|E|$P|Q]]|$1|V|3|W|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|X|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|Y|$]]

If you need a dense matrix then it would be easier to allocate a big chunk of <code>array[]</code> of size M x N and wrap it in a Matrix class which can translate matrix(r, c) into <code>array[r*C + c]</code>.

This way you will do only one array copy operation for the internal <code>array[]</code>.

Something like this:

EDIT: Added row-major matrix concatenation using <code>System.arraycopy()</code>:

<pre><code>package example;

import java.util.Arrays;
import java.util.Random;

public class Matrix {
 private double[] array;
 int R;
 int C;

 Matrix(int R, int C) {
 this.R = R;
 this.C = C;
 this.array = new double[R * C];
 }

 Matrix(double[] array, int R, int C) {
 this.R = R;
 this.C = C;
 this.array = array;
 }

 Matrix(Matrix that) {
 this.R = that.R;
 this.C = that.C;
 array = Arrays.copyOf(that.array, that.array.length);
 }

 public void set(int r, int c, double value) {
 assert (r &gt;= 0 &amp;&amp; r &lt; R);
 assert (c &gt;= 0 &amp;&amp; c &lt; C);
 array[C * r + c] = value;
 }

 public double get(int r, int c) {
 assert (r &gt;= 0 &amp;&amp; r &lt; R);
 assert (c &gt;= 0 &amp;&amp; c &lt; C);
 return array[C * r + c];
 }

 public static Matrix concatRows(Matrix m1, Matrix m2) {
 double[] array = concat(m1.array, m2.array);
 Matrix m = new Matrix(array, m1.R + m2.R, m1.C);
 return m;
 }

 private static double[] concat(double[] array2, double[] array3) {
 int aLen = array2.length;
 int bLen = array3.length;
 double[] C = new double[aLen + bLen];
 System.arraycopy(array2, 0, C, 0, aLen);
 System.arraycopy(array3, 0, C, aLen, bLen);
 return C;
 }

 public void print() {
 for (int r = 0; r &lt; R; r++) {
 for (int c = 0; c &lt; C; c++) {
 double v = get(r, c);
 System.out.print(String.format("%.3f ", v));
 }
 System.out.println();
 }
 System.out.println();
 }

 public static void main(String[] args) {
 double[] a1 = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
 Matrix m1 = new Matrix(a1, 3, 3);
 m1.print();

 double[] a2 = { 3, 2, 1, 6, 5, 4 };
 Matrix m2 = new Matrix(a2, 2, 3);
 m2.print();

 Matrix m3 = Matrix.concatRows(m1, m2);
 m3.print();
 }
}
</code></pre>

OUTPUT:

<pre><code>1.000 2.000 3.000 
4.000 5.000 6.000 
7.000 8.000 9.000 

3.000 2.000 1.000 
6.000 5.000 4.000 

1.000 2.000 3.000 
4.000 5.000 6.000 
7.000 8.000 9.000 
3.000 2.000 1.000 
6.000 5.000 4.000 
</code></pre>

Basically, unless you can ensure that that matrix is immutable, you can only resort to deep-copy of the whole matrix. So the order is still <code>O(N)</code> where <code>N = ROWS * COLS</code> of the matrix.

blocks|key|2042528|text|对于复制数组，请使用System#arrayCopy或java.util.Arrays#copyOf。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2042529|无法获得用于复制数组的O(1)操作。唯一这样的方法是创建一个引用：Object[]+newArray+=+oldArray。这不会复制旧的数组。它简单地将newArray指向oldArray。要理解为什么O(1)的深拷贝是不可能的，请从计算机的层面来思考：|2042530|创建数组时，将为该数组留出一块内存。要复制每个元素，计算机必须遍历数组的每一部分并将其复制到其他地方(相反，每一位都要复制到其他地方)。对于单个元素数组，这只需进行一次操作。对于一个5元素数组，它需要5个操作。显然，对于n元素数组，这需要n操作。|2042531|因此，复制数组的时间复杂度是O(n)的下限。|2042532|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/7/docs/api/java/lang/System.html#arraycopy%2528java.lang.Object,%2520int,%2520java.lang.Object,%2520int,%2520int%2529|1|http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#copyOf%2528T%255B%255D,%2520int%2529^0|A|G|R|N|A|G|0|R|N|1|0|X|S|25|8|2F|8|0|32|1|3B|1|0|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]|$9|13|A|14|1|15]]|E|$]]|$1|F|3|G|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|C]|$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1I|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]|T|$5|O|P|Q|E|$R|U]]]]

For copying arrays, use <a href="http://docs.oracle.com/javase/7/docs/api/java/lang/System.html#arraycopy%28java.lang.Object,%20int,%20java.lang.Object,%20int,%20int%29" rel="nofollow"><code>System#arrayCopy</code></a> or <a href="http://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#copyOf%28T%5B%5D,%20int%29" rel="nofollow"><code>java.util.Arrays#copyOf</code></a>.

You cannot get an O(1) operation for copying an array. The only such way would be creating a reference: <code>Object[] newArray = oldArray</code>. This does not copy the old array. It simply points <code>newArray</code> to <code>oldArray</code>. To understand why a deep copy of O(1) is impossible, think about it on the computer's level:

When you create an array, a chunk of memory is set aside for that array. To copy each element, the computer has to go through each part of the array and copy it somewhere else (rather, each bit and copy it somewhere else). With a single element array, this only takes one operation. With a 5 element array, it takes 5 operations. Clearly, with an <code>n</code> element array, this takes <code>n</code> operations.

Thus the time complexity of copying an array has a lower bound of O(n)

I need to merge two double matrices in Java and I am aware of 

<code>public static double[] copyOf(double[] original, int newLength)</code>which is defined in the class <code>java.util.Array</code>

But I am concerned about the runtime because I need the most efficient outcome in terms of runtime which is of course ideally O(1) but I guess the operation is O(n) or even worse?

Can anyone provide advise?

<hr>

Supplemental

I just realized that this method only applies to vectors (double[]) and need matrices. Any ideas are appreciated.

What I want to achieve is having the following:

let <code>m1</code> and <code>m2</code> be double matrices such as

<code>m1</code> = 

<pre><code>[1,2,3]
[4,5,6]
[7,8,9]
</code></pre>

and <code>m2</code> =

<pre><code>[3,2,1]
[6,5,4]
</code></pre>

then I want to have a double matrix <code>m3</code> which is

<pre><code>[1,2,3]
[4,5,6]
[7,8,9]
[3,2,1]
[6,5,4]
</code></pre>

Performance of copying/merging arrays in Java

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

我需要在Java中合并两个双矩阵，并且我知道public static double[] copyOf(double[] original, int newLength)，它在类java.util.Array中定义。但我担心运行时，因为我需要运行时方面最有效的结果，当然，理想情况是O(1)，但我想操作是O(n)，甚至更糟？有人能提供建议吗？补充我刚刚意识到这种方法只适用于向量(double[])，

问Java中复制/合并数组的性能
EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中复制/合并数组的性能EN

回答 6

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Java中复制/合并数组的性能
EN