精华内容
下载资源
问答
  • java面试题26 java语言的下面几种数组复制方法中,哪个效率最高? A for 循环逐一复制 B System.arraycopy C Array.copyOf D 使用clone方法 效率:System.arraycopy > clone > Arrays.copyOf > ...

    java面试题26 java语言的下面几种数组复制方法中,哪个效率最高?

     

    A for 循环逐一复制
    B System.arraycopy
    C Array.copyOf
    D 使用clone方法

    效率:System.arraycopy > clone > Arrays.copyOf > for循环


    1、System.arraycopy的用法:

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

    参数:src - 源数组。srcPos - 源数组中的起始位置。dest - 目标数组。destPos - 目标数据中的起始位置。length - 要复制的数组元素的数量

    应用实例:

      public class Main{
            public static void main(String[] args) {
         
                 int[] a1={1,2,3,4,5,6};
                 int[] a2={11,12,13,14,15,16};
                
                 System.arraycopy(a1, 2, a2, 3, 2);
                 System.out.print("copy后结果:");
                 for(int i=0;i<a2.length;i++){
                     System.out.print(a2[i]+" ");    
                 }
            }
        }

    运行结果:

    2、clone 的用法:

    java.lang.Object类的clone()方法为protected类型,不可直接调用,需要先对要克隆的类进行下列操作:

    首先被克隆的类实现Cloneable接口;然后在该类中覆盖clone()方法,并且在该clone()方法中调用super.clone();这样,super.clone()便可以调用java.lang.Object类的clone()方法。

    应用实例:

      //被克隆的类要实现Cloneable接口
        class Cat implements Cloneable
        {
            private String name;
            private int age;
            public Cat(String name,int age)
            {
                this.name=name;
                this.age=age;
            }
            //重写clone()方法
            protected Object clone()throws CloneNotSupportedException{  
                return super.clone() ;  
            }
        }
        public class Clone {
            public static void main(String[] args) throws CloneNotSupportedException {
         
                Cat cat1=new Cat("xiaohua",3);
                System.out.println(cat1);
                //调用clone方法
                Cat cat2=(Cat)cat1.clone();
                System.out.println(cat2);
            }
        }

    3、复制引用和复制对象的区别

    复制引用:是指将某个对象的地址复制,所以复制后的对象副本的地址和源对象相同,这样,当改变副本的某个值后,源对象值也被改变;

    复制对象:是将源对象整个复制,对象副本和源对象的地址并不相同,当改变副本的某个值后,源对象值不会改变;

        Cat cat1=new Cat("xiaohua",3);//源对象
                System.out.println("源对象地址"+cat1);
                //调用clone方法,复制对象
                Cat cat2=(Cat)cat1.clone();
                Cat cat3=(Cat)cat1;//复制引用
                System.out.println("复制对象地址:"+cat2);
                System.out.println("复制引用地址:"+cat3);

    输出结果:


    可以看出,复制引用的对象和源对象地址相同,复制对象和源对象地址不同

    4、Arrays.copyOf 的用法:

    Arrays.copyOf有十种重载方法,复制指定的数组,返回原数组的副本。具体可以查看jdk api

    背后原理探究

    首先要申明的是这4种方法中的前3种是没有本质区别的,对象都是浅复制(复制地址),而普通类型都是深复制(复制值),简单来说
    浅复制:复制地址,相当于复制了房子(内存数据)的钥匙,一改全改
    深复制:复制值,通俗意义上的拷贝,相当于建了一个一模一样的房子(内存的数据)
     接下来说说3种方式:
      System.arraycopy()

        源码如下:
        

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

    可以看到这是一个native(本地)方法,也就是说是用C++写的,所以其效率比非native方法更高

    但更要注意的是上面的注解@HotSpotIntrinsicCandidate,我们来看官方对这个注解的解释

     * The {@code @HotSpotIntrinsicCandidate} annotation is specific to the
     * HotSpot Virtual Machine. It indicates that an annotated method
     * may be (but is not guaranteed to be) intrinsified by the HotSpot VM. A method
     * is intrinsified if the HotSpot VM replaces the annotated method with hand-written
     * assembly and/or hand-written compiler IR -- a compiler intrinsic -- to improve
     * performance. The {@code @HotSpotIntrinsicCandidate} annotation is internal to the
     * Java libraries and is therefore not supposed to have any relevance for application
     * code.

    注意红字粗体所说,为了提升性能,在JVM里对该注解的进行了手写,这里要提一个叫JNI(Java Native Interface)的东西,普通的native方法通俗的讲就是编译后还要通过JNI再次编译成.cpp文件才能执行.而有 @HotSpotIntrinsicCandidate这个注解的方法在JVM里就是用.cpp文件写好的,所以就跳过了JNI阶段,所以速度就能提升,这也是System.arraycopy()速度冠绝群雄的原因.
    Object.clone()

        源码如下:
     

            @HotSpotIntrinsicCandidate
            protected native Object clone() throws CloneNotSupportedException;

    可以看到它也是native方法,也有@HotSpotIntrinsicCandidate注解,那为啥速度比上面的大哥慢呢?这就要看到官方解释的一句

    It indicates that an annotated method may be (but is not guaranteed to be) intrinsified by the HotSpot VM

    注意用词:may be (but is not guaranteed to be),是的,clone()方法就是悲催的but,它并没有被手工写在JVM里面,所以它不得不走JNI的路子,所以它就成了2哥。
     Arrays.copyof()

         源码如下
        

            @HotSpotIntrinsicCandidate
            public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
                @SuppressWarnings("unchecked")
                T[] copy = ((Object)newType == (Object)Object[].class)
                    ? (T[]) new Object[newLength]
                    : (T[]) Array.newInstance(newType.getComponentType(), newLength);
                System.arraycopy(original, 0, copy, 0,
                                 Math.min(original.length, newLength));
                return copy;
            }

    3弟也有注解 @HotSpotIntrinsicCandidate,但它甚至不是native方法,所以这个注解也就是混子,也更印证了2哥的待遇,

    而且可以很明显的看到里面本质是调用了大哥  System.arraycopy()来实现的,所以效率垫底也是妥妥的。
    for()

    这个就可以退出群聊吧!for()无论是基本数据类型还是引用数据类型统统是深复制,而且其也不是封装的函数,所以退出群聊妥妥的。
     最后上测试代码,有兴趣的可以看看:

        package 问题;
         
       

     import java.util.Arrays;
         
        public class CopySpeed implements Cloneable {
         
         
            /*
             *
             * 数组复制速度 1.System.arraycopy() 2.clone() 3.Arrays.copyof() 4.for()
             *
             *
             *
             */
         
            int i = 0;
            String value = "123";
         
            /*
             * 基本数据类型测试
             *
             * */
            public long[] CopySpeedTest(int[] t) {
                /*
                 * 初始化所有
                 *
                 */
                int length = t.length;
                int[] systemCopy = new int[t.length];
                int[] clone = new int[t.length];
                int[] arraysCopyOf = new int[t.length];
                int[] For = new int[t.length];
         
                /*
                 * 执行复制操作,并统计时间
                 *
                 */
         
                long begin = System.currentTimeMillis();
                System.arraycopy(t, 0, systemCopy, 0, t.length);
                long end = System.currentTimeMillis();
                long arraycopyTimes = end - begin;
         
                begin = System.currentTimeMillis();
                clone = t.clone();
                end = System.currentTimeMillis();
                long cloneTimes = end - begin;
         
                begin = System.currentTimeMillis();
                arraysCopyOf = Arrays.copyOf(t, t.length);
                end = System.currentTimeMillis();
                long arraysCopyOfTimes = end - begin;
         
                /*
                 * 为了方便查看,这里设定下面程序只执行一次
                 *
                 */
                if (i == 0) {
         
                    /*
                     * 查看哈希值
                     */
                    System.out.println("t:\t" + t.hashCode());
                    System.out.println("systemCopy:\t" + systemCopy.hashCode());
                    System.out.println("clone:\t" + clone.hashCode());
                    System.out.println("arraysCopyOf:\t" + arraysCopyOf.hashCode());
         
                    i++;
                }
         
                /*
                 * 运行时间统计
                 *
                 */
                long[] times = new long[3];
                times[0] = arraycopyTimes;
                times[1] = cloneTimes;
                times[2] = arraysCopyOfTimes;
         
                return times;
         
            }
            
            
            /*
             *
             * 引用数据类型结果
             *
             * */
            
            public long[] CopySpeedTest(CopySpeed[] t) {
         
                /*
                 * 初始化所有
                 *
                 */
                int length = t.length;
                CopySpeed[] systemCopy = new CopySpeed[length];
                CopySpeed[] clone = new CopySpeed[length];
                CopySpeed[] arraysCopyOf = new CopySpeed[length];
         
                /*
                 * 执行复制操作,并统计时间
                 *
                 */
                long begin = System.currentTimeMillis();
                System.arraycopy(t, 0, systemCopy, 0, t.length);
                long end = System.currentTimeMillis();
                long arraycopyTimes = end - begin;
         
                begin = System.currentTimeMillis();
                clone = t.clone();
                end = System.currentTimeMillis();
                long cloneTimes = end - begin;
         
                begin = System.currentTimeMillis();
                arraysCopyOf = Arrays.copyOf(t, t.length);
                end = System.currentTimeMillis();
                long arraysCopyOfTimes = end - begin;
         
                /*
                 * 为了方便查看,这里设定下面程序只执行一次
                 *
                 */
                if (i == 1) {
         
                    /*
                     * 查看哈希值
                     */
                    System.out.println("t[0]:\t" + t[0].hashCode());
                    System.out.println("systemCopy[0]:\t" + systemCopy[0].hashCode());
                    System.out.println("clone[0]:\t" + clone[0].hashCode());
                    System.out.println("arraysCopyOf[0]:\t" + arraysCopyOf[0].hashCode());
         
                    /*
                     * 修改新对象的值来判断是浅复制还是深复制
                     *
                     */
                    System.out.println("深浅复制判断,以value属性判断");
                    System.out.println("修改前t[0]:\t" + t[0].value);
                    System.out.println("修改前systemCopy[0]:\t" + systemCopy[0].value);
                    System.out.println("修改前clone[0]:\t" + clone[0].value);
                    System.out.println("修改前arraysCopyOf[0]:\t" + arraysCopyOf[0].value);
         
                    System.out.println("---------------------------");
                    t[0].value = "t";
                    systemCopy[0].value = "systemCopy";
                    clone[0].value = "clone";
                    arraysCopyOf[0].value = "arraysCopyOf";
                    System.out.println("修改后t[0]:\t" + t[0].value);
                    System.out.println("修改后systemCopy[0]:\t" + systemCopy[0].value);
                    System.out.println("修改后clone[0]:\t" + clone[0].value);
                    System.out.println("修改后arraysCopyOf[0]:\t" + arraysCopyOf[0].value);
         
                    i++;
                }
         
                /*
                 * 运行时间统计
                 */
                long[] times = new long[3];
                times[0] = arraycopyTimes;
                times[1] = cloneTimes;
                times[2] = arraysCopyOfTimes;
         
                return times;
         
            }
         
            
         
            public static void main(String args[]) {
         
                CopySpeed speed = new CopySpeed();
         
                System.out.println("基本类型");
                long[] baseTimes = new long[] { 0, 0, 0 };
                int[] baseArrays = new int[10000000];
                for (int i = 0; i < baseArrays.length; i++) {
                    baseArrays[i] = i;
                }
                for (int i = 0; i < 20; i++) {
                    // System.out.print(i+"次");
                    long[] temp = speed.CopySpeedTest(baseArrays);
                    baseTimes[0] += temp[0];
                    baseTimes[1] += temp[2];
                    baseTimes[2] += temp[1];
                    // System.out.println();
                }
         
                baseTimes[0] /= 20;
                baseTimes[1] /= 20;
                baseTimes[2] /= 20;
                System.out.println(Arrays.toString(baseTimes));
         
                System.out.println("引用类型");
                long[] ObjectTimes = new long[] { 0, 0, 0 };
                CopySpeed[] ObjectArrays = new CopySpeed[10000000];
                for (int i = 0; i < ObjectArrays.length; i++) {
                    ObjectArrays[i] = new CopySpeed();
                }
                for (int i = 0; i < 20; i++) {
                    // System.out.print(i+"次");
                    long[] temp = speed.CopySpeedTest(ObjectArrays);
                    ObjectTimes[0] += temp[0];
                    ObjectTimes[1] += temp[1];
                    ObjectTimes[2] += temp[2];
                    // System.out.println();
                }
         
                ObjectTimes[0] /= 20;
                ObjectTimes[1] /= 20;
                ObjectTimes[2] /= 20;
                System.out.println(Arrays.toString(ObjectTimes));
         
            }
         
        }

    结果:

     

       基本类型
        t:    1552787810
        systemCopy:    1361960727
        clone:    739498517
        arraysCopyOf:    125130493
        [10, 14, 15]
        引用类型
        t[0]:    166239592
        systemCopy[0]:    166239592
        clone[0]:    166239592
        arraysCopyOf[0]:    166239592
        深浅复制判断,以value属性判断
        修改前t[0]:    123
        修改前systemCopy[0]:    123
        修改前clone[0]:    123
        修改前arraysCopyOf[0]:    123
        ---------------------------
        修改后t[0]:    t
        修改后systemCopy[0]:    t
        修改后clone[0]:    t
        修改后arraysCopyOf[0]:    t
        [22, 31, 55]

    结果分析:

        基本类型
        t:    1552787810
        systemCopy:    1361960727
        clone:    739498517
        arraysCopyOf:    125130493
        [10, 14, 15]


       
        对于基本数据类型可以看到4个对象的hashcode完全不同,也就验证了前面的深复制的猜想
       
        而10,14,15的运行时间也能证明他们的效率差别,当然因为是基本数据类型,
        而且数据量不算恐怖,所以差距并不大,特别是clone和arraysCopyOf
        可以明显的看到,clone因为JNI的耽误,而Arrays.CopyOf因为System.Copy的加成速度也不赖。
       
        

        引用类型
        t[0]:    166239592
        systemCopy[0]:    166239592
        clone[0]:    166239592
        arraysCopyOf[0]:    166239592
         


        对于引用类型,额可以看到4个对象的hashcode值完全相同,说明指向的是同一块内存
         

        深浅复制判断,以value属性判断
        修改前t[0]:    123
        修改前systemCopy[0]:    123
        修改前clone[0]:    123
        修改前arraysCopyOf[0]:    123
        ---------------------------
        修改后t[0]:    t
        修改后systemCopy[0]:    t
        修改后clone[0]:    t
        修改后arraysCopyOf[0]:    t
        [22, 31, 55]
         


        这里以对象的属性value做测试,可以看到t[0]里面的数据更改后,所有的数据都更改了,
         
        说明3种方法对于对象都是浅复制
    答案为B

    我是歌谣,若与不合理之处欢迎指出。喜欢敲代码,没事刷刷题。

    阅读目录(置顶)(长期更新计算机领域知识)

    阅读目录(置顶)(长期更新计算机领域知识)

    阅读目录(置顶)(长期科技领域知识)

    歌谣带你看java面试题

     

    展开全文
  • for循环逐一复制:这个应该是比较慢的。 System.arraycopy( ):查看源码,可知 public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length); Arrays.copyof( ):本质上调...

    for循环逐一复制:这个应该是比较慢的。

    System.arraycopy( ):查看源码,可知 public static native void arraycopy(Object src, int srcPos,Object dest, int destPos,int length);

    Arrays.copyof( ):本质上调用的是arraycopy( )方法,所以效率上肯定比System.arraycopy( )要低。

    Clone( )方法:查看源码可知,protected native Object clone() throws CloneNotSupportedException;可以看到是native方法:native关键字说明其修饰的方法是一个原生态方法,方法对应的实现不是在当前文件,而是在用其他语言(如C和C++)实现的文件中。但是返回的是Object类型,需要强制转换。 一般用clone效率是最差的。

    转载于:https://www.cnblogs.com/itaylor/p/7819344.html

    展开全文
  • 数组的四种复制方法

    千次阅读 2017-10-26 09:26:14
    java数组拷贝主要有四种方法,分别是循环赋值,System.arraycopy(),Arrays.copyOf()(或者Arrays.copyOfRange)和clone()方法下面分别介绍一下这几种拷贝。 循环拷贝(速度相对比较慢) 循环拷贝其实没什么好说的...

    java数组拷贝主要有四种方法,分别是循环赋值,System.arraycopy(),Arrays.copyOf()(或者Arrays.copyOfRange)和clone()方法。下面分别介绍一下这几种拷贝。

    循环拷贝(速度相对比较慢)

    循环拷贝其实没什么好说的啦,就是用一个for循环进行元素的逐个拷贝,进行深拷贝或者浅复制这个大家可以自己把握。

    System.arraycopy(浅拷贝)

    这个是系统提供的拷贝方式,也是我们推荐使用的拷贝方式,它是浅拷贝,也就是说对于非基本类型而言,它拷贝的是对象的引用,而不是去新建一个新的对象。通过它的代码我们可以看到,这个方法不是用java语言写的,而是底层用c或者c++实现的,因而速度会比较快。

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

    通过源代码我们可以看到,关键字native说明它不是用java语言写的,而是调用其他语言的代码。

    Arrays.copyOf(浅拷贝)

    这个方法也是浅拷贝,为什么呢?我们看一下它的源代码就知道了。

    public static byte[] copyOfRange(byte[] original, int from, int to) {                   
       int newLength = to - from;
       if (newLength < 0)
           throw new IllegalArgumentException(from + " > " + to);
           byte[] copy = new byte[newLength];
           System.arraycopy(original, from, copy, 0,
                  Math.min(original.length - from, newLength));
            return copy;
        }
    

    实际上它调用的就是System.arraycopy,所以肯定也是浅拷贝。

    Object.clone

    clone()比较特殊,对于对象而言,它是深拷贝,但是对于数组而言,它是浅拷贝。

    对象拷贝

    首先讲一下对象的拷贝,它是深拷贝,大家可以用对象去测试一下。下面我们看一下它的源代码:

    protected native Object clone() throws CloneNotSupportedException;

    这里也有native关键字,所以也是底层的c语言实现的。
    还要注意的是,这里修饰符是protected,也就是说,我们创建了一个Object类以后,是不能直接调用这个clone()方法的,因为protected关键字只允许同一个包内的类和它的子类调用,所以我们声明一个object类时,肯定不是同一个包内,所以就不能去调用它。

    要调用这个方法,就需要我们写一个类,然后声明实现cloneable接口就好了,不需要去显示地声明继承于object,因为java中的类如果不显示说明父类的话,默认父类就是object。然后我们继承这个方法:

    @Override
        public Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return super.clone();
        }

    这里需要是,为了能够在不同包内去调用这个方法,我们需要把这个权限升级为public。现在我们就可以调用这个类的clone()方法去拷贝我们的类了。

    数组拷贝

    对于数组而言,它不是简单的将引用赋值为另外一个数组引用,而是创建一个新的数组。但是我们知道,对于数组本身而言,它它的元素是对象的时候,本来数组每个元素中保存的就是对象的引用,所以,拷贝过来的数组自然而言也是对象的引用,所以对于数组对象元素而言,它又是浅拷贝。我们用以下代码验证一下:

    
    class Aby implements Cloneable{
        public int i;
        public Aby(int i) {
            this.i = i;
        }
        @Override
        public Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return super.clone();
        }
    }
    
    public class Solution {
    
        public static void main(String[] args) throws CloneNotSupportedException {
            Aby aby1 = new Aby(1);
            Aby aby2 = (Aby) aby1.clone();
            aby1.i = 2;
            System.out.println(aby1.i); //2
            System.out.println(aby2.i); //1
    
            Aby[] arr = {aby1,aby2};
    
            Aby[] arr2 = arr.clone();
            arr2[0].i = 3;
            System.out.println(arr[0].i);   //3
            System.out.println(arr2[0].i);  //3
        }
    }
    展开全文
  • JAVA语言的下面几种数组复制方法中,哪个效率最高? A.for循环逐一复制 B.System.arraycopy C.System.copyof D.使用clone方法 效率:System.arraycopy > clone > Arrays.copyOf > for循环 1、System....

    java语言复制数组的四种方法

     

    JAVA语言的下面几种数组复制方法中,哪个效率最高?

    A.for循环逐一复制
    B.System.arraycopy
    C.System.copyof
    D.使用clone方法

    效率:System.arraycopy > clone > Arrays.copyOf > for循环

    1、System.arraycopy的用法:

    其为native方法,即原生态方法,关键字native说明它不是用java语言写的,而是调用其他语言的代码,因此效率最高

    1. public static void native arraycopy(Object src,  
    2.                                        int srcPos,  
    3.                                             Object dest,  
    4.                                             int destPos,  
    5.                                             int length)  

      参数:    src - 源数组。

          srcPos - 源数组中的起始位置。

          dest - 目标数组。

          destPos - 目标数据中的起始位置。

          length - 要复制的数组元素的数量

    2、clone 的用法

    Object.clone
    从源码来看同样也是native方法,所以也是底层的C语言实现的,但返回为Object类型,所以赋值时将发生强转,所以效率不如1
     
    protected native Object clone() throws CloneNotSupportedException;
     
    例:
    class Aby implements Cloneable{
        public int i;
        public Aby(int i) {
            this.i = i;
        }
        @Override
        public Object clone() throws CloneNotSupportedException {
            // TODO Auto-generated method stub
            return super.clone();
        }
    }

    public class Solution {

        public static void main(String[] args) throws CloneNotSupportedException {
            Aby aby1 = new Aby(1);
            Aby aby2 = (Aby) aby1.clone();
            aby1.i = 2;
            System.out.println(aby1.i); //2
            System.out.println(aby2.i); //1

             Aby[] arr = {aby1,aby2};

            Aby[] arr2 = arr.clone();
            arr2[0].i = 3;
            System.out.println(arr[0].i);   //3
            System.out.println(arr2[0].i);  //3
        }
    }
     

    3、Arrays.copyOf 的用法:

    有十种重载方法,复制指定的数组,返回原数组的副本。具体可以查看jdk api

     

    java.util.Arrays.Arrays.copyOf(源数组,新数组长度);

    java.util.Arrays.copyOfRange(源数组,开始拷贝位置,结束拷贝位置);

     

     

    它的源代码

    + View code

    public static int[] copyOf(int[] original, int newLength) {

      int[] copy = new int[newLength];

      System.arraycopy(original, 0, copy, 0,

        Math.min(original.length, newLength));

      return copy;

    }

    实际上它调用的就是System.arraycopy。

     

    4、for循环

    代码灵活,但效率低

     
    展开全文
  • Java 数组

    千次阅读 2018-05-24 14:55:06
    Java 数组数组对于每一门编程语言来说都是重要的数据结构之一,当然不同语言对数组的实现及处理也不尽相同。Java 语言中提供的数组是用来存储固定大小的同类型元素。你可以声明一个数组变量,如 numbers[100] 来代替...
  • C#——字符串复制+数组复制

    千次阅读 2019-11-26 20:34:15
    CopyTo(要复制字符的起始位置(从第几个字符开始往后复制(不包括第几个字符)),目标字符数组,目标数组中的开始存放位置,要复制的字符个数); //Copy静态方法:string.方法来引用 string str="QiaoPeichen"; ...
  • JAVA中复制数组的五种方法

    千次阅读 2017-06-29 20:17:08
    “=”相当于将一个数组变量的引用传递给另一个数组;... 使用clone方法,得到数组的值,而不是引用,不能复制指定元素,灵活性差一点 使用System.arraycopy(src, srcPos, dest, destPos, length)方法,推荐使用,效率最高
  • 数组内置方法数组操作方法

    千次阅读 2019-04-20 16:00:35
    数组内置方法数组操作方法数组操作方法concat() 方法unshift() 方法slice() 方法splice() 数组操作方法 concat() 方法 用于连接两个或多个数组。 语法:arra.concat(arrayX,arrayX,......,arrayX); 该方法不会改变...
  • js数组常用方法

    万次阅读 多人点赞 2018-12-26 15:04:25
    数组转字符串,方法只接收一个参数:即默认为逗号分隔符()。 &lt;script&gt; var arr=[1,2,3,4]; console.log(arr.join()); //1,2,3,4 console.log(arr.join(":")); //1:2:3:4 console....
  • 1.2、for循环1.3、Arrays类1.4、System.arraycopy方法2、数组长度不等 复制数组 这是我做leetbook数组题的第一题时遇到的疑问,决定分两个情况考虑。 1、数组长度相等 假设nums和nums1是长度相等的两个数组。 1.1、...
  • java复制数组的四种方法

    千次阅读 2017-07-25 20:45:19
    java语言的下面几种数组复制方法中,哪个效率最高? 正确答案: B 你的答案: C (错误) for 循环逐一复制 System.arraycopy Array.copyOf 使用clone方法
  • 深拷贝和浅拷贝最根本的区别在于是否是真正获取了一个对象的复制实体,而不是引用。 浅拷贝:只是拷贝了基本类型的数据,而引用类型数据,复制后也是会发生引用,我们把这种拷贝叫做“浅拷贝”,换句话说,浅复制...
  • python数组的使用

    千次阅读 2018-07-07 12:22:38
    python数组的使用 python数组的使用 2010-07-28 17:17 1、Python的数组分三种类型:
  • java8中将数组进行分割Here you will learn how ... 在这里,您将学习如何使用Java将一个数组复制到另一个数组。 There are mainly four different ways to copy all elements of one array into another array in...
  • java语言复制数组的四种方法

    万次阅读 多人点赞 2016-08-28 13:47:01
    JAVA语言的下面几种数组复制方法中,哪个效率最高? A.for循环逐一复制 B.System.arraycopy C.System.copyof D.使用clone方法 效率:System.arraycopy > clone > Arrays.copyOf > for循环 1、System.arraycopy...
  • 在Java语言中,一般会采用下面的几种方法进行数组复制。 a) for循环逐一复制; b) System.arraycopy方法 c) Arrays.copyOf方法 d) 使用clone方法 e) Arrays.copyOfRange方法 接下来,我们看下这几种方法的源码和...
  • js数组方法

    千次阅读 2019-05-24 20:37:26
    JavaScript中创建数组有两种方式: 使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array("lily","lucy","Tom"); // 创建一...
  • JavaScript数组方法

    千次阅读 多人点赞 2019-01-13 20:30:42
    在w3c里面,官方给出的数组方法共有30个之多,实际上在开发当中,我们常用的可能也就十多个,下面就把数组方法写下来: 1、concat(),连接两个或者更多的数组,并返回一个新的数组。 let arr = [2, 3, 1, 9, 7,...
  • Java数组拷贝的四种方法

    万次阅读 多人点赞 2015-06-10 17:49:37
    Java数组拷贝java数组拷贝主要有四种方法,分别是循环赋值,System.arraycopy(),Arrays.copyOf()(或者Arrays.copyOfRange)和clone()方法下面分别介绍一下这几种拷贝。循环拷贝(速度相对比较慢)循环拷贝其实没...
  • ES6新增数组方法

    千次阅读 2019-02-15 02:08:16
    Array.from 方法用于将两类对象转为真正的数组:类似数组的对象(array-like object)和可遍历(iterable)的对象(包括 ES6 新增的数据结构 Set 和 Map) let arrayLike = { "0": "a", "...
  • Java的数组拷贝——四种方法

    千次阅读 2019-03-22 21:36:53
    在java语言中,Java数组复制操作可以分为深度复制和浅度复制。 简单来说深度复制,可以将对象的值和对象的内容复制; 浅复制是指对对象引用的复制。 第一种方法:clone() 方法 clone() 方法可以实现复制数组。...
  • lodash数组常用方法

    千次阅读 2018-12-04 17:28:15
    lodash是js的一个实用工具库,现在es6盛行,搭配loash工具库是最方便的一件事了。lodash内部封装了关于字符串,数组,对象一些常见数据类型的处理函数。...下面整理的是项目上比较常用到的方法,主...
  • 数组的所有方法

    万次阅读 多人点赞 2019-03-04 09:20:39
    JavaScript中创建数组有两种方式 (一)使用 Array 构造函数: var arr1 = new Array(); //创建一个空数组 var arr2 = new Array(20); // 创建一个包含20项的数组 var arr3 = new Array(“lily”,“lucy”,“Tom”);...
  • 数组实例的copyWithin()方法,在当前数组内部,将指定位置的成员复制到其他位置(会覆盖原有成员),然后返回当前数组。也就是说,使用这个方法,会修改当前数组。 Array.prototype.copyWithin(tar点击打开链接get,...
  • Javascript创建对象的方法有很多,现在就来列举一下: 1. 使用Object构造函数来创建一个对象,下面代码创建了一个person对象,并用两种方式打印出了Name的属性值。 var person = new Object(); person.name="...
  • 声明和创建数组 声明数组方式如下: int [] pins; 数组元素并非只能是基元数据类型,还可以是结构、枚举或类. 比如,以下代码创建由Time结构构成的数组. Time[] times; 创建数组实例 无论元素是什么类型,数组始终...
  • 数组实例的copyWithin方法,在当前数组内部,将指定位置的成员复制到其他位置(会覆盖原有成员),然后返回当前数组。也就是说,使用这个方法,会修改当前数组。 [javascript] view plain copy Array....
  • 介绍 js数组操作,赋值指向同一指针问题并剖析 js数组的引用传递和值传递
  • 由于“push”采用可变数量的参数,因此可以使用push函数的apply方法来推送另一个数组的所有元素。 It constructs a call to push using its first argument ("newArray" here) as "this" and the elements of the ...
  • 【java】数组复制几种方式比较

    千次阅读 2016-12-21 14:32:47
    import java.util.Arrays;... * 从指定源数组复制一个数组复制从指定的位置开始,到目标数组的指定位置结束 */ public class LessionSystemArraycopy { public static void main(String[] args) { // 此方法为n

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 182,371
精华内容 72,948
关键字:

下面不是数组复制方法的是