bufferedinputstream的用法,Java 中 BufferedInputStream 到底有什么用？怎么感觉它很多余呢？

bufferedinputstream的用法,Java 中 BufferedInputStream 到底有什么用？怎么感觉它很多余呢？详细介绍

本文目录一览： Java 中 BufferedInputStream 到底有什么用？怎么感觉它很多余呢？

其实看使用场景，一次性读取将整个文件都加入的内存中很慢，多次读取但是每次读取字节太小也会很慢，这个速度需要一个调试权衡的过程，一般情况下8092是个比较适中的读取数组大小。其实BufferedInputStream的确有缓冲的实现，但是文件流的读取速度和缓冲关系不大，关系最大的是8092，如果将8092改成16的话就慢多了。你如果用FileInputStream读取文件每次读取数组大小也是8092，那么也不会比BufferedInputStream慢。当然缓冲流BufferedInputStream的使用场景肯定有的，而且很多，比如视频播放，音乐播放这些多媒体的场景就非常适合用缓冲流，而文件下载上传复制拷贝这些场景直接使用FileInputStream就行了
在bufferedinputstream的read函数实现当中，读多个字符是使用System.arraycopy( src, srcPos, dest, destPos, length )这个函数，意思是直接将一片内存进行拷贝过去，而不是像其他的read函数一样一次只拷贝一个字节或字符。这样就快了很多。
为什么不直接把自己buffer 写进去，感觉还是这样快!
有想法就是最好的,但是不要光感觉,你是不是可以做一些测试呢?just do it!
FileInputStream 里面的read(buffer)方法，直接读取到自己的buffer 里面
这个是读取到一个数组里面，jvm里面创建一个新对象都需要耗费时间的，而且每一次read都要执行I/O操作，比较慢。
BufferedInputStream在你创建对象的时候就已经建立好缓冲区数组拉，一定程度上可以减少java生成新对象消费的时间。另外用buffered好处，可以参考API...
作为另一种输入流，BufferedInputStream 为添加了功能，即缓冲输入和支持 mark 和 reset 方法的能力。创建 BufferedInputStream 时即创建了一个内部缓冲区数组。读取或跳过流中的各字节时，必要时可根据所包含的输入流再次填充该内部缓冲区，一次填充多个字节。mark 操作记录输入流中的某个点，reset 操作导致在从所包含的输入流中获取新的字节前，再次读取自最后一次 mark 操作以来所读取的所有字节。

缓冲流(Buffered)

缓冲流，也叫高效流，是对4个基本的Filexxx流的增强，所以也是4个流，按照数据类型分类：
缓冲流的基本原理，是在创建流对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率。
构造方法： BufferedoutputStream（OutputStream out）创建一个新的缓冲输出流，以将数据写入指定的底层输出流。 BufferedoutputStream（OutputStream out，int size）创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流
参数： OutputStream out：字节输出流 我们可以传递FileOutputStream，缓冲流会给FileOutputStream增加一个缓冲区，提高FileOutputStream的写入效率 int size：指定缓冲流内部缓冲区的大小，不指定默认
使用步骤（重点） 1.创建FiLeOutputstream对象，构造方法中绑定要输出的目的地 2.创建BufferedOutput stream对象，构造方法中传递FileOutputStream对象对象，提高FileOutputStream对象效率 3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中 4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据，刷新到文件中 5.释放资源（会先调用flush方法刷新数据，第4步可以省略）
继承自父类的成员方法： int read（）从输入流中读取数据的下一个字节。 int read（byte[] b）从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。 void close（）关闭此输入流并释放与该流关联的所有系统资源。 构造方法： BufferedInputStream（InputStream in）创建一个BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。 BufferedInputStream（InputStream in，int size）创建具有指定缓冲区大小的BufferedInputStream并保存其参数，即输入流 参数： Inputstream in：字节输入流 我们可以传递FileInputstream，缓冲流会给FileInputStream增加一个缓冲区，提高FileInputStream的读取效率int size：指定缓冲流内部缓冲区的大小，不指定默认
使用步骤（重点）： 1.创建FileInputStream对象，构造方法中绑定要读取的数据源 2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputstream对象的读取效率 3.使用BufferedInputstream对象中的方法read，读职文件 4.释放资源
利用缓冲流复制文件，大大提高速度
java.io.Buffereduriter extends Writer Buffereduriter：字符缓冲输出流 继承自父类的共性成员方法： -void write（int c）写入单个字符。 void write（char[]cbuf）写入字符数组。 abstract void write（char[]cbuf，int off，int Len）写入字符数组的某一部分，off数组的开始索引，Len写的字符个数。 void write（String str）写入字符串。 void write（String str，int off，int Len）写入字符串的某一部分，off字符串的开始索引，Len写的字符个数。 void flush（）刷新该流的缓冲。 -void close（）关闭此流，但要先刷新它。
构造方法： Buffereduriter（uriter out）创建一个使用默认大小输出缓冲区的缓冲字符输出流。 Buffereduriter（writer out，int sz）创建一个使用给定大小输出缓冲区的新缓冲字符输出流。
参数： writer out：字符输出流 我们可以传递Filewriter，缓冲流会给Filewriter增加一个缓冲区，提高Filewriter的写入效率int sz：指定缓冲区的大小，不写默认大小
特有的成员方法： void newline（）写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符换行：换行符号 windows:\rln Linux:/n mac:/r
使用步骤： 1.创建字符缓冲输出流对象，构造方法中传递字符输出流 2.调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中 3.调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据，刷新到文件中 4.释放资源
java.io.BufferedReader extends Reader继承自父类的共性成员方法： int read（）读取单个字符并返回。 int read（char[]cbuf）一次读取多个字符，将字符读入数组。 void close（）关闭该流并释放与之关联的所有资源。
构造方法： BufferedReader（Reader in）创建一个使用默认大小输入缓冲区的缓冲字符输入流。 BufferedReader（Reader in，int sz）创建一个使用指定大小输入缓冲区的缓冲字符输入流。
参数： Reader in：字符输入流 我们可以传递FiLeReader，缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率特有的成员方法： string readline（）读取一个文本行。读取一行数据行的终止符号：通过下列字符之一即可认为某行已终止：换行（‘\n'）、回车（\r'）或回车后直接跟着换行（\r\n）。 返回值： 包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回null
使用步骤： 1.创建字符缓冲输入流对象，构造方法中传递字符输入流 2.使用字符缓冲输入流对象中的方法read/readLine读取文本 3.释放资源

请简述可以使用IO流的哪些方式将对一个文本文件进行拷贝 在线急等

万物皆字节。
使用
BufferedInputStream[缓冲区输入流]
BufferedOutputStream[缓冲区输出流]
这两个流是内置了缓冲区流,也就是说内部有一个 字节数组
直接使用
FileInputStream 文件输入流
FileOutputStream 文件输出流
然后new一个byte[]，用来储存移动字节
while(( b = xxx1.read()) != -1){xxx2.write(b);}
这样两种方法，实现文件的复制（先要定一个文件路径，不然程序找不到文件）
如果要复制文件夹，可以使用递归，里面夹杂文件复制。
——如果对你有帮助，请采纳，谢谢

关于BufferedInputStream和FileInputStream的区别

一、数据处理方式不同
1、BufferedInputStream：内部缓冲区当read时会先把缓冲区填满(默认缓冲区是8192)，然后下次读取是直接从缓冲区读取。当读取的位置大于缓冲区时会再一次加载缓冲区。
2、FileInputStream：会直接读取文件，不经过缓冲。
二、内部方法不同
1、BufferedInputStream：copyWithBufferedStream方法实现了使用BufferedInputStream和BufferedOutputStream复制文件。
2、FileInputStream：copyWithFileStream方法实现了使用FileInputStream和FileOutputStream复制文件。
三、使用规则不同
1、BufferedInputStream：套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能。
2、FileInputStream：读取一个文件来作InputStream。所以可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
参考资料来源：百度百科-字节流
参考资料来源：百度百科-数据流
BufferedInputStream是套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能（如果可能的话），它自己不能脱离里面那个单独存在。FileInputStream是读取一个文件来作InputStream。所以你可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
FileInputStream与BufferedInputStream区别：
FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞；
FileInputStream与FileReader区别：
FileInputStream是字节流，FileReader是字符流，用字节流读取中文的时候，可能会出现乱码，而用字符流则不会出现乱码，而且用字符流读取的速度比字节流要快；
ObjectOutputStream与ByteArrayOutputStream的区别：
ObjectOutputStream可以将java对象写入outputstream流中（序列化），然后进行持久化，此对象必须是实现了java.io.Serializable 接口；
ByteArrayOutputStream是将数据写入byte数组中；
了解“堵塞”的意思吧！
假设一个文件的长度是100个字节，要将之读取到内存中，再假设您每次只读取10个字节，那么读完整个文件是不是读取10次的呀？
假设老板让你完成100件事情，老板说，你每天只完成10件就可以了，难道你非得等到第十天才完成第100件事情吗？有一天您在中午下班前就完成了10件事情，下午您不妨多干一点，那么也许在第9天的时候就完成了100件事情。
同理，BufferedInputStream有可能会读取比您规定的更多的东西到内存，以减少访问IO的次数，
总之您要记住一句话，访问IO的次数越少，性能就越高，原因就在于CPU和内存的速度》》》》远大于硬盘或其他外部设备的速度。
换一个不太恰当的例子来说，您和您的朋友一起去登山，你朋友太不给力了，走一会儿就要休息，而您呢，您的体力比他要好的多，根本不需要休息，所以每当他休息的时候，您得等着他，您那时候什么也干不了，这就叫堵塞，堵塞就是说您有能力干某事，但是迫于某种原因您什么也干不了，只能干等。所以您朋友休息的次数越少，你们两个到达山顶所花费的时间就越少。CPU访问硬盘的次数越少，程序就越快。BufferedInputStream在小型文件中的性能优势无法体现出来，假设您将以个2G大小的文件从D盘完全复制到E盘，性能之优势便展露无疑！
我使用过程，目前最大的区别在于【BufferedInputStream】支持读取外网文件
区别：FileInputStream是字节流，BufferedInputStream是字节缓冲流，使用BufferedInputStream读资源比FileInputStream读取资源的效率高（BufferedInputStream的read方法会读取尽可能多的字节），且FileInputStream对象的read方法会出现阻塞。
1、FileInputStream，直接操作本机I/O,把持着一个文件的句柄，说白了它是面向文件的。
2、BufferedInputStream,它只是面向字节流的，你可以不使用它，自己创建数组，将字节放在里面，也就缓存在jvm内存里，之后操作内存数据。
3、BufferedInputStream是套在某个其他的InputStream外，起着缓存的功能，用来改善里面那个InputStream的性能（如果可能的话），它自己不能脱离里面那个单独存在。
4、FileInputStream是读取一个文件来做InputStream。所以你可以把BufferedInputStream套在FileInputStream外，来改善FileInputStream的性能。
扩展资料
FileInputStream是Java语言中抽象类InputStream用来具体实现类的创建对象。FileInputStream可以从文件系统中的某个文件中获得输入字节，获取的文件可用性取决于主机环境。
FileInputStream的构造方法需要指定文件的来源，通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
参考资料：百度百科－FileInputStream

java中如何用使用输入输出流读写文件！

public static void main(String[] args) throws IOException {
FileOutputStream out1=new FileOutputStream("./src/test1/a.txt");
BufferedOutputStream out2=new BufferedOutputStream(out1);
DataOutputStream out=new DataOutputStream(out2);
out.write(-12);
out.write(12);
out.writeChar('1');
out.writeUTF("你好");
out.close();

InputStream in1=new FileInputStream("./src/test1/a.txt");
BufferedInputStream in2=new BufferedInputStream(in1);
DataInputStream in=new DataInputStream(in2);
System.out.println(in.readByte());
System.out.println(in.readLong());
System.out.println(in.readChar());
//System.out.println(in.readUTF(in));
in.close();
}
Reader r=new FileReader(file);
BufferedReader br=new BufferedReader(r);
String str=br.readLine();
while(str!=null){
txtContent.append(str+"\r\n");
str=br.readLine();
}
br.close();
r.close();
Writer w=new FileWriter(file);
BufferedWriter bw=new BufferedWriter(w);
w.write(txtContent.getText());
bw.append(txtContent.getText());
wbw.close();
w.close();

java 中配置文件路径读取使用FileReader和InputStream区别和用法？

一、按数据来源（去向）分类：
1、是文件： FileInputStream, FileOutputStream, FileReader, FileWriter
2、是byte[]：ByteArrayInputStream, ByteArrayOutputStream
3、是Char[]: CharArrayReader, CharArrayWriter
4、是String: StringBufferInputStream, StringReader, StringWriter
5、网络数据流：InputStream, OutputStream, Reader, Writer
二、按是否格式化输出分：
1、要格式化输出：PrintStream, PrintWriter
三、按是否要缓冲分：
1、要缓冲：BufferedInputStream, BufferedOutputStream, BufferedReader, BufferedWriter
四、按数据格式分：
1、二进制格式（只要不能确定是纯文本的）: InputStream, OutputStream及其所有带Stream结束的子类
2、纯文本格式（含纯英文与汉字或其他编码方式）；Reader, Writer及其所有带Reader, Writer的子类
五、按输入输出分：
1、输入：Reader, InputStream类型的子类
2、输出：Writer, OutputStream类型的子类
六、特殊需要：
1、从Stream到Reader,Writer的转换类：InputStreamReader, OutputStreamWriter
2、对象输入输出：ObjectInputStream, ObjectOutputStream
3、进程间通信：PipeInputStream, PipeOutputStream, PipeReader, PipeWriter
4、合并输入：SequenceInputStream
5、更特殊的需要：PushbackInputStream, PushbackReader, LineNumberInputStream, LineNumberReader
决定使用哪个类以及它的构造进程的一般准则如下（不考虑特殊需要）：
首先，考虑最原始的数据格式是什么： 原则四
第二，是输入还是输出：原则五
第三，是否需要转换流：原则六第1点
第四，数据来源（去向）是什么：原则一
第五，是否要缓冲：原则三 （特别注明：一定要注意的是readLine()是否有定义，有什么比read, write更特殊的输入或输出方法）
第六，是否要格式化输出：原则二
Java中Inputstream与Reader的区别
Reader支持16位的Unicode字符输出，InputStream支持8位的字符输出。
Reader和InputStream分别是I/O库提供的两套平行独立的等级机构，
InputStream、OutputStream是用来处理8位元的流，
Reader、Writer是用来处理16位元的流。
而在JAVA语言中，byte类型是8位的，char类型是16位的，所以在处理中文的时候需要用Reader和Writer。
值得说明的是，在这两种等级机构下，还有一道桥梁InputStreamReader、OutputStreamWriter负责进行InputStream到Reader的适配和由OutputStream到Writer的适配。
java.io.Reader 和 java.io.InputStream 组成了 Java输入类。Reader 用于读入16位字符，也就是 Unicode编码的字符；而 InputStream 用于读入 ASCII字符和二进制数据。
在 Java中，有不同类型的 Reader 输入流对应于不同的数据源：
FileReader 用于从文件输入；
CharArrayReader 用于从程序中的字符数组输入；
StringReader 用于从程序中的字符串输入；
PipedReader 用于读取从另一个线程中的 PipedWriter 写入管道的数据。
相应的也有不同类型的 InputStream 输入流对应于不同的数据源：FileInputStream，ByteArrayInputStream，StringBufferInputStream，PipedInputStream。另外，还有两种没有对应 Reader 类型的 InputStream 输入流：
Socket 用于套接字；
URLConnection 用于 URL 连接。
这两个类使用 getInputStream() 来读取数据。
相应的，java.io.Writer 和 java.io.OutputStream 也有类似的区别。

如何使用java压缩文件夹成为zip包

电脑上有winrar吧，没有的话下载一个，有的话如你所说，对a文件点右键，出现菜单，选择添加到压缩文件选项，出现一个对话框，如图所示，在里面选择你要的格式和保存压缩包的地址 ，你选图片中的 文件 选项 之后 下面有把每个文件放到单独的压缩文件中 把前面的方框点对号
java压缩文件夹zip操作代码如下：import java.io.*;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;public class FileZip {public static void main(String[] args)throws Exception {File f = new File("d:/taobao");ZipOutputStream out = new ZipOutputStream(new FileOutputStream("d:/test.zip"));zip(out, f, null);System.out.println("zip done");out.close();}private static void zip(ZipOutputStream out, File f, String base)throws Exception {System.out.println("zipping " + f.getAbsolutePath());if (f.isDirectory()) {File[] fc = f.listFiles();if (base != null)out.putNextEntry(new ZipEntry(base + "/"));base = base == null ? "" : base + "/";for (int i = 0; i < fc.length; i++) {zip(out, fc[i], base + fc[i].getName());}} else {out.putNextEntry(new ZipEntry(base));FileInputStream in = new FileInputStream(f);int b;while ((b = in.read()) != -1)out.write(b);in.close();}}}
在JDK中有一个zip工具类：
java.util.zip Provides classes for reading and writing the standard ZIP and GZIP file formats.
使用此类可以将文件夹或者多个文件进行打包压缩操作。
在使用之前先了解关键方法：
ZipEntry(String name) Creates a new zip entry with the specified name.
使用ZipEntry的构造方法可以创建一个zip压缩文件包的实例，然后通过ZipOutputStream将待压缩的文件以流的形式写进该压缩包中。具体实现代码如下：
import java.io.BufferedInputStream; import java.io.BufferedOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.util.zip.ZipEntry; import java.util.zip.ZipOutputStream; /** * 将文件夹下面的文件 * 打包成zip压缩文件 * * @author admin * */ public final class FileToZip { private FileToZip(){} /** * 将存放在sourceFilePath目录下的源文件，打包成fileName名称的zip文件，并存放到zipFilePath路径下 * @param sourceFilePath :待压缩的文件路径 * @param zipFilePath :压缩后存放路径 * @param fileName :压缩后文件的名称 * @return */ public static boolean fileToZip(String sourceFilePath,String zipFilePath,String fileName){ boolean flag = false; File sourceFile = new File(sourceFilePath); FileInputStream fis = null; BufferedInputStream bis = null; FileOutputStream fos = null; ZipOutputStream zos = null; if(sourceFile.exists() == false){ System.out.println("待压缩的文件目录："+sourceFilePath+"不存在."); }else{ try { File zipFile = new File(zipFilePath + "/" + fileName +".zip"); if(zipFile.exists()){ System.out.println(zipFilePath + "目录下存在名字为:" + fileName +".zip" +"打包文件."); }else{ File[] sourceFiles = sourceFile.listFiles(); if(null == sourceFiles || sourceFiles.length<1){ System.out.println("待压缩的文件目录：" + sourceFilePath + "里面不存在文件，无需压缩."); }else{ fos = new FileOutputStream(zipFile); zos = new ZipOutputStream(new BufferedOutputStream(fos)); byte[] bufs = new byte[1024*10]; for(int i=0;i
<sourcefiles.length;i++){ 创建zip实体，并添加进压缩包 zipentry="new" zipentry(sourcefiles[i].getname()); zos.putnextentry(zipentry); 读取待压缩的文件并写进压缩包里 fis="new" fileinputstream(sourcefiles[i]); bis="new" bufferedinputstream(fis, 1024*10); int read="0;" while((read="bis.read(bufs," 0, 1024*10)) !="zos)" zos.write(bufs,0,read); } flag="FileToZip.fileToZip(sourceFilePath," catch (filenotfoundexception e) { e.printstacktrace(); throw new runtimeexception(e); (ioexception finally{ 关闭流 try if(null bis.close(); zos.close(); return flag; public static void main(string[] args){ string sourcefilepath="D:\\TestFile" ; zipfilepath="D:\\tmp" filename="12700153file" boolean zipfilepath, filename); if(flag){ system.out.println("文件打包成功!"); }else{ system.out.println("文件打包失败!"); }

java我用流来复制文件可是老是拒绝访问怎么回事

你要访问的文件有文件名吧，要加后缀吧，C:\Users\Administrator\Desktop\Copy_source 这是什么你自己知道吗。
兄弟，首先window环境下文件目录是不能用Java流来读取的，目录是使用mkdir或者mkdirs方法创建的。
第二你复制的时候BufferedInputStream的read() 每次是读取一个字节，你用int来接收，这样会隐式转型成4个字节，复制的文件会不对。
第三文件读取的截至调试是返回的 -1 ， 不是 1，也不是0
第四当然能正确关闭流这是对的，但是缓存流关闭流的时候，并没有关闭FileInputStream和FileOutputStream,所以建议在关闭缓存流之前先关闭掉FileInputStream和FileOutputStream。
文件复制我是这么写的：
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class MyFile extends File {
private List

childFiles;

public MyFile(String pathname) {

super(pathname);

}

public MyFile(File file) {

super(file.getAbsolutePath());

}

public List

getChildFiles() {

return childFiles;

}

public void setChildFiles(List

childFiles) {

this.childFiles = childFiles;

}

}

------------------------------------------------------------------------------

import java.io.BufferedInputStream;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.junit.Test;

public class TestFile {

@Test

public void fileTest() {

MyFile myFile = new MyFile("D:\\迅雷下载");

getAllChildFiles(myFile);

printFile(myFile);

}

@Test

public void copyFileTest() {

MyFile srcFile = new MyFile("D:\\迅雷下载\\activiti-6.0.0");

MyFile targetFile = new MyFile("D:\\迅雷下载\\activiti-6.0.1");

try {

getAllChildFiles(srcFile);

copyFile(srcFile,targetFile);

} catch (Exception e) {

e.printStackTrace();

}

}

public void getAllChildFiles(MyFile myFile) {

myFile.setWritable(true,true);

File[] files = myFile.listFiles();

List

childFiles = new ArrayList

();

for (File file : files) {

MyFile mf = new MyFile(file);

childFiles.add(mf);

if(mf.isDirectory()) {

getAllChildFiles(mf);

}

}

myFile.setChildFiles(childFiles);

}

public void printFile(MyFile myFile) {

System.out.println(myFile.getAbsolutePath());

System.out.println("====>"+myFile.getName());

List

childFiles = myFile.getChildFiles();

if(childFiles != null && childFiles.size() > 0) {

for (MyFile mf : childFiles) {

printFile(mf);

}

}

}

public void copyFile(MyFile srcFile,MyFile targetFile) throws Exception {

if(srcFile.isDirectory()) {

targetFile.mkdirs();

}else {

FileInputStream fis = new FileInputStream(srcFile);

FileOutputStream fos = new FileOutputStream(targetFile);

byte[] buffer = new byte[1024];

int len = 0;

while((len = fis.read(buffer)) != -1) {

fos.write(buffer,0,len);

}

fis.close();

fos.close();

}

List

srcChildFiles = srcFile.getChildFiles();

List

targetChidFiles = new ArrayList

();

if(srcChildFiles != null && srcChildFiles.size() > 0) {

for (MyFile srcf : srcChildFiles) {

StringBuilder targFilePath = new StringBuilder(targetFile.getAbsolutePath());

targFilePath.append(MyFile.separator).append(srcf.getName());

System.out.println(targFilePath.toString());

MyFile targf = new MyFile(targFilePath.toString());

targetChidFiles.add(targf);

copyFile(srcf,targf);

}

}

targetFile.setChildFiles(targetChidFiles);

}

}

希望能帮助到你，谢谢！！

Java使用FileReader和PrintWriter复制的图片无法打开？为什么？

“/”换成一个再试一试。
或者用“\\”
参考一下：
import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.IOException;public class PictureCopy { public static void main(String[] args) throws IOException { BufferedInputStream in = new BufferedInputStream(new FileInputStream("E://a//QQ图片20138003.jpg")); BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("E://b//copy.jpg")); int i; while((i=in.read())!=-1){ out.write(i); } out.flush(); out.close(); in.close(); }}