一、Java io流 的概念
流存在的意义：
1. 数据的传输量很大
2. 内存有限
3. 带宽有限
而Stream可以1点1点地逐步传输所有数据, 这就是Stream存在的根本意义。想想我们是怎样下载1个大文件的, 下载软件(例如x雷)并不会占用你内存很大的空间, 而只是在内存划分1个缓冲区, 一点一点地下载到自己的内存(缓冲区满了再写到硬盘), 这也是流的1个例子。
1、java的io是实现输入和输出的基础，可以方便的实现数据的输入和输出操作。在java中把不同的输入/输出源（键盘，文件，网络连接等）抽象表述为“流”(stream)。通过流的形式允许java程序使用相同的方式来访问不同的输入/输出源。stram是从起源（source）到接收的（sink）的有序数据。
2、Stream是java的1个类, 这个类专门用于程序和外部设备的输入输出(IO). 基本上所有流都在 java.io这个包中.
实际上Stream就是数据在程序和外部设备的单向管道, 流的各种方法相当于管道上的各种按钮.
所谓的外部设备可以包括硬盘文件, 网络设备, 另个程序等. 也就是当前程序之外的数据设备
Java将所有传统的流类型都放在Java.io包下，用于实现输入和输出功能。
二、io 流的分类
按照流的不同的分类方式，可以把流分为不同的类型，流常见的分类有3种：
1、按照流的流向分：输入流和输出流
- 输入流： 只能从中读取数据，而不能向其写入数据。
- 输出流：只能向其写入数据，而不能向其读取数据。
此处的输入,输出涉及一个方向的问题，对于如图15.1所示的数据流向，数据从内存到硬盘，通常称为输出流——也就是说，这里的输入，输出都是从程序运行所在的内存的角度来划分的。
注：java的输入流主要是InputStream和Reader作为基类，而输出流则是主要由outputStream和Writer作为基类。它们都是一些抽象基类，无法直接创建实例。
2、按照操作单元划分，可以划分为字节流和字符流。
字节流和字符流的用法几乎完成全一样，区别在于字节流和字符流所操作的数据单元不同，字节流操作的单元是数据单元是8位的字节，字符流操作的是数据单元为16位的字符。
字节流主要是由InputStream和outPutStream作为基类，而字符流则主要有Reader和Writer作为基类。
3、按照流的角色划分为节点流和处理流。
可以从/向一个特定的IO设备（如磁盘，网络）读/写数据的流，称为节点流。节点流也被称为低级流。图15.3显示了节点流的示意图。
从图15.3中可以看出，当使用节点流进行输入和输出时，程序直接连接到实际的数据源，和实际的输入/输出节点连接。
处理流则用于对一个已存在的流进行连接和封装，通过封装后的流来实现数据的读/写功能。处理流也被称为高级流。
节点流：
节点流的类型：
1）File 文件流。对文件进行读、写操作 ：FileReader、FileWriter、FileInputStream、FileOutputStream。、
（2）Memory
1）从/向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
2）从/向内存字符串读写数据 StringReader、StringWriter、StringBufferInputStream。
（3）Pipe管道流。 实现管道的输入和输出（进程间通信）: PipedReader与PipedWriter、PipedInputStream与PipedOutputStream
节点流执行图示：
处理流：
处理流的类型：
（1）Buffering缓冲流：在读入或写出时，对数据进行缓存，以减少I/O的次数：BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
- （2）Filtering 滤流：在数据进行读或写时进行过滤：FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
- （3）Converting between Bytes and Characters 转换流：按照一定的编码/解码标准将字节流转换为字符流，或进行反向转换（Stream到Reader）：InputStreamReader、OutputStreamWriter。
- （4）Object Serialization 对象流 ：ObjectInputStream、ObjectOutputStream。
- （5）DataConversion数据流： 按基本数据类型读、写（处理的数据是Java的基本类型（如布尔型，字节，整数和浮点数））：DataInputStream、DataOutputStream 。
- （6）Counting计数流： 在读入数据时对行记数 ：LineNumberReader、LineNumberInputStream。
- （7）Peeking Ahead预读流： 通过缓存机制，进行预读 ：PushbackReader、PushbackInputStream。
- （8）Printing打印流： 包含方便的打印方法 ：PrintWriter、PrintStream。
处理流的执行图示：
缓冲流（buffering）是处理流的一种，对I/O进行缓冲是一种常见的性能优化，缓冲流为I/O流增加了内存缓冲区，增加缓冲区的两个目的：
（1）允许Java的I/O一次不只操作一个字符，这样提高䇖整个系统的性能；
（2）由于有缓冲区，使得在流上执行skip、mark和reset方法都成为可能。
【2】缓冲流：它是要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，
提高了读写的效率，同时增加了一些新的方法。例如：BufferedReader中的readLine方法，
BufferedWriter中的newLine方法。
j2sdk提供了4种缓冲流，重用的构造方法如下：
//字符输入流
BufferedReader(Reader in)//创建一个32字节的缓冲区
BufferedReader(Reader in, int size)//size为自定义缓存区的大小
//字符输出流
BufferedWriter(Writer out)
BufferedWriter(Writer out, int size)
//字节输入流
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
//字节输出流
BufferedOutputStream(OutputStream in)
BufferedOutputStream(OutputStream in, int size)备注：
（1）缓冲输入流BufferedInputSTream除了支持read和skip方法意外，还支持其父类的mark和reset方法;
（2）BufferedReader提供了一种新的ReadLine方法用于读取一行字符串（以\r或\n分隔）;
（3）BufferedWriter提供了一种新的newLine方法用于写入一个行分隔符;
（4）对于输出的缓冲流，BufferedWriter和BufferedOutputStream，写出的数据会先在内存中缓存，
使用flush方法将会使内存的数据立刻写出。
分类2：
1、java Io流共涉及40多个类，这些类看上去很杂乱，但实际上很有规则，而且彼此之间存在非常紧密的联系， Java Io流的40多个类都是从如下4个抽象类基类中派生出来的。
- InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
- OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
2、java输入/输出流体系中常用的流的分类表
分类 | 字节输入流 | 字节输出流 | 字符输入流 | 字符输出流 |
抽象基类 | InputStream | OutputStream | Reader | Writer |
访问文件 | FileInputStream | FileOutputStream | FileReader | FileWriter |
访问数组 | ByteArrayInputStream | ByteArrayOutputStream | CharArrayReader | CharArrayWriter |
访问管道 | PipedInputStream | PipedOutputStream | PipedReader | PipedWriter |
访问字符串 | | | StringReader | StringWriter |
缓冲流 | BufferedInputStream | BufferedOutputStream | BufferedReader | BufferedWriter |
转换流 | | | InputStreamReader | OutputStreamWriter |
对象流 | ObjectInputStream | ObjectOutputStream | | |
抽象基类 | FilterInputStream | FilterOutputStream | FilterReader | FilterWriter |
打印流 | | PrintStream | | PrintWriter |
推回输入流 | PushbackInputStream | | PushbackReader | |
特殊流 | DataInputStream | DataOutputStream | | |
注：表中粗体字所标出的类代表节点流，必须直接与指定的物理节点关联：斜体字标出的类代表抽象基类，无法直接创建实例。
CODE:
/**2019.6.14
* cpu将数据传入设备叫输出流-写入数据write，设备将数据传到cpu输入流-读数据
*java.io 包
* 定规范就是为了让别人写出想要的方法
* InputStream int read()
* OutputStream void write(,int);
* File:对文件进行的操作：FileInputStream 是从文件里面读东西的 ，调用read
* FileOutStream :从文件里面输出信息 ，调用write（）方法
*/
package flow;
import org.junit.Test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.*;
import java.util.Date;
import test.Student;
public class TestIo {
/*测试文件输出流*/
@Test
public void test1() throws Exception {
//与众多的设备打交道的流叫基础流（低级流）文件流是低级流
FileOutputStream fout = new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\a.txt");
int a = 20;//00000000 00000000 00000000 00010100 一个字节代表8位
byte[] b = {0,0,0,20};
fout.write(b[0]);
fout.write(b[1]);
fout.write(b[2]);
fout.write(b[3]);
fout.close();
//0号字符，20号字符显示不出来
FileInputStream fin = new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\a.txt");
byte[] c = new byte[4];
c[0] = (byte) fin.read();
c[1] = (byte) fin.read();
c[2] = (byte) fin.read();
c[3] = (byte) fin.read();
System.out.println(b[3]);
fin.close();
}
@Test
public void test2() throws Exception {
FileOutputStream fout = new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\b.txt");
String mesg = "Hello！Laurence。";
// 00000000 1010111 Java采用Unicod码
byte[] ss = mesg.getBytes();
for (byte s : ss) {//for循环遍历的另一种形式
fout.write(s);//对象流
}
fout.close();
}
//读
@Test
public void test3() throws Exception {
FileInputStream fin = new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\b.txt");
byte[] b = new byte[fin.available()];//测量文件占用的字节长度
int t;
byte i = 0;
while ((t = fin.read()) != -1) {
b[i] = (byte) t;
i++;
}
String c = new String(b);
System.out.println(c);
fin.close();//释放流的资源
}
/*
高级流一般不读写文件
*/
@Test
public void test4() throws Exception {
OutputStream fout = new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\b.txt");
//OutputStream :写
ObjectOutputStream objout = new ObjectOutputStream(fout);//实际上是fout在写字节
// ObjectOutputStream :类型转换：将其他类型转换为字节类型
//write()是写字节的方法
objout.writeInt(222);//对象流完成其他类型到字节类型的转换
objout.writeDouble(22.0);
objout.writeBoolean(true );
objout.writeChar('l');
objout.writeChars("liujiaheng is a good man!");
objout.flush();//刷新
objout.close();
fout.close();//释放流的资源
}
//装饰模式：两个流类合作完成一个功能
@Test
public void test5() throws Exception {
InputStream fin = new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\b.txt");
ObjectInputStream objout = new ObjectInputStream(fin);//实际上是fout在写字节
int r=objout.readInt();//对象流完成其他类型到字节类型的转换
System.out.println(r);
double t1=objout.readDouble();
System.out.println(t1);
boolean t2=objout.readBoolean();
System.out.println(t2);
char e=objout.readChar();
System.out.println(e);
// String t3=objout.readUTF();//此方法读不出字符串
System.out.println(t3);
objout.close();
fin.close();//释放流的资源
}
@Test
public void test6() throws Exception {
OutputStream fout = new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
//OutputStream :写
ObjectOutputStream objout =new ObjectOutputStream(fout);
Date d=new Date();
objout.writeObject(d);
Student s=new Student(2000,"Laurence");
objout.writeObject(s);
objout.flush();
objout.close();
}
@Test
public void test7() throws Exception {
InputStream fin = new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
//OutputStream :实现写的操作
ObjectInputStream obin = new ObjectInputStream(fin);//实际上是fout在写字节
// ObjectOutputStream :类型转换
//write()是写字节的方法;
Date d=(Date)obin.readObject();
Student s=(Student)obin.readObject();
System.out.println(d);
System.out.println(s.getName());
System.out.println(s.getId());
obin.close();
}
//高级流实现读写操作
public void test8() throws Exception {
OutputStream fout = new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
//OutputStream :实现写的操作
//下面也是高级流
BufferedOutputStream bout = new BufferedOutputStream(fout);
ObjectOutputStream obin = new ObjectOutputStream(bout);//实际上是fout在写字节
fout.write(22);
bout.write(222);
bout.flush();//此时将数据写入文件里了
ObjectOutputStream objout = new ObjectOutputStream(
new BufferedOutputStream(
new FileOutputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\d.txt")
)
);
Date d=new Date();
objout.writeObject(d);
Student s=new Student(2000,"Laurence");
objout.writeObject(s);
objout.flush();
objout.close();
}
public void test9() throws Exception {
InputStream fin = new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
//OutputStream :实现写的操作
ObjectInputStream obin = new ObjectInputStream(
new BufferedInputStream(
new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt")
)
);//实际上是fout在写字节
// ObjectOutputStream :类型转换
//write()是写字节的方法;
Date d=(Date)obin.readObject();
Student s=(Student)obin.readObject();
System.out.println(d);
System.out.println(s.getName());
System.out.println(s.getId());
obin.close();
}
}
package flow;
import org.junit.Test;
import java.io.*;
import java.util.*;
public class testIo2 {
@Test
public void test1() throws Exception{
FileInputStream fin=new FileInputStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
int a;
while ((a=fin.read())!=-1){
System.out.println((char)a);
}
fin.close();//因为字节流是一个字节一个字节读的，但是一个字符是占用两个字节。所以读出来的数据是乱码的
//Reader、 Writer字符流
}
@Test
public void test2() throws Exception{
FileWriter w=new FileWriter("D:\\新建文件夹\\练习\\javacode\\src\\test\\c.txt");
w.write('A');
w.write("刘家亨真棒！");
w.close();
}
//字符流
@Test
public void test3() throws Exception{
BufferedWriter w=new BufferedWriter(
new FileWriter("D:\\新建文件夹\\练习\\javacode\\src\\test\\e.txt")
);
w.write("sucessful\n");
w.flush();//
w.close();
}
@Test
public void test4() throws Exception{
FileReader w=new FileReader("D:\\新建文件夹\\练习\\javacode\\src\\test\\e.txt");
int a;
while((a=w.read())!=-1){
System.out.print((char)a);
}
w.close();
}
@Test
public void test5() throws Exception{
BufferedReader w=new BufferedReader(new FileReader("D:\\新建文件夹\\练习\\javacode\\src\\test\\e.txt")
);
String mesg = w.readLine();
System.out.println(mesg);
w.close();
}
//输入流 //输入流不需要flush//输入流包装字符流
@Test
public void tes6() throws Exception {
InputStreamReader ir=new InputStreamReader(System.in) ;
BufferedReader br=new BufferedReader(ir);
String mesg=br.readLine();
System.out.println(mesg);
}
@Test
public void test7() throws Exception{
OutputStreamWriter w=new OutputStreamWriter(System.out);
BufferedWriter bw=new BufferedWriter(w);
bw.write("中国你好！");
bw.flush();
bw.close();
}
@Test//PrintStream主要用于包装其他字符流，还可以用来写字符串
public void test8() throws Exception{
PrintStream c=new PrintStream("D:\\新建文件夹\\练习\\javacode\\src\\test\\rr.txt");
c.print("hello"+"my name is Laurence");//
c.flush();//刷新后才能写进去
}
//既可以包装字符流，又可以包装字节流,还可以给文件直接写字符，它可以和其他的流搭配着用
@Test
public void test9()throws Exception {
PrintWriter pw = new PrintWriter("D:\\新建文件夹\\练习\\javacode\\src\\test\\rr.txt");
pw.println("hello"+"bjdhsvcjhdbvcjhdsc");//给文件中写入这样一段字符
pw.flush();
pw.close();
}
@Test//文件对象 用来标识文件的，判断文件或目录是否存在
public void test10() throws Exception{
File f=new File("D:\\liujiaheng\\pp");
if(f.exists()){//判断文件目录是否存在
System.out.println("存在");
}else{
System.out.println("不存在");
System.out.println( f.mkdirs());//如果不存在就创建一个目录树
}
}
@Test
public void tes11() throws Exception {
File f = new File( "D:\\新建文件夹\\练习\\aa.txt" );
if(f.exists()){//判断文件是否存在
System.out.println("存在");
}else{
System.out.println("不存在");
f.createNewFile();//必须在已将创建的目录下才可以创建一个空文件
}
}
@Test
public void tes12() throws Exception {
File f = new File("D:\\新建文件夹\\练习\\javacode\\src\\test");//这是一个目录
File e=new File("D:\\新建文件夹\\练习\\javacode\\src\\test\\rr.txt");
System.out.println(f.isDirectory());//判断目录是否存在
System.out.println(f.isFile());//判断是否为文件返回值为true或false
System.out.println(e.isDirectory());
System.out.println(e.isFile());
}
@Test
public void tes13() throws Exception {
File f = new File("D:\\新建文件夹");
//目录名两端加一个[]代表它是一个目录。
if(f.isDirectory()){
System.out.println("[" + f.getName() + "]");
}else{
System.out.println(f.getName());
}
File[] fs = f.listFiles();
if(fs != null && fs.length > 0){
listFile(fs,1);
}
}
private void writeBlank(int level){
for(int i = 0 ; i < level ; i++)
System.out.print(" ");//一级打两个空格
}
private void listFile(File[] fs,int level){//file数组，level表示是第几层
for(File f : fs){//循环
writeBlank(level);//打空格
if(f.isDirectory()){//判断这个文件是不是目录
System.out.println("[" + f.getName() + "]");
File[] ff = f.listFiles();
if(ff != null && ff.length > 0){//判断目录是否为空
listFile(ff,++level);//不为空就迭代
}
}else{
System.out.println(f.getName());//不是目录打印出名字
}
}
}
}流的重要特性：
1、流是Java 的1个类，但类不是流。
2、数据并不会在流里自动流动，因此需要我们调用流的方法，一次传输一定量的数据。
3、一个流对象只有一个传输方向，也就是说流是单向的, 数据要么从程序到设备(OutputStream), 要么从设备到程序(InputStream)。
