用java的IO复制文件的内容时，为什么不java 调用shellclose（）；方法就没法复制
点击联系发帖人
时间：2012-08-03 12:41
Java如何快速复制大文件-java-电脑编程网Java如何快速复制大文件作者：paodan 和相关&&我希望从本地和远程复制文件，文件都很大，10G级的，如何快速的复制？看网上有人说使用管道到管道，这确实比其他的快，不知道fastcopy是怎样实现的，各位有什么想法？------回答---------------回答（2分）---------内存文件映射------回答（1分）---------学习中..------回答（1分）---------学习中......------回答（1分）---------用CLOB类型吧，单个变量可以存储4G，再加上BufferedStream.------回答（2分）---------本地远程复制大文件啊，而且还是10G这么大的。你看看迅雷啊，他是多部分一起传的。传输文件就是一般的文件操作啊，你可以模仿迅雷，开多个线程下载，每个线程记录下载部分的开始和结束索引，一起下到远程去。至于效率有多高，我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。------回答（1分）---------引用 6 楼 youjianbo_han_87 的回复:至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。------回答（2分）---------用nio，比io效率好点------回答（1分）---------支持------回答（1分）---------学习中。。。。。。------回答（1分）---------多线程 + FTP------回答（3分）---------顶------回答（3分）---------引用 7 楼 hemowolf 的回复:引用 6 楼 youjianbo_han_87 的回复:至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。多线程下载，我同意，我也是这样说的，至于你说的 端运行 java ，而 客户端不用 java 做是因为JVM的关系，我不同意。想这种远程IO操作，C++效率肯定要比java高。你用脚指头想想，并看下java io部分那个.dll是用什么实现的，你就知道了。------回答（1分）---------引用楼主 paodan 的回复:我希望从本地和远程复制文件，文件都很大，10G级的，如何快速的复制？看网上有人说使用管道到管道，这确实比其他的快，不知道fastcopy是怎样实现的，各位有什么想法？使用nio------回答（2分）---------引用 13 楼 paodan 的回复:我使用nio和io来测试一个100m的文件，虽然每次速度不同，但是都是io的比nio的快怎么回事Java codeimport java.io.Fimport java.io.FileInputSimport java.io.FileNotFoundEimport java.io.FileOutputSimport java.nio.ByteBimport java.nio.channels.FileCpublicclass CopyFile {/*** nio拷贝*@param inFile
源文件*@param outFile 目标文件*@return*@throws Exception*/publicstaticlong FileChannelCopy(String inFile,String outFile)throws Exception{long begin= System.currentTimeMillis();File in=new File(inFile);
File out=new File(outFile);FileInputStream fin=new FileInputStream(in);FileOutputStream fout=new FileOutputStream(out);FileChannel inc= fin.getChannel();FileChannel outc= fout.getChannel();int bufferLen=2097152;ByteBuffer bb= ByteBuffer.allocateDirect(bufferLen);while (true){int ret= inc.read(bb);if (ret==-1){
fin.close();fout.flush();fout.close();}bb.flip();outc.write(bb);bb.clear();}long end= System.currentTimeMillis();long runtime=0;if(end&
begin)runtime= end-}/*** io拷贝*@param inFile 源文件*@param outFile 目标文件*@return*@throws Exception*/publicstaticlong FileStraeamCopy(String inFile,String outFile)throws Exception{long begin= System.currentTimeMillis();File in=new File(inFile);File out=new File(outFile);FileInputStream fin=new FileInputStream(in);FileOutputStream fout=new FileOutputStream(out);int length=2097152;//2m内存byte[] buffer=newbyte[length];while(true){int ins=fin.read(buffer);if(ins==-1){fin.close();fout.flush();fout.close();}elsefout.write(buffer,0,ins);}long end= System.currentTimeMillis();long runtime=0;if(end& begin)runtime= end-}staticpublicvoid main(String args[])throws Exception {String inFile=&D:\\big4.pdf&;//源文件
String outFile=&D:\\big4copy1.pdf&;//输出文件1
String outFile2=&D:\\big4copy2.pdf&;//输出文件2long runtime1,runtime2;runtime1= FileChannelCopy(inFile,outFile);runtime2= FileStraeamCopy(inFile,outFile2);System.out.println(&FileChannelCopy running time:&+ runtime1);System.out.println(&FileStraeamCopy running time:&+ runtime2);}}某一次运行输出结果Java codeFileChannelCopy running time:9969FileStraeamCopy running time:6421不可能& nio 肯定更快------回答（2分）---------lz可以test下Java code
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
//从得到的耗时结果来看 nio效率高很多!!
public class TestFileChannel {
public static void main(String args[])throws Exception{
ByteBuffer buff=ByteBuffer.allocate(1024);
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileChannelOut.txt&);
FileChannel in=fileIn.getChannel();
FileChannel out=fileOut.getChannel();
long l=System.currentTimeMillis();
while(in.read(buff)!=-1){
buff.flip();
//把极限设为位置
再把位置设为0
out.write(buff);
buff.clear();
//不改变极限
把位置设为0
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//31ms
in.close();
out.close();
fileIn.close();
fileOut.close();
public static void main(String[] args)throws Exception{
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileOutputStreamCopyTime.txt&);
long l=System.currentTimeMillis();
while((i=fileIn.read())!=-1){
fileOut.write(i);
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//516ms
fileIn.close();
fileOut.close();
------回答（1分）---------顶------回答（5分）---------引用 15 楼 paodan 的回复:有个工具叫fastcopy，不知道是采用什么思想好像有源代码：http://www.ipmsg.org/archive/FastCopy199r4src.zip------回答（1分）---------UP------回答（1分）---------学习学习了，这代码真有用，真的能复制东西了，呵呵！！------回答（3分）---------其实NIO的主要提高源自共享内存，native code和java code能共享非jvm堆的内存，这是一个最显著的提高------回答（1分）---------学习了, 下次自己试一下.------回答（1分）---------mm------回答（1分）---------学习中~~------回答（1分）---------学习！！------回答（1分）---------用FileChannel的transferTo(long position, long count, WritableByteChannel target)方法试试------回答（1分）---------引用 9 楼 lovecj6185 的回复:用nio，比io效率好点同意 假期写过用channel的复制功能 挺不错的 4G的多久就搞定了 nio里面------回答（1分）---------期待好的解决方法&
收藏了！~------回答（1分）---------并不是线程开的越多，速度就越来。------回答（1分）---------学习中、、、------回答（1分）---------帅------回答（1分）---------google一下不就知道了------回答（1分）---------...------回答（1分）---------学习中。。。。。。------回答（1分）---------学习了------回答（1分）---------顶！------回答---------------回答（2分）---------内存文件映射------回答（1分）---------学习中..------回答（1分）---------学习中......------回答（1分）---------用CLOB类型吧，单个变量可以存储4G，再加上BufferedStream.------回答（2分）---------本地远程复制大文件啊，而且还是10G这么大的。你看看迅雷啊，他是多部分一起传的。java传输文件就是一般的文件操作啊，你可以模仿迅雷，开多个线程下载，每个线程记录下载部分的开始和结束索引，一起下到远程去。至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。------回答（1分）---------引用 6 楼 youjianbo_han_87 的回复:至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。------回答（2分）---------用nio，比io效率好点------回答（1分）---------支持------回答（1分）---------学习中。。。。。。------回答（1分）---------多线程 + FTP------回答（3分）---------顶------回答（3分）---------引用 7 楼 hemowolf 的回复:引用 6 楼 youjianbo_han_87 的回复: 至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。 楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗 快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM 快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。多线程下载，我同意，我也是这样说的，至于你说的 端运行 java ，而 客户端不用 java 做是因为JVM的关系，我不同意。想这种远程IO操作，C++效率肯定要比java高。你用脚指头想想，并看下java io部分那个.dll是用什么实现的，你就知道了。------回答（1分）---------引用楼主 paodan 的回复:我希望从本地和远程复制文件，文件都很大，10G级的，如何快速的复制？看网上有人说使用管道到管道，这确实比其他的快，不知道fastcopy是怎样实现的，各位有什么想法？使用nio------回答（2分）---------引用 13 楼 paodan 的回复:我使用nio和io来测试一个100m的文件，虽然每次速度不同，但是都是io的比nio的快怎么回事Java codeimport java.io.Fimport java.io.FileInputSimport java.io.FileNotFoundEimport java.io.FileOutputSimport java.nio.ByteBimport java.nio.channels.FileCpublicclass CopyFile {/**
*@param inFile
*@param outFile 目标文件
*@throws Exception*/publicstaticlong FileChannelCopy(String inFile,String outFile)throws Exception
{long begin= System.currentTimeMillis();
File in=new File(inFile);
File out=new File(outFile);
FileInputStream fin=new FileInputStream(in);
FileOutputStream fout=new FileOutputStream(out);
FileChannel inc= fin.getChannel();
FileChannel outc= fout.getChannel();int bufferLen=2097152;
ByteBuffer bb= ByteBuffer.allocateDirect(bufferLen);while (true)
{int ret= inc.read(bb);if (ret==-1)
fin.close();
fout.flush();
fout.close();
bb.flip();
outc.write(bb);
bb.clear();
}long end= System.currentTimeMillis();long runtime=0;if(end&
runtime= end-
*@param inFile 源文件
*@param outFile 目标文件
*@throws Exception*/publicstaticlong FileStraeamCopy(String inFile,String outFile)throws Exception
{long begin= System.currentTimeMillis();
File in=new File(inFile);
File out=new File(outFile);
FileInputStream fin=new FileInputStream(in);
FileOutputStream fout=new FileOutputStream(out);int length=2097152;//2m内存byte[] buffer=newbyte[length];while(true)
{int ins=fin.read(buffer);if(ins==-1)
fin.close();
fout.flush();
fout.close();
fout.write(buffer,0,ins);
}long end= System.currentTimeMillis();long runtime=0;if(end& begin)
runtime= end-
}staticpublicvoid main(String args[])throws Exception {
String inFile=&D:\\big4.pdf&;//源文件
String outFile=&D:\\big4copy1.pdf&;//输出文件1
String outFile2=&D:\\big4copy2.pdf&;//输出文件2long runtime1,runtime2;
runtime1= FileChannelCopy(inFile,outFile);
runtime2= FileStraeamCopy(inFile,outFile2);
System.out.println(&FileChannelCopy running time:&+ runtime1);
System.out.println(&FileStraeamCopy running time:&+ runtime2);
}} 某一次运行输出结果Java codeFileChannelCopy running time:9969FileStraeamCopy running time:6421不可能& nio 肯定更快------回答（2分）---------lz可以test下Java code
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
//从得到的耗时结果来看 nio效率高很多!!
public class TestFileChannel {
public static void main(String args[])throws Exception{
ByteBuffer buff=ByteBuffer.allocate(1024);
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileChannelOut.txt&);
FileChannel in=fileIn.getChannel();
FileChannel out=fileOut.getChannel();
long l=System.currentTimeMillis();
while(in.read(buff)!=-1){
buff.flip();
//把极限设为位置
再把位置设为0
out.write(buff);
buff.clear();
//不改变极限
把位置设为0
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//31ms
in.close();
out.close();
fileIn.close();
fileOut.close();
public static void main(String[] args)throws Exception{
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileOutputStreamCopyTime.txt&);
long l=System.currentTimeMillis();
while((i=fileIn.read())!=-1){
fileOut.write(i);
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//516ms
fileIn.close();
fileOut.close();
------回答（1分）---------顶------回答（5分）---------引用 15 楼 paodan 的回复:有个工具叫fastcopy，不知道是采用什么思想好像有源代码：http://www.ipmsg.org/archive/FastCopy199r4src.zip------回答（1分）---------UP------回答（1分）---------学习学习了，这代码真有用，真的能复制东西了，呵呵！！------回答（3分）---------其实NIO的主要提高源自共享内存，native code和java code能共享非jvm堆的内存，这是一个最显著的提高------回答（1分）---------学习了, 下次自己试一下.------回答（1分）---------mm------回答（1分）---------学习中~~------回答（1分）---------学习！！------回答（1分）---------用FileChannel的transferTo(long position, long count, WritableByteChannel target)方法试试------回答（1分）---------引用 9 楼 lovecj6185 的回复:用nio，比io效率好点同意 假期写过用channel的复制功能 挺不错的 4G的多久就搞定了 nio里面------回答（1分）---------
期待好的解决方法 &
收藏了！~------回答（1分）---------并不是线程开的越多，速度就越来。------回答（1分）---------学习中、、、------回答（1分）---------帅------回答（1分）---------google一下不就知道了------回答（1分）---------...------回答（1分）---------学习中。。。。。。------回答（1分）---------学习了------回答（1分）---------顶！相关资料：｜｜｜｜｜｜｜Java如何快速复制大文件来源网络，如有侵权请告知，即处理！编程Tags： & 当前位置： >
> java中的IO源操作大全
java中的IO源操作大全
joven & at
java中的IO流操作大全 JAVA&中的IO流
一、流的概念
流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
&&&&&& 一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。
&&&&&& &流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。
&&&&& &实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。&
形象的比喻——水流 ，文件======程序 ，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出.便于理解，这么定义流： 流就是一个管道里面有流水，这个管道连接了文件和程序。
二、流的分类
java.io包中的类对应两类流，一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为结点流(node stream)，其它的流则称为过滤器(filters)。过滤器输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤器输出流的原理也类似。
Java的常用输入、输出流
java.io包中的stream类根据它们操作对象的类型是字符还是字节可分为两大类： 字符流和字节流。
Java的字节流
InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。
Java的字符流
Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。
结合开始所说的输入/输出流 ，出现了个一小框架。
&&&&&&&&&&&&&&&&&&&&&&& 字节流&&&&&&&&&&&&&&&&&&&&&& 字符流
输入流&&&&&&& InputStream&&&&&&&&&&&&&& Reader
输出流&&&&&&& OutputStream&&&&&&&&&&& Writer
创建一个新文件
import java.io.*;
class hello{
public static void main(String[] args) {
File f=new File(&D:\\hello.txt&);
f.createNewFile();
}catch (Exception e) {
e.printStackTrace();
程序运行之后，在d盘下会有一个名字为hello.txt的文件。
File类的两个常量
import java.io.*;
class hello{
public static void main(String[] args) {
System.out.println(File.separator);
System.out.println(File.pathSeparator);
此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。呵呵、
现在我们使用File类中的常量改写上面的代码：
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
f.createNewFile();
}catch (Exception e) {
e.printStackTrace();
}你看，没有多写多少吧，呵呵。所以建议使用File类中的常量。
删除一个文件
* 删除一个文件
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
if(f.exists()){
f.delete();
System.out.println(&文件不存在&);
创建一个文件夹
* 创建一个文件夹
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello&;
File f=new File(fileName);
f.mkdir();
D盘下多了一个hello文件夹
列出指定目录的全部文件（包括隐藏文件）：
* 使用list列出指定目录的全部文件
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
String[] str=f.list();
for (int i =0; i & str. i++) {
System.out.println(str[i]);
$RECYCLE.BIN
360Downloads
360Rec
360SoftMove
Config.Msi
Downloads
DriversBackup
eclipse
java web整合开发和项目实战
Lenovo
MSOCache
Program
Program Files
python
RECYGLER.{8F92DA15-A229-A4D5-B5CE-C19}
System Volume Information
Tomcat6
vod_cache_data
新建文件夹
（你的运行结果应该和这个不一样的，呵呵）
但是使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.他返回的是File的数组
列出指定目录的全部文件（包括隐藏文件）：
* 使用listFiles列出指定目录的全部文件
* listFiles输出的是完整路径
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
File[] str=f.listFiles();
for (int i =0; i & str. i++) {
System.out.println(str[i]);
D:\$RECYCLE.BIN
D:\360
D:\360Downloads
D:\360Rec
D:\360SoftMove
D:\Config.Msi
D:\Downloads
D:\DriversBackup
D:\eclipse
D:\java web整合开发和项目实战
D:\Lenovo
D:\MSOCache
D:\Program
D:\Program Files
D:\python
D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-C19}
D:\System Volume Information
D:\Tomcat6
D:\var
D:\vod_cache_data
D:\新建文件夹
通过比较可以指定，使用listFiles更加方便、
判断一个指定的路径是否为目录
* 使用isDirectory判断一个指定的路径是否为目录
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
if(f.isDirectory()){
System.out.println(&YES&);
System.out.println(&NO&);
搜索指定目录的全部内容
* 列出指定目录的全部内容
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
public static void print(File f){
if(f!=null){
if(f.isDirectory()){
File[] fileArray=f.listFiles();
if(fileArray!=null){
for (inti = 0; i & fileArray. i++) {
//递归调用
print(fileArray[i]);
System.out.println(f);
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class
* 使用RandomAccessFile写入文件
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
RandomAccessFile demo=new RandomAccessFile(f,&rw&);
demo.writeBytes(&asdsad&);
demo.writeInt(12);
demo.writeBoolean(true);
demo.writeChar('A');
demo.writeFloat(1.21f);
demo.writeDouble(12.123);
demo.close();
}如果你此时打开hello。txt查看的话，会发现那是乱码。
* 向文件中写入字符串
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str=&你好&;
byte[] b=str.getBytes();
out.write(b);
out.close();
}查看hello.txt会看到“你好”
当然也可以一个字节一个字节的写。
* 向文件中一个字节一个字节的写入字符串
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str=&你好&;
byte[] b=str.getBytes();
for (int i =0; i & b. i++) {
out.write(b[i]);
out.close();
}结果还是：“你好”
向文件中追加新内容：
* 向文件中追加新内容：
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f,true);
String str=&Rollen&;
//String str=&\r\nRollen&;
byte[] b=str.getBytes();
for (int i =0; i & b. i++) {
out.write(b[i]);
out.close();
你好Rollen
* 读文件内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
in.read(b);
in.close();
System.out.println(new String(b));
你好Rollen
Rollen_
但是这个例子读取出来会有大量的空格，我们可以利用in.read(b);的返回值来设计程序。如下：
* 读文件内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int len=in.read(b);
in.close();
System.out.println(&读入长度为：&+len);
System.out.println(new String(b,0,len));
读入长度为：18
你好Rollen
Rollen
读者观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样干：
* 读文件内容,节省空间
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int)f.length()];
in.read(b);
System.out.println(&文件长度为：&+f.length());
in.close();
System.out.println(new String(b));
}文件长度为：18
你好Rollen
Rollen
将上面的例子改为一个一个读：
* 读文件内容,节省空间
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int)f.length()];
for (int i =0; i & b. i++) {
b[i]=(byte)in.read();
in.close();
System.out.println(new String(b));
}输出的结果和上面的一样。
细心的读者可能会发现，上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int count =0;
int temp=0;
while((temp=in.read())!=(-1)){
b[count++]=(byte)
in.close();
System.out.println(new String(b));
你好Rollen
Rollen_
提醒一下，当独到文件末尾的时候会返回-1.正常情况下是不会返回-1的
现在我们使用字符流
* 写入数据
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
Writer out =new FileWriter(f);
String str=&hello&;
out.write(str);
out.close();
当你打开hello。txt的时候，会看到hello
其实这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。
当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：
Writer out =new FileWriter(f,true);
这样，当你运行程序的时候，会发现文件内容变为：
hellohello如果想在文件中换行的话，需要使用“\r\n”
比如将str变为String str=&\r\nhello&;
这样文件追加的str的内容就会换行了。
从文件中读内容：
* 从文件中读出内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
char[] ch=new char[100];
Reader read=new FileReader(f);
int count=read.read(ch);
read.close();
System.out.println(&读入的长度为：&+count);
System.out.println(&内容为&+newString(ch,0,count));
读入的长度为：17
内容为hellohello
当然最好采用循环读取的方式，因为我们有时候不知道文件到底有多大。
* 从文件中读出内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
char[] ch=new char[100];
Reader read=new FileReader(f);
int temp=0;
int count=0;
while((temp=read.read())!=(-1)){
ch[count++]=(char)
read.close();
System.out.println(&内容为&+newString(ch,0,count));
内容为hellohello
关于字节流和字符流的区别
实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。
读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。
使用字节流好还是字符流好呢？
答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。
文件的复制
其实ＤＯＳ下就有一个文件复制功能，比如我们想把ｄ盘下面的ｈｅｌｌｏ．ｔｘｔ文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：
copy d:\hello.txt d:\rollen.txt
运行之后你会在d盘中看见hello.txt.，并且两个文件的内容是一样的，（这是屁话）
下面我们使用程序来复制文件吧。
基本思路还是从一个文件中读入内容，边读边写入另一个文件，就是这么简单。、
首先编写下面的代码：
* 文件的复制
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
if(args.length!=2){
System.out.println(&命令行参数输入有误，请检查&);
System.exit(1);
File file1=new File(args[0]);
File file2=new File(args[1]);
if(!file1.exists()){
System.out.println(&被复制的文件不存在&);
System.exit(1);
InputStream input=new FileInputStream(file1);
OutputStream output=new FileOutputStream(file2);
if((input!=null)&&(output!=null)){
int temp=0;
while((temp=input.read())!=(-1)){
output.write(temp);
input.close();
output.close();
然后在命令行下面
javac hello.java
java hello d:\hello.txt d:\rollen.txt
现在你就会在d盘看到rollen。txt了，
OutputStreramWriter 和InputStreamReader类
整个IO类中除了字节流和字符流还包括字节和字符转换流。
OutputStreramWriter将输出的字符流转化为字节流
InputStreamReader将输入的字节流转换为字符流
但是不管如何操作，最后都是以字节的形式保存在文件中的。
将字节输出流转化为字符输出流
* 将字节输出流转化为字符输出流
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName= &d:&+File.separator+&hello.txt&;
File file=new File(fileName);
Writer out=new OutputStreamWriter(newFileOutputStream(file));
out.write(&hello&);
out.close();
文件中内容为：hello
将字节输入流变为字符输入流
* 将字节输入流变为字符输入流
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName= &d:&+File.separator+&hello.txt&;
File file=new File(fileName);
Reader read=new InputStreamReader(newFileInputStream(file));
char[] b=new char[100];
int len=read.read(b);
System.out.println(new String(b,0,len));
read.close();
前面列举的输出输入都是以文件进行的，现在我们以内容为输出输入目的地，使用内存操作流
ByteArrayInputStream 主要将内容写入内容
ByteArrayOutputStream& 主要将内容从内存输出
使用内存操作流将一个大写字母转化为小写字母
* 使用内存操作流将一个大写字母转化为小写字母
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String str=&ROLLENHOLT&;
ByteArrayInputStream input=newByteArrayInputStream(str.getBytes());
ByteArrayOutputStream output=newByteArrayOutputStream();
int temp=0;
while((temp=input.read())!=-1){
char ch=(char)
output.write(Character.toLowerCase(ch));
String outStr=output.toString();
input.close();
output.close();
System.out.println(outStr);
rollenholt
内容操作流一般使用来生成一些临时信息采用的，这样可以避免删除的麻烦。
管道流主要可以进行两个线程之间的通信。
PipedOutputStream 管道输出流
PipedInputStream 管道输入流
验证管道流
* 验证管道流
import java.io.*;
* 消息发送类
class Send implements Runnable{
private PipedOutputStream out=
public Send() {
out=new PipedOutputStream();
public PipedOutputStream getOut(){
return this.
public void run(){
String message=&hello , Rollen&;
out.write(message.getBytes());
}catch (Exception e) {
e.printStackTrace();
out.close();
}catch (Exception e) {
e.printStackTrace();
* 接受消息类
class Recive implements Runnable{
private PipedInputStream input=
public Recive(){
this.input=new PipedInputStream();
public PipedInputStream getInput(){
return this.
public void run(){
byte[] b=new byte[1000];
int len=0;
len=this.input.read(b);
}catch (Exception e) {
e.printStackTrace();
input.close();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&接受的内容为 &+(newString(b,0,len)));
class hello{
public static void main(String[] args) throws IOException {
Send send=new Send();
Recive recive=new Recive();
//管道连接
send.getOut().connect(recive.getInput());
}catch (Exception e) {
e.printStackTrace();
new Thread(send).start();
new Thread(recive).start();
接受的内容为 hello , Rollen
* 使用PrintStream进行输出
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
PrintStream print = new PrintStream(new FileOutputStream(newFile(&d:&
+ File.separator + &hello.txt&)));
print.println(true);
print.println(&Rollen&);
print.close();
Rollen
当然也可以格式化输出
* 使用PrintStream进行输出
* 并进行格式化
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
PrintStream print = new PrintStream(new FileOutputStream(newFile(&d:&
+ File.separator + &hello.txt&)));
String name=&Rollen&;
int age=20;
print.printf(&姓名：%s. 年龄：%d.&,name,age);
print.close();
姓名：Rollen. 年龄：20.
使用OutputStream向屏幕上输出内容
* 使用OutputStream向屏幕上输出内容
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
OutputStream out=System.
out.write(&hello&.getBytes());
}catch (Exception e) {
e.printStackTrace();
out.close();
}catch (Exception e) {
e.printStackTrace();
输入输出重定向
import java.io.F
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.PrintS
* 为System.out.println()重定向输出
public class systemDemo{
public static void main(String[] args){
// 此刻直接输出到屏幕
System.out.println(&hello&);
File file = new File(&d:&+ File.separator + &hello.txt&);
System.setOut(new PrintStream(newFileOutputStream(file)));
}catch(FileNotFoundException e){
e.printStackTrace();
System.out.println(&这些内容在文件中才能看到哦！&);
eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！
import java.io.F
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.PrintS
* System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息
public class systemErr{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
System.err.println(&这些在控制台输出&);
System.setErr(new PrintStream(newFileOutputStream(file)));
}catch(FileNotFoundException e){
e.printStackTrace();
System.err.println(&这些在文件中才能看到哦！&);
你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！
import java.io.F
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.IOE
* System.in重定向
public class systemIn{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
if(!file.exists()){
System.setIn(new FileInputStream(file));
}catch(FileNotFoundException e){
e.printStackTrace();
byte[] bytes = newbyte[1024];
int len = 0;
len = System.in.read(bytes);
}catch(IOException e){
e.printStackTrace();
System.out.println(&读入的内容为：&+ new String(bytes, 0, len));
前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！
BufferedReader的小例子
注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
下面给一个实例：
import java.io.BufferedR
import java.io.IOE
import java.io.InputStreamR
* 使用缓冲区从键盘上读入内容
public class BufferedReaderDemo{
public static void main(String[] args){
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
String str =
System.out.println(&请输入内容&);
str = buf.readLine();
}catch(IOException e){
e.printStackTrace();
System.out.println(&你输入的内容是：&+ str);
请输入内容
dasdas
你输入的内容是：dasdas
其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧
import java.util.S
* Scanner的小例子，从键盘读数据
public class ScannerDemo{
public static void main(String[] args){
Scanner sca = new Scanner(System.in);
// 读一个整数
int temp = sca.nextInt();
System.out.println(temp);
//读取浮点数
float flo=sca.nextFloat();
System.out.println(flo);
//读取字符
//...等等的，都是一些太基础的，就不师范了。
}其实Scanner可以接受任何的输入流
下面给一个使用Scanner类从文件中读出内容
import java.io.F
import java.io.FileNotFoundE
import java.util.S
* Scanner的小例子，从文件中读内容
public class ScannerDemo{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
Scanner sca =
sca = new Scanner(file);
}catch(FileNotFoundException e){
e.printStackTrace();
String str = sca.next();
System.out.println(&从文件中读取的内容是：&+ str);
从文件中读取的内容是：这些文件中的内容哦！
数据操作流DataOutputStream、DataInputStream类
import java.io.DataOutputS
import java.io.F
import java.io.FileOutputS
import java.io.IOE
public class DataOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
char[] ch = { 'A','B', 'C' };
DataOutputStream out =
out = new DataOutputStream(newFileOutputStream(file));
for(char temp : ch){
out.writeChar(temp);
out.close();
现在我们在上面例子的基础上，使用DataInputStream读出内容
import java.io.DataInputS
import java.io.F
import java.io.FileInputS
import java.io.IOE
public class DataOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
DataInputStream input = new DataInputStream(new FileInputStream(file));
char[] ch = new char[10];
int count = 0;
while((temp = input.readChar()) != 'C'){
ch[count++] =
System.out.println(ch);
合并流 SequenceInputStream
SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.io.SequenceInputS
* 将两个文本文件合并为另外一个文本文件
public class SequenceInputStreamDemo{
public static void main(String[] args) throws IOException{
File file1 = new File(&d:&+ File.separator + &hello1.txt&);
File file2 = new File(&d:&+ File.separator + &hello2.txt&);
File file3 = new File(&d:&+ File.separator + &hello.txt&);
InputStream input1 = new FileInputStream(file1);
InputStream input2 = new FileInputStream(file2);
OutputStream output = new FileOutputStream(file3);
SequenceInputStream sis = newSequenceInputStream(input1, input2);
int temp = 0;
while((temp = sis.read()) != -1){
output.write(temp);
input1.close();
input2.close();
output.close();
sis.close();
结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。
文件压缩 ZipOutputStream类
先举一个压缩单个文件的例子吧：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.util.zip.ZipE
import java.util.zip.ZipOutputS
public class ZipOutputStreamDemo1{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
File zipFile = new File(&d:&+ File.separator + &hello.zip&);
InputStream input = new FileInputStream(file);
ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
zipFile));
zipOut.putNextEntry(new ZipEntry(file.getName()));
// 设置注释
zipOut.setComment(&hello&);
int temp = 0;
while((temp = input.read()) != -1){
zipOut.write(temp);
input.close();
zipOut.close();
运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。
不过结果肯定是正确的，我只是提出我的一个疑问而已。
上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.util.zip.ZipE
import java.util.zip.ZipOutputS
* 一次性压缩多个文件
public class ZipOutputStreamDemo2{
public static void main(String[] args) throws IOException{
// 要被压缩的文件夹
File file = new File(&d:&+ File.separator + &temp&);
File zipFile = new File(&d:&+ File.separator + &zipFile.zip&);
InputStream input =
ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
zipFile));
zipOut.setComment(&hello&);
if(file.isDirectory()){
File[] files = file.listFiles();
for(int i = 0; i & files. ++i){
input = new FileInputStream(files[i]);
zipOut.putNextEntry(newZipEntry(file.getName()
+ File.separator + files[i].getName()));
int temp = 0;
while((temp = input.read()) != -1){
zipOut.write(temp);
input.close();
zipOut.close();
先看看要被压缩的文件吧：
接下来看看压缩之后的：
大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的
import java.io.F
import java.io.IOE
import java.util.zip.ZipF
* ZipFile演示
public class ZipFileDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.zip&);
ZipFile zipFile = new ZipFile(file);
System.out.println(&压缩文件的名称为：&+ zipFile.getName());
压缩文件的名称为：d:\hello.zip
现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件（也就是压缩文件中只有一个文件的情况），我们采用前面的例子产生的压缩文件hello.zip
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.zip.ZipE
import java.util.zip.ZipF
* 解压缩文件（压缩文件中只有一个文件的情况）
public class ZipFileDemo2{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.zip&);
File outFile = new File(&d:&+ File.separator + &unZipFile.txt&);
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = zipFile.getEntry(&hello.txt&);
InputStream input = zipFile.getInputStream(entry);
OutputStream output = new FileOutputStream(outFile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
input.close();
output.close();
解压缩之前：
这个压缩文件还是175字节
解压之后产生：
又回到了56字节，表示郁闷。
现在让我们来解压一个压缩文件中包含多个文件的情况吧
ZipInputStream类
当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.zip.ZipE
import java.util.zip.ZipF
import java.util.zip.ZipInputS
* 解压缩一个压缩文件中包含多个文件的情况
public class ZipFileDemo3{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &zipFile.zip&);
File outFile =
ZipFile zipFile = new ZipFile(file);
ZipInputStream zipInput = newZipInputStream(new FileInputStream(file));
ZipEntry entry =
InputStream input =
OutputStream output =
while((entry = zipInput.getNextEntry()) !=null){
System.out.println(&解压缩& + entry.getName() + &文件&);
outFile = new File(&d:&+ File.separator + entry.getName());
if(!outFile.getParentFile().exists()){
outFile.getParentFile().mkdir();
if(!outFile.exists()){
outFile.createNewFile();
input = zipFile.getInputStream(entry);
output = new FileOutputStream(outFile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
input.close();
output.close();
被解压的文件：
解压之后再D盘下会出现一个temp文件夹，里面内容：
PushBackInputStream回退流
import java.io.ByteArrayInputS
import java.io.IOE
import java.io.PushbackInputS
* 回退流操作
public class PushBackInputStreamDemo{
public static void main(String[] args) throws IOException{
String str = &hello,rollenholt&;
PushbackInputStream push =
ByteArrayInputStream bat =
bat = new ByteArrayInputStream(str.getBytes());
push = new PushbackInputStream(bat);
int temp = 0;
while((temp = push.read()) != -1){
if(temp == ','){
push.unread(temp);
temp = push.read();
System.out.print(&(回退&+ (char) temp + &) &);
System.out.print((char) temp);
hello(回退,)rollenholt
* 取得本地的默认编码
public class CharSetDemo{
public static void main(String[] args){
System.out.println(&系统默认编码为：&+ System.getProperty(&file.encoding&));
系统默认编码为：GBK
乱码的产生：
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.OutputS
* 乱码的产生
public class CharSetDemo2{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
OutputStream out = new FileOutputStream(file);
byte[] bytes = &你好&.getBytes(&ISO8859-1&);
out.write(bytes);
out.close();
一般情况下产生乱码，都是由于编码不一致的问题。
对象的序列化
对象序列化就是把一个对象变为二进制数据流的一种方法。
一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。
先让我们实现一个具有序列化能力的类吧：
import java.io.*;
* 实现具有序列化能力的类
public class SerializableDemo implementsSerializable{
public SerializableDemo(){
public SerializableDemo(String name, int age){
this.name=
public String toString(){
return &姓名：&+name+&
}这个类就具有实现序列化能力，
在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类
先给一个ObjectOutputStream的例子吧：
import java.io.S
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.ObjectOutputS
* 实现具有序列化能力的类
public class Person implementsSerializable{
public Person(){
public Person(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
* 示范ObjectOutputStream
public class ObjectOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
oos.writeObject(new Person(&rollen&,20));
oos.close();
当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。
虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：
import java.io.F
import java.io.FileInputS
import java.io.ObjectInputS
* ObjectInputStream示范
public class ObjectInputStreamDemo{
public static void main(String[] args) throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
姓名：rollen&年龄：20
到底序列化什么内容呢？
其实只有属性会被序列化。
Externalizable接口
被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。
当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。
现在我们来演示一下序列化和反序列话：
package IO;
import java.io.E
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.ObjectI
import java.io.ObjectInputS
import java.io.ObjectO
import java.io.ObjectOutputS
* 序列化和反序列化的操作
public class ExternalizableDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
public static void ser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(new Person(&rollen&,20));
out.close();
public static void dser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
class Person implements Externalizable{
public Person(){
public Person(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
// 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
public void writeExternal(ObjectOutput out)throws IOException{
out.writeObject(this.name);
out.writeInt(age);
// 复写这个方法，根据需要读取内容 反序列话的时候需要
public void readExternal(ObjectInput in)throws IOException,
ClassNotFoundException{
this.name = (String) in.readObject();
this.age = in.readInt();
姓名：rollen&年龄：20
本例中，我们将全部的属性都保留了下来，
Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，
当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：
下面举一个例子：
package IO;
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.ObjectInputS
import java.io.ObjectOutputS
import java.io.S
* 序列化和反序列化的操作
public class serDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
public static void ser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(new Person1(&rollen&,20));
out.close();
public static void dser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
class Person1 implements Serializable{
public Person1(){
public Person1(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
// 注意这里
private transient S
姓名：null&年龄：20
最后在给一个序列化一组对象的例子吧：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.ObjectInputS
import java.io.ObjectOutputS
import java.io.S
* 序列化一组对象
public class SerDemo1{
public static void main(String[] args) throws Exception{
Student[] stu = { new Student(&hello&,20), new Student(&world&,30),
new Student(&rollen&,40) };
Object[] obj = dser();
for(int i =0; i & obj. ++i){
Student s = (Student) obj[i];
System.out.println(s);
public static void ser(Object[] obj) throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(obj);
out.close();
// 反序列化
public static Object[] dser()throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object[] obj = (Object[]) input.readObject();
input.close();
class Student implements Serializable{
public Student(){
public Student(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：
& + name +&
姓名：&
hello& 年龄：20
姓名：&
world& 年龄：30
姓名：& rollen&年龄：40
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&&&增值电信业务经营许可证湘B2-}
源文件*@param outFile 目标文件*@return*@throws Exception*/publicstaticlong FileChannelCopy(String inFile,String outFile)throws Exception{long begin= System.currentTimeMillis();File in=new File(inFile);
File out=new File(outFile);FileInputStream fin=new FileInputStream(in);FileOutputStream fout=new FileOutputStream(out);FileChannel inc= fin.getChannel();FileChannel outc= fout.getChannel();int bufferLen=2097152;ByteBuffer bb= ByteBuffer.allocateDirect(bufferLen);while (true){int ret= inc.read(bb);if (ret==-1){
fin.close();fout.flush();fout.close();}bb.flip();outc.write(bb);bb.clear();}long end= System.currentTimeMillis();long runtime=0;if(end&
begin)runtime= end-}/*** io拷贝*@param inFile 源文件*@param outFile 目标文件*@return*@throws Exception*/publicstaticlong FileStraeamCopy(String inFile,String outFile)throws Exception{long begin= System.currentTimeMillis();File in=new File(inFile);File out=new File(outFile);FileInputStream fin=new FileInputStream(in);FileOutputStream fout=new FileOutputStream(out);int length=2097152;//2m内存byte[] buffer=newbyte[length];while(true){int ins=fin.read(buffer);if(ins==-1){fin.close();fout.flush();fout.close();}elsefout.write(buffer,0,ins);}long end= System.currentTimeMillis();long runtime=0;if(end& begin)runtime= end-}staticpublicvoid main(String args[])throws Exception {String inFile=&D:\\big4.pdf&;//源文件
String outFile=&D:\\big4copy1.pdf&;//输出文件1
String outFile2=&D:\\big4copy2.pdf&;//输出文件2long runtime1,runtime2;runtime1= FileChannelCopy(inFile,outFile);runtime2= FileStraeamCopy(inFile,outFile2);System.out.println(&FileChannelCopy running time:&+ runtime1);System.out.println(&FileStraeamCopy running time:&+ runtime2);}}某一次运行输出结果Java codeFileChannelCopy running time:9969FileStraeamCopy running time:6421不可能& nio 肯定更快------回答（2分）---------lz可以test下Java code
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
//从得到的耗时结果来看 nio效率高很多!!
public class TestFileChannel {
public static void main(String args[])throws Exception{
ByteBuffer buff=ByteBuffer.allocate(1024);
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileChannelOut.txt&);
FileChannel in=fileIn.getChannel();
FileChannel out=fileOut.getChannel();
long l=System.currentTimeMillis();
while(in.read(buff)!=-1){
buff.flip();
//把极限设为位置
再把位置设为0
out.write(buff);
buff.clear();
//不改变极限
把位置设为0
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//31ms
in.close();
out.close();
fileIn.close();
fileOut.close();
public static void main(String[] args)throws Exception{
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileOutputStreamCopyTime.txt&);
long l=System.currentTimeMillis();
while((i=fileIn.read())!=-1){
fileOut.write(i);
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//516ms
fileIn.close();
fileOut.close();
------回答（1分）---------顶------回答（5分）---------引用 15 楼 paodan 的回复:有个工具叫fastcopy，不知道是采用什么思想好像有源代码：http://www.ipmsg.org/archive/FastCopy199r4src.zip------回答（1分）---------UP------回答（1分）---------学习学习了，这代码真有用，真的能复制东西了，呵呵！！------回答（3分）---------其实NIO的主要提高源自共享内存，native code和java code能共享非jvm堆的内存，这是一个最显著的提高------回答（1分）---------学习了, 下次自己试一下.------回答（1分）---------mm------回答（1分）---------学习中~~------回答（1分）---------学习！！------回答（1分）---------用FileChannel的transferTo(long position, long count, WritableByteChannel target)方法试试------回答（1分）---------引用 9 楼 lovecj6185 的回复:用nio，比io效率好点同意 假期写过用channel的复制功能 挺不错的 4G的多久就搞定了 nio里面------回答（1分）---------期待好的解决方法&
收藏了！~------回答（1分）---------并不是线程开的越多，速度就越来。------回答（1分）---------学习中、、、------回答（1分）---------帅------回答（1分）---------google一下不就知道了------回答（1分）---------...------回答（1分）---------学习中。。。。。。------回答（1分）---------学习了------回答（1分）---------顶！------回答---------------回答（2分）---------内存文件映射------回答（1分）---------学习中..------回答（1分）---------学习中......------回答（1分）---------用CLOB类型吧，单个变量可以存储4G，再加上BufferedStream.------回答（2分）---------本地远程复制大文件啊，而且还是10G这么大的。你看看迅雷啊，他是多部分一起传的。java传输文件就是一般的文件操作啊，你可以模仿迅雷，开多个线程下载，每个线程记录下载部分的开始和结束索引，一起下到远程去。至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。------回答（1分）---------引用 6 楼 youjianbo_han_87 的回复:至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。------回答（2分）---------用nio，比io效率好点------回答（1分）---------支持------回答（1分）---------学习中。。。。。。------回答（1分）---------多线程 + FTP------回答（3分）---------顶------回答（3分）---------引用 7 楼 hemowolf 的回复:引用 6 楼 youjianbo_han_87 的回复: 至于效率有多高，java我还真不敢说，要不迅雷，快车这种工具怎么不用java来开发。 楼上的，你见过用 java 开发的运行在 windows 上的桌面应用软件吗 快车这些东西之所以不用 java 做，最大的原因不是它的效率，而是它必须要安装JVM 快车只不过客户端的东西，服务端运行 java 是很常见的。楼主的这个问题用多线程来解决应该不存在效率问题。多线程下载，我同意，我也是这样说的，至于你说的 端运行 java ，而 客户端不用 java 做是因为JVM的关系，我不同意。想这种远程IO操作，C++效率肯定要比java高。你用脚指头想想，并看下java io部分那个.dll是用什么实现的，你就知道了。------回答（1分）---------引用楼主 paodan 的回复:我希望从本地和远程复制文件，文件都很大，10G级的，如何快速的复制？看网上有人说使用管道到管道，这确实比其他的快，不知道fastcopy是怎样实现的，各位有什么想法？使用nio------回答（2分）---------引用 13 楼 paodan 的回复:我使用nio和io来测试一个100m的文件，虽然每次速度不同，但是都是io的比nio的快怎么回事Java codeimport java.io.Fimport java.io.FileInputSimport java.io.FileNotFoundEimport java.io.FileOutputSimport java.nio.ByteBimport java.nio.channels.FileCpublicclass CopyFile {/**
*@param inFile
*@param outFile 目标文件
*@throws Exception*/publicstaticlong FileChannelCopy(String inFile,String outFile)throws Exception
{long begin= System.currentTimeMillis();
File in=new File(inFile);
File out=new File(outFile);
FileInputStream fin=new FileInputStream(in);
FileOutputStream fout=new FileOutputStream(out);
FileChannel inc= fin.getChannel();
FileChannel outc= fout.getChannel();int bufferLen=2097152;
ByteBuffer bb= ByteBuffer.allocateDirect(bufferLen);while (true)
{int ret= inc.read(bb);if (ret==-1)
fin.close();
fout.flush();
fout.close();
bb.flip();
outc.write(bb);
bb.clear();
}long end= System.currentTimeMillis();long runtime=0;if(end&
runtime= end-
*@param inFile 源文件
*@param outFile 目标文件
*@throws Exception*/publicstaticlong FileStraeamCopy(String inFile,String outFile)throws Exception
{long begin= System.currentTimeMillis();
File in=new File(inFile);
File out=new File(outFile);
FileInputStream fin=new FileInputStream(in);
FileOutputStream fout=new FileOutputStream(out);int length=2097152;//2m内存byte[] buffer=newbyte[length];while(true)
{int ins=fin.read(buffer);if(ins==-1)
fin.close();
fout.flush();
fout.close();
fout.write(buffer,0,ins);
}long end= System.currentTimeMillis();long runtime=0;if(end& begin)
runtime= end-
}staticpublicvoid main(String args[])throws Exception {
String inFile=&D:\\big4.pdf&;//源文件
String outFile=&D:\\big4copy1.pdf&;//输出文件1
String outFile2=&D:\\big4copy2.pdf&;//输出文件2long runtime1,runtime2;
runtime1= FileChannelCopy(inFile,outFile);
runtime2= FileStraeamCopy(inFile,outFile2);
System.out.println(&FileChannelCopy running time:&+ runtime1);
System.out.println(&FileStraeamCopy running time:&+ runtime2);
}} 某一次运行输出结果Java codeFileChannelCopy running time:9969FileStraeamCopy running time:6421不可能& nio 肯定更快------回答（2分）---------lz可以test下Java code
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
//从得到的耗时结果来看 nio效率高很多!!
public class TestFileChannel {
public static void main(String args[])throws Exception{
ByteBuffer buff=ByteBuffer.allocate(1024);
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileChannelOut.txt&);
FileChannel in=fileIn.getChannel();
FileChannel out=fileOut.getChannel();
long l=System.currentTimeMillis();
while(in.read(buff)!=-1){
buff.flip();
//把极限设为位置
再把位置设为0
out.write(buff);
buff.clear();
//不改变极限
把位置设为0
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//31ms
in.close();
out.close();
fileIn.close();
fileOut.close();
public static void main(String[] args)throws Exception{
FileInputStream fileIn=new FileInputStream(&d:/JavaTests/TestFileChannel.txt&);
FileOutputStream fileOut=new FileOutputStream(&d:/JavaTests/TestFileOutputStreamCopyTime.txt&);
long l=System.currentTimeMillis();
while((i=fileIn.read())!=-1){
fileOut.write(i);
System.out.println(&Take time:&+(System.currentTimeMillis()-l)+&ms&);//516ms
fileIn.close();
fileOut.close();
------回答（1分）---------顶------回答（5分）---------引用 15 楼 paodan 的回复:有个工具叫fastcopy，不知道是采用什么思想好像有源代码：http://www.ipmsg.org/archive/FastCopy199r4src.zip------回答（1分）---------UP------回答（1分）---------学习学习了，这代码真有用，真的能复制东西了，呵呵！！------回答（3分）---------其实NIO的主要提高源自共享内存，native code和java code能共享非jvm堆的内存，这是一个最显著的提高------回答（1分）---------学习了, 下次自己试一下.------回答（1分）---------mm------回答（1分）---------学习中~~------回答（1分）---------学习！！------回答（1分）---------用FileChannel的transferTo(long position, long count, WritableByteChannel target)方法试试------回答（1分）---------引用 9 楼 lovecj6185 的回复:用nio，比io效率好点同意 假期写过用channel的复制功能 挺不错的 4G的多久就搞定了 nio里面------回答（1分）---------
期待好的解决方法 &
收藏了！~------回答（1分）---------并不是线程开的越多，速度就越来。------回答（1分）---------学习中、、、------回答（1分）---------帅------回答（1分）---------google一下不就知道了------回答（1分）---------...------回答（1分）---------学习中。。。。。。------回答（1分）---------学习了------回答（1分）---------顶！相关资料：｜｜｜｜｜｜｜Java如何快速复制大文件来源网络，如有侵权请告知，即处理！编程Tags： & 当前位置： >
> java中的IO源操作大全
java中的IO源操作大全
joven & at
java中的IO流操作大全 JAVA&中的IO流
一、流的概念
流(stream)的概念源于UNIX中管道(pipe)的概念。在UNIX中，管道是一条不间断的字节流，用来实现程序或进程间的通信，或读写外围设备、外部文件等。
&&&&&& 一个流，必有源端和目的端，它们可以是计算机内存的某些区域，也可以是磁盘文件，甚至可以是Internet上的某个URL。
&&&&&& &流的方向是重要的，根据流的方向，流可分为两类：输入流和输出流。用户可以从输入流中读取信息，但不能写它。相反，对输出流，只能往输入流写，而不能读它。
&&&&& &实际上，流的源端和目的端可简单地看成是字节的生产者和消费者，对输入流，可不必关心它的源端是什么，只要简单地从流中读数据，而对输出流，也可不知道它的目的端，只是简单地往流中写数据。&
形象的比喻——水流 ，文件======程序 ，文件和程序之间连接一个管道，水流就在之间形成了,自然也就出现了方向：可以流进，也可以流出.便于理解，这么定义流： 流就是一个管道里面有流水，这个管道连接了文件和程序。
二、流的分类
java.io包中的类对应两类流，一类流直接从指定的位置（如磁盘文件或内存区域）读或写，这类流称为结点流(node stream)，其它的流则称为过滤器(filters)。过滤器输入流往往是以其它输入流作为它的输入源，经过过滤或处理后再以新的输入流的形式提供给用户，过滤器输出流的原理也类似。
Java的常用输入、输出流
java.io包中的stream类根据它们操作对象的类型是字符还是字节可分为两大类： 字符流和字节流。
Java的字节流
InputStream是所有字节输入流的祖先，而OutputStream是所有字节输出流的祖先。
Java的字符流
Reader是所有读取字符串输入流的祖先，而writer是所有输出字符串的祖先。
结合开始所说的输入/输出流 ，出现了个一小框架。
&&&&&&&&&&&&&&&&&&&&&&& 字节流&&&&&&&&&&&&&&&&&&&&&& 字符流
输入流&&&&&&& InputStream&&&&&&&&&&&&&& Reader
输出流&&&&&&& OutputStream&&&&&&&&&&& Writer
创建一个新文件
import java.io.*;
class hello{
public static void main(String[] args) {
File f=new File(&D:\\hello.txt&);
f.createNewFile();
}catch (Exception e) {
e.printStackTrace();
程序运行之后，在d盘下会有一个名字为hello.txt的文件。
File类的两个常量
import java.io.*;
class hello{
public static void main(String[] args) {
System.out.println(File.separator);
System.out.println(File.pathSeparator);
此处多说几句：有些同学可能认为，我直接在windows下使用\进行分割不行吗？当然是可以的。但是在linux下就不是\了。所以，要想使得我们的代码跨平台，更加健壮，所以，大家都采用这两个常量吧，其实也多写不了几行。呵呵、
现在我们使用File类中的常量改写上面的代码：
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
f.createNewFile();
}catch (Exception e) {
e.printStackTrace();
}你看，没有多写多少吧，呵呵。所以建议使用File类中的常量。
删除一个文件
* 删除一个文件
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
if(f.exists()){
f.delete();
System.out.println(&文件不存在&);
创建一个文件夹
* 创建一个文件夹
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.separator+&hello&;
File f=new File(fileName);
f.mkdir();
D盘下多了一个hello文件夹
列出指定目录的全部文件（包括隐藏文件）：
* 使用list列出指定目录的全部文件
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
String[] str=f.list();
for (int i =0; i & str. i++) {
System.out.println(str[i]);
$RECYCLE.BIN
360Downloads
360Rec
360SoftMove
Config.Msi
Downloads
DriversBackup
eclipse
java web整合开发和项目实战
Lenovo
MSOCache
Program
Program Files
python
RECYGLER.{8F92DA15-A229-A4D5-B5CE-C19}
System Volume Information
Tomcat6
vod_cache_data
新建文件夹
（你的运行结果应该和这个不一样的，呵呵）
但是使用list返回的是String数组，。而且列出的不是完整路径，如果想列出完整路径的话，需要使用listFiles.他返回的是File的数组
列出指定目录的全部文件（包括隐藏文件）：
* 使用listFiles列出指定目录的全部文件
* listFiles输出的是完整路径
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
File[] str=f.listFiles();
for (int i =0; i & str. i++) {
System.out.println(str[i]);
D:\$RECYCLE.BIN
D:\360
D:\360Downloads
D:\360Rec
D:\360SoftMove
D:\Config.Msi
D:\Downloads
D:\DriversBackup
D:\eclipse
D:\java web整合开发和项目实战
D:\Lenovo
D:\MSOCache
D:\Program
D:\Program Files
D:\python
D:\RECYGLER.{8F92DA15-A229-A4D5-B5CE-C19}
D:\System Volume Information
D:\Tomcat6
D:\var
D:\vod_cache_data
D:\新建文件夹
通过比较可以指定，使用listFiles更加方便、
判断一个指定的路径是否为目录
* 使用isDirectory判断一个指定的路径是否为目录
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
if(f.isDirectory()){
System.out.println(&YES&);
System.out.println(&NO&);
搜索指定目录的全部内容
* 列出指定目录的全部内容
import java.io.*;
class hello{
public static void main(String[] args) {
String fileName=&D:&+File.
File f=new File(fileName);
public static void print(File f){
if(f!=null){
if(f.isDirectory()){
File[] fileArray=f.listFiles();
if(fileArray!=null){
for (inti = 0; i & fileArray. i++) {
//递归调用
print(fileArray[i]);
System.out.println(f);
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\framepages\web4welcome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\help_005fhome_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\home_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\index_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\login_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\modify_005fuser_005finfo_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\register_005fnotify_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.class
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\sign_005fup_jsp.java
D:\Tomcat6\work\Catalina\localhost\nevel\org\apache\jsp\transit_jsp.class
* 使用RandomAccessFile写入文件
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
RandomAccessFile demo=new RandomAccessFile(f,&rw&);
demo.writeBytes(&asdsad&);
demo.writeInt(12);
demo.writeBoolean(true);
demo.writeChar('A');
demo.writeFloat(1.21f);
demo.writeDouble(12.123);
demo.close();
}如果你此时打开hello。txt查看的话，会发现那是乱码。
* 向文件中写入字符串
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str=&你好&;
byte[] b=str.getBytes();
out.write(b);
out.close();
}查看hello.txt会看到“你好”
当然也可以一个字节一个字节的写。
* 向文件中一个字节一个字节的写入字符串
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f);
String str=&你好&;
byte[] b=str.getBytes();
for (int i =0; i & b. i++) {
out.write(b[i]);
out.close();
}结果还是：“你好”
向文件中追加新内容：
* 向文件中追加新内容：
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
OutputStream out =new FileOutputStream(f,true);
String str=&Rollen&;
//String str=&\r\nRollen&;
byte[] b=str.getBytes();
for (int i =0; i & b. i++) {
out.write(b[i]);
out.close();
你好Rollen
* 读文件内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
in.read(b);
in.close();
System.out.println(new String(b));
你好Rollen
Rollen_
但是这个例子读取出来会有大量的空格，我们可以利用in.read(b);的返回值来设计程序。如下：
* 读文件内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int len=in.read(b);
in.close();
System.out.println(&读入长度为：&+len);
System.out.println(new String(b,0,len));
读入长度为：18
你好Rollen
Rollen
读者观察上面的例子可以看出，我们预先申请了一个指定大小的空间，但是有时候这个空间可能太小，有时候可能太大，我们需要准确的大小，这样节省空间，那么我们可以这样干：
* 读文件内容,节省空间
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int)f.length()];
in.read(b);
System.out.println(&文件长度为：&+f.length());
in.close();
System.out.println(new String(b));
}文件长度为：18
你好Rollen
Rollen
将上面的例子改为一个一个读：
* 读文件内容,节省空间
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[(int)f.length()];
for (int i =0; i & b. i++) {
b[i]=(byte)in.read();
in.close();
System.out.println(new String(b));
}输出的结果和上面的一样。
细心的读者可能会发现，上面的几个例子都是在知道文件的内容多大，然后才展开的，有时候我们不知道文件有多大，这种情况下，我们需要判断是否独到文件的末尾。
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
InputStream in=new FileInputStream(f);
byte[] b=new byte[1024];
int count =0;
int temp=0;
while((temp=in.read())!=(-1)){
b[count++]=(byte)
in.close();
System.out.println(new String(b));
你好Rollen
Rollen_
提醒一下，当独到文件末尾的时候会返回-1.正常情况下是不会返回-1的
现在我们使用字符流
* 写入数据
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
Writer out =new FileWriter(f);
String str=&hello&;
out.write(str);
out.close();
当你打开hello。txt的时候，会看到hello
其实这个例子上之前的例子没什么区别，只是你可以直接输入字符串，而不需要你将字符串转化为字节数组。
当你如果想问文件中追加内容的时候，可以使用将上面的声明out的哪一行换为：
Writer out =new FileWriter(f,true);
这样，当你运行程序的时候，会发现文件内容变为：
hellohello如果想在文件中换行的话，需要使用“\r\n”
比如将str变为String str=&\r\nhello&;
这样文件追加的str的内容就会换行了。
从文件中读内容：
* 从文件中读出内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
char[] ch=new char[100];
Reader read=new FileReader(f);
int count=read.read(ch);
read.close();
System.out.println(&读入的长度为：&+count);
System.out.println(&内容为&+newString(ch,0,count));
读入的长度为：17
内容为hellohello
当然最好采用循环读取的方式，因为我们有时候不知道文件到底有多大。
* 从文件中读出内容
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName=&D:&+File.separator+&hello.txt&;
File f=new File(fileName);
char[] ch=new char[100];
Reader read=new FileReader(f);
int temp=0;
int count=0;
while((temp=read.read())!=(-1)){
ch[count++]=(char)
read.close();
System.out.println(&内容为&+newString(ch,0,count));
内容为hellohello
关于字节流和字符流的区别
实际上字节流在操作的时候本身是不会用到缓冲区的，是文件本身的直接操作的，但是字符流在操作的时候下后是会用到缓冲区的，是通过缓冲区来操作文件的。
读者可以试着将上面的字节流和字符流的程序的最后一行关闭文件的代码注释掉，然后运行程序看看。你就会发现使用字节流的话，文件中已经存在内容，但是使用字符流的时候，文件中还是没有内容的，这个时候就要刷新缓冲区。
使用字节流好还是字符流好呢？
答案是字节流。首先因为硬盘上的所有文件都是以字节的形式进行传输或者保存的，包括图片等内容。但是字符只是在内存中才会形成的，所以在开发中，字节流使用广泛。
文件的复制
其实ＤＯＳ下就有一个文件复制功能，比如我们想把ｄ盘下面的ｈｅｌｌｏ．ｔｘｔ文件复制到d盘下面的rollen.txt文件中，那么我们就可以使用下面的命令：
copy d:\hello.txt d:\rollen.txt
运行之后你会在d盘中看见hello.txt.，并且两个文件的内容是一样的，（这是屁话）
下面我们使用程序来复制文件吧。
基本思路还是从一个文件中读入内容，边读边写入另一个文件，就是这么简单。、
首先编写下面的代码：
* 文件的复制
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
if(args.length!=2){
System.out.println(&命令行参数输入有误，请检查&);
System.exit(1);
File file1=new File(args[0]);
File file2=new File(args[1]);
if(!file1.exists()){
System.out.println(&被复制的文件不存在&);
System.exit(1);
InputStream input=new FileInputStream(file1);
OutputStream output=new FileOutputStream(file2);
if((input!=null)&&(output!=null)){
int temp=0;
while((temp=input.read())!=(-1)){
output.write(temp);
input.close();
output.close();
然后在命令行下面
javac hello.java
java hello d:\hello.txt d:\rollen.txt
现在你就会在d盘看到rollen。txt了，
OutputStreramWriter 和InputStreamReader类
整个IO类中除了字节流和字符流还包括字节和字符转换流。
OutputStreramWriter将输出的字符流转化为字节流
InputStreamReader将输入的字节流转换为字符流
但是不管如何操作，最后都是以字节的形式保存在文件中的。
将字节输出流转化为字符输出流
* 将字节输出流转化为字符输出流
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName= &d:&+File.separator+&hello.txt&;
File file=new File(fileName);
Writer out=new OutputStreamWriter(newFileOutputStream(file));
out.write(&hello&);
out.close();
文件中内容为：hello
将字节输入流变为字符输入流
* 将字节输入流变为字符输入流
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String fileName= &d:&+File.separator+&hello.txt&;
File file=new File(fileName);
Reader read=new InputStreamReader(newFileInputStream(file));
char[] b=new char[100];
int len=read.read(b);
System.out.println(new String(b,0,len));
read.close();
前面列举的输出输入都是以文件进行的，现在我们以内容为输出输入目的地，使用内存操作流
ByteArrayInputStream 主要将内容写入内容
ByteArrayOutputStream& 主要将内容从内存输出
使用内存操作流将一个大写字母转化为小写字母
* 使用内存操作流将一个大写字母转化为小写字母
import java.io.*;
class hello{
public static void main(String[] args) throws IOException {
String str=&ROLLENHOLT&;
ByteArrayInputStream input=newByteArrayInputStream(str.getBytes());
ByteArrayOutputStream output=newByteArrayOutputStream();
int temp=0;
while((temp=input.read())!=-1){
char ch=(char)
output.write(Character.toLowerCase(ch));
String outStr=output.toString();
input.close();
output.close();
System.out.println(outStr);
rollenholt
内容操作流一般使用来生成一些临时信息采用的，这样可以避免删除的麻烦。
管道流主要可以进行两个线程之间的通信。
PipedOutputStream 管道输出流
PipedInputStream 管道输入流
验证管道流
* 验证管道流
import java.io.*;
* 消息发送类
class Send implements Runnable{
private PipedOutputStream out=
public Send() {
out=new PipedOutputStream();
public PipedOutputStream getOut(){
return this.
public void run(){
String message=&hello , Rollen&;
out.write(message.getBytes());
}catch (Exception e) {
e.printStackTrace();
out.close();
}catch (Exception e) {
e.printStackTrace();
* 接受消息类
class Recive implements Runnable{
private PipedInputStream input=
public Recive(){
this.input=new PipedInputStream();
public PipedInputStream getInput(){
return this.
public void run(){
byte[] b=new byte[1000];
int len=0;
len=this.input.read(b);
}catch (Exception e) {
e.printStackTrace();
input.close();
}catch (Exception e) {
e.printStackTrace();
System.out.println(&接受的内容为 &+(newString(b,0,len)));
class hello{
public static void main(String[] args) throws IOException {
Send send=new Send();
Recive recive=new Recive();
//管道连接
send.getOut().connect(recive.getInput());
}catch (Exception e) {
e.printStackTrace();
new Thread(send).start();
new Thread(recive).start();
接受的内容为 hello , Rollen
* 使用PrintStream进行输出
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
PrintStream print = new PrintStream(new FileOutputStream(newFile(&d:&
+ File.separator + &hello.txt&)));
print.println(true);
print.println(&Rollen&);
print.close();
Rollen
当然也可以格式化输出
* 使用PrintStream进行输出
* 并进行格式化
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
PrintStream print = new PrintStream(new FileOutputStream(newFile(&d:&
+ File.separator + &hello.txt&)));
String name=&Rollen&;
int age=20;
print.printf(&姓名：%s. 年龄：%d.&,name,age);
print.close();
姓名：Rollen. 年龄：20.
使用OutputStream向屏幕上输出内容
* 使用OutputStream向屏幕上输出内容
import java.io.*;
class hello {
public static void main(String[] args) throws IOException {
OutputStream out=System.
out.write(&hello&.getBytes());
}catch (Exception e) {
e.printStackTrace();
out.close();
}catch (Exception e) {
e.printStackTrace();
输入输出重定向
import java.io.F
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.PrintS
* 为System.out.println()重定向输出
public class systemDemo{
public static void main(String[] args){
// 此刻直接输出到屏幕
System.out.println(&hello&);
File file = new File(&d:&+ File.separator + &hello.txt&);
System.setOut(new PrintStream(newFileOutputStream(file)));
}catch(FileNotFoundException e){
e.printStackTrace();
System.out.println(&这些内容在文件中才能看到哦！&);
eclipse的控制台输出的是hello。然后当我们查看d盘下面的hello.txt文件的时候，会在里面看到：这些内容在文件中才能看到哦！
import java.io.F
import java.io.FileNotFoundE
import java.io.FileOutputS
import java.io.PrintS
* System.err重定向 这个例子也提示我们可以使用这种方法保存错误信息
public class systemErr{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
System.err.println(&这些在控制台输出&);
System.setErr(new PrintStream(newFileOutputStream(file)));
}catch(FileNotFoundException e){
e.printStackTrace();
System.err.println(&这些在文件中才能看到哦！&);
你会在eclipse的控制台看到红色的输出：“这些在控制台输出”，然后在d盘下面的hello.txt中会看到：这些在文件中才能看到哦！
import java.io.F
import java.io.FileInputS
import java.io.FileNotFoundE
import java.io.IOE
* System.in重定向
public class systemIn{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
if(!file.exists()){
System.setIn(new FileInputStream(file));
}catch(FileNotFoundException e){
e.printStackTrace();
byte[] bytes = newbyte[1024];
int len = 0;
len = System.in.read(bytes);
}catch(IOException e){
e.printStackTrace();
System.out.println(&读入的内容为：&+ new String(bytes, 0, len));
前提是我的d盘下面的hello.txt中的内容是：“这些文件中的内容哦！”，然后运行程序，输出的结果为：读入的内容为：这些文件中的内容哦！
BufferedReader的小例子
注意： BufferedReader只能接受字符流的缓冲区，因为每一个中文需要占据两个字节，所以需要将System.in这个字节输入流变为字符输入流，采用：
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
下面给一个实例：
import java.io.BufferedR
import java.io.IOE
import java.io.InputStreamR
* 使用缓冲区从键盘上读入内容
public class BufferedReaderDemo{
public static void main(String[] args){
BufferedReader buf = new BufferedReader(
new InputStreamReader(System.in));
String str =
System.out.println(&请输入内容&);
str = buf.readLine();
}catch(IOException e){
e.printStackTrace();
System.out.println(&你输入的内容是：&+ str);
请输入内容
dasdas
你输入的内容是：dasdas
其实我们比较常用的是采用Scanner类来进行数据输入，下面来给一个Scanner的例子吧
import java.util.S
* Scanner的小例子，从键盘读数据
public class ScannerDemo{
public static void main(String[] args){
Scanner sca = new Scanner(System.in);
// 读一个整数
int temp = sca.nextInt();
System.out.println(temp);
//读取浮点数
float flo=sca.nextFloat();
System.out.println(flo);
//读取字符
//...等等的，都是一些太基础的，就不师范了。
}其实Scanner可以接受任何的输入流
下面给一个使用Scanner类从文件中读出内容
import java.io.F
import java.io.FileNotFoundE
import java.util.S
* Scanner的小例子，从文件中读内容
public class ScannerDemo{
public static void main(String[] args){
File file = new File(&d:&+ File.separator + &hello.txt&);
Scanner sca =
sca = new Scanner(file);
}catch(FileNotFoundException e){
e.printStackTrace();
String str = sca.next();
System.out.println(&从文件中读取的内容是：&+ str);
从文件中读取的内容是：这些文件中的内容哦！
数据操作流DataOutputStream、DataInputStream类
import java.io.DataOutputS
import java.io.F
import java.io.FileOutputS
import java.io.IOE
public class DataOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
char[] ch = { 'A','B', 'C' };
DataOutputStream out =
out = new DataOutputStream(newFileOutputStream(file));
for(char temp : ch){
out.writeChar(temp);
out.close();
现在我们在上面例子的基础上，使用DataInputStream读出内容
import java.io.DataInputS
import java.io.F
import java.io.FileInputS
import java.io.IOE
public class DataOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
DataInputStream input = new DataInputStream(new FileInputStream(file));
char[] ch = new char[10];
int count = 0;
while((temp = input.readChar()) != 'C'){
ch[count++] =
System.out.println(ch);
合并流 SequenceInputStream
SequenceInputStream主要用来将2个流合并在一起，比如将两个txt中的内容合并为另外一个txt。下面给出一个实例：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.io.SequenceInputS
* 将两个文本文件合并为另外一个文本文件
public class SequenceInputStreamDemo{
public static void main(String[] args) throws IOException{
File file1 = new File(&d:&+ File.separator + &hello1.txt&);
File file2 = new File(&d:&+ File.separator + &hello2.txt&);
File file3 = new File(&d:&+ File.separator + &hello.txt&);
InputStream input1 = new FileInputStream(file1);
InputStream input2 = new FileInputStream(file2);
OutputStream output = new FileOutputStream(file3);
SequenceInputStream sis = newSequenceInputStream(input1, input2);
int temp = 0;
while((temp = sis.read()) != -1){
output.write(temp);
input1.close();
input2.close();
output.close();
sis.close();
结果会在hello.txt文件中包含hello1.txt和hello2.txt文件中的内容。
文件压缩 ZipOutputStream类
先举一个压缩单个文件的例子吧：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.util.zip.ZipE
import java.util.zip.ZipOutputS
public class ZipOutputStreamDemo1{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
File zipFile = new File(&d:&+ File.separator + &hello.zip&);
InputStream input = new FileInputStream(file);
ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
zipFile));
zipOut.putNextEntry(new ZipEntry(file.getName()));
// 设置注释
zipOut.setComment(&hello&);
int temp = 0;
while((temp = input.read()) != -1){
zipOut.write(temp);
input.close();
zipOut.close();
运行结果之前，我创建了一个hello.txt的文件，原本大小56个字节，但是压缩之后产生hello.zip之后，居然变成了175个字节，有点搞不懂。
不过结果肯定是正确的，我只是提出我的一个疑问而已。
上面的这个例子测试的是压缩单个文件，下面的们来看看如何压缩多个文件。
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.util.zip.ZipE
import java.util.zip.ZipOutputS
* 一次性压缩多个文件
public class ZipOutputStreamDemo2{
public static void main(String[] args) throws IOException{
// 要被压缩的文件夹
File file = new File(&d:&+ File.separator + &temp&);
File zipFile = new File(&d:&+ File.separator + &zipFile.zip&);
InputStream input =
ZipOutputStream zipOut = new ZipOutputStream(new FileOutputStream(
zipFile));
zipOut.setComment(&hello&);
if(file.isDirectory()){
File[] files = file.listFiles();
for(int i = 0; i & files. ++i){
input = new FileInputStream(files[i]);
zipOut.putNextEntry(newZipEntry(file.getName()
+ File.separator + files[i].getName()));
int temp = 0;
while((temp = input.read()) != -1){
zipOut.write(temp);
input.close();
zipOut.close();
先看看要被压缩的文件吧：
接下来看看压缩之后的：
大家自然想到，既然能压缩，自然能解压缩，在谈解压缩之前，我们会用到一个ZipFile类，先给一个这个例子吧。java中的每一个压缩文件都是可以使用ZipFile来进行表示的
import java.io.F
import java.io.IOE
import java.util.zip.ZipF
* ZipFile演示
public class ZipFileDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.zip&);
ZipFile zipFile = new ZipFile(file);
System.out.println(&压缩文件的名称为：&+ zipFile.getName());
压缩文件的名称为：d:\hello.zip
现在我们呢是时候来看看如何加压缩文件了，和之前一样，先让我们来解压单个压缩文件（也就是压缩文件中只有一个文件的情况），我们采用前面的例子产生的压缩文件hello.zip
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.zip.ZipE
import java.util.zip.ZipF
* 解压缩文件（压缩文件中只有一个文件的情况）
public class ZipFileDemo2{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.zip&);
File outFile = new File(&d:&+ File.separator + &unZipFile.txt&);
ZipFile zipFile = new ZipFile(file);
ZipEntry entry = zipFile.getEntry(&hello.txt&);
InputStream input = zipFile.getInputStream(entry);
OutputStream output = new FileOutputStream(outFile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
input.close();
output.close();
解压缩之前：
这个压缩文件还是175字节
解压之后产生：
又回到了56字节，表示郁闷。
现在让我们来解压一个压缩文件中包含多个文件的情况吧
ZipInputStream类
当我们需要解压缩多个文件的时候，ZipEntry就无法使用了，如果想操作更加复杂的压缩文件，我们就必须使用ZipInputStream类
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.InputS
import java.io.OutputS
import java.util.zip.ZipE
import java.util.zip.ZipF
import java.util.zip.ZipInputS
* 解压缩一个压缩文件中包含多个文件的情况
public class ZipFileDemo3{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &zipFile.zip&);
File outFile =
ZipFile zipFile = new ZipFile(file);
ZipInputStream zipInput = newZipInputStream(new FileInputStream(file));
ZipEntry entry =
InputStream input =
OutputStream output =
while((entry = zipInput.getNextEntry()) !=null){
System.out.println(&解压缩& + entry.getName() + &文件&);
outFile = new File(&d:&+ File.separator + entry.getName());
if(!outFile.getParentFile().exists()){
outFile.getParentFile().mkdir();
if(!outFile.exists()){
outFile.createNewFile();
input = zipFile.getInputStream(entry);
output = new FileOutputStream(outFile);
int temp = 0;
while((temp = input.read()) != -1){
output.write(temp);
input.close();
output.close();
被解压的文件：
解压之后再D盘下会出现一个temp文件夹，里面内容：
PushBackInputStream回退流
import java.io.ByteArrayInputS
import java.io.IOE
import java.io.PushbackInputS
* 回退流操作
public class PushBackInputStreamDemo{
public static void main(String[] args) throws IOException{
String str = &hello,rollenholt&;
PushbackInputStream push =
ByteArrayInputStream bat =
bat = new ByteArrayInputStream(str.getBytes());
push = new PushbackInputStream(bat);
int temp = 0;
while((temp = push.read()) != -1){
if(temp == ','){
push.unread(temp);
temp = push.read();
System.out.print(&(回退&+ (char) temp + &) &);
System.out.print((char) temp);
hello(回退,)rollenholt
* 取得本地的默认编码
public class CharSetDemo{
public static void main(String[] args){
System.out.println(&系统默认编码为：&+ System.getProperty(&file.encoding&));
系统默认编码为：GBK
乱码的产生：
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.OutputS
* 乱码的产生
public class CharSetDemo2{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
OutputStream out = new FileOutputStream(file);
byte[] bytes = &你好&.getBytes(&ISO8859-1&);
out.write(bytes);
out.close();
一般情况下产生乱码，都是由于编码不一致的问题。
对象的序列化
对象序列化就是把一个对象变为二进制数据流的一种方法。
一个类要想被序列化，就行必须实现java.io.Serializable接口。虽然这个接口中没有任何方法，就如同之前的cloneable接口一样。实现了这个接口之后，就表示这个类具有被序列化的能力。
先让我们实现一个具有序列化能力的类吧：
import java.io.*;
* 实现具有序列化能力的类
public class SerializableDemo implementsSerializable{
public SerializableDemo(){
public SerializableDemo(String name, int age){
this.name=
public String toString(){
return &姓名：&+name+&
}这个类就具有实现序列化能力，
在继续将序列化之前，先将一下ObjectInputStream和ObjectOutputStream这两个类
先给一个ObjectOutputStream的例子吧：
import java.io.S
import java.io.F
import java.io.FileOutputS
import java.io.IOE
import java.io.ObjectOutputS
* 实现具有序列化能力的类
public class Person implementsSerializable{
public Person(){
public Person(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
* 示范ObjectOutputStream
public class ObjectOutputStreamDemo{
public static void main(String[] args) throws IOException{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(
oos.writeObject(new Person(&rollen&,20));
oos.close();
当我们查看产生的hello.txt的时候，看到的是乱码，呵呵。因为是二进制文件。
虽然我们不能直接查看里面的内容，但是我们可以使用ObjectＩｎｐｕｔＳｔｒｅａｍ类查看：
import java.io.F
import java.io.FileInputS
import java.io.ObjectInputS
* ObjectInputStream示范
public class ObjectInputStreamDemo{
public static void main(String[] args) throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
姓名：rollen&年龄：20
到底序列化什么内容呢？
其实只有属性会被序列化。
Externalizable接口
被Serializable接口声明的类的对象的属性都将被序列化，但是如果想自定义序列化的内容的时候，就需要实现Externalizable接口。
当一个类要使用Externalizable这个接口的时候，这个类中必须要有一个无参的构造函数，如果没有的话，在构造的时候会产生异常，这是因为在反序列话的时候会默认调用无参的构造函数。
现在我们来演示一下序列化和反序列话：
package IO;
import java.io.E
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.IOE
import java.io.ObjectI
import java.io.ObjectInputS
import java.io.ObjectO
import java.io.ObjectOutputS
* 序列化和反序列化的操作
public class ExternalizableDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
public static void ser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(new Person(&rollen&,20));
out.close();
public static void dser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
class Person implements Externalizable{
public Person(){
public Person(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
// 复写这个方法，根据需要可以保存的属性或者具体内容，在序列化的时候使用
public void writeExternal(ObjectOutput out)throws IOException{
out.writeObject(this.name);
out.writeInt(age);
// 复写这个方法，根据需要读取内容 反序列话的时候需要
public void readExternal(ObjectInput in)throws IOException,
ClassNotFoundException{
this.name = (String) in.readObject();
this.age = in.readInt();
姓名：rollen&年龄：20
本例中，我们将全部的属性都保留了下来，
Serializable接口实现的操作其实是吧一个对象中的全部属性进行序列化，当然也可以使用我们上使用是Externalizable接口以实现部分属性的序列化，但是这样的操作比较麻烦，
当我们使用Serializable接口实现序列化操作的时候，如果一个对象的某一个属性不想被序列化保存下来，那么我们可以使用transient关键字进行说明：
下面举一个例子：
package IO;
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.ObjectInputS
import java.io.ObjectOutputS
import java.io.S
* 序列化和反序列化的操作
public class serDemo{
public static void main(String[] args) throws Exception{
ser(); // 序列化
dser(); // 反序列话
public static void ser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(new Person1(&rollen&,20));
out.close();
public static void dser() throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object obj = input.readObject();
input.close();
System.out.println(obj);
class Person1 implements Serializable{
public Person1(){
public Person1(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：& + name + &
// 注意这里
private transient S
姓名：null&年龄：20
最后在给一个序列化一组对象的例子吧：
import java.io.F
import java.io.FileInputS
import java.io.FileOutputS
import java.io.ObjectInputS
import java.io.ObjectOutputS
import java.io.S
* 序列化一组对象
public class SerDemo1{
public static void main(String[] args) throws Exception{
Student[] stu = { new Student(&hello&,20), new Student(&world&,30),
new Student(&rollen&,40) };
Object[] obj = dser();
for(int i =0; i & obj. ++i){
Student s = (Student) obj[i];
System.out.println(s);
public static void ser(Object[] obj) throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
out.writeObject(obj);
out.close();
// 反序列化
public static Object[] dser()throws Exception{
File file = new File(&d:&+ File.separator + &hello.txt&);
ObjectInputStream input = newObjectInputStream(new FileInputStream(
Object[] obj = (Object[]) input.readObject();
input.close();
class Student implements Serializable{
public Student(){
public Student(String name, intage){
this.name =
this.age =
public String toString(){
return &姓名：
& + name +&
姓名：&
hello& 年龄：20
姓名：&
world& 年龄：30
姓名：& rollen&年龄：40
本问题标题：
本问题地址：
温馨提示：本问题已经关闭，不能解答。
暂无合适的专家
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&&&增值电信业务经营许可证湘B2-}
我要回帖
更多推荐
- ·手机版网易云mv在哪里音乐怎么看mv？
- ·求排名前十小说推荐
- ·谁用过的比较好用滋润公认最好用的身体乳乳推荐下呗？
- ·2013第二届亚洲国际声乐比赛报名大赛第二届亚洲国际歌剧比赛
- ·2017.1.13号12.30男孩命里查孩子五行缺什么么？
- ·求做一张FLASH电子贺卡几个画面转换 带文字飘过或者雪花怎样拍飘落的雪花 可爱点的 主题不限
- ·我那几个铁哥们收藏的极品18岁女生。空姐。XXOO.网站里面有！
- ·万利达 MDVD-6668 hdmi高清diy论坛歌王DVD 万首歌曲hdmi高清diy论坛HDMI 影碟机 送话筒求品牌的
- ·php正则，请高手帮忙看一下这个正则应该自我评价怎么写写？
- ·表情的名字p是什么表情?
- ·3685=3,2588=4,1469=2,6143=1,8630=4,8639=4,9634=2,5634=1,9842=( ) 急急急!!!!!!!!!!!!!!!!!!!!!!!!!!!
- ·我的电脑放歌就和酷我k歌没有伴奏时的伴奏一样，，所有电脑声音都是。怎么回事
- ·htcg18手机报价提示灯在那右边 那左边是什么灯
- ·哪位好心人送我个6-9位数的号啊.非常大家要感谢好人啊.好人一生平安
- ·DIV IE7,IE8,IE9,火狐，兼容代码ie8怎么升级ie9写？
- ·qq看不到图片论坛图片
- ·cdlinuxx C系统编程中的文件传输问题:只能传送文本文件，不能传送二进制文件。（TCP+文件I/O实现）
- ·谁能给我个YY号，重谢了. 一定给分. QQ邮箱：
- ·为什么我的腾讯微博上传不了头像，新浪微博自定义皮肤肤也不行，只是微博而已。其他的QQ什么的一切正常
- ·谁帮我申请五个qq？
- ·用java的IO复制文件的内容时，为什么不java 调用shellclose（）；方法就没法复制
- ·无线路由器受限制限制速度对手机没有用呢
- ·宏基aspire4540g4540g温度过高，灰尘清过，硅胶换过，也有散热器，主板 cpu 显卡温度全过90，求高手帮助！！
- ·网络流行语基友bd版是什么意思思?
- ·泰囧笔记本本的硬盘、主板温度过高。。很高！可以烤肉了。。囧，肿么办？
- ·想登一个网站，但在同一时刻访问的人梦幻经验太多怎么办了进不去怎么办？求救啊！
- ·速贝泛优化系统CMS优化的网站效果真的像大家传的那么神奇吗？
- ·张继科vs王皓和王皓是不是好朋友
- ·一周打试纸两次结果不一样羽毛球有必要穿不一样的运动服吗？
- ·宝力豪健身俱乐部部管理有何要点？
- ·北京北京市育英学校校高中有足球队吗，高中每年有足球联赛吗？？？
- ·伦敦奥运会金牌榜上获得3枚以上金牌的中国男选手有哪些
- ·2008感动中国颁奖词2008得了多少块银牌？
- ·2012年美国《人物》 赛琳包娜排第几
- ·为什么伦敦奥运会田径决赛比赛开始得晚？
- ·伦敦奥运会女子体操艺术体操是什么时候比赛
