精华内容
下载资源
问答
  • Java对象的复制四种方式

    千次阅读 2019-03-16 08:57:56
    先介绍一下两不同的克隆方法,浅克隆(ShallowClone)和深克隆(DeepClone)。 在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用...

    1、概述
    在实际编程过程中,我们常常要遇到这种情况:有一个对象A,在某一时刻A中已经包含了一些有效值,此时可能 会需要一个和A完全相同新对象B,并且此后对B任何改动都不会影响到A中的值,也就是说,A与B是两个独立的对象,但B的初始值是由A对象确定的。例如下面程序展示的情况:

    class Student {  
        private int number;  
    
        public int getNumber() {  
            return number;  
        }  
    
        public void setNumber(int number) {  
            this.number = number;  
        }  
    
    }  
    public class Test {   
        public static void main(String args[]) {  
            Student stu1 = new Student();  
            stu1.setNumber(12345);  
            Student stu2 = stu1;  
            stu1.setNumber(54321);  
            System.out.println("学生1:" + stu1.getNumber());  
            System.out.println("学生2:" + stu2.getNumber());  
        }  
    }

    结果:

    学生1:54321 
    学生2:54321

    为什么改变学生2的学号,学生1的学号也发生了变化呢? 
    原因出在(stu2 = stu1) 这一句。该语句的作用是将stu1的引用赋值给stu2, 
    这样,stu1和stu2指向内存堆中同一个对象。如图:

    è¿éå代ç ç

    那么,怎么能干干净净清清楚楚地复制一个对象呢。在 Java语言中,用简单的赋值语句是不能满足这种需求的。要满足这种需求有很多途径, 
    (1)将A对象的值分别通过set方法加入B对象中; 
    (2)通过重写java.lang.Object类中的方法clone(); 
    (3)通过org.apache.commons中的工具类BeanUtils和PropertyUtils进行对象复制; 
    (4)通过序列化实现对象的复制。

    2、将A对象的值分别通过set方法加入B对象中
    对属性逐个赋值,本实例为了演示简单就设置了一个属性:

    Student stu1 = new Student();  
    stu1.setNumber(12345);  
    Student stu2 = new Student();  
    stu2.setNumber(stu1.getNumber());

    我们发现,属性少对属性逐个赋值还挺方便,但是属性多时,就需要一直get、set了,非常麻烦。

    3、重写java.lang.Object类中的方法clone()
    先介绍一下两种不同的克隆方法,浅克隆(ShallowClone)和深克隆(DeepClone)。

    在Java语言中,数据类型分为值类型(基本数据类型)和引用类型,值类型包括int、double、byte、boolean、char等简单数据类型,引用类型包括类、接口、数组等复杂类型。浅克隆和深克隆的主要区别在于是否支持引用类型的成员变量的复制,下面将对两者进行详细介绍。

    3.1 浅克隆
    一般步骤:

    被复制的类需要实现Clonenable接口(不实现的话在调用clone方法会抛出CloneNotSupportedException异常), 该接口为标记接口(不含任何方法)

    覆盖clone()方法,访问修饰符设为public。方法中调用super.clone()方法得到需要的复制对象。(native为本地方法)

    class Student implements Cloneable{  
        private int number;  
    
        public int getNumber() {  
            return number;  
        }  
    
        public void setNumber(int number) {  
            this.number = number;  
        }  
    
        @Override  
        public Object clone() {  
            Student stu = null;  
            try{  
                stu = (Student)super.clone();  
            }catch(CloneNotSupportedException e) {  
                e.printStackTrace();  
            }  
            return stu;  
        }  
    }  
    public class Test {  
        public static void main(String args[]) {  
            Student stu1 = new Student();  
            stu1.setNumber(12345);  
            Student stu2 = (Student)stu1.clone();  
    
            System.out.println("学生1:" + stu1.getNumber());  
            System.out.println("学生2:" + stu2.getNumber());  
    
            stu2.setNumber(54321);  
    
            System.out.println("学生1:" + stu1.getNumber());  
            System.out.println("学生2:" + stu2.getNumber());  
        }  
    }  

    结果: 
    学生1:12345 
    学生2:12345 
    学生1:12345 
    学生2:54321

    在浅克隆中,如果原型对象的成员变量是值类型,将复制一份给克隆对象;如果原型对象的成员变量是引用类型,则将引用对象的地址复制一份给克隆对象,也就是说原型对象和克隆对象的成员变量指向相同的内存地址。

    简单来说,在浅克隆中,当对象被复制时只复制它本身和其中包含的值类型的成员变量,而引用类型的成员对象并没有复制。

     è¿éåå¾çæè¿°
    在Java语言中,通过覆盖Object类的clone()方法可以实现浅克隆。3.2 深克隆

    package abc;  
    
    class Address implements Cloneable {  
        private String add;  
    
        public String getAdd() {  
            return add;  
        }  
    
        public void setAdd(String add) {  
            this.add = add;  
        }  
    
        @Override  
        public Object clone() {  
            Address addr = null;  
            try{  
                addr = (Address)super.clone();  
            }catch(CloneNotSupportedException e) {  
                e.printStackTrace();  
            }  
            return addr;  
        }  
    }  
    
    class Student implements Cloneable{  
        private int number;  
    
        private Address addr;  
    
        public Address getAddr() {  
            return addr;  
        }  
    
        public void setAddr(Address addr) {  
            this.addr = addr;  
        }  
    
        public int getNumber() {  
            return number;  
        }  
    
        public void setNumber(int number) {  
            this.number = number;  
        }  
    
        @Override  
        public Object clone() {  
            Student stu = null;  
            try{  
                stu = (Student)super.clone();   //浅复制  
            }catch(CloneNotSupportedException e) {  
                e.printStackTrace();  
            }  
            stu.addr = (Address)addr.clone();   //深度复制  
            return stu;  
        }  
    }  
    public class Test {  
    
        public static void main(String args[]) {  
    
            Address addr = new Address();  
            addr.setAdd("杭州市");  
            Student stu1 = new Student();  
            stu1.setNumber(123);  
            stu1.setAddr(addr);  
    
            Student stu2 = (Student)stu1.clone();  
    
            System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
            System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    
            addr.setAdd("西湖区");  
    
            System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
            System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
        }  
    }

    结果: 
    学生1:123,地址:杭州市 
    学生2:123,地址:杭州市 
    学生1:123,地址:西湖区 
    学生2:123,地址:西湖区

    怎么两个学生的地址都改变了?

    原因是浅复制只是复制了addr变量的引用,并没有真正的开辟另一块空间,将值复制后再将引用返回给新对象。

    为了达到真正的复制对象,而不是纯粹引用复制。我们需要将Address类可复制化,并且修改clone方法,完整代码如下:

    package abc;  
    
    class Address implements Cloneable {  
        private String add;  
    
        public String getAdd() {  
            return add;  
        }  
    
        public void setAdd(String add) {  
            this.add = add;  
        }  
    
        @Override  
        public Object clone() {  
            Address addr = null;  
            try{  
                addr = (Address)super.clone();  
            }catch(CloneNotSupportedException e) {  
                e.printStackTrace();  
            }  
            return addr;  
        }  
    }  
    
    class Student implements Cloneable{  
        private int number;  
    
        private Address addr;  
    
        public Address getAddr() {  
            return addr;  
        }  
    
        public void setAddr(Address addr) {  
            this.addr = addr;  
        }  
    
        public int getNumber() {  
            return number;  
        }  
    
        public void setNumber(int number) {  
            this.number = number;  
        }  
    
        @Override  
        public Object clone() {  
            Student stu = null;  
            try{  
                stu = (Student)super.clone();   //浅复制  
            }catch(CloneNotSupportedException e) {  
                e.printStackTrace();  
            }  
            stu.addr = (Address)addr.clone();   //深度复制  
            return stu;  
        }  
    }  
    public class Test {  
    
        public static void main(String args[]) {  
    
            Address addr = new Address();  
            addr.setAdd("杭州市");  
            Student stu1 = new Student();  
            stu1.setNumber(123);  
            stu1.setAddr(addr);  
    
            Student stu2 = (Student)stu1.clone();  
    
            System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
            System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
    
            addr.setAdd("西湖区");  
    
            System.out.println("学生1:" + stu1.getNumber() + ",地址:" + stu1.getAddr().getAdd());  
            System.out.println("学生2:" + stu2.getNumber() + ",地址:" + stu2.getAddr().getAdd());  
        }  
    }

    结果: 
    学生1:123,地址:杭州市 
    学生2:123,地址:杭州市 
    学生1:123,地址:西湖区 
    学生2:123,地址:杭州市

    在深克隆中,无论原型对象的成员变量是值类型还是引用类型,都将复制一份给克隆对象,深克隆将原型对象的所有引用对象也复制一份给克隆对象。

    简单来说,在深克隆中,除了对象本身被复制外,对象所包含的所有成员变量也将复制。 
     è¿éåå¾çæè¿°
    在Java语言中,如果需要实现深克隆,可以通过覆盖Object类的clone()方法实现,也可以通过序列化(Serialization)等方式来实现。

    (如果引用类型里面还包含很多引用类型,或者内层引用类型的类里面又包含引用类型,使用clone方法就会很麻烦。这时我们可以用序列化的方式来实现对象的深克隆。)

    4、工具类BeanUtils和PropertyUtils进行对象复制

    Student stu1 = new Student();  
    stu1.setNumber(12345);  
    Student stu2 = new Student(); 
    BeanUtils.copyProperties(stu2,stu1);

    这种写法无论多少种属性都只需要一行代码搞定,很方便吧!除BeanUtils外还有一个名为PropertyUtils的工具类,它也提供copyProperties()方法,作用与BeanUtils的同名方法十分相似,主要的区别在于BeanUtils提供类型转换功能,即发现两个JavaBean的同名属性为不同类型时,在支持的数据类型范围内进行转换,而PropertyUtils不支持这个功能,但是速度会更快一些。在实际开发中,BeanUtils使用更普遍一点,犯错的风险更低一点。

    5、通过序列化实现对象的复制
    序列化就是将对象写到流的过程,写到流中的对象是原有对象的一个拷贝,而原对象仍然存在于内存中。通过序列化实现的拷贝不仅可以复制对象本身,而且可以复制其引用的成员对象,因此通过序列化将对象写到一个流中,再从流里将其读出来,可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口,否则无法实现序列化操作。

    要更多干货、技术猛料的孩子,快点拿起手机扫码关注我,我在这里等你哦~

                                                           

    展开全文
  • js 复制文本的四种方式

    万次阅读 2017-04-21 09:50:02
    目前copy主流有四种方式:ZeroClipboard,Clipboard.js,execCommand,setData,再就是其他只支持IE的鸡肋法了不在此讨论。。 概况:  ZeroClipboard 就是常说的Flash法,通过加载一个Flash,让其

    纯 转载复制,非原创

    原地址:http://www.cnblogs.com/xhyu/p/5370111.html

    目前copy主流有四种方式:ZeroClipboardClipboard.jsexecCommand,setData,再就是其他只支持IE的鸡肋法了不在此讨论。。

    概况:

      ZeroClipboard 就是常说的Flash法,通过加载一个Flash,让其访问系统剪贴板来绕过绝大多数系统的权限限制,然而体积稍微庞大些

      Clipboard.js 近几年使用较多,体积相对小,兼容性可以接受,使用还比较方便。

      execCommand 新兴势力,safari等主流正在努力兼容,是个好东西。

      setData 太老。。一般不太用,基本只适合IE

    兼容性:

      ZeroClipboard 兼容性最好,能全面兼容chrome/ FireFox/ IE/ 甚至Safari 这种“友好”的浏览器

      Clipboard.js和execCommand兼容性相似,兼容chrome/ FF/ IE>9/ Safari新版(不太懂Safari版本号如何算。。感觉15年以后的都可以)

      setData 仅IE

    体积:

      ZeroClipboard 插件较大,230KB

      Clipboard.js 较小,4KB

      execCommand是document方法,不用插件直接搞

    虽说体积有差,加载起来速度差不多的其实。。话说git好像就是用的ZeroClipboard

     

    Clipboard.js 实验经过:

      直接忽略胖胖的Flash法,,先盯上的Clipboard.js,用起来着实简单,先引用压缩版:

    <script src="dist/clipboard.min.js"></script>

    新建Clipboard对象(顺便:'.btn'给所有class="btn"的元素都加了监听,其他用法可查JS)

    复制代码
    var clipboard = new Clipboard('.btn');
    
    //可以自己加些处理
    clipboard.on('success', function(e) {
        console.info('Action:', e.action);
        console.info('Text:', e.text);
        console.info('Trigger:', e.trigger);
    
        e.clearSelection();
    });
    clipboard.on('error', function(e) {
        console.error('Action:', e.action);
        console.error('Trigger:', e.trigger);
    });
    复制代码

    HTML里这样就OK了

    <button class="btn" data-clipboard-target="#foo">

    使用清爽,测试通过,然而项目只有一个地方用到copy,为了他加个插件真是不优美。。于是终于找到了近期出现的execCommand()大法 (生在了好时代Orz)

     

    execCommand()大法:

      其实只需要选中要复制的内容,执行document.execCommand('copy', false, null)就好了。execCommand里可以跑很多例如paste等方法,第一个参数是方法名,第二个是是否展示默认ui,第三个是可选参数列表,对copy来说后两个都用不到。

      根据兼容不同,执行后可能的情况(涉及返回值):

        1.不支持execCommand:抛出异常          2.不支持copy方法:返回false                    3.成功:true

      因此框架可以这样写:

    复制代码
    copy_target.focus();
    copy_target.select();
    try{
        if(document.execCommand('copy', false, null)){
            //success info
        } else{
            //fail info
        }
    } catch(err){
        //fail info
    }
    复制代码

      给用户的反馈用的jquery的tooltip,然后写成一个function就是如下:

    复制代码
    function copy(copytargetid,copybtnid){
        var cpt = document.getElementById(copytargetid);
        var cpb = document.getElementById(copybtnid);
        $(cpt).focus();
        $(cpt).select();
        try{
            if(document.execCommand('copy', false, null)){
                $(cpb).tooltip({title:"copied!", placement: "bottom", trigger: "manual"});
                $(cpb).tooltip('show');
                cpb.onmouseout=function(){$(cpb).tooltip('destroy')};
            } else{
                $(cpb).tooltip({title:"failed!", placement: "bottom", trigger: "manual"});
                $(cpb).tooltip('show');
                cpb.onmouseout=function(){$(cpb).tooltip('destroy')};
            }
        } catch(err){
            $(cpb).tooltip({title:"failed!", placement: "bottom", trigger: "manual"});
            $(cpb).tooltip('show');
            cpb.onmouseout=function(){$(cpb).tooltip('destroy')};
        }
    }
    复制代码

    用的时候直接

    <button id="cpbtn" onclick="copy('cptar', 'cpbtn')">copy</button>

    即可

     

    到此还没有结束。。。

    项目用的vue,于是需要做成vue的method,又是用coffee写的,改了下语法,在初次渲染的html中测试通过了,然后。。。我的copy妞是个vex模态框。。button是写在vex.dialog.open的message里的,message是个字符串,弹窗时候强注一段html。而且vue函数是只在渲染阶段绑定,所以。。。初次vue渲染的时候不会识别到字符串中的v-on:click,无法绑定。。于是不能从button元素直接调。

    决定搞一个隐藏input中继一下,最后终于用比较优美的姿势实现了。。。(上次是直接在message里强行注入script。。。涉及script嵌套还加了个转义<\/script>,结果丑的一bi。。)

    button里 οnclick="document.getElementById('copyrelay').select()",input里@select('copy(...)')(@是vue的v-on:的缩写)。

    终于测试一切完好,天真的以为加个display: none就大功告成。。结果发现跪了

    原来是display:none的元素并不能被select。。

    同样的,也不能focus, change等等,于是顺着onerror等事件挨个试了一遍。。发现貌似只有onclick work。。。

    另外还顺带试了一下,<input type="hidden"/>也是不能用那些事件;即使正常显示元素,value=""的话也不能触发select。

    当然,至于是.select()没有成功,还是元素没有触发select事件,还是没有触发v-on:select,有待确定,有时间可以试一下。

     

    Anyway,最终代码:

    <input id="copyrelay" style="display: none;" @click=“copy('cptg','cpbt')”/>
    
    <!--vex.dialog.open的message中:-->
    <input id="cpbt" type="button" onclick="document.getElementById('copyrelay').click()"/>
    <input id="cptg" value="copy test" readonly/>

    method中的copy函数如上所提,转为coffee。

     

    我这个伪frontend太弱了。。还是希望给贵司多搞点贡献。。。

    感谢lrx,lyy,P8,zzl,xxm犇们Orz。。。

    就这样。

    展开全文
  • * 字节流四种方式复制文件: * 基本字节流一次读写一个字节: 共耗时:117235毫秒 * 基本字节流一次读写一个字节数组: 共耗时:156毫秒 * 高效字节流一次读写一个字节: 共耗时:1141毫秒 * 高效字节流一次读写...
    /*
    * 需求:把e:\\a.mp4复制到当前项目目录下的copy.mp4中
    *
    * 字节流四种方式复制文件:
    * 基本字节流一次读写一个字节: 共耗时:117235毫秒
    * 基本字节流一次读写一个字节数组: 共耗时:156毫秒
    * 高效字节流一次读写一个字节: 共耗时:1141毫秒
    * 高效字节流一次读写一个字节数组: 共耗时:47毫秒

    */

    package cn.itcast_06;
    
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    
    
    public class CopyMp4Demo {
    	public static void main(String[] args) throws IOException {
    		long start = System.currentTimeMillis();
    		// method1("e:\\a.mp4", "copy1.mp4");
    		// method2("e:\\a.mp4", "copy2.mp4");
    		// method3("e:\\a.mp4", "copy3.mp4");
    		method4("e:\\a.mp4", "copy4.mp4");
    		long end = System.currentTimeMillis();
    		System.out.println("共耗时:" + (end - start) + "毫秒");
    	}
    
    	// 高效字节流一次读写一个字节数组:
    	public static void method4(String srcString, String destString)
    			throws IOException {
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    				srcString));
    		BufferedOutputStream bos = new BufferedOutputStream(
    				new FileOutputStream(destString));
    
    		byte[] bys = new byte[1024];
    		int len = 0;
    		while ((len = bis.read(bys)) != -1) {
    			bos.write(bys, 0, len);
    		}
    
    		bos.close();
    		bis.close();
    	}
    
    	// 高效字节流一次读写一个字节:
    	public static void method3(String srcString, String destString)
    			throws IOException {
    		BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    				srcString));
    		BufferedOutputStream bos = new BufferedOutputStream(
    				new FileOutputStream(destString));
    
    		int by = 0;
    		while ((by = bis.read()) != -1) {
    			bos.write(by);
    
    		}
    
    		bos.close();
    		bis.close();
    	}
    
    	// 基本字节流一次读写一个字节数组
    	public static void method2(String srcString, String destString)
    			throws IOException {
    		FileInputStream fis = new FileInputStream(srcString);
    		FileOutputStream fos = new FileOutputStream(destString);
    
    		byte[] bys = new byte[1024];
    		int len = 0;
    		while ((len = fis.read(bys)) != -1) {
    			fos.write(bys, 0, len);
    		}
    
    		fos.close();
    		fis.close();
    	}
    
    	// 基本字节流一次读写一个字节
    	public static void method1(String srcString, String destString)
    			throws IOException {
    		FileInputStream fis = new FileInputStream(srcString);
    		FileOutputStream fos = new FileOutputStream(destString);
    
    		int by = 0;
    		while ((by = fis.read()) != -1) {
    			fos.write(by);
    		}
    
    		fos.close();
    		fis.close();
    	}
    }
    


    展开全文
  • 使用字节流操作时文件,有四种方式,现对一个flac文件分别使用四种方式进行复制,测试其效率。测试类:public static void main(String[] args) throws IOException { long startTime = System.cur

    在java.io包中操作文件内容的主要有两大类:字节流、字符流。在对音乐和视频等文件进行IO操作时,都是使用字节流。
    使用字节流操作时文件,有四种方式,现对一个flac文件分别使用四种方式进行复制,测试其效率。

    测试类:

    public static void main(String[] args) throws IOException {
        long startTime = System.currentTimeMillis();
        //此处调用复制方法。
        long endTime = System.currentTimeMillis();
        System.out.println("耗时: " + (endTime - startTime) + " 毫秒。");
    
    }

    1、使用基本字节流一次读写一个字节

    public static void method1() throws IOException {
        FileInputStream fis = new FileInputStream(new File("flacTest.flac"));
        FileOutputStream fos = new FileOutputStream(new File("copy1.flac"));
    
        int by = 0;
        while ((by = fis.read()) != -1) {
            fos.write(by);
        }
    
        fos.close();
        fis.close();
    }

    2、使用基本字节流一次读写一个字节数组

    public static void method2() throws IOException {
        FileInputStream fis = new FileInputStream(new File("flacTest.flac"));
        FileOutputStream fos = new FileOutputStream(new File("copy2.flac"));
    
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = fis.read(bys)) != -1) {
            fos.write(bys, 0, len);
        }
    
        fos.close();
        fis.close();
    }
    

    3、使用高效字节流一次读写一个字节

    public static void method3() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                "flacTest.flac"));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("copy3.flac"));
        int by = 0;
        while ((by = bis.read()) != -1) {
            bos.write(by);
        }
    
        bos.close();
        bis.close();
    }
    

    4、使用高效字节流一次读写一个字节数组

    public static void method4() throws IOException {
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
                "flacTest.flac"));
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream("copy4.flac"));
    
        byte[] bys = new byte[1024];
        int len = 0;
        while ((len = bis.read(bys)) != -1) {
            bos.write(bys, 0, len);
        }
    
        bos.close();
        bis.close();
    }
    

    测试文件大小为 26,817,919 bytes。

    使用四种复制方法,耗时分别为:68420 毫秒;138 毫秒;877 毫秒;64 毫秒。

    展开全文
  • 四种文件复制方式的效率比较 文件复制方式,字节流,一共4个方式,源文件的大小是:40.8 MB (42,885,472 字节) 1.字节流读写单个字节 运行时间:210546ms 2.字节流读写字节数组 运行时间:438ms 3.字节流缓冲区读写...
  • java复制文件的4种方式

    万次阅读 多人点赞 2016-08-02 22:38:44
    java复制文件的几种方式
  • Java复制文件的4种方式

    万次阅读 多人点赞 2017-09-30 14:38:37
    java复制文件的4种方式 摘要 尽管Java提供了一个可以处理文件的IO操作类。 但是没有一个复制文件的方法。 复制文件是一个重要的操作,当你的程序必须处理很多文件相关的时候。 然而有几种方法可以进行Java文件...
  • 数组的四种复制方法

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

    千次阅读 2018-01-21 21:59:34
    // 第四种: 使用FileOutputStream和FileInputStream,一次读取一个字节数组 FileInputStream fis = new FileInputStream("D:\\a.txt"); FileOutputStream fos = new FileOutputStream("D:\\b.txt"); int ch; ...
  • Copy ArrayList的四种方式

    千次阅读 2020-05-01 08:47:40
    Copy ArrayList的四种方式 简介 ArrayList是我们经常会用到的集合类,有时候我们需要拷贝一个ArrayList,今天向大家介绍拷贝ArrayList常用的四种方式。 使用构造函数 ArrayList有个构造函数,可以传入一个集合: ...
  • 实现web数据同步的四种方式

    千次阅读 2016-07-23 00:42:58
    实现web数据同步的四种方式 ======================================= 1、nfs实现web数据共享 2、rsync +inotify实现web数据同步 3、rsync+sersync更快更节约资源实现web数据同步 4、unison+inotify实现web数据...
  • java复制数组的四种方法

    千次阅读 2017-07-25 20:45:19
    java语言的下面几数组复制方法中,哪个效率最高? 正确答案: B 你的答案: C (错误) for 循环逐一复制 System.arraycopy Array.copyOf 使用clone方法
  • Java对象的快速复制的几种方式

    万次阅读 2018-07-25 18:01:08
    浅拷贝、深度复制、BeanUtils.copyProperties() 对象的克隆是指创建一个新的对象,且新的对象的状态与原始对象的状态相同。当对克隆的新对象进行修改时,不会影响原始对象的状态。 注释:clone()是object类的...
  • 部署Web应用的四种方式

    千次阅读 2017-02-24 22:50:50
    在Tomcat中部署Web应用的四种方式:-利用Tomcat自动部署 -利用控制台部署 -增加自定义的Web部署文件 -修改server.xml文件部署Web应用1、利用Tomcat自动部署将Web应用复制到Tomcat的webapps下,系统将会把该应用...
  • 谈容灾,谈灾备,我们总是不可避免的要提到复制技术。因为复制技术具有备份所不具备的切换优势(详见备份和复制的区别),能够得到更好的恢复点目标(PRO)和恢复时间...按照技术特点分为两模式:同步复制(又称实时复
  • 创建线程池的四种方式

    万次阅读 2019-02-22 09:41:40
    Java通过Executors提供四种线程池,分别为: newCachedThreadPool创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。 newFixedThreadPool 创建一个定长线程池,可...
  • Redis持久化的四种方式

    万次阅读 2017-02-28 14:39:51
    redis支持四种持久化方式,一是 Snapshotting(快照)也是默认方式;二是Append-only file(缩写aof)的方式;三是虚拟内存方式;四是diskstore方式。下面分别介绍之。 (一)Snapshotting  快照是默认的...
  • 本地直播平台的搭建—四种方式

    万次阅读 多人点赞 2018-11-16 16:26:23
    本地直播平台的搭建—四种方式方法一:Windows下用FFmpeg+nginx+rtmp搭建直播环境 实现推流、拉流 (`测试通过`)环境1. 简介:2. 准备文件3. 启动nginx服务器4. 配置FFmpeg5.运行方法二:打开两个VLC,一个作为推流...
  • Golang文件写入的四种方式

    千次阅读 2020-06-03 20:47:08
    复制操作的文件写入 Golang 中关于文件写入的方法很多 简单覆盖式文件写入 常规文件写入 带有缓冲区的文件写入 复制操作的文件写入 1. 简单覆盖式文件写入 特点 : 操作简单一个函数完成数据写入 新内容覆盖旧...
  • WebService 四种发布方式总结

    万次阅读 多人点赞 2016-06-08 12:03:32
    WebService 四种发布方式总结 1. CXF方式 CXF与spring搭建webservice是目前最流行的方式,但是传闻cxf与jdk1.5有些不兼容,我没有遇到过,我遇到的问题是cxf与was6.1.1不兼容,表现在cxf必须的jar包“wsdl4j-...
  • linux服务器之间传输文件的四种方式

    万次阅读 多人点赞 2018-05-02 16:11:47
    本文为大家分享了linux服务器之间传输文件的四种方式,供大家参考,具体内容如下1. scp【优点】简单方便,安全可靠;支持限速参数 【缺点】不支持排除目录【用法】scp就是secure copy,是用来进行远程文件拷贝的。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 441,231
精华内容 176,492
关键字:

复制的四种方式