static void Main(string[] args)
int[] src = new[] { 1, 2, 3, 4, 5, 6 };
const int destLen = 4;//目标数组大小
int int_size = sizeof(int);//用于获取值类型的字节大小。
int[] dest = new int[destLen];
//只支持基元类型，按字节偏移复制
Buffer.BlockCopy(src, (src.Length - destLen) * int_size, dest, 0, destLen * int_size);
foreach (var i in dest)
Console.Write(i + "
Console.WriteLine("\n-------------------------------------------");
string[] srcstr = new[] { "A", "B", "C", "D", "E", "F" };
object[] destobj = new object[src.Length - 2];
//移除的元素个数
const int dellen = 2;
//保证不破坏目标数组的元素（回滚）。不装箱、拆箱、或向下转换，否则报错。
//如果srcstr改为src则报错，因为装箱。
Array.ConstrainedCopy(srcstr, dellen, destobj, 0, srcstr.Length - dellen);
foreach (var s in destobj)
Console.Write(s + "
对指定数组和目标数组，两者类型一致的前提下，进行复制10亿次，
消耗时间如下：
copy:59.374s,constrainecopy:48.415 s,blockcopy:23.219s
代码没什么就是测试下,核心测试如下：
&int[]&ints&=&{&,&332,&423,&524,&,&734,&567,&43,&3,&,&345,&575,&235,&1,&342,&1,&6,&5,&5&};&int[]&dest&=&new&int[ints.Length];
Array.Copy(ints,&dest,&ints.Length);
Array.ConstrainedCopy(ints,&0,&dest,&0,&ints.Length);
Buffer.BlockCopy(ints,&0,&dest,&0,&ints.Length&*&4);
注解分析：
1，Array.Copy在CLR处理机制中最灵活，最强大,可装箱，拆箱复制，可加宽CLR基元类型，可内部判断实现了IFarmattable接口的兼容转换，当然这种强大方式必然会带来一定的性能损失。
2，Array.ConstrainedCopy&对复制要求严格，只能是同类型或者源数组类型是目标类型的派生元素类型，不执行装箱，拆箱，向下转换
3，Buffer.BlockCopy&则从本质上以字节为复制单位，这在底层语言C，C++的处理优势上，同理，效率之高可以理解。
当然如果对性能要求不高，Copy足矣，毕竟在上千次复制下，三者基本没消耗多少时间。使用时可根据项目需求斟酌选择！
问题：c#如何把某个长数组的一部分复制到另一个短数组里面
byte[] shortAry=new byte[4];byte[] longAry=new byte[20];如何把longAry[5,9（不含）]这4个字节复制到shortAry里面？不要用循环。
用Array.Copy方法将数组或者数组的一部分复制到另个数组。Array.Copy是静态方法，有多个重载版本。其中常用的是：
public static void Copy(
Array sourceArray,
int sourceIndex,
Array destinationArray,
int destinationIndex,
int length);
各个参数含义如下
sourceArray && 源数组
sourceIndex && 表示 sourceArray 中复制开始处的索引
destinationArray && 目标数组，它接收数据
destinationIndex && 表示 destinationArray 中存储开始处的索引
length && 要复制的元素数目。
用法举例如下：
（1）复制数组的一部分到另一个数组
int[] src = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
int[] dest = new int[4];
// 将数组 src 中元素 2,3,4,5 复制到 dest
Array.Copy(src, 1, dest, 0, 4);
（2）复制整个数组
int[] src = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
int[] dest = new int[src.Length];
// 将数组 src 所有元素复制到 dest
Array.Copy(src, 0, dest, 0, src.Length);
阅读(...) 评论()System.arraycopy()实现数组的复制与交换 - 简书
System.arraycopy()实现数组的复制与交换
今天在读别人代码的时候，发现了一个数组之间复制很不错的方法，就分享记录下吧。同时小小的研究下了它的使用方法。System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。其函数原型是：
public static void arraycopy(Object src,
int srcPos,
Object dest,
int destPos,
int length)
src:源数组；srcPos:复制源数组的起始位置；dest:目的数组；destPos:放置目的数组的起始位置；length:需要复制的长度。
注意：src 和 dest都必须是同类型或者可以进行转换类型的数组。
1.一维数组的复制
函数也很好理解，直接上代码吧。
import java.util.A
public class MyClass {
public static void main(String[] args) {
int [] srcArray = new int []{0,1,2,3,4,5,6,7,8} ;
int [] destArray = new int [srcArray.length] ;
System.arraycopy(srcArray, 0, destArray, 0, srcArray.length) ;
System.out.println(Arrays.toString(srcArray));
System.out.println(Arrays.toString(destArray));
arraycopy()实现复制
不仅如此，更加有趣的是这个函数可以实现自己到自己的复制，比如：
import java.util.A
public class MyClass {
public static void main(String[] args) {
int [] srcArray = new int []{0,1,2,3,4,5,6,7,8} ;
System.out.println(Arrays.toString(srcArray));
System.arraycopy(srcArray, 0, srcArray , 3, 3) ;
System.out.println(Arrays.toString(srcArray));
则结果为：
arraycopy()自我复制
实现过程是这样的，先生成一个长度为length的临时数组,将fun数组中srcPos到srcPos+length-1之间的数据拷贝到临时数组中，再执行System.arraycopy(临时数组,0,srcArray ,3,3)。
2.一维数组的交换
其实从arraycopy()自我复制的例子就可以想到，只要借助于临时数组，就可以实现数组左边和右边的交换。
import java.util.A
public class MyClass {
public static void main(String[] args) {
int [] srcArray = new int []{0,1,2,3,4,5,6,7,8} ;
int [] destArray = new int[srcArray.length];
//从第3位开始数组左右交换
int index = 3;
System.arraycopy(srcArray, index, destArray, 0, srcArray.length-index);
System.arraycopy(srcArray, 0, destArray, srcArray.length-index, index);
System.out.println(Arrays.toString(srcArray));
System.out.println(Arrays.toString(destArray));
arraycopy()实现交换
怎么样，是不是看起来代码很简洁，不需要调用for或者while循环去实现数组的交换啦。
3.二维数组的复制
由于java没有二维数组的概念，平常实现的二维数组只是元素是一维数组的一维数组，而数组也是引用类型，继承自Object类。数组是new出来的。这些性质也就导致arraycopy()二维数组会出现问题。这是个坑，不可大意。怎么样一个坑呢，我们来对比下一维数组复制和二维数组复制的代码你就知道啦。
import java.util.A
public class MyClass {
public static void main(String[] args) {
int [] srcArray = new int []{0,1,2,3,4,5,6,7,8} ;
int [] destArray = new int [srcArray.length] ;
System.arraycopy(srcArray, 0, destArray, 0, srcArray.length) ;
System.out.println("srcArray:"+Arrays.toString(srcArray));
System.out.println("destArray:"+Arrays.toString(destArray));
destArray[0] = 9 ;
destArray[1] = 9 ;
System.out.println("srcArray after changed value:"+Arrays.toString(srcArray));
System.out.println("destArray after changed value:"+Arrays.toString(destArray));
一维数组复制
从结果中可以看出，设置destArray[0] = 9 ，destArray[1] = 9 后，srcArray after changed value的结果并没有改变，仅仅只有destArray after changed value的结果改变。所以有如下结论：在一维数组中，元素都是基础类型（如int，double等），使用arraycopy()方法后，是把原数组的值传给了新数组，属于值传递。
接下来我们看看二维数组的复制代码：
import java.util.A
public class MyClass {
public static void main(String[] args) {
char [][]one = new char[][]{{'a','b'},{'c','d'},{'e','f'}};
System.out.println("srcArray:"+Arrays.toString(one[0]));
char [][] another = new char [2][2] ;
System.arraycopy(one, 0, another, 0, 2) ;
System.out.println("destArray:"+Arrays.toString(another[0]));
one[0][0] = 'x' ;
one[0][1] = 'y' ;
System.out.println("srcArray after changed value:"+Arrays.toString(one[0]));
System.out.println("destArray after changed value:"+Arrays.toString(another[0]));
二维数组复制
从结果中可以看出，设置one[0][0] = 'x'，one[0][1] = 'y'
后，srcArray after changed value的结果和destArray after changed value的结果相同。所以有如下结论：二维数组使用arraycopy()方法后，第一维的引用被复制给新数组的第一维，也就是两个数组的第一维都指向相同的“那些数组”。而这时改变其中任何一个数组的元素的值，其实都修改了“那些数组”的元素的值，所以原数组和新数组的元素值都一样了。
总结：1.一维数组的复制属于值传递 ，修改副本原来的不会变2.二维的数组，复制的结果是将源二维数组里一维数组的引用变量传递给副本，修改任意一个数组的值，另一个数组的值也会相应改变。也就是one[2][2]中，one[i]是复制，one[i][j]是引用。
我不是大咖，我只是大咖的搬运工。。。System.arraycopy()实现数组之间的复制
更多相关资料:
本文相关关键词：
System提供了一个静态方法arraycopy(),我们可以使用它来实现数组之间的复制。
其函数原型是： public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
src:源数组；
srcPos:源数组要复制的起始位置；
dest:目的数组；
destPos:目的数组放置的起始位置；
length:复制的长度。
注意：src and dest都必须是同类型或者可以进行转换类型的数组。
这个函数还可以实现自己到自己复制，比如： int[] fun ={0,1,2,3,4,5,6}; System.arraycopy(fun,0,fun,3,3); 则结果为：{0,1,2,0,1,2,6}; 实现过程是这样的，先生成一个长度为length的临时数组,将fun数组中srcPos 到srcPos+length-1之间的数据拷贝到临时数组中，再执行System.arraycopy(临时数组,0,fun,3,3).
You can read more:
本文相关关键词：JavaScript数组深拷贝和浅拷贝的两种方法
字体：[ ] 类型：转载 时间：
在使用JavaScript对数组进行操作的时候，我们经常需要将数组进行备份，事实证明如果只是简单的将它赋予其他变量，那么我们只要更改其中的任何一个，然后其他的也会跟着改变，这就导致了问题的发生。
例如这个例子： 代码如下:var arr = ["One","Two","Three"];var arrto =arrto[1] = "test";document.writeln("数组的原始值：" + arr + "&br /&");//Export:数组的原始值：One,test,Threedocument.writeln("数组的新值：" + arrto + "&br /&");//Export:数组的新值：One,test,Three
像上面的这种直接赋值的方式就是浅拷贝，很多时候，这样并不是我们想要得到的结果，其实我们想要的是arr的值不变，不是吗？
方法一：js的slice函数 代码如下:对于array对象的slice函数， 返回一个数组的一段。（仍为数组） arrayObj.slice(start, [end])& 参数 arrayObj& 必选项。一个 Array 对象。& start& 必选项。arrayObj 中所指定的部分的开始元素是从零开始计算的下标。& end& 可选项。arrayObj 中所指定的部分的结束元素是从零开始计算的下标。& 说明 slice 方法返回一个 Array 对象，其中包含了 arrayObj 的指定部分。 slice 方法一直复制到 end 所指定的元素，但是不包括该元素。如果 start 为负，将它作为 length + start处理，此处 length 为数组的长度。如果 end 为负，就将它作为 length + end 处理，此处 length 为数组的长度。如果省略 end ，那么 slice 方法将一直复制到 arrayObj 的结尾。如果 end 出现在 start 之前，不复制任何元素到新数组中。例子： 代码如下:var arr = ["One","Two","Three"];var arrtoo = arr.slice(0);arrtoo[1] = "set Map";document.writeln("数组的原始值：" + arr + "&br /&");//Export:数组的原始值：One,Two,Threedocument.writeln("数组的新值：" + arrtoo + "&br /&");//Export:数组的新值：One,set Map,Three
方法二：js的concat方法 代码如下:concat() 方法用于连接两个或多个数组。该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。语法arrayObject.concat(arrayX,arrayX,......,arrayX)说明返回一个新的数组。该数组是通过把所有 arrayX 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组，那么添加的是数组中的元素，而不是数组。var arr = ["One","Two","Three"];例子： 代码如下:&& var arrtooo = arr.concat();arrtooo[1] = "set Map To";document.writeln("数组的原始值：" + arr + "&br /&");//Export:数组的原始值：One,Two,Threedocument.writeln("数组的新值：" + arrtooo + "&br /&");//Export:数组的新值：One,set Map To,Three
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具