Java基础.docx
《Java基础.docx》由会员分享，可在线阅读，更多相关《Java基础.docx（21页珍藏版）》请在冰点文库上搜索。
Java基础
Java.io包
包含文件操作的类
File类
File类提供了操作“文件”或者“目录”对象的方法
创建File对象的方法有三种形式:
1……Filefile1=newFile（"c:
/test/file1.txt"）;
//根据参数指定的文件路径来构造一个File实体对象。
2…..Filefile2=newFile（"c:
/test","file1.txt"）;
//在这种方式中，根据给定的目录来构造一个File实体对象，
//其中“c:
/test”为目录的路径，“file1.txt”为文件的名称。
3……Filedir=newFile（"c:
/test"）;
Filefile3=newFile（dir,"file1.txt"）;
publicclassFileDemo{
publicvoiddoOne（）throwsIOException{
//创建File对象的方法有三种形式:
Filef1=newFile（"F:
\\temp\\studentDB.sql"）;
Filef2=newFile（"F:
/test","三字经.txt"）;
Filedir=newFile（"dir2"）;
Filef3=newFile（dir,"demo.txt"）;
System.out.println（"文件名"+f1.getName（）+"父目录:
"+f1.getParent（））;
System.out.println（"文件长度:
"+f1.length（））;
booleanb=f2.exists（）;
if（b）{
f2.delete（）;//删除文件
}
if（!
f3.exists（））{
dir.mkdir（）;//新建目录
f3.createNewFile（）;//新建空白文件
System.out.println（"指定目录不存在新建了"+f3.getAbsolutePath（））;
}else{
System.out.println（f3.getAbsolutePath（））;//获取文件的绝对路径
System.out.println（"f3长度:
"+f3.length（））;
System.out.println（"f3最后修改时间：
"+newDate（f3.lastModified（）））;
System.out.println（"f3是否为目录:
"+f3.isDirectory（））;
System.out.println（"dri是否为目录:
"+dir.isDirectory（））;
}
}
//递归获取文件信息
publicvoiddoFile（Filefile）{
if（file.exists（））{
if（file.isDirectory（））{
File[]fs=file.listFiles（）;//获取文件夹下的文件及子目录列表
for（Filef:
fs）{
if（f.isFile（））{
System.out.println（f.getAbsolutePath（））;
}else{
doFile（f）;//如果是目录则递归
}
}
}else{
System.out.println（file.getAbsolutePath（））;
}
}else{
System.out.println（"文件未找到..."）;
}
}
publicstaticvoidmain（String[]args）throwsIOException{
FileDemodemo=newFileDemo（）;
demo.doOne（）;
System.out.println（"======================="）;
demo.doFile（newFile（"F:
\\MyDocuments\\J2EE\\eclipseworkspace\\JavaOOPDemo"））;
}
}
流的概念
流指数据通信通道
当程序需要读取数据的时候，
就会开启一个通向数据源的流，这个数据源可以是文件，内存，或是网络连接。
类似的，当程序需要写入数据的时候，就会开启一个通向目的地的流
JAVA定义了两种类型的流：
字节流和字符流
字节流和字符流
字节流为处理字节的输入和输出提供了方法，用于读写二进制等数据
字符流为处理字符的输入和输出提供方法，它们采用Unicode能够国际化
字节流：
输入字节流
InputStream（abstract）
|
|--------FileInputStream
|
|--------ObjectInputStream
|
|--------FilterInputStream
|
|--------DataInputStream
|
|--------BufferedInputStream
输出字节流
OutputStream（abstract）
|
|--------FileOutputStream
|
|--------ObjectOutputStream
|
|--------FilterOutputStream
|
|--------DataOutputStream
|
|--------BufferedOutputStream
|
|--------PrintStream
InputStream
InputStream类是所有输入字节流类的abstract基类
常用方法
intavailable（）返回当前可读的输入字节数。
voidclose（）关闭输入流
intread（）从输入流读取下一个数据字节，
返回一个整数。
如果到了文件的末尾，则返回-1
intread（byte[] b）
从输入流中读取一定数量的字节并将其存储在字节数组b中
intread（byte[] b,intbegin,intlength）
从输入流中从开始位置读取长度为length的字节
并将其存储在字节数组b中
OutputStream
所有输出字节流类的abstract基类
常用方法
voidclose（）关闭输出流
voidflush（）清空输出缓冲区。
voidwrite（byte[]b）将b.length个字节从指定的字节数组写入此输出流。
voidwrite（byte[]b,intoff,intlen）
将指定字节数组中从偏移量off开始的len个字节写入此输出流。
voidwrite（intb）
将指定的字节写入此输出流。
用于操作文件的字节流
FileInputStream
1..FileInputStreamfis=newFileInputStream（“文件名”）;
2…Filefile=newFile（“文件名”）;
FileInputStreamfis=newFileInputStream（file）;
FileOutputStream
1…FileOutputStreamfos=newFileOutputStream（“文件名”）;
2....Filefile=newFile（“文件名”）;
FileOutputStreamfos=newFileOutputStream（file）;
publicclassStreamDemo{
/**
*读取文件内容
*参数:
filename文件名
*/
publicvoiddoInputStream（Stringfilename）throwsIOException{
Filef=newFile（filename）;
if（f.exists（））{
InputStreamin=newFileInputStream（filename）;
System.out.println（"可读取的字节：
"+（in.available（）））;
while（in.available（）>0）{
System.out.print（（char）in.read（））;//读取文件
}
in.close（）;//关闭输入流
}else{
System.out.println（"文件未找到...."）;
}
}
/**
*写入文件
*str需要写入的字符串
*filename文件名
*/
publicvoiddoOutputStream（Stringstr,Stringfilename）throwsIOException{
OutputStreamout=newFileOutputStream（filename）;
byte[]bs=str.getBytes（）;
out.write（bs,0,bs.length）;
//将指定字节数组中从偏移量off开始的len个字节写入此输出流
out.close（）;//关闭输出流
}
/**
*复制文件
*
*srcFile源文件名
*destFile目标文件名
*@throwsIOException
*/
publicvoiddoCopy（StringsrcFile,StringdestFile）throwsIOException{
InputStreamin=newFileInputStream（srcFile）;
OutputStreamout=newFileOutputStream（destFile，true）;//true追加
while（in.available（）>0）{
out.write（in.read（））;
}
in.close（）;
out.close（）;
}
publicstaticvoidmain（String[]args）throwsIOException{
StreamDemodemo=newStreamDemo（）;
demo.doInputStream（"dir1/studentDB.sql"）;
Stringstr="testoutputStreaminputStream";
demo.doOutputStream（str,"dir1/demo.txt"）;
demo.doCopy（"dir1/studentDB.sql","dir1/studentDB.txt"）;
}
}
以二进制的形式读写数据的字节流
DataInputStream
DataInputStreamdataInputStream=newDataInputStream（inputStream实例）
DataOutputStream
DataOutputStreamout=newDataOutputStream（OutputStream实例）
要构建以上字节流需要获取InputStream或OutputStream实例
publicclassDataStreamDemo{
/**
*复制二进制文件
*@paramsrcFileName源文件
*@paramdestFileName目标文件
*@throwsIOException
*/
publicvoiddoDataStream（StringsrcFileName,StringdestFileName）throwsIOException{
DataInputStreamin=newDataInputStream（newFileInputStream（srcFileName））;
DataOutputStreamout=newDataOutputStream（newFileOutputStream（destFileName））;
inttemp;
while（（temp=in.read（））!
=-1）{//-1表示数据读取结束
out.write（temp）;
}
in.close（）;
out.close（）;
System.out.println（"文件复制完成...哈哈可以扫雷啦...."）;
Runtime.getRuntime（）.exec（destFileName）;//执行exe文件
}
publicstaticvoidmain（String[]args）throwsIOException{
DataStreamDemodemo=newDataStreamDemo（）;
demo.doDataStream（"C:
/WINDOWS/system32/winmine.exe","dir1/mywinwine.exe"）;
}
}
ObjectOutputStream
ObjectInputStream
用于将包含基本数据类型的Java对象作为流操作
创建:
ObjectOutputStreamout=newObjectOutputStream（OutputStream实例）;
ObjectInputStreamin=newObjectInputStream（InputStream实例）;
注意：
java对象必须实现序列化接口
publicclassObjectStreamDemo{
publicvoidwriteObject（StringfileName）throwsException{
ObjectOutputStreamout=null;
//创建ObjectOutputStream
try{
out=newObjectOutputStream（newFileOutputStream（fileName））;
Employeeemp=newEmployee（）;
emp.setId（100）;
emp.setName（"东方不败"）;
emp.setEmail（"df@"）;
out.writeObject（emp）;//将java对象写入到文件
emp=newEmployee（）;
emp.setId（100）;
emp.setName（"西门吹雪"）;
emp.setEmail（"xm@"）;
out.writeObject（emp）;
}finally{
out.close（）;
}
}
publicvoidreadObject（StringfileName）throwsException{
//创建ObjectInputStream
ObjectInputStreamin=
newObjectInputStream（newFileInputStream（fileName））;
try{
Employeeemp=（Employee）in.readObject（）;//读出一个对象
while（emp!
=null）{
System.out.printf（"employeeid:
%d\tname:
%s\temail:
%s%n",
emp.getId（）,emp.getName（）,emp.getEmail（））;
emp=（Employee）in.readObject（）;
}
}catch（EOFExceptione）{//到达文件或流的末尾异常
System.out.println（"\n已达文件末尾..."）;
}finally{
in.close（）;
}
}
publicstaticvoidmain（String[]args）throwsException{
ObjectStreamDemodemo=newObjectStreamDemo（）;
demo.writeObject（"dir1/employee.txt"）;
demo.readObject（"dir1/employee.txt"）;
}
}
//注意实现序列化接口
classEmployeeimplementsSerializable{
privatestaticfinallongserialVersionUID=-5855420840327542571L;
privateintid;
privateStringname;
privateStringemail;
publicintgetId（）{
returnid;
}
publicvoidsetId（intid）{
this.id=id;
}
publicStringgetName（）{
returnname;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicStringgetEmail（）{
returnemail;
}
publicvoidsetEmail（Stringemail）{
this.email=email;
}
}
PrintStream
在基本输出流的基础上提供了一些的输出方法,System.out是它的实例
publicclassPrintStreamDemo{
publicvoiddoPrintStream（StringfileName）{
//使用PrintStream输出数据到文件
PrintStreamps=null;
try{
ps=newPrintStream（fileName）;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
System.out.println（"文件未找到..."）;
}
ps.print（"helloworld"）;
ps.println（"hellochina"）;
ps.close（）;
//缓冲输入流执行效益有所提高
BufferedInputStreambis=null;
try{
bis=newBufferedInputStream（newFileInputStream（fileName））;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
System.out.println（"文件未找到..."）;
}
try{
while（bis.available（）>0）{
System.out.print（（char）bis.read（））;
}
}catch（IOExceptione）{
e.printStackTrace（）;
System.out.println（"文件读写错误..."）;
}finally{
try{
bis.close（）;
}catch（IOExceptione）{
}
}
}
publicstaticvoidmain（String[]args）{
PrintStreamDemodemo=newPrintStreamDemo（）;
demo.doPrintStream（"dir1/txt.txt"）;
}
}
字符流：
字符流用来处理双字节的Unicode字符，分别操作字符、字符数组或字符串
字节流处理单元为1个字节，操作字节和字节数组。
音频文件、图片、歌曲，就用字节流比较好，
但如果是关系到中文（文本）的，用字符流比较好。
字节流没有缓冲区，是直接输出的，而字符流是输出到缓冲区的。
因此在输出时，字节流不调用colse（）方法时，信息已经输出了，
而字符流只有在调用close（）方法关闭缓冲区时，信息才输出。
要想字符流在未关闭时输出信息，则需要手动调用flush（）方法
输入字符流
Reader（abstract）
|
|--------BufferedReader
|
|--------InputStreamReader
|
|--------FileReader
输出字符流
Writer（abstract）
|
|--------BufferedWriter
|
|--------PrintWriter
|
|--------OutputStreamWriter
|
|--------FileWriter
Reader
Readerabstract类是所有输入字符流类的基类
常用方法
intread（）
返回输入流中下一个可用字符的整数表示。
如果文件结束，返回-1。
voidclose（）
Writer
Writerabstract类是所有输出字符流类的基类
常用方法
voidwrite（Stringstr）
写入str到调用输出流
voidflush（）
清空输出缓冲区
close（）
关闭此流，但要先刷新它
InputStreamReader
OutputStreamWriter
字节流转字符流
publicclassCharStreamDemo_1{
publicvoiddoWriterAndReader（StringfileName）throwsIOException{
//写文件
OutputStreamos=newFileOutputStream（fileName,true）;//字
升级会员 