java io流原理,java中的io流分为几种
本篇文章给大家带来了关于爪哇岛的相关知识，其中主要整理了O流原理及流的分类的相关问题，包括了节点流、缓冲流、转换流、输出流等等内容，下面一起来看一下，希望对大家有帮助。
写爬虫互联网协议(互联网协议)被封了怎么解决？立即使用
一、概述
二、流的分类
1. 概述
Java的IO流共涉及40多个类，实际上非常规则，都是从以上4个抽象基类派生的，由这4个类派生出来的子类名称都是以其父类名作为子类名后缀。
| (抽象基类) | 字节流 | 字符流 |
|---|---|---|
| 输入流 | InputStream | Reader |
| 输出流 | OutputStream | Writer |
超正析象管(图片Orthicon)流体系体系：
2. InputStream
概述
方法
| 方法 | 描述 |
|---|---|
int read() | 从输入流中读取数据的下一个字节。返回 0 到 255 范围内的 int 字节值。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。 |
int read(byte[] b) | 从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。如果因为已经到达流末尾而没有可用的字节，则返回值 -1。否则以整数形式返回实际读取的字节数。 |
int read(byte[] b, int off,int len) | 将输入流中最多 len 个数据字节读入 byte 数组。尝试读取 len 个字节，但读取的字节也可能小于该值。以整数形式返回实际读取的字节数。如果因为流位于文件末尾而没有可用的字节，则返回值 -1。 |
public void close() throws IOException | 关闭此输入流并释放与该流关联的所有系统资源 |
代码演示：
@测试
public void testfile inputstream(){
FileInputStream fis=null
尝试{
//1.造文件
File File=new File( hello。txt’)；
//2.造流
fis=新文件输入流(文件);
//3.读数据
字节[]缓冲区=新字节[5];
int len//记录每次读取的字节的个数
while((len=fis.read(buffer))！=-1){
字符串str=新字符串(buffer，0，len)；
系统。出去。打印(字符串)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(fis！=null){
//4.关闭资源
尝试{
fis。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
3. Reader
概述
方法
| 方法 | 描述 |
|---|---|
int read() | 读取单个字符。作为整数读取的字符，范围在 0 到 65535 之间 (0x00-0xffff)（2个字节的Unicode码），如果已到达流的末尾，则返回 -1 |
int read(char[] cbuf) | 将字符读入数组。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。 |
int read(char[] cbuf,int off,int len) | 将字符读入数组的某一部分。存到数组cbuf中，从off处开始存储，最多读len个字符。如果已到达流的末尾，则返回 -1。否则返回本次读取的字符数。 |
public void close() throws IOException | 关闭此输入流并释放与该流关联的所有系统资源。 |
@测试
public void testFileReader(){
FileReader fr=null
尝试{
//1.实例化文件类的对象，指明要操作的文件
File File=new File( hello。txt’)；//相较于当前组件
//2.提供具体的流
fr=新文件阅读器(文件);
//3.数据的读入
//read():返回读入的一个字符。如果达到文件末尾，返回-1
//方式一：//int data=fr。read()；//while(数据！=-1){//系统。出去。打印((char)数据)；//data=fr。read()；//}
//方式二：语法上针对于方式一的修改
（同Internationalorganizations）国际组织数据；
while((data=fr.read())！=-1){
System.out.print((char)数据);
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.流的关闭操作//try {//if(fr！=null)//fr。close()；//} catch(io异常e){//e . printstacktrace()；//}
//或
如果(fr！=null){
尝试{
法郎close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
//对阅读()操作升级：使用阅读的重载方法
@测试
public void testFileReader1() {
FileReader fr=null
尝试{
//1.文件类的实例化
File File=new File( hello。txt’)；
//2.字符输入流流的实例化
fr=新文件阅读器(文件);
//3.读入的操作
//read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
char[]cbuf=new char[5]；
int len
while((len=fr.read(cbuf))！=-1){
//方式一：
//错误的写法//for(int I=0；i cbuf.lengthI){//system。出去。print(cbuf[I])；//}
//正确的写法//for(int I=0；我lenI){//系统。出去。print(cbuf[I])；//}
//方式二：
//错误的写法，对应着方式一的错误的写法//字符串str=新字符串(cbuf)；//系统。出去。打印(字符串)；
//正确的写法
字符串str=新字符串(cbuf，0，len)；
系统。出去。打印(字符串)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(fr！=null){
//4.资源的关闭
尝试{
法郎close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
4. OutputStream
概述
方法
| 方法 | 描述 |
|---|---|
void write(int b) | 将指定的字节写入此输出流。write 的常规协定是：向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。 即写入0~255范围的。 |
void write(byte[] b) | 将 b.length 个字节从指定的 byte 数组写入此输出流。write(b) 的常规协定是：应该与调用 write(b, 0, b.length) 的效果完全相同。 |
void write(byte[] b,int off,int len) | 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。 |
public void flush()throws IOException | 刷新此输出流并强制写出所有缓冲的输出字节，调用此方法指示应将这些字节立即写入它们预期的目标。 |
public void close() throws IOException | 关闭此输出流并释放与该流关联的所有系统资源。 |
/*
实现对图片的复制操作
*/
@测试
public void testFileInputOutputStream(){
FileInputStream fis=null
FileOutputStream fos=null
尝试{
//
文件srcFile=新文件(爱情与友情. jpg’)；
文件destFile=新文件(爱情与友情2 .jpg’)；
//
fis=新文件inputstream(src文件)；
fos=新文件输出流(dest文件)；
//复制的过程
字节[]缓冲区=新字节[5];
int len
while((len=fis.read(buffer))！=-1){
fos.write(buffer，0，len)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(fos！=null){
//
尝试{
福斯。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(fis！=null){
尝试{
fis。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
5. Writer
概述
方法
| 方法 | 描述 |
|---|---|
void write(int c) | 写入单个字符。要写入的字符包含在给定整数值的 16 个低位中，16 高位被忽略。 即写入0 到 65535 之间的Unicode码。 |
void write(char[] cbuf) | 写入字符数组。 |
void write(char[] cbuf,int off,int len) | 写入字符数组的某一部分。从off开始，写入len个字符 |
void write(String str) | 写入字符串。 |
void write(String str,int off,int len) | 写入字符串的某一部分。 |
void flush() | 刷新该流的缓冲，则立即将它们写入预期目标。 |
public void close() throws IOException | 关闭此输出流并释放与该流关联的所有系统资源。 |
概述代码演示//从内存中写出数据到硬盘的文件里。
@测试
public void testFileWriter() {
文件写入器fw=null
尝试{
//1.提供文件类的对象，指明写出到的文件
文件文件=新文件(‘你好1。txt’)；
//2.提供字符输出流的对象，用于数据的写出
fw=new FileWriter(file，false)；
//3.写出的操作
fw。写(我有一个梦想！\ n’)；
fw.write(你需要有一个梦想!);
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.流资源的关闭
如果(fw！=null){
尝试{
fw。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
6. 练习：复制操作
代码演示：
实现对文本的复制操作@测试
public void testFileReaderFileWriter(){
FileReader fr=null
文件写入器fw=null
尝试{
//1.创建文件类的对象，指明读入和写出的文件
File src File=new File( hello。txt’)；
文件destFile=新文件(‘你好2。txt’)；
//不能使用字符流来处理图片等字节数据//文件srcFile=新文件(爱情与友情. jpg’)；//文件destFile=新文件(爱情与友情1 .jpg’)；
//2.创建输入流和输出流的对象
fr=新文件阅读器(src文件)；
fw=新文件写入器(dest文件)；
//3.数据的读入和写出操作
char[]cbuf=new char[5]；
int len//记录每次读入到cbuf数组中的字符的个数
while((len=fr.read(cbuf))！=-1){
//每次写出低输入联网(低入门网络的缩写)个字符
fw.write(cbuf，0，len)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.关闭流资源
//方式一：//try {//if(fw！=null)//fw。close()；//} catch(io异常e){//e . printstacktrace()；//}最后{//试试{//if(fr！=null)//fr。close()；//} catch(io异常e){//e . printstacktrace()；//}//}
//方式二：
尝试{
如果(fw！=空)
fw。close()；
} catch (IOException e) {
e。printstacktrace()；
}
尝试{
如果(fr！=空)
法郎close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
} }实现对图片的复制操作@测试
public void testFileInputOutputStream(){
FileInputStream fis=null
FileOutputStream fos=null
尝试{
//
文件srcFile=新文件(爱情与友情. jpg’)；
文件destFile=新文件(爱情与友情2 .jpg’)；
//
fis=新文件inputstream(src文件)；
fos=新文件输出流(dest文件)；
//复制的过程
字节[]缓冲区=新字节[5];
int len
while((len=fis.read(buffer))！=-1){
fos.write(buffer，0，len)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(fos！=null){
//
尝试{
福斯。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(fis！=null){
尝试{
fis。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
//指定路径下文件的复制
公共void副本文件(字符串src路径，字符串destPath){
FileInputStream fis=null
FileOutputStream fos=null
尝试{
//
文件srcFile=新文件(src路径)；
文件destFile=新文件(目的地路径)；
//
fis=新文件inputstream(src文件)；
fos=新文件输出流(dest文件)；
//复制的过程
字节[]缓冲区=新字节[1024];
int len
while((len=fis.read(buffer))！=-1){
fos.write(buffer，0，len)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(fos！=null){
//
尝试{
福斯。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(fis！=null){
尝试{
fis。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
@测试
public void testCopyFile(){
长启动=系统。当前时间毫秒()；
string src path= C:\ \ Users \ \ Administrator \ \ Desktop \ \ 01-视频. avi ；
string dest path= C:\ \ Users \ \ Administrator \ \ Desktop \ \ 02-视频. avi ；//String src path= hello。txt ；//String dest path= hello 3。txt ；
copyFile(srcPath，dest path)；
长端=系统。当前时间毫秒()；
System.out.println(复制操作花费的时间为：(end-start))；//618
} }
三、节点流(或文件流)
1. 概述
2. 读取文件
概述代码演示FileReader fr=null；尝试{ fr=new FileReader(新文件( c:\ \ test。txt’))；char[]buf=new char[1024]；int lenwhile ((len=fr.read(buf))！=-1){系统。出去。print(新字符串(buf，0，len))；} } catch(io异常e){ system。出去。println( read-Exception: e . getmessage())；}最后{if (fr！=null){ try { fr。close()；} catch(io异常e){ system。出去。println( close-Exception: e . getmessage())；} } }:尝试{ fw=new File writer(new File( test。txt’))；fw。写(‘在鬼谷——宋宏康);} catch(io异常e){ e . printstacktrace()；}最后{如果(fw！=空)请尝试{ fw。close()；} catch(io异常e){ e . printstacktrace()；} }
3. 写入文件
四、缓冲流
1. 概述
@测试
public void BufferedStreamTest()抛出文件未找到异常{
BufferedInputStream bis=null
BufferedOutputStream bos=null
尝试{
//1.造文件
文件srcFile=新文件(爱情与友情. jpg’)；
文件destFile=新文件(爱情与友情3 .jpg’)；
//2.造流
//2.1 造节点流
文件输入流fis=新文件输入流((src文件))；
文件输出流fos=新文件输出流(dest file)；
//2.2 造缓冲流
bis=新缓冲区输入流(fis)；
bos=新BufferedOutputStream(fos)；
//3.复制的细节：读取、写入
字节[]缓冲区=新字节[10];
int len
while((len=bis.read(buffer))！=-1){
bos.write(buffer，0，len)；//Bos。flush()；//刷新缓冲区
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
如果(bos！=null){
尝试{
博斯。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(bis！=null){
尝试{
之二。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略. fos//fos。close()；//fis。close()；
}
}
2. 实现非文本文件的复制
@测试
public void testCopyFileWithBuffered(){
长启动=系统。当前时间毫秒()；
string src path= C:\ \ Users \ \ Administrator \ \ Desktop \ \ 01-视频. avi ；
string dest path= C:\ \ Users \ \ Administrator \ \ Desktop \ \ 03-视频. avi ；
copyFileWithBuffered(srcPath，dest path)；
长端=系统。当前时间毫秒()；
System.out.println(复制操作花费的时间为：(end-start))；//618 - 176
}
//实现文件复制的方法
public void copyFileWithBuffered(String src path，String destPath){
BufferedInputStream bis=null
BufferedOutputStream bos=null
尝试{
//1.造文件
文件srcFile=新文件(src路径)；
文件destFile=新文件(目的地路径)；
//2.造流
//2.1 造节点流
文件输入流fis=新文件输入流((src文件))；
文件输出流fos=新文件输出流(dest file)；
//2.2 造缓冲流
bis=新缓冲区输入流(fis)；
bos=新BufferedOutputStream(fos)；
//3.复制的细节：读取、写入
字节[]缓冲区=新字节[1024];
int len
while((len=bis.read(buffer))！=-1){
bos.write(buffer，0，len)；
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
//4.资源关闭
//要求：先关闭外层的流，再关闭内层的流
如果(bos！=null){
尝试{
博斯。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(bis！=null){
尝试{
之二。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
//说明：关闭外层流的同时，内层流也会自动的进行关闭。关于内层流的关闭，我们可以省略. fos//fos。close()；//fis。close()；
}
}
/*
使用类和缓冲区输出实现文本文件的复制
*/
@测试
public void testBufferedReaderBufferedWriter(){
BufferedReader br=null
BufferedWriter bw=null
尝试{
//创建文件和相应的流
br=新缓冲读取器(新文件读取器(新文件( dbcp。txt ))))；
bw=新缓冲编写器(新文件编写器(新文件( dbcp 1。txt ))))；
//读写操作
//方式一：使用char[]数组//char[]cbuf=new char[1024]；//int len；//while((len=br.read(cbuf))！=-1){//bw.write(cbuf，0，len)；////bw。flush()；//}
//方式二：使用线
字符串数据；
while((data=br.readLine())！=null){
//方法一：//bw。write(data \ n )；//数据中不包含换行符
//方法二：
bw.write(数据);//数据中不包含换行符
bw。newline()；//提供换行的操作
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
//关闭资源
如果(bw！=null){
尝试{
bw。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
如果(br！=null){
尝试{
br。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}}
3. 实现文件复制
五、 转换流
1. 概述
概述
代码演示
|
|---|
public InputStreamReader(InputStream in) |
public InputSreamReader(InputStream in,String charsetName) |
2. InputStreamReader
概述
构造器
|
|---|
public OutputStreamWriter(OutputStream out) |
public OutputSreamWriter(OutputStream out,String charsetName) |
3. OutputStreamWriter
概述
@测试
公共void test1()引发IOException {
文件输入流fis=新文件输入流( dbcp。txt’)；//InputStreamReader ISR=new InputStreamReader(fis)；//使用系统默认的字符集
//参数2指明了字符集，具体使用哪个字符集，取决于文件dbcp.txt保存时使用的字符集
InputStreamReader isr=新的InputStreamReader(fis，“UTF-8”)；//使用系统默认的字符集
char[]cbuf=new char[20]；
int len
while((len=isr.read(cbuf))！=-1){
字符串str=新字符串(cbuf，0，len)；
系统。出去。打印(字符串)；
}
ISR。close()；
}（2）构造器
@测试
公共void test2()引发异常{
//1.造文件、造流
文件file1=新文件(dbcp。txt’)；
文件file2=新文件( dbcp _ gbk。txt’)；
文件输入流fis=新文件输入流(文件1)；
文件输出流fos=新文件输出流(文件2)；
InputStreamReader ISR=new InputStreamReader(fis， utf-8 )；
output streamwriter OSW=new output streamwriter(fos， gbk )；
//2.读写过程
char[]cbuf=new char[20]；
int len
while((len=isr.read(cbuf))！=-1){
osw.write(cbuf，0，len)；
}
//3.关闭资源
ISR。close()；
OSW。close()；
}}
4. 代码演示
六、标准输入、输出流
1. 概述
/*
从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
直至当输入" e "或者"退出"时，退出程序。
方法一：使用扫描仪实现，调用下一个()返回一个字符串
方法二：使用系统输入实现系统。在-转换流- BufferedReader的读取线()
*/
公共静态void main(String[] args) {
BufferedReader br=null
尝试{
InputStreamReader ISR=新的InputStreamReader(system。在)；
br=新缓冲阅读器(ISR)；
while (true) {
System.out.println(请输入字符串：);
字符串数据=br。readline()；
如果( e .equalsIgnoreCase(data) exit .equalsIgnoreCase(数据)){
System.out.println(程序结束);
打破；
}
线大写=数据。toupper case()；
System.out.println(大写);
}
} catch (IOException e) {
e。printstacktrace()；
}最后{
如果(br！=null) {
尝试{
br。close()；
} catch (IOException e) {
e。printstacktrace()；
}
}
}
}
2. 代码演示
七. 打印流
1. 概述
/*
2.PrintStream: printstream和PrintWriter
2.1提供了一系列重载的print()和println()
2.2实践：
*/
@测试
public void test2() {
PrintStream ps=null
尝试{
File output stream fos=new File output stream(新文件( D:\ \ IO \ \ text . txt )；
//创建打印输出流并将其设置为自动刷新模式(当写入新的行字符或字节 \n 时，将刷新输出缓冲区)
ps=new PrintStream(fos，true)；
如果(ps！=null) {//将标准输出流(控制台输出)更改为文件
system . setout(PS)；
}
for(int I=0；i=255I) {//输出ASCII字符
system . out . print((char)I)；
If (i% 50==0) {//每50个数据一行
system . out . println()；//换行
}
}
} catch(file not found exception e){
e . printstacktrace()；
}最后{
如果(ps！=null) {
PS . close()；
}
}
}
2. 代码演示
|
|---|
boolean readBoolean() |
byte readByte() char |
readChar() |
float readFloat() |
double readDouble() |
long readLong() |
int readInt() |
short readShort() |
String readUTF() |
void readFully(byte[] b) |
推荐：《java视频教程》以上是Java总结的IO流原理和流分类的详细内容。请多关注我们的其他相关文章！
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。