javaIO流分类基础入门.docx
《javaIO流分类基础入门.docx》由会员分享，可在线阅读，更多相关《javaIO流分类基础入门.docx（28页珍藏版）》请在冰点文库上搜索。
javaIO流分类基础入门
1IO流分类
FileOutputStreamDemo.java
packagecn.itcast_01;
importjava.io.File;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*IO流的分类：
*流向：
*输入流读取数据
*输出流写出数据
*数据类型：
*字节流
*字节输入流读取数据InputStream
*字节输出流写出数据OutputStream
*字符流
*字符输入流读取数据Reader
*字符输出流写出数据Writer
*
*注意：
一般我们在探讨IO流的时候，如果没有明确说明按哪种分类来说，默认情况下是按照数据类型来分的。
*
*需求：
我要往一个文本文件中输入一句话：
"hello,io"
*
*分析：
*A:
这个操作最好是采用字符流来做，但是呢，字符流是在字节流之后才出现的，所以，今天我先讲解字节流如何操作。
*B:
由于我是要往文件中写一句话，所以我们要采用字节输出流。
*
*通过上面的分析后我们知道要使用：
OutputStream
*但是通过查看API，我们发现该流对象是一个抽象类，不能实例化。
*所以，我们要找一个具体的子类。
*而我们要找的子类是什么名字的呢?
这个时候，很简单，我们回想一下，我们是不是要往文件中写东西。
*文件是哪个单词：
File
*然后用的是字节输出流，联起来就是：
FileOutputStream
*注意：
每种基类的子类都是以父类名作为后缀名。
*XxxOutputStream
*XxxInputStream
*XxxReader
*XxxWriter
*查看FileOutputStream的构造方法：
*FileOutputStream（Filefile）
*FileOutputStream（Stringname）
*
*字节输出流操作步骤：
*A:
创建字节输出流对象
*B:
写数据
*C:
释放资源
*/
publicclassFileOutputStreamDemo{
publicstaticvoidmain（String[]args）throwsIOException{
//创建字节输出流对象
//FileOutputStream（Filefile）
//Filefile=newFile（"fos.txt"）;
//FileOutputStreamfos=newFileOutputStream（file）;
//FileOutputStream（Stringname）
FileOutputStreamfos=newFileOutputStream（"fos.txt"）;
/*
*创建字节输出流对象了做了几件事情：
*A:
调用系统功能去创建文件
*B:
创建fos对象
*C:
把fos对象指向这个文件
*/
//写数据
fos.write（"hello,IO".getBytes（））;
fos.write（"java".getBytes（））;
//释放资源
//关闭此文件输出流并释放与此流有关的所有系统资源。
fos.close（）;
/*
*为什么一定要close（）呢?
*A:
让流对象变成垃圾，这样就可以被垃圾回收器回收了
*B:
通知系统去释放跟该文件相关的资源
*/
//java.io.IOException:
StreamClosed
//fos.write（"java".getBytes（））;
}
}
FileOutputStreamDemo1.java
packagecn.itcast_01;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*字节输出流操作步骤：
*A:
创建字节输出流对象
*B:
调用write（）方法
*C:
释放资源
*
*publicvoidwrite（intb）:
写一个字节
*publicvoidwrite（byte[]b）:
写一个字节数组
*publicvoidwrite（byte[]b,intoff,intlen）:
写一个字节数组的一部分
*/
publicclassFileOutputStreamDemo2{
publicstaticvoidmain（String[]args）throwsIOException{
//创建字节输出流对象
//OutputStreamos=newFileOutputStream（"fos2.txt"）;//多态
FileOutputStreamfos=newFileOutputStream（"fos2.txt"）;
//调用write（）方法
//fos.write（97）;//97--底层二进制数据--通过记事本打开--找97对应的字符值--a
//fos.write（57）;
//fos.write（55）;
//publicvoidwrite（byte[]b）:
写一个字节数组
byte[]bys={97,98,99,100,101};
fos.write（bys）;
//publicvoidwrite（byte[]b,intoff,intlen）:
写一个字节数组的一部分
fos.write（bys,1,3）;
//释放资源
fos.close（）;
}
}
FileOutputStreamDemo.java
packagecn.itcast_01;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*如何实现数据的换行?
*为什么现在没有换行呢?
因为你值写了字节数据，并没有写入换行符号。
*如何实现呢?
写入换行符号即可呗。
*刚才我们看到了有写文本文件打开是可以的，通过windows自带的那个不行，为什么呢?
*因为不同的系统针对不同的换行符号识别是不一样的?
*windows:
\r\n
*linux:
\n
*Mac:
\r
*而一些常见的个高级记事本，是可以识别任意换行符号的。
*
*如何实现数据的追加写入?
*用构造方法带第二个参数是true的情况即可
*/
publicclassFileOutputStreamDemo3{
publicstaticvoidmain（String[]args）throwsIOException{
//创建字节输出流对象
//FileOutputStreamfos=newFileOutputStream（"fos3.txt"）;
//创建一个向具有指定name的文件中写入数据的输出文件流。
如果第二个参数为true，则将字节写入文件末尾处，而不是写入文件开始处。
FileOutputStreamfos=newFileOutputStream（"fos3.txt",true）;
//写数据
for（intx=0;x<10;x++）{
fos.write（（"hello"+x）.getBytes（））;
fos.write（"\r\n".getBytes（））;
}
//释放资源
fos.close（）;
}
}
FileOutputStreamDemo.java
packagecn.itcast_01;
importjava.io.FileNotFoundException;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*加入异常处理的字节输出流操作
*/
publicclassFileOutputStreamDemo4{
publicstaticvoidmain（String[]args）{
//分开做异常处理
//FileOutputStreamfos=null;
//try{
//fos=newFileOutputStream（"fos4.txt"）;
//}catch（FileNotFoundExceptione）{
//e.printStackTrace（）;
//}
//
//try{
//fos.write（"java".getBytes（））;
//}catch（IOExceptione）{
//e.printStackTrace（）;
//}
//
//try{
//fos.close（）;
//}catch（IOExceptione）{
//e.printStackTrace（）;
//}
//一起做异常处理
//try{
//FileOutputStreamfos=newFileOutputStream（"fos4.txt"）;
//fos.write（"java".getBytes（））;
//fos.close（）;
//}catch（FileNotFoundExceptione）{
//e.printStackTrace（）;
//}catch（IOExceptione）{
//e.printStackTrace（）;
//}
//改进版
//为了在finally里面能够看到该对象就必须定义到外面，为了访问不出问题，还必须给初始化值
FileOutputStreamfos=null;
try{
//fos=newFileOutputStream（"z:
\\fos4.txt"）;
fos=newFileOutputStream（"fos4.txt"）;
fos.write（"java".getBytes（））;
}catch（FileNotFoundExceptione）{
e.printStackTrace（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}finally{
//如果fos不是null，才需要close（）
if（fos!
=null）{
//为了保证close（）一定会执行，就放到这里了
try{
fos.close（）;
}catch（IOExceptione）{
e.printStackTrace（）;
}
}
}
}
}
2字节输入流操作步骤
FileInputStreamDemo.java
packagecn.itcast_02;
importjava.io.FileInputStream;
importjava.io.IOException;
/*
*字节输入流操作步骤：
*A:
创建字节输入流对象
*B:
调用read（）方法读取数据，并把数据显示在控制台
*C:
释放资源
*
*读取数据的方式：
*A:
intread（）:
一次读取一个字节
*B:
intread（byte[]b）:
一次读取一个字节数组
*/
publicclassFileInputStreamDemo{
publicstaticvoidmain（String[]args）throwsIOException{
//FileInputStream（Stringname）
//FileInputStreamfis=newFileInputStream（"fis.txt"）;
FileInputStreamfis=newFileInputStream（"FileOutputStreamDemo.java"）;
////调用read（）方法读取数据，并把数据显示在控制台
////第一次读取
//intby=fis.read（）;
//System.out.println（by）;
//System.out.println（（char）by）;
//
////第二次读取
//by=fis.read（）;
//System.out.println（by）;
//System.out.println（（char）by）;
//
////第三次读取
//by=fis.read（）;
//System.out.println（by）;
//System.out.println（（char）by）;
////我们发现代码的重复度很高，所以我们要用循环改进
////而用循环，最麻烦的事情是如何控制循环判断条件呢?
////第四次读取
//by=fis.read（）;
//System.out.println（by）;
////第五次读取
//by=fis.read（）;
//System.out.println（by）;
////通过测试，我们知道如果你读取的数据是-1，就说明已经读取到文件的末尾了
//用循环改进
//intby=fis.read（）;
//while（by!
=-1）{
//System.out.print（（char）by）;
//by=fis.read（）;
//}
//最终版代码
intby=0;
//读取，赋值，判断
while（（by=fis.read（））!
=-1）{
System.out.print（（char）by）;
}
//释放资源
fis.close（）;
}
}
FileInputStream.java
packagecn.itcast_02;
importjava.io.FileInputStream;
importjava.io.IOException;
/*
*一次读取一个字节数组：
intread（byte[]b）
*返回值其实是实际读取的字节个数。
*/
publicclassFileInputStreamDemo2{
publicstaticvoidmain（String[]args）throwsIOException{
//创建字节输入流对象
//FileInputStreamfis=newFileInputStream（"fis2.txt"）;
FileInputStreamfis=newFileInputStream（"FileOutputStreamDemo.java"）;
//读取数据
//定义一个字节数组
//第一次读取
//byte[]bys=newbyte[5];
//intlen=fis.read（bys）;
////System.out.println（len）;
////System.out.println（newString（bys））;
////System.out.println（newString（bys,0,len））;
//System.out.print（newString（bys,0,len））;
//
////第二次读取
//len=fis.read（bys）;
////System.out.println（len）;
////System.out.println（newString（bys））;
////System.out.println（newString（bys,0,len））;
//System.out.print（newString（bys,0,len））;
//
////第三次读取
//len=fis.read（bys）;
////System.out.println（len）;
////System.out.println（newString（bys））;
////System.out.println（newString（bys,0,len））;
//System.out.print（newString（bys,0,len））;
//
////第四次读取
//len=fis.read（bys）;
////System.out.println（len）;
////System.out.println（newString（bys,0,len））;
//System.out.print（newString（bys,0,len））;
////代码重复了，用循环改进
////但是，我不知道结束条件
////len=fis.read（bys）;
////System.out.println（len）;
////len=fis.read（bys）;
////System.out.println（len）;
////如果读取到的实际长度是-1，就说明没有数据了
//byte[]bys=newbyte[115];//0
//intlen=0;
//while（（len=fis.read（bys））!
=-1）{
//System.out.print（newString（bys,0,len））;
////System.out.print（newString（bys））;//千万要带上len的使用
//}
//最终版代码
//数组的长度一般是1024或者1024的整数倍
byte[]bys=newbyte[1024];
intlen=0;
while（（len=fis.read（bys））!
=-1）{
System.out.print（newString（bys,0,len））;
}
//释放资源
fis.close（）;
}
}
3复制文件
CopyFileDemo.java
packagecn.itcast_03;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*复制文本文件。
*
*数据源：
从哪里来
*a.txt--读取数据--FileInputStream
*
*目的地：
到哪里去
*b.txt--写数据--FileOutputStream
*
*java.io.FileNotFoundException:
a.txt（系统找不到指定的文件。
）
*
*这一次复制中文没有出现任何问题，为什么呢?
*上一次我们出现问题的原因在于我们每次获取到一个字节数据，就把该字节数据转换为了字符数据，然后输出到控制台。
*而这一次呢?
确实通过IO流读取数据，写到文本文件，你读取一个字节，我就写入一个字节，你没有做任何的转换。
*它会自己做转换。
*/
publicclassCopyFileDemo{
publicstaticvoidmain（String[]args）throwsIOException{
//封装数据源
FileInputStreamfis=newFileInputStream（"a.txt"）;
//封装目的地
FileOutputStreamfos=newFileOutputStream（"b.txt"）;
intby=0;
while（（by=fis.read（））!
=-1）{
fos.write（by）;
}
//释放资源（先关谁都行）
fos.close（）;
fis.close（）;
}
}
FileDemo2.java
packagecn.itcast_03;
importjava.io.FileInputStream;
importjava.io.FileOutputStream;
importjava.io.IOException;
/*
*需求：
把c盘下的a.txt的内容复制到d盘下的b.txt中
*
*数据源：
*c:
\\a.txt--读取数据--FileInputStream
*目的地：
*d:
\\b.txt--写出数据--FileOutputStream
*/
publicclassCopyFileDemo2{
publicstaticvoidmain（String[]args）throwsIOException{
//封装数据源
FileInputStreamfis=newFileInputStream（"c:
\\a.txt"）;
//封装目的地
FileOutputStreamfos=newFileOutputStream（"d:
\\b.txt"）;
//复制数据
intby=0;
while（（by=fis.re
升级会员 