精华内容
下载资源
问答
  • 复制文件的几种方法
    千次阅读
    2019-11-28 10:34:19

    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面试题

     

    更多相关内容
  • python运行py文件几种方法

    千次阅读 2020-11-20 18:09:33
    有时候我们在进行python编程的时候,想运行py文件,怎么运行呢,下面来分享一下方法工具/原料python运行py文件几种方法方法一:通过命令行窗口运行1第一步我们首先复制一下py文件存放的路径,这里的py文件放在f...

    有时候我们在进行python编程的时候,想运行py文件,怎么运行呢,下面来分享一下方法

    工具/原料

    python

    运行py文件的几种方法

    方法一:通过命令行窗口运行

    1

    第一步我们首先复制一下py文件存放的路径,这里的py文件放在f盘根目录,如下图所示:

    9b2098254193cee89fb0e9af5a0ff2260c9aa808.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    2

    第二步打开命令行窗口,进去之后,首先切换到py文件的路径下面,然后输入“python py文件名称”,如下图所示:

    16d8f72abab84240534a7ea07ac595ee40c19e08.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    3

    第三步按回车键,可以看到已经运行py文件了,需要注意的是在命令行窗口中运行py文件,需要将python安装路径添加到环境变量path中,如下图所示:

    07c98f2ca5cadce8d4fcbd48fcf7980e5e209508.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    END

    方法二:通过python的ide编辑器运行

    1

    第一步我们可以下载安装python的ide代码编辑器pycharm,新建一个项目,将py文件放到项目中执行,如下图所示:

    b87bd38920c5260fd881603ed2de450789018908.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    2

    第二步点击Run进行执行py文件,可以看到运行结果,如下图所示:

    a749bb0f94fc508cc77a7a4c01775ddd894cfd08.jpg?x-bce-process=image%2Fresize%2Cm_lfit%2Cw_500%2Climit_1

    END

    注意事项

    如果你觉得这篇对你有用的话,请投一下票

    经验内容仅供参考,如果您需解决具体问题(尤其法律、医学等领域),建议您详细咨询相关领域专业人士。

    举报作者声明:本篇经验系本人依照真实经历原创,未经许可,谢绝转载。

    展开阅读全部

    展开全文
  • 把两图片选中后,拖到“要复制文件和文件夹”里那一栏,工具会显示出这两个图片的路径在上面, 当然,也可以点右边那一排里面“添加文件”的按钮把我们两个可爱的图片添加进去。 接下来就是目标位置,我就把左边...

    首先,需要用到的这个工具:
    在这里插入图片描述
    文本账号文件免安装便捷管理神器

    百度
    密码:qwu2
    蓝奏云
    密码:2r1z


    现在开始说具体操作

    1、首先,我准备了3个文件夹和两个可爱的图片:
    在这里插入图片描述
    当然,在实际使用的时候肯定不止这些,我这里只是演示一下下。

    2、然后打开这个工具,按下CTRL+5,切换到文件批量复制的功能模块。

    把两种图片选中后,拖到“要复制的文件和文件夹”里那一栏,工具会显示出这两个图片的路径在上面,
    当然,也可以点右边那一排里面“添加文件”的按钮把我们两个可爱的图片添加进去。

    接下来就是目标位置,我就把左边1、2、3命名的这3个空的文件夹选中,拖到“复制到的文件夹的目录”,就显示这3个文件夹的路径了在上面了,也可以用右边的按钮添加
    在这里插入图片描述
    3、下面的“复制选项”一栏默认就行了,如果有其他要求,根据里面选择就好了,挺简单的。

    点击里面的“开始复制”按钮,出现提示,点“是”,然后不用动,等它运行结束就好了。
    (如果操作的文件几千几万个的话,过程会要一点时间但不卡,我试过,嘿嘿,就是想知道性能怎么样)
    在这里插入图片描述
    4、然后就完成了,这些文件夹里面也有这些可爱的图片了,非常省事,操作简单
    而且操作的这些文件路径可以保存,能够反复操作,适合经常要批量处理文件的事情
    在这里插入图片描述


    下载地址:
    文本账号文件免安装便捷管理神器

    https://pan.baidu.com/s/1FYj8NxOdl7i9SHnCrFR3jA
    提取码:qwu2

    展开全文
  • 局域网传输文件几种方法盘点

    千次阅读 2021-09-29 10:12:50
    3、在要下载的电脑上(同一个局域网),如图所示操作 \共享文件的那个机器局域网ip 4、看到效果,然后将该文件夹拖到某个存放的位置即可 远程桌面连接后下载 略,后续补充 备注:Windows10远程连接后,被连接的...

    共享文件夹(速度一般是1~2M每秒)

    1、选中要共享的文件夹,按照如图所示操作
    在这里插入图片描述
    2、Windows通过ipconfig查看ip地址
    在这里插入图片描述
    3、在要下载的电脑上(同一个局域网),如图所示操作 \共享文件的那个机器局域网ip
    在这里插入图片描述

    4、看到效果,然后将该文件夹拖到某个存放的位置即可
    在这里插入图片描述

    远程桌面连接后下载

    1、运行中输入以下命令

    mstsc
    

    在这里插入图片描述
    2、按图输入要连接主机ip及账号密码名称
    在这里插入图片描述
    3、连接成功后如图
    在这里插入图片描述
    4、直接在远程那台机器上Ctrl+C,然后鼠标点击当前机器,Ctrl+V就可以复制了

    5、如果发现过程中远程机器拒绝,则看下该远程机器系统与安全的配置是否运行
    在这里插入图片描述

    备注:
    参考1:Windows10远程连接后,被连接的机器会锁屏。
    参考2:http://www.xitongcheng.com/jiaocheng/win10_article_56055.html

    本地起一个python服务器(速度一般是1M内)

    1、在要共享的目录下,执行命令

    python -m http.server 8800在这里插入图片描述
    2、在要下载的电脑上(同一个局域网),浏览器中输入对应的ip:port,点击所需要的内容下载即可
    在这里插入图片描述

    起一个nginx,然后拖到对应的路径下(适用于公网、局域网都可以)

    略,后续补充
    备注:建议适用docker启动一个nginx,然后外放80端口即可

    展开全文
  • 如何快速复制文件或文件夹路径?

    千次阅读 2020-12-08 14:28:20
    MacOS 中没有 Windows 那样的地址栏,无法直观的复制文件的链接,下面介绍几种方法快速获得文件和文件夹的路径。一起来跟小编看看吧~ 一、快捷键 Command+Option+C 在Finder中选择文件或是文件夹,然后按下...
  • 用Python来copy文件几种方法

    万次阅读 2019-08-19 21:59:47
    1. os.system 2. shutil.copy和shutil....不知道有没有其它的了,os.rename不算,那个是移动文件。另外我在测试它们的性能如何。学习过程中有什么不懂得可以加我的python学习交流扣扣qun,7847582...
  • MySQL 主从复制几种方式

    千次阅读 2017-04-24 09:48:14
    MySQL 主从复制主要有以下几种方式:  基于 SQL 语句的复制(statement-based replication, SBR); 基于行的复制(row-based replication, RBR);混合模式复制(mixed-based replication, MBR); 基于 SQL 语句...
  • 关于JAVA IO流中拷贝文件几种方法

    千次阅读 2015-09-10 17:28:51
    上一篇中的拷贝文件,采取的是批量的方法,还有2中方法分别是按字节拷贝和带缓冲的拷贝。带缓冲的拷贝主要是BufferedInputStream和BuferedOutputStream. BufferedInputStream&BuffredOutputStream 这两个流类为IO...
  • 复制文字到剪贴板的几种方法

    千次阅读 2020-06-06 12:54:13
    复制文字到剪贴板的几种方法 工作中经常会遇到复制文字到剪贴板的需求,今天来整理一下几种方法。 1. 浏览器的复制命令 当一个HTML文档切换到设计模式时,document暴露 execCommand 方法,该方法允许运行命令来操纵...
  • Linux cp 复制文件强制覆盖的用法

    千次阅读 2021-11-24 10:52:11
    一两个文件很少量的还好说,就输几个yes 进行覆盖,但是要是n多文件怎么办,手动输入也太麻烦了,主要有以下几种解决办法。 方法一 为什么 rm -rf 文件或目录 就可以达到强制的效果呢,即使文件或者目录不存在也不会...
  • 然而有几种方法可以进行Java文件复制操作,下面列举出4中最受欢迎的方式。 1. 使用FileStreams复制 这是最经典的方式将一个文件的内容复制到另一个文件中。 使用FileInputStream读取文件A的字节,使用Fil
  • 两台Linux系统之间传输文件几种方法

    万次阅读 多人点赞 2016-06-14 17:11:23
    scp传输当两台LINUX主机之间要互传文件时可使用SCP命令来实现scp传输速度较慢,但使用ssh通道保证了传输的安全性复制文件 将本地文件拷贝到远程 scp 文件名 –用户名@计算机IP或者计算机名称:远程路径 从远程将文件拷...
  • Java获取文件类型的5种方法

    万次阅读 2021-02-05 08:00:00
    前言工作中经常会用到,判断一个文件文件类型,这里总结一把,一般判断文件类型的原理有2方式:根据文件扩展名判断优点:速度快,代码简单缺点:无法判断出真实的文件类型,例如一些伪造的文件或者...
  •  Vmware正确安装完linux虚拟机之后,这里以Ubuntu为例(其他linux或windows系统也是类似的),... 下面把可能的几种情况做一个总结,包括手工安装vmware tools的两种方法。 一、Vmware tools灰色不能安装 打开vm...
  • 从主机复制文件到Docker的几种方法

    千次阅读 2014-10-21 10:33:26
    今天我们来讲解一下从主机复制文件到Docker的几种方法. 在分享之前, 我们看看Docker社区对这个问题的需求是有多么强(ju)烈(jin). 下面开始今天高(tu)大(yuan)上(fei)的分享. 1. 通过Build Docker Image添加...
  • Linux下同时复制多个文件

    千次阅读 2021-05-12 15:35:19
    file2,file3,file4} /home/usr/destination/需要注意的是这文件之间不要有空格具有共同前缀cp /home/usr/dir/file{1..4} ./复制文件是file1, file2, file3, file4方法二使用python脚本 shutil库import os,sys,...
  • java复制文件的4方式

    千次阅读 2018-10-11 11:08:06
    这是最经典的方式将一个文件的内容复制到另一个文件中。 使用FileInputStream读取文件A的字节,使用FileOutputStream写入到文件B。 这是第一个方法的代码: 1 private static void copyFileUsingFileStreams...
  • 一、使用FileZilla上传文件 1.启动虚拟机,打开Linux终端,输入ifconfig命令查看IP地址 IP地址为192.168.59.6 2.打开FileZilla,输入IP地址,用户名,密码,端口号,点击快速连接 连接成功后,左边为...
  • 1.虚拟机和主机之间在安装了VMWare Tool之后可以实现剪贴板的共享,即可以复制粘贴。但是中文目录和中文文件和带空格的路径会出现不能拷贝的情况。2.网络共享文件:虚拟机网络设置为NAT方式。使用Feiq等文件传输工具...
  • Java复制文件的4方式

    万次阅读 2018-03-30 13:33:07
    java复制文件的4种方式... 然而有几种方法可以进行Java文件复制操作,下面列举出4中最受欢迎的方式。 1. 使用FileStreams复制 这是最经典的方式将一个文件的内容复制到另一个文件中。 使用FileInputStream读取文件A...
  • linux复制文件命令

    千次阅读 2021-01-23 15:55:15
    定义:cp is short for copy, 意为复制文件。用于将文件或目录从一个位置复制到另一个位置。 参数列表预览: 用法1: $ cp sourceFile destinationFile 当sourceFile 和 destinationFile 参数都是文件名时,cp ...
  • 快速删除大文件1. 通过重定向到 Null 来清空文件内容清空或者让一个文件成为空白的最简单方式,是像下面那样,通过 shell 重定向 null (不存在的事物)到该文件:# &...另一清空文件方法是将 : 或者 true 内...
  • 本文介绍几种常见的方法,把文件上传到Linux服务器中!常见有使用:scp命令、xshell软件里的xftp程序、U盘挂载、服务器自带的lrzsz程序。一、scp使用说明:1、把本机的文件传给目的服务器:1scp get66.pcap root@...
  • JAVA中文件写入的6种方法

    千次阅读 2021-08-26 10:35:10
    在 Java 中操作文件方法本质上只有两:字符流和字节流,而字节流和字符流的实现类又有很多,因此在文件写入时我们就可以选择各种各样的类来实现。我们本文就来盘点一下这些方法,顺便测试一下它们性能,以便为...
  • Java对象的快速复制几种方式

    万次阅读 2018-07-25 18:01:08
    浅拷贝、深度复制、BeanUtils.copyProperties() 对象的克隆是指创建一个新的对象,且新的对象的状态与原始对象的状态相同。当对克隆的新对象进行修改时,不会影响原始对象的状态。 注释:clone()是object类的...
  • 随着互联网的飞速发展,人们...不过现在有很多读者对文件加密的方法还不太了解,所以今天笔者就为大家介绍几种文件加密的方法,让大家远离各种“门”。Windows加密从Windows Vista时代开始,微软系统就会自带一个Bit...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 602,013
精华内容 240,805
关键字:

复制文件的几种方法