51CTO下载Java网络编程+讲义Word文件下载.docx

51CTO下载Java网络编程+讲义Word文件下载.docx

《51CTO下载Java网络编程+讲义Word文件下载.docx》由会员分享，可在线阅读，更多相关《51CTO下载Java网络编程+讲义Word文件下载.docx（98页珍藏版）》请在冰豆网上搜索。

"

）;

bytebuffer[]=newbyte[512];

//输入缓冲区

intcount=System.in.read（buffer）;

//读取标准输入流

Output:

for（inti=0;

i<

COUNT;

I++）{//输出buffer元素值

System.out.print（"

+buffer[i]）;

}

System.out.println（）;

I++）{//按字符方式输出buffer

System.out.print（（char）buffer[i]）;

count="

+count）;

//buffer实际长度

程序中，main方法采用throws子句抛出IOException异常交由系统处理。

2、java.io包中的数据流及文件类

字节流：

从InputStream和OutputStream派生出来的一系列类。

这类流以字节（byte）为基本处理单位。

◇InputStream、OutputStream

◇FileInputStream、FileOutputStream

◇PipedInputStream、PipedOutputStream

◇ByteArrayInputStream、ByteArrayOutputStream

◇FilterInputStream、FilterOutputStream

◇DataInputStream、DataOutputStream

◇BufferedInputStream、BufferedOutputStream

字符流：

从Reader和Writer派生出的一系列类，这类流以16位的Unicode码表示的字符为基本处理单位。

◇Reader、Writer

◇InputStreamReader、OutputStreamWriter

◇FileReader、FileWriter

◇CharArrayReader、CharArrayWriter

◇PipedReader、PipedWriter

◇FilterReader、FilterWriter

◇BufferedReader、BufferedWriter

◇StringReader、StringWriter

第二节字节流初步

InputStream和OutputStream

read（）：

从流中读入数据

skip（）：

跳过流中若干字节数

available（）：

返回流中可用字节数

mark（）：

在流中标记一个位置

reset（）：

返回标记过得位置

markSupport（）：

是否支持标记和复位操作

close（）：

关闭流

intread（）从输入流中读一个字节，形成一个0～255之间的整数返回（是一个抽象方法）。

intread（byteb[]）读多个字节到数组中。

intread（byteb[],intoff,intlen）

write（intb）将一个整数输出到流中（只输出低位字节，抽象）

write（byteb[]）将字节数组中的数据输出到流中

write（byteb[],intoff,intlen）将数组b中从off指定的位置开始，长度为len的数据输出到流中

flush（）：

刷空输出流，并将缓冲区中的数据强制送出

从输入流中读取长度为len的数据，写入数组b中从索引off开始的位置，并返回读取得字节数。

进行I/O操作时可能会产生I/O例外，属于非运行时例外，应该在程序中处理。

如：

型FileNotFoundException,EOFException,IOException

例2打开文件。

本例以FileInputStream的read（buffer）方法，每次从源程序文件OpenFile.java中读取512个字节，存储在缓冲区buffer中，再将以buffer中的值构造的字符串newString（buffer）显示在屏幕上。

publicclassOpenFile{

publicstaticvoidmain（Stringargs[]）throwsIOException{

try{//创建文件输入流对象

FileInputStreamrf=newFileInputStream（"

OpenFile.java"

intn=512;

bytebuffer[]=newbyte[n];

while（（rf.read（buffer,0,n）!

=-1）&

&

（n>

0））//读取输入流

{System.out.print（newString（buffer））;

}

rf.close（）;

//关闭输入流

}catch（IOExceptionioe）{System.out.println（ioe）;

catch（Exceptione）{System.out.println（e）;

例3写入文件。

本例用System.in.read（buffer）从键盘输入一行字符，存储在缓冲区buffer中，再以FileOutStream的write（buffer）方法，将buffer中内容写入文件Write1.txt中，程序如下：

publicclassWrite1{

publicstaticvoidmain（Stringargs[]）{

try{

intcount,n=512;

count=System.in.read（buffer）;

FileOutputStreamwf=newFileOutputStream（"

Write1.txt"

//创建文件输出流对象

wf.write（buffer,0,count）;

//写入输出流

wf.close（）;

//关闭输出流

SavetoWrite1.txt!

"

}catch（IOExceptionioe）{

System.out.println（ioe）;

}catch（Exceptione）{

System.out.println（e）;

第三节文件操作

1、File类

File类声明如下：

publicclassFileectendsObjectimplementsSerializable,Comparable

构造方法：

publicFile（Stringpathname）

publicFile（Filepatent,Stringchile）

publicFile（Stringpatent,Stringchild）

2、文件名的处理

StringgetName（）；

//得到一个文件的名称（不包括路径）

StringgetPath（）；

//得到一个文件的路径名

StringgetAbsolutePath（）；

//得到一个文件的绝对路径名

StringgetParent（）；

//得到一个文件的上一级目录名

StringrenameTo（FilenewName）;

//将当前文件名更名为给定文件的完整路径文件属性测试

booleanexists（）；

//测试当前File对象所指示的文件是否存在

booleancanWrite（）；

//测试当前文件是否可写

booleancanRead（）；

//测试当前文件是否可读

booleanisFile（）；

//测试当前文件是否是文件（不是目录）

booleanisDirectory（）；

//测试当前文件是否是目录

3、普通文件信息和工具

longlastModified（）;

//得到文件最近一次修改的时间

longlength（）;

//得到文件的长度，以字节为单位

booleandelete（）;

//删除当前文件

4、目录操作

booleanmkdir（）;

//根据当前对象生成一个由该对象指定的路径

Stringlist（）;

//列出当前目录下的文件

例4自动更新文件。

本例使用File类对象对指定文件进行自动更新的操作。

importjava.util.Date;

importjava.text.SimpleDateFormat;

publicclassUpdateFile{

publicstaticvoidmain（Stringargs[]）throwsIOException{

Stringfname="

;

//待复制的文件名

Stringchilddir="

backup"

//子目录名

newUpdateFile（）.update（fname,childdir）;

publicvoidupdate（Stringfname,Stringchilddir）throwsIOException{

Filef1,f2,child;

f1=newFile（fname）;

//当前目录中创建文件对象f1

child=newFile（childdir）;

//当前目录中创建文件对象child

if（f1.exists（））{

if（!

child.exists（））//child不存在时创建子目录

child.mkdir（）;

f2=newFile（child,fname）;

//在子目录child中创建文件f2

f2.exists（）||//f2不存在时或存在但日期较早时

f2.exists（）&

（f1.lastModified（）>

f2.lastModified（）））

copy（f1,f2）;

//复制

getinfo（f1）;

getinfo（child）;

}else

System.out.println（f1.getName（）+"

filenotfound!

publicvoidcopy（Filef1,Filef2）throwsIOException{

FileInputStreamrf=newFileInputStream（f1）;

//创建文件输入流对象

FileOutputStreamwf=newFileOutputStream（f2）;

//创建文件输出流对象

count=rf.read（buffer,0,n）;

//读取输入流

while（count!

=-1）{

CopyFile"

+f2.getName（）+"

!

publicstaticvoidgetinfo（Filef1）throwsIOException{

SimpleDateFormatsdf;

sdf=newSimpleDateFormat（"

yyyy年MM月dd日hh时mm分"

if（f1.isFile（））

<

FILE>

\t"

+f1.getAbsolutePath（）+"

+

f1.length（）+"

+sdf.format（newDate（f1.lastModified（））））;

else{

\t"

+f1.getAbsolutePath（））;

File[]files=f1.listFiles（）;

FILES.LENGTH;

I++）

getinfo（files[i]）;

f1.lastModified（）返回一个表示日期的长整型，值为从1970年1月1日零时开始计算的毫秒数，并以此长整型构造一个日期对象，再按指定格式输出日期。

5、文件过滤器

类FilterInputStream和FilterOutputStream分别对其他输入/输出流进行特殊处理，它们在读/写数据的同时可以对数据进行特殊处理。

另外还提供了同步机制，使得某一时刻只有一个线程可以访问一个输入/输出流。

类FilterInputStream和FilterOutputStream分别重写了父类InputStream和OutputStream的所有方法，同时，它们的子类也应该重写它们的方法以满足特定的需要。

要使用过滤流，首先必须把它连接到某个输入/输出流上，通常在构造方法的参数中指定所要连接的流：

FilterInputStream（InputStreamin）;

FilterOutputStream（OutputStreamout）;

这两个类是抽象类，构造方法也是保护方法。

类BufferedInputStream和BufferedOutputStream实现了带缓冲的过滤流，它提供了缓冲机制，把任意的I/O流“捆绑”到缓冲流上，可以提高读写效率。

在初始化时，除了要指定所连接的I/O流之外，还可以指定缓冲区的大小。

缺省大小的缓冲区适合于通常的情形；

最优的缓冲区大小常依赖于主机操作系统、可使用的内存空间以及机器的配置等；

一般缓冲区的大小为内存页或磁盘块等地整数倍，如8912字节或更小。

BufferedInputStream（InputStreamin[,intsize]）

BufferedOutputStream（OutputStreamout[,intsize]）

例5列出当前目录中带过滤器的文件名清单。

本例实现FilenameFilter接口中的accept方法，在当前目录中列出带过滤器的文件名。

publicclassDirFilterimplementsFilenameFilter{

privateStringprefix="

suffix="

//文件名的前缀、后缀

publicDirFilter（Stringfilterstr）{

filterstr=filterstr.toLowerCase（）;

inti=filterstr.indexOf（'

*'

intj=filterstr.indexOf（'

.'

if（i>

0）

prefix=filterstr.substring（0,i）;

if（j>

suffix=filterstr.substring（j+1）;

FilenameFilterfilter=newDirFilter（"

w*abc.txt"

//创建带通配符的文件名过滤器对象

Filef1=newFile（"

Filecurdir=newFile（f1.getAbsolutePath（）,"

//当前目录

System.out.println（curdir.getAbsolutePath（））;

String[]str=curdir.list（filter）;

//列出带过滤器的文件名清单

STR.LENGTH;

+str[i]）;

publicbooleanaccept（Filedir,Stringfilename）{

booleanyes=true;

try{

filename=filename.toLowerCase（）;

yes=（filename.startsWith（prefix））&

（filename.endsWith（suffix））;

}catch（NullPointerExceptione）{}

returnyes;

程序运行时，列出当前目录中符合过滤条件“w*.txt“的文件名清单。

6、随机文件操作

对于InputStream和OutputStream来说，它们的实例都是顺序访问流，也就是说，只能对文件进行顺序地读/写。

随机访问文件则允许对文件内容进行随机读/写。

在java中，类RandomAccessFile提供了随机访问文件的方法。

类RandomAccessFile的声明为：

publicclassRandomAccessFileextendsObjectimplementsDataInput,DataOutput

File：

以文件路径名的形式代表一个文件

FileDescriptor：

代表一个打开文件的文件描述

FileFilter&

FilenameFilter：

用于列出满足条件的文件

File.list（FilenameFilterfnf）

File.listFiles（FileFilterff）

FileDialog.setFilenameFilter（FilenameFilterfnf）

FileInputStream&

FileReader：

顺序读文件

FileOutputStream&

FileWriter：

顺序写文件

RandomAccessFile：

提供对文件的随机访问支持

类RandomAccessFile则允许对文件内容同时完成读和写操作，它直接继承Object，并且同时实现了接口DataInput和DataOutput，提供了支持随机文件操作的方法

DataInput和DataOutput中的方法

readInt（）,writeDouble（）…

intskipBytes（intn）：

将指针乡下移动若干字节

length（）：

返回文件长度

longgetFilePointer（）：

返回指针当前位置

voidseek（longpos）：

将指针调到所需位置

voidsetLength（longnewLength）：

设定文件长度

RandomAccessFile（Filefile,Stringmode）

RandomAccessFile（Stringname,Stringmode）

mode的取值

“r”只读.任何写操作都将抛出IOException。

“rw”读写.文件不存在时会创建该文件，文件存在时，原文件内容不变，通过写操作改变文件内容。

“rws”同步读写.等同于读写，但是任何协操作的内容都被直接写入物理文件，包括文件内容和文件属性。

“rwd”数据同步读写.等同于读写，但任何内容写操作都直接写到物理文件，对文件属性内容的修改不是这样。

例6随机文件操作。

本例对一个二进制整数文件实现访问操作当以可读写方式“rw“打开一个文件”prinmes.bin“时，如果文件不存在，将创建一个新文件。

先将2作为最小素数写入文件，再依次测试100以内的奇数，将每次产生一个素数写入文件尾。

publicclassPrimesFile{

RandomAccessFileraf;

（newPrimesFile（））.createprime（100）;

publicvoidcreateprime（intmax）throwsIOException{

raf=newRandomAccessFile（"

primes.bin"

"

rw"

//创建文件对象

raf.seek（0）;

//文件指针为0

raf.writeInt

（2）;

//写入整型

intk=3;

while（k<

=max）{

if（isPrime（k））

raf.writeInt（k）;

k=k+2;

output（max）;

raf.close（）;

//关闭文件

publicbooleanisPrime（intk）throwsIOException{

inti=0,j;

boo