———–android培训、java培训、java学习型技术博客、期待与您交流!————
1
IO流(掌握)
(1)IO流的作用:上传文件和下载文件。
上传文件:
数据源:本地
目的地:服务器
下载文件:
数据源:服务器
目的地:本地
(2)IO流的分类:
A:流向
输入流 读取数据
输出流 写出数据
B:数据类型
字节流
字节输入流
字节输出流
字符流
字符输入流
字符输出流
一般来说,如果没有说明按照哪种类型分,指的是按照数据类型分。
(3)什么时候使用字符流,什么时候使用字节流。
如果一个要操作的文件,通过记事本打开并能够读懂其内容,就可以考虑使用字符流。否则,就使用字节流。什么都不知道,就用字节流。
(4)IO的基类及具体类
IO
|--字节流
字节输入流
InputStream(抽象类)
--FileInputStream
字节输出流
OutputStream(抽象类)
FileOutputStream
|--字符流
字符输入流
Reader(抽象类)
FileReader
字符输出流
Writer(抽象类)
FileWriter
2
(1)FileWriter写数据的步骤及代码体现:
FileWriter 的构造方法
--FileWriter(String fileName)//
注意,参数可以只是一个文件名,则是在本建文件(也就是在workspace中创建)也可是是一个绝对路径,那就就在这个绝对路径下创建该文件
--public FileWriter(File file)//把路径封装成一个file对象传进来
--public FileWriter(File file,String name)
public class Io2
{
/*从程序向文件中写数据,步骤
* A:创建字符输出流对象。
B:调用write方法。
C:释放资源。
*/
public static void main(String[] args) throws IOException
{
//A:创建字符输出流对象。
FileWriter fw=new FileWriter("a.txt");
//B:调用write方法。
fw.write("你好。该吃饭了");
fw.flush();//刷新缓冲区
fw.close();//释放资源
}
}
几个要注意的小问题:
A:创建字符输出流对象做了哪些事情?
--调用系统功能,创建一个名字为a.txt的文件
--创建一个输出流对象fw
--把这个流对象指向此文件
B:为什么要刷新缓冲区?
因为我们使用的是字符流对象,而数据的底层用的字节流实现的(1字符=2字节),
即,底层在读取数据的时候是每次只能读取一个字节,每个字符的输出都要用到缓冲区,
只有把缓冲区刷新,才能把字符拿到
C:为什么要释放流资源?
fw.close();
作用
--关闭流对象,流对象就是垃圾
--通知操作系统去释放和开始创建的那个文件相关的资源
释放资源,首先会自动调用一次fw.flush(),保证数据不丢失
而后,流对象就是垃圾,不能再使用,
D:刷新和释放有什么区别?
fw.flush();刷新后,还可以继续使用流对象进行相关的操作
fw.close();释放后,流对象就是垃圾,不能再使用了
E:如何实现数据的换行?
fw("\n");
F:如何实现数据的追加写入?
使用带参数的构造方法
public FileOutputStream(String name,boolean append)
FileWriter fw=new FileWriter("java.txt",true);
这样在用对象调用write()方法的时候,不是覆盖数据,而是从该文件的末尾开始 追加数据
(2)FileReader读数据的步骤及代码体现:
构造方法:
----public FileReader(File file)
----public FileReader(String fileName)
参数是一个已经存在的文件的名字
public class IO3
{
/*1 创建输入流对象
*2 调用Read()方法
*3 释放资源
*
*/
public static void main(String[] args) throws IOException
{
//1 创建输入流对象
//从该文件读取数据到程序中,所以前提必须是该文件存在
FileReader fr=new FileReader("java.txt");
//2 调用read()方法
//read()此方法返回的是java.txt文件中,对应字符的ASCII值,read()方法的返回值是一个int类型的数,当返回值为-1的时候说明以及读到该文件的结尾,
----------
//这是第一种读取数据方法:一次只读一个字节
int leng=0;
while((leng=fr.read())!=-1)
{
System.out.println((char)leng);
//把int类型强转为字符类型
}
----------
//这是第二种读取数据的方法:一次读一个字符数组
char[] ch=new char[1024];
int leng=0;
while((leng=fr.read(ch))!=-1)
{
System.out.println(String.valueOf(ch, 0, leng));
}
}
}
(3)复制文本数据:
public class IO
{//复制文件
public static void main(String[] args) throws IOException
{
//创建输入流对象(字节流)
InputStream ip=new FileInputStream("java.txt");
//创建输出流对象
OutputStream op=new FileOutputStream("b.txt");
----------
方法一:一次读一个字符:
// int leng=0;
// while((leng=ip.read())!=-1)
// {
// op.write(leng);
//
// }
----------
方法二:一次读一个字符字符数组:
byte[] bys=new byte[1024];
int leng=0;
while((leng=ip.read(bys))!=-1)
{
op.write(bys);
}
ip.close();
op.close();
}
}
3
高效流(掌握)//只是提供高效的操作,底层的读写,还是靠基本操作流
(1)字符高效流
BufferedReader–输入流
构造方法--BufferedReader(Reader in)
BufferedWriter—输出流
构造方法-- public BufferedWriter(Writer out)
高效流的读操作,也和上边一样,有两种方法
一次读一个字符和一次读一个字符数
但是,需要注意的是,
BufferedReader有一个特有的方法
String readLine()//一次读一行数据,,注意,该方法不读换行字符
BufferedWriter也有一个特有的方法
void newLine()//系统自自己分配换行
public class IO4
{
public static void main(String[] args) throws IOException
{
//创建高效输入流对象和高效输出流对象(字符流)
BufferedReader br=new BufferedReader(new FileReader("java.txt"));
BufferedWriter bw=new BufferedWriter(new FileWriter("c.txt"));
//先从java.txt中读取文件数据在向c.txt中写入数据
String leng=null;
while((leng=br.readLine())!=null)
{
bw.write(leng);
bw.newLine();////因为readLine()方法不能自动读取换行符,
bw.flush();
}
bw.close();
br.close();
}
}
(2)字节高效流
BufferedInputStream—输入流
构造方法----public BufferedInputStream(InputStream in)
BufferedOutputStream—输出流
构造方法----public BufferedOutputStream(OutputStream out)
用法和基础流的用方法一样
4
转换流
InputStreamReader—是字节流通向字符流的桥梁
构造方法---- public InputStreamReader(InputStream in)
注意一个问题:
System.in//返回的是一个InputStream的对象
所以
inputStream is=System.is;//这里是多态
//用System.in录入数据,写到文本文件。
public static void main(String[] args) throws IOException
{
//从键盘录入数据
// InputStream in=System .in;
// //把字节流转换成字符流
// InputStreamReader isr=new InputStreamReader(in);
// //把字符流转换成高效字符流
// BufferedReader br=new BufferedReader(isr);
//上边的三句话,可以缩减为一条语句
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
//创建输出流对象,
BufferedWriter bw=new BufferedWriter(new FileWriter("e.txt"));
String len=null;
while((len=br.readLine())!=null)
{
if(len.equals("over"))
{
break;
}
bw.write(len);
bw.newLine();
bw.flush();
}
}
}
OutputStreamWriter 是字符流通向字节流的桥梁
(理解,就是把字符流的文件数据输出到字节流的地方并显示 出来)
构造方法----public OutputStreamWriter(OutputStream out)
小问题:
System.out--返回的是PrintStream(类)对象,
PrintStream(类)继承 FilterOutputStream(类)
FilterOutputStream(类)继承OutputStream(抽象类)
所以,System.out--返回的是OutputStream(抽象类)的子类对象
OutputStream os=System.out;
public class Io6
{
public static void main(String[] args) throws IOException, Exception
{
//封装数据源
BufferedReader ps=new BufferedReader(new FileReader("e.txt"));
//封装目的地
// OutputStream os=System.out;
// OutputStreamWriter osa=new OutputStreamWriter(os);
// BufferedWriter bw=new BufferedWriter(osa);
//上边三句 可以压缩为下面的一句
BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
String lenString=null;
while((lenString=ps.readLine())!=null)
{
bw.write(lenString);
bw.newLine();
bw.flush();
}
bw.close();
ps.close();
}
}
5
字符流继承体系简图
字节流继承体系简图