java+i+,i=i++ java
Yyds干货库存
IO流可以分为输入流和输出流。
根据流处理的数据类型，可分为字节流和字符流(用于处理Unicode字符数据)。
字节流主要基于InputStream和OutputStream，字符流主要基于Reader和Writer。
节点流(低级流)和处理流(高级流):
使用JAVA处理流来封装节点流是典型的装饰性设计模式。通过使用处理流来封装不同的节点流，不仅可以消除不同节点流的实现差异，还可以提供更方便的方式来完成输入输出功能，使得Java应用程序可以使用相同的代码，以透明的方式访问不同输入输出设备的数据流。因此，加工流程也称为包装流程。
下图说明了相关的系统：
类：(文件):
提供文件操作功能(File可以对文件或目录进行创建、删除等操作，但要访问文件的内容，必须使用输入/输出流)
1.创建文件类对象：
文件f；
f=新文件( test . Java )；
f=新文件( E:\\ex\ ， test . Java )；
2.将目录视为文件。File类提供了实现目录管理功能的方法：
文件路径=新文件( E:\ \ ex \ )；
File f=新文件(路径， test . Java )；
方法：
F.getName():返回文件名temp.dat
F.getParent():返回文件所在的目录名数据。
F.getPath():返回文件路径data\temp.dat
F.getAbsolutePath():返回绝对路径… \ data \ temp.dat。
F.exists():文件存在吗？
F.canWrite()、f.canRead():文件是否可写或可读。
F.isFile()、f.isDirectory():是文件还是目录？
F.lastmodified()、f.length()、f.delete():文件的最后修改日期和长度；删除文件
F.mkdir()、f.list():创建目录；列出目录中的所有文件。
几个例子说明：
导入Java . io . *；
类别FileTest{
public static void main(String[]str){
File f=新文件( E:\ \ Workspace \ \ AAA . txt )；
//确定它是否存在于该文件中。
如果(！f.exists()){
System.out.println(文件不存在)；
尝试{
f . create new file()；//如果文件不存在，创建一个新文件
} catch (IOException e) {
e . printstacktrace()；
}
}
File f1=新文件( E:\ \ Workspace \ \ AAA 1 \ \ SDF SDF \ \ asdf )；
If (f1.mkdir()){ //创建一个目录
system . out . println( yes )；
}
否则{
system . out . println(“errors”)；
}
}
}导入Java . io . *；
//浏览当前目录中的所有文件和目录
类别文件目录{
公共静态void main( String[] args ) {
尝试{
文件f1=新文件(“”)；
string ss=f1 . getabsolutepath()；
system . out . println( ss= ss)；
文件f=新文件(ss)；
if( f.isDirectory() ) {
//获取目录中所有文件的列表
file[]files=f . list files()；
for(int I=0；I文件.长度；i ) {
if( files[ i ].isDirectory() ) {
System.out.println( dir 文件[ i ])。getName())；
}
否则{
System.out.println( files[ i ].getName())；
}
}
}
}
捕捉(异常e ) {
e . printstacktrace()；
}
}
}导入Java . io . *；
超级测试等级{
公共静态void main(String args[]) {
File dir=新文件( E:\ \ Workspace \ \ Java \ \ test 2011 11 08 )；//使用文件对象来表示目录
Filter Filter=new Filter( txt )；//生成一个名为java的过滤器
System.out.println(列出目录中的java文件 dir)；
string[]files=dir . list(filter)；//列出目录dir中所有文件后缀为txt的文件
for(int I=0；I文件.长度；i ) {
File f=新文件(dir，files[I])；//为目录dir下的文件或目录创建一个File对象
If (f.isFile()) //如果对象是带有java后缀的文件，则打印文件名。
system . out . println( file: f )；
其他
System.out.println(子目录 f)；//如果是目录，打印目录名
}
}
}
类别筛选器实现FilenameFilter {
字符串范围；
过滤器(字符串范围){
this.extent=范围；
}
public boolean accept(文件目录，字符串名称){
返回name.endsWith( . 程度)；//返回文件的后缀
}
}
字节流：文件输入流和文件输出流
导入Java . io . *；
/**
*将一个文件的所有内容写入另一个文件。
*/
类FileStreamTest{
公共静态void main(字符串参数[]中的字符串)
尝试[
导入数据文件=新建文件(‘测试1。txt’)；
outFile=新文件( test2.txt ):
文件输入流fis=新建文件输入流(不可信):
fileoutput stream fos=新文件输出流(outfile)；
内部c；
while((c=fis.read())！=-1)/(l读取一个字节
{
福斯。写(c)；
}
fis。close()；
福斯。close()；
} catch(文件notfounindexception e)}
系统。出去。println( filestreamtest: e )；
} catch(io异常e)}
系统。呃。println( filestreamtest: e )；
}
}
}导入java.io.*:
复制线程类[
公共静态void main(字符串参数[]中的字符串)
复制线程cf=新复制线程()；
参见copyFile(test1.txt ， test 3。txt’)；
}
公共布尔复制文件(src字串，字串)
srcFile文件，取消；
srcFile=新文件(src)；
偏移=新文件(des):
fileinputstream fis=null
fileoutputstream fos=null
尝试[
演示。创建新文件()；
fis=新文件输入流(src文件)；
fos=新建文件输出流（退出)://覆盖
//fos=新文件输出流(sfile，true)；//追加
int字节读取
字节[]缓冲=新字节[4 * 1024];//4K缓冲区
while((bytesRead=fis.read(buf))！===1)}
fos.write(buf，0，bytes read)；
}
fos.flush():
福斯。close()；
fis。close()；
} catch(io异常e)}
系统。输出。println(e)；
返回错误的
}
返回真实的
}
}如果只是在尾部追加，而不是覆盖需要调用FileOutputStream("file "，true)就好吧云娥，对于字符流文件就是FileWriter("file "，true)就好吧魏冄。
父类过滤流：
过滤器输入流(输入流in):
过滤器输出流(输出流输出):
过滤流—缓冲流
类缓冲EDI输入流你好输出流缓冲区继承滤流你好filteroutputstream，实现了带缓冲的过滤流，它提供了缓冲机制，把任意的输入输出(输入/输出)""诶哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟哟""到缓冲流上，可以提高该输入输出(输入/输出)流的读取效率，在初始化时，除了要指定所连接的输入输出(输入/输出)流之外，还可以指定缓冲区的大小。
在读写的同时对数据缓存，这样避免每次读写数据都要进行实际的物理读写操作，在用缓冲输出流输出时，数据先输入缓冲区，当缓冲区满的时再写入连接的输出流，可以调用齐平()来清空缓冲区。
导入java.io.*:
类超集[
公共静态void main(字符串参数[]中的字符串)
尝试[
导入数据文件=新建文件(‘测试1。txt’)；
输出文件=新建文件(‘测试4。txt’)；
缓冲区EDI输入流buffetis=新缓冲区EDI输入流(新文件输入流，256);
buffer output stream buffet us=new buffer output stream(新文件输出流(outfile)，256)；
内部低输入联网（low-entry networking的缩写）
字节barray[]=新字节[256];
的双曲馀弦值
系统。出去。println( while )；
len=buffis。阅读(巴拉雷):
好笑。写（巴利，0,伦);
System.out.println(len: len):
}而(len==256)；
自助餐。close()；
搞笑。close()；
} catch(文件notfounindexception e)}
系统。出去。println( filestreamtest: e )；
} catch(io异常e)}
系统。呃。println( filestreamtest: e )；
}
}
}
过滤流—数据流
输入流你好数据输出流，继承滤流你好filteroutputstream，可以用来与计算机无关的格式读写Java(Java)的基本数据类型以及字串(字符串)对象。
readBoolean()读一字节，非零为真
读取字节()僧儿8位读字节
readChar()读统一码(unicode)字符
readInt()读整数值
writeChar(int v)把字符写进输出流
writeLong(长五)把长整写进输出流
writeInt(int v)把整数写进输出流
数据输出流可以是一个已经建立好的输入数据流对象，例如网络的连结，文件等。数据流可通过如下方式建立。
文件输入流fis=新建fileinputstream( file 1。txt’)；
fileoutput stream fos=新文件输出流( file 2。txt’)；
datainputstream dis=新数据输入流(fis)；
dataoutput stream dos=新数据输出流(fos)；
导入java.io.*:
类数据流测试
公共静态void main(string args[])引发io异常
{
fileoutput stream fos=新文件输出流( a . txt )；
dataoutput stream dos=新数据输出流(fos)；
尝试[
dos。write boolean(true)；
写字节((字节)123);
二。写char( j )；
2 .写double(3.141592654)；
dos。写浮点型(2.7182 f)；
dos。写int(1234567890)；
dos。写long(998877665544332211 l)；
dos。写短((短)11223)；
}最后{
dos。close()；
}
file inputstream fis=新文件输入流( a . txt )；
数据输入流dis=新数据输入流(fis)；
尝试{
系统。出去。println( \ t dis。读取boolean())；
系统。出去。println( \ t dis。读取byte())；
系统。出去。println( \ t dis。read char())；
系统。出去。println( \ t dis。read double())；
系统。出去。println( \ t dis。读取float())；
系统。出去。println( \ t dis。readint())；
系统。出去。println( \ t dis。read long())；
系统。出去。println( \ t dis。读短())；
}最后{
dis。close()；
}
}
}//需要注意的是必须抛出异常才可以编译通过。
字符流
例子：利用字符输出流来写文件
尝试
{
文件编写器fw=新文件编写器( mydata。txt’)；
PrintWriter输出=新的PrintWriter(fw)；
out.print(面朝大海，);
out.println(春暖花开!);
out.println(环境美好！);
出去。close()；
fw。close()；
}catch(IOException e)
{
e。printstacktrace()；
}例子：字符缓冲流类
导入Java。io。*;
超级测试等级{
公共静态void main(字符串参数[])引发异常
{
文件file=新文件(‘我的数据。txt’)；
尝试{
缓冲读取器in=新缓冲读取器(新文件读取器(文件))；
字符串s；
s=英寸。readline()；
while ( s！=null ) {
系统。出去。println( Read: s )；
s=英寸。readline()；
}
英寸close()；
} catch(找不到文件异常E1){
System.err.println(文件未找到： 文件);
} catch (IOException e2) {
E2。printstacktrace()；
}
}
}例子：拷贝（文件阅读器和FileWriter)
尝试{
FileReader input=new FileReader(args[0])；
FileWriter output=new FileWriter(args[1])；
char[]buffer=new char[128]；
int charsRead
字符读取=输入。读取(缓冲区)；
while ( charsRead！=-1 )
{
output.write(buffer，0，chars read)；
字符读取=输入。读取(缓冲区)；
}
输入。close()；
输出。close()；
} catch (IOException e)
{
e。printstacktrace()；
}
}例子：拷贝(BufferedWriter)
尝试{
FileReader input=new FileReader(args[0])；
缓冲读取器buf输入=新的缓冲读取器(输入)；
FileWriter output=new FileWriter(args[1])；
缓冲写入器buf输出=新缓冲写入器(输出)；
弦线；
line=buf输入。readline()；
而（行！=空)
{
bufOutput.write(line，0，line。length())；
buf输出。newline()；
line=buf输入。readline()；
}
buf输入。close()；
buf输出。close()；
}
捕捉(IOException e)
{
e。printstacktrace()；
}
随机存取文件流- RandomAccessFile
一随机访问文件是一种特殊的文件流，可以用它在文件的任何地方查找或者插入数据
2随机访问文件同时实现了数据输入和数据输出接口，所以可以用它来读/写文件
3构造器：
RandomAccessFile(java.io.File f，字符串模式)
随机访问文件(字符串文件，字符串模式)
四模式可以为" r "或“rw”
方法：
1 readXXX()或writeXXX():
如ReadInt()，ReadLine()，WriteChar()，WriteDouble()等
2 int skipBytes(int n):将指针向下移动若干字节
3长度():返回文件长度
4 long getFilePointer():返回指针当前位置
5无效寻道（长位置):将指针调到所需位置
导入Java。io。*;
导入Java。util。*;
类RandomAccessFileTest{
公共静态void main(字符串参数[])
{
尝试{
文件日志文件=新文件(‘我的数据。txt’)；
if(logfile.exists())
{
RandomAccessFile RAF=new RandomAccessFile(日志文件，‘rw’)；
系统。出去。println( leghth= RAF。length())；
皇家空军。求(RAF。length())；
for(int I=0；我我)
{
皇家空军。写入字节( Write new Date() \ r \ n )；
}
皇家空军。seek(0)；
字符串x=RAF。readline()；
而(x！=空)
{
系统。出去。println(x)；
x=RAF。readline()；
}
皇家空军。close()；
}
}catch(IOException e){
e。printstacktrace()；
}
}
}
爪哇岛流总结：
一在爪哇中有数据传输的地方都用到输入-输出流（通常是文件，网络，内存和标准输入输出等)。
2输入流和输出流是所有字节流的祖先（只有RandomAccessFile类是一个例外),阅读和写是它们最基本的方法，读写单位是字节
3阅读器和书写器是所有字符流的祖先，读写是它们最基本的方法，读写的单位是字符。
在众多的stream对象中，并不是每一个都是单独使用的，filter stream的子类会在数据发出之前做必要的处理。
5、文件(输入/输出)流，随机存取文件是一个处理本地文件的类。
6(输入/输出)流是过滤流的子类，可以读写各种基础数据，常用于文件和网络。例如readByte、writeBoolean等。
7 Buffered(Input/Output)Stream的作用是在数据发送到目的地之前进行缓存，达到一定量后再发送到目的地，减少了阻塞次数。
8管道(输入/输出)流适用于一个进程的输出被用作另一个进程的输入的情况。
版权归作者所有：来自博主的苦糖？原创作品请联系作者授权转载，否则将追究法律责任。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。