java复制

① java怎么实现文件拷贝

工具/原料

一台配置了java环境的电脑

一款适合自己的开发集成环境，这里用的是eclipse Kepler

文件拷贝DEMO

1.首先，理清思路，然后我们再动手操作。

拷贝，有源文件，和目的文件。

如果原文件不存在，提示，报错。

如果目的文件不存在，创建空文件并被覆盖。

如果目的地址，也即目的路径不存在，创建路径。

拷贝，输入流，输出流，关闭流。

拷贝前输出文件大小，计算拷贝大小，比较并核实。输出。

② Java 如何复制对象

可以使用clone来实现，clone用于为引用类型的复制
1.使用clone方法的类必须先实现Cloneable接口，不然clone方法会直接返回CloneNotSupportedException不支持克隆的异常
2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。
3、在Java.lang.Object类中克隆方法是这么定义的：
protected Object clone()
throws CloneNotSupportedException
创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。

③ java中数组复制的方法有几种

最简单的一种就是直接挨个把原数组的值赋给新数组 不过一般都用System.array(原数组起始复制的标号，新数组接收复制的起始标号，赋值的长度) 这个方法

例如：public class llx {
public static void main(String args[]) {
int a[] = {1,2,3,4,5};
int b[] = new int[10];//搞一个10位置的新数组
System.array(a[0],b[0],a.length);//从a的第一个位置开始复制；从b的第一个位置开始接收；一共接收a的总长度（a.length)；；；懂了吗？这样的话 b的前5个值就被传递了，但是后5个是初始值0。
}
}

补充：Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。

④ java怎么复制一个一样的对象

可以使用clone来实现，clone用于为引用类型的复制
1.使用clone方法的类必须先实现Cloneable接口，不然clone方法会直接返回CloneNotSupportedException不支持克隆的异常
2、实现Cloneable接口的类应该使用公共方法重写 Object.clone（它是受保护的）。某个对象实现了此接口就克隆它是不可能的。即使 clone 方法是反射性调用的，也无法保证它将获得成功。
3、在Java.lang.Object类中克隆方法是这么定义的：
protected Object clone()
throws CloneNotSupportedException
创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见。
按照惯例，返回的对象应该通过调用 super.clone 获得。

详见关于clone的API文档

⑤ java中如何实现快速复制文件

public class IOTest2 {

/**
* @author jiang
* @param args
* BufferedReader
* BufferedWriter
* @throws IOException
*/
public static void main(String[] args) throws IOException {
//一次能读取一行 readLine()方法
BufferedReader br=new BufferedReader(new InputStreamReader(new FileInputStream("1.txt")));
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("2.txt")));
String str=null;
while((str=br.readLine())!=null){
//文件末尾读取为null就结束
bw.write(str);
}
bw.flush();//写入后刷新
bw.close();//关闭文件
br.close();//关闭文件
}
}

⑥ java文件复制粘贴

复制粘贴实际上是文件的流读取和写入可以通过如下方法实现：
读写是两个不同的分支，通常都是分开单独使用的。
可以通过BufferedReader 流的形式进行流缓存，之后通过readLine方法获取到缓存的内容。
BufferedReader bre = null;
try {
String file = "D:/test/test.txt";
bre = new BufferedReader(new FileReader(file));//此时获取到的bre就是整个文件的缓存流
while ((str = bre.readLine())!= null) // 判断最后一行不存在，为空结束循环
{
System.out.println(str);//原样输出读到的内容
}；
备注： 流用完之后必须close掉，如上面的就应该是：bre.close()，否则bre流会一直存在，直到程序运行结束。
可以通过“FileOutputStream”创建文件实例，之后过“OutputStreamWriter”流的形式进行存储，举例：
OutputStreamWriter pw = null;//定义一个流
pw = new OutputStreamWriter(new FileOutputStream(“D:/test.txt”),"GBK");//确认流的输出文件和编码格式，此过程创建了“test.txt”实例
pw.write("我是要写入到记事本文件的内容");//将要写入文件的内容，可以多次write
pw.close();//关闭流
备注：文件流用完之后必须及时通过close方法关闭，否则会一直处于打开状态，直至程序停止，增加系统负担。

⑦ java中复制字符串

主要部分就1句

text2.setText(text1.getSelectedText());

⑧ java如何实现文件的复制粘贴

打开D盘，点编辑，全部选定，右键点变篮的文件选复制，打开E盘右键点空白处选粘贴。

⑨ java 如何拷贝

package czday0017;

import java.io.*;
import java.util.*;
/** IO 工具类 */
public class IO {
/**
* 获取目录的全部文件
* @param dir
* @return
*/
public static List<File> listFile(File dir){
return null;
}
/**
* 获取目录的全部文件, 指定扩展名的文件
* @param dir
* @return
*/
public static List<File> listFile(
File dir, String ext){
return null;
}
/**
* 递归获取目录的全部文件
* @param dir
* @return
*/
public static List<File> listAll(
File dir){
return null;
}
/**
* 递归获取目录的全部文件, 指定扩展名的文件
* @param dir
* @return
*/
public static List<File> listAll(
File dir, String ext){
return null;
}

/**
* 复制文件
*/
public static void cp(String from, String to)
throws IOException {
cp(new File(from), new File(to));
}
/**
* 复制文件
*/
public static void cp(File from, File to)
throws IOException {
cp(new FileInputStream(from),
new FileOutputStream(to));
}
/**
* 复制文件
*/
public static void cp(InputStream in,
OutputStream out)
throws IOException {
//1K byte 的缓冲区!
byte[] buf = new byte[1024];
int count;
while((count=in.read(buf))!=-1){
System.out.println(count);
out.write(buf, 0, count);
}
in.close();
out.close();
}
/**
* 从流中读取一行文本, 读取到一行的结束为止
* @param in
* @return 一行文本
*/
public static String readLine(
InputStream in, String charset)
throws IOException{
byte[] buf = {};
int b;
while(true){
b = in.read();
if(b=='\n' || b=='\r' || b==-1){//编码是否是回车换行
break;
}
buf=Arrays.Of(buf, buf.length+1);
buf[buf.length-1]=(byte)b;
}
if(buf.length==0 && b==-1)
return null;
return new String(buf,charset);
}

/**
* 读取文件的全部内容到一个byte数组
* 可以缓存一个"小"文件到堆内存中
*/
public static byte[] read(String filename)
throws IOException{
return read(new File(filename));
}
/**
* 读取文件的全部内容到一个byte数组
* 可以缓存一个"小"文件到堆内存中
*/
public static byte[] read(File file)
throws IOException{
//用RAF打开文件
RandomAccessFile raf =
new RandomAccessFile(file, "r");
//安装文件的长度开辟 缓冲区数组(byte数组)
byte[] buf = new byte[(int)raf.length()];
//读取文件的缓冲区
raf.read(buf);
//关闭文件(RAF)
raf.close();
//返回缓冲区数组引用.
return buf;
}
/**
* 读取文件的全部内容到一个byte数组
* 可以缓存一个"小"文件到堆内存中
* 如: 文件内容: ABC中 读取为: {41, 42, 43, d6, d0}
*/
public static byte[] read(InputStream in)
throws IOException{
byte[] ary = new byte[in.available()];
in.read(ary);
in.close();
return ary;
}
/**
* 连接byte 数组的全部内容为字符串,
* 以hex(十六进制)形式连接
* 如: 数组{0x41, 0x42, 0x43, 0xd6, 0xd0}
* 结果: "[41, 42, 43, d6, d0]"
*/
public static String join(byte[] ary){
if(ary==null || ary.length==0)
return "[]";
StringBuilder buf =
new StringBuilder();
buf.append("[").append(
leftPad(Integer.toHexString(ary[0]&0xff),'0',2));
for(int i=1; i<ary.length; i++){
String hex=Integer.toHexString(ary[i]&0xff);
buf.append(",").append(leftPad(hex,'0',2));
}
buf.append("]");
return buf.toString();
}

public static String toBinString(byte[] ary){
if(ary==null || ary.length==0)
return "[]";
StringBuilder buf =
new StringBuilder();
buf.append("[").append(
leftPad(Integer.toBinaryString(ary[0]&0xff),'0',8));
for(int i=1; i<ary.length; i++){
String hex=Integer.toBinaryString(ary[i]&0xff);
buf.append(",").append(leftPad(hex,'0',8));
}
buf.append("]");
return buf.toString();
}
/**
* 实现leftPad功能, 对字符串实现左填充
* @param str 被填充字符串: 5
* @param ch 填充字符: #
* @param length 填充以后的长度: 8
* @return "#######5"
*/
public static String leftPad(
String str, char ch, int length){
if(str.length() == length){
return str;
}
char[] chs = new char[length];
Arrays.fill(chs, ch);
System.array(str.toCharArray(), 0, chs,
length - str.length(), str.length());
return new String(chs);
}
/**
* 将text追加到文件 filename的尾部
* 使用系统默认文本编码
*/
public static void println (
String filename, String text)
throws IOException{
println(new File(filename),text);
}
public static void println(
File file, String text)throws IOException{
OutputStream out = new FileOutputStream(file,true);
println(out, text);
out.close();
}
/**
* 向流中输出一行字符串, 使用默认编码
* 不关闭流
* @param out 目标流
* @param text 文本
* @throws IOException
*/
public static void println(
OutputStream out, String text)throws IOException{
out.write(text.getBytes());
out.write('\n');
}
/**
* 向流中输出一行字符串, 使用指定的编码
* 不关闭流
* @param out 目标流
* @param text 文本
* @param charset 指定的编码
* @throws IOException
*/
public static void println(
OutputStream out, String text, String charset)throws IOException{
out.write(text.getBytes(charset));
out.write('\n');
}
/**
* 文件切分
* @param file
* @param size
* @throws IOException
*/
public static void spilt(String file,int size) throws IOException{
if(size<=0){
throw new IllegalArgumentException("干吗啊!输入有误阿!");
}
int idx = 0;//文件序号
InputStream in = new BufferedInputStream(new FileInputStream(file));
OutputStream out = new BufferedOutputStream(new FileOutputStream(file+"."+idx++));
int b;
int count = 0;
while((b = in.read())!=-1){
out.write(b);
count++;
if(count%(size*1024)==0 ){
out.close();
out = new BufferedOutputStream(new FileOutputStream(file+"."+idx++));
}
}
in.close();
out.close();
}
/**
* 将文件进行连接
* @param filename是一个文件名;如:file.dat.0
*/
public static void join(String file)throws IOException{
String filename = file.substring(0, file.lastIndexOf("."));
String num = file.substring(file.lastIndexOf(".")+1);
int idx = Integer.parseInt(num);
OutputStream out = new BufferedOutputStream(new FileOutputStream(filename));
File f = new File(filename+"."+idx++);
while(f.exists()){
InputStream in = new BufferedInputStream(new FileInputStream(f));
cp(in,out);
in.close();
f = new File(filename+"."+idx++);
}
out.close();
}
/**
* 序列化对象
*/
public static byte[] Serialize(Serializable obj)throws IOException{
return null;
}

public static Object unSerializable(byte[] data)throws IOException{
return null;
}

public static Object clone(Serializable obj)throws IOException{
return unSerializable(Serialize(obj)) ;
}
}

//使用cp工具!

⑩ java 怎样复制一个类

直接无视1楼
实现Cloneable接口，重载clone方法即可
public class A implements Cloneable {
public String name;

public Object clone() {
A o = null;
try {
o = (A) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}

}