IO流

java.io包

1.什么是流？

io流就是java中运输数据的一种载体

它能够把数据从一个地方运输到另一个地方
2.流的分类

a 根据流运输数据的方向<以内存为参考物>

输入流

输出流
 b 根据数据传输时转换的类型
           字节流    byte           
           字符流    char  
           
           字符流主要运用于纯文本的传输   

3.流的体系

以上两种流的分类可以互相组合成下面四种

字节输入流   字节输出流    字符输入流   字符输出流
    整个流的体系结构如下
     closeable<可关闭的>(close())          flushable<可刷新的>(flush())
 
inputStream   OutputStream   Reader    Writer
   所有的字节输入流都是 inputStream的子类
   所有的字节输出流都是 OutputStream的子类
   所有的字符输入流都是 Reader的子类
   所有的字符输出流都是 Writer的子类
   以上4个流都实现了closeable接口
   以上2个输出流都实现了flushable接口 

4.我们要学习的流<16>

4个文件流<掌握>

FileInputStream

FileOutputStream

FileReader

FileWriter
FileInputStream fis = new FileInputStream("D:/c.txt");
	byte [] bytes = new byte[1024];
	int temp;
	while((temp=fis.read(bytes))!=-1){
		System.out.print(new String(bytes,0,temp));
	}
	
	fis.close();


/*

* 文件输出流如果指向的文件不存在

* 则会自动创建一个

*/

FileOutputStream fos = new FileOutputStream(“D:/a.txt”);
	String info = "许俊皇是个皇军";
	
	//把数据转成byte数组《String-->数组》
	byte [] bytes = info.getBytes();
	
	//fos.write(bytes);
	fos.write(bytes,0,12);
	
	//刷新  强制写入
	fos.flush();
	
	fos.close();


public static void main(String[] args) {
	FileReader fr=null;
	FileWriter fw=null;
	
	try {
		
		fr=new FileReader("D:\\b.txt");
		fw=new FileWriter("D:\\c.txt");
		
		char [] bytes=new char[100];
		int i;
		while((i=fr.read(bytes))!=-1) {
			
			fw.write(bytes,0,i);
			
		}
		
		fw.flush();
		
	}catch(IOException e){
		
		e.printStackTrace();
		
	}finally {
		
		if(fr!=null) {
			
			try {
				fr.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
		
		if(fw!=null) {
			try {
				fw.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
			
		}
	}
}


public static void main(String[] args) {

FileInputStream file1 = null ;

FileOutputStream file2 = null;

try {
		byte[] bytes = new byte[1024];
		int a;
		while((a=file1.read(bytes))!=-1){
			file2.write(bytes,0,a);
		}
		
		file2.flush();
		
	}catch(IOException e){
		e.printStackTrace();
	}finally {
		if(file1 != null) {
			try {
				file1.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
		if(file2 != null) {
			try {
				file2.close();
			}catch(IOException e){
				e.printStackTrace();
			}
			
		}
	}
}

4个缓冲流<掌握>

BufferedInputStream

BufferedOutputStream

BufferedReader

BufferedWriter
public static void main(String[] args) throws IOException {
	
	FileInputStream fis = new FileInputStream("D:/b.txt");
	
	InputStreamReader  isr = new InputStreamReader(fis);
	
	BufferedReader br = new BufferedReader(isr);
	
	String temp;
	
	while((temp=br.readLine())!=null){
		System.out.println(temp);
	}
	
	br.close();

}


public static void main(String[] args) throws IOException {

	FileWriter fw = new FileWriter("D:/b.txt");
	
	BufferedWriter bw = new BufferedWriter(fw);
    		
	bw.write("哈哈哈  许俊黄");
	bw.newLine();
	bw.write("哈哈哈  张建兵");
	bw.write("哈哈哈  许俊慌");
	
	bw.flush();		
	bw.close();

}

2个转换流<掌握>

InputStreramReader

OutputSTreamWriter
2个打印流<掌握>

PrintWriter

PrintStream
2个数据流

DataInputStream

DataOutputStream
 序列化与反序列化流

ObjectInputStream

ObjectOutputStream
java.io.File: 表示文件和文件夹类

File不是流  不能直接操作文件

IO流
IO流:
1. 字节缓冲流
2. 字符缓冲流
3. 对象流

IO流:
Reader  reader = new FileReader(File file);

Writer writer = new Writer writer(File file);
InputStream is = new FileInputStream(File file);

OutputStream os = new FileOutputStream(File file);
缓冲流: 属于功能流,用于增强性能,提高功能,提高读写速度.

功能流的使用:功能流包裹节点流.  功能流(节点流)
1. 字节缓冲流
BufferedInputStream和BufferedOutputStream
InputStream is = new BufferedInputStream(new FileInputStream("X:/xxx/xx"))
OutputStream os = new BufferedOutputStream(new FileOutputStream("X:/xxx/xx"))

2. 字符缓冲流
新增方法:  String readLine()  读取 一个文本行

void newLine() 写入一个行分隔符

BufferedRead rd = new BufferedReader(new FileReader(“X:/xxx/xx”))

BufferedWriter rw = new BufferedWriter(new FileReader(“X:/xxx/xx”))
3. 对象流
对象流:保留数据+数据类型

使用方式: 对象流包节点流  对象流(节点流)

序列化:将对象的信息状态,变为可存储,可传输的过程

序列化输出流:ObjectOutputStream(OutputStream)

新增方法: void writeObject(Object obj)将指定的对象写入objectOutputStream.

反序列化输入流 ObjectInputStream(InputStream)
注意:

不是所有类型的对象都能序列化  实现 java.io.Serializable
先序列化后反序列化  写出读入的过程一致
不是对象的所有属性都需要序列化 transient
static不能被序列化
如果父类实现了Serializable接口,子类中所有内容都能序列化
如果父类没有实现,子类实现了Serializable接口,只能序列化子类中独有的内容

public class ObjectDemo04 {
	public static void main(String[] args) throws FileNotFoundException, IOException, ClassNotFoundException {
		write("D:/bbb.txt");
		read("D:/bbb.txt");
	}
	
	//读入对象信息
	public static void read(String pathName) throws FileNotFoundException, IOException, ClassNotFoundException{
		//流
		ObjectInputStream is=new ObjectInputStream(new BufferedInputStream(new FileInputStream(pathName)));
		//读
		Person obj1=(Person)(is.readObject());
		String[] obj2=(String[])(is.readObject());
		System.out.println(obj1+"-->"+Arrays.toString(obj2));
		//关闭
		is.close();
	}
	
	//写出对象信息
	public static void write(String pathName) throws FileNotFoundException, IOException{
		//构建流
		ObjectOutputStream wr=new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(pathName)));
		Person p=new Person("李毅",25,"hehe");
		String[] arr={"呵呵","哈哈"};
		//写出
		wr.writeObject(p);
		wr.writeObject(arr);
		
		p.setName("老裴");
		p.haha="lllllllllll";
		//刷出
		wr.flush();
		//关闭
		wr.close();
	}
}

class Person implements Serializable{
	private String name;
	private transient int age;
	static String haha="123345";
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age,String haha) {
		super();
		this.name = name;
		this.age = age;
		this.haha=haha;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
	@Override
	public String toString() {
		return "Person [name=" + name + ","+age+","+haha+"]";
	}
	
}

java基础知识点07_文件与IO流
File类的四个静态成员变量：
public static void main(String[] args) {
	//路径分隔符，windows系统为; linux系统为:
	String pathseparator = File.pathSeparator;
	char pathseparatorchar = File.pathSeparatorChar;
	//文件分隔符, windows系统为\ linux系统为/
	String separator = File.separator;
	char separatorchar = File.separatorChar;
	
	System.out.println(pathseparator);
	System.out.println(pathseparatorchar);
	System.out.println(separator);
	System.out.println(separatorchar);
	
}

运行结果：
;
;
\
\

pathSeparator		路径分隔符 ; 	String类型
pathSeparatorChar	路径分隔符 ; 	char类型
separator			文件分隔符 \		String类型
separatorChar		文件分隔符 \		char类型

获取功能的方法：
public String getAbsolutePath()		获取绝对路径
public String getPath()				获取构造路径（构造方法中传递的路径）
public String getName()				获取文件名称
public String length()				获取文件大小（单位：字节）

判断功能的方法：
public boolean exists()				判断文件或目录是否存在
public boolean isDirectory()		判断是否是目录（不要求一定要存在）
public boolean isFile()				判断是否是文件（不要求一定要存在）

创建和删除功能的方法：
public boolean createNewFile()		创建新文件（若文件已存在，则不会创建并返回false）
public boolean delete()				删除文件或目录
public boolean mkdir()				创建单级文件夹                                     
public boolean mkdirs()				创建多级文件夹

遍历目录（文件夹）的方法：
public String[] list()			返回String数组，存储该文件夹中所有的子文件和子目录的名称
public File[] listFiles()		返回File数组，存储该文件夹中所有的子文件和子目录的File对象


IO流




流
输入流
输出流




字节流
InputStream
OutputStream


字符流（1个字符=2个字节）
Reader
Writer


抽象类 字节输出流 OutputStream 的方法：
close()
flush()
write(byte[] b)
write(byte[] b,int off,int len)
write(int b)

最常用子类 FileOutputStream
构造方法1（直接传递文件路径字符串）：
FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt");

构造方法2（传递文件对象）：
File myfile = new File("D:\\temp\\a.txt");
FileOutputStream fos = new FileOutputStream(myfile);

写数据时，会将10进制的整数97转换成2进制1100001存入文件，用文本编辑器打开时，其会根据编码表将字节转换为字符a
fos.write(97);
释放资源，清空内存
fos.close();

数据追加写（在构造方法中添加一个true的boolean参数，就实现了数据追加写，参数为false则会覆盖源文件）
FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
fos.write("你好，BLU".getBytes());
fos.close();

数据换行写
FileOutputStream fos = new FileOutputStream("D:\\temp\\a.txt",true);
fos.write("\r\n".getBytes());
fos.write("你好，BLU".getBytes());
fos.close();

抽象类 字节输入流 InputStream 的方法：
int read()
int read(byte[] b)
void close()

最常用子类 FileInputStream
//文件内容：abc	读取结果：97 98 99 -1
FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
//read方法每一次读取都只会读取1个字节，下一次会读取下一个字节，末尾之后读取到的值都为-1
int len1 = fis.read();
System.out.println(len1);
int len2 = fis.read();
System.out.println(len2);
int len3 = fis.read();
System.out.println(len3);
int len4 = fis.read();
System.out.println(len4);
fis.close();

循环优化：
FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
int len = 0;
while((len = fis.read())!=-1) {
	System.out.println((char)len);
}

//文件复制（每次复制一个字节）
FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
int len = 0;
while((len = fis.read())!=-1) {
	fos.write(len);
}
fos.close();
fis.close();

//文件加密
package com.blu.file01;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class Test01 {
	
	public static void main(String[] args) throws IOException {
		FileInputStream fis = new FileInputStream("D:\\temp\\a.txt");
		FileOutputStream fos = new FileOutputStream("D:\\temp\\b.txt");
		jiami(fis,fos);
		fos.close();
		fis.close();
	}
	
	public static void jiami(FileInputStream fis,FileOutputStream fos) throws IOException {
		byte[] bytes = new byte[204800];
		int len = 0;
		while((len=fis.read(bytes))!=-1) {
			for(int i=0;i<204700;i++) {
				bytes[i]++;
			}
			fos.write(bytes, 0, len);
		}
		
	}
	
	public static void jiemi(FileInputStream fis,FileOutputStream fos) throws IOException {
		byte[] bytes = new byte[204800];
		int len = 0;
		while((len=fis.read(bytes))!=-1) {
			for(int i=0;i<204700;i++) {
				bytes[i]--;
			}
			fos.write(bytes, 0, len);
		}
	}

}

io流概述：
IO流用来处理设备之间的数据传输，上传文件和下载文件，Java对数据的操作是通过流的方式，Java用于操作流的对象都在IO包中。
IO流分类
按照数据流向
输入流	读入数据
输出流	写出数据
按照数据类型
字节流
字符流
什么情况下使用哪种流呢?
如果数据所在的文件通过windows自带的记事本打开并能读懂里面的内容，就用字符流，其他用字节流。
如果你什么都不知道，就用字节流。
IO流常用基类
字节流的抽象基类：
InputStream ，OutputStream。
字符流的抽象基类：
Reader ， Writer。
注：

由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

如：InputStream的子类FileInputStream。

如：Reader的子类FileReader。
OutputStream的子类FileOutputStream
构造方法：
FileOutputStream(File file)
FileOutputStream(String name)
推荐第二种构造方法：
FileOutputStream outputStream = new FileOutputStream("a.txt");

创建字节输出流对象了做了几件事情：
A:调用系统功能去创建文件
B:创建outputStream对象
C:把foutputStream对象指向这个文件

通过字节输出流写出数据到文本
public void write(int b)
public void write(byte[] b)
public void write(byte[] b,int off,int len)

从方法中可看出，只能通过字节写出
outputStream.write("hello".getBytes()); 文本中出现hello
outputStream.write(96)  //文本中出现 a

byte[] bys={97,98,99,100,101};
outputStream.write(bys,1,3); 文本中出现bcd

如此写出，文本中数据不会换行，不会追加，每次写出都是覆盖原来。
追加：
FileOutputStream outputStream = new FileOutputStream("a.txt",true);
//第二个参数true设置为可追加。

换行 \n\r ：
for (int i = 0; i <5 ; i++) {
    outputStream.write("hello".getBytes());
    outputStream.write("\n\r".getBytes());
    }

注：用完流一定要记得关闭。
outputStream.close();

完整示例：
package io2;

import java.io.FileOutputStream;
import java.io.IOException;
/**
 * new FileOutputStream("a.txt",true);  第二个参数true，设置为写入的数据拼接在尾部
 * \n\r 换行
 * write(bys,1,3);  写入字节数组
 */
public class out {
    public static void main(String args[]){
        FileOutputStream outputStream = null;
        try {
            //FileOutputStream fos = new FileOutputStream(file);
            outputStream = new FileOutputStream("a.txt",true);
            /*
             * 创建字节输出流对象了做了几件事情：
             * A:调用系统功能去创建文件
             * B:创建outputStream对象
             * C:把foutputStream对象指向这个文件
             */

//            for (int i = 0; i <5 ; i++) {
//                outputStream.write("hello".getBytes());
//                outputStream.write("\n\r".getBytes());
//            }
            byte[] bys={97,98,99,100,101};
            outputStream.write(bys,1,3);
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


    }
}


InputStream的子类FileInputStream
FileInputStream的构造方法
FileInputStream(File file)
FileInputStream(String name)

推荐第二种构造方法：
 FileInputStream inputStream = new FileInputStream("a.txt");

把刚才写的数据现在读取到控制台：
public int read()
public int read(byte[] b)

第一个read是读一个字节，第二个read是读一个字节数组。
//读一个字节
int by = 0;
while ((by=inputStream.read())!=-1){
      System.out.println((char)by);
}

读到没数据了就返回-1，这个用来判断是否读完。
//读一个字节数组，一般是1024大小
int len = 0 ;
byte[] bys = new byte[1024];
while ((len = inputStream.read(bys)) != -1) {
    System.out.println(new String(bys,0,len));
}

两个read的返回值略有不同，read()返回读取的字节，读到末尾返回-1，read(byte[] b)返回的是读到的字节个数，读到的字节放在了bytes字节数组里，读到末尾没数据了返回-1。
两种读取方式图解：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Yv0oyKLy-1603813798619)(http://p5kllyq5h.bkt.clouddn.com/174401.jpg)]
同样的用完了流，也要及时的关闭，以防占用内存。
inputStream.close();

完整示例：
建议以字节数组的方式读取数据。
package io2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/**
 * Create by stefan
 * Date on 2018-05-27  23:00
 * Convertion over Configuration!
 */
public class input2 {
    public static void main(String args[]){
        FileInputStream inputStream = null;
        try {
            inputStream = new FileInputStream("a.txt");
//            byte[] bys = new byte[4];
//            int len = inputStream.read(bys);
//            System.out.println(new String(bys));  //bcd
//            System.out.println(len);  //3
//            System.out.println(inputStream.read(bys));  //-1
            int len = 0 ;
            byte[] bys = new byte[1024];
            while ((len = inputStream.read(bys)) != -1) {
                System.out.println(new String(bys,0,len));
            }
            /**
             *    public String(byte bytes[]) {
             this(bytes, 0, bytes.length);
             }
             */

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                inputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}


字节流复制文件
利用输入流读取一个文件里的字节，再利用输出流将读取到的字节写出到另一个文件中（不存在会自动创建）
package io2;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Arrays;

/**
 * Create by stefan
 * Date on 2018-05-27  23:19
 * Convertion over Configuration!
 */
public class copy {
    public static void main(String args[]) throws IOException {
        FileInputStream inputStream = new FileInputStream("E:\\huge1.jpg");
        FileOutputStream outputStream = new FileOutputStream("E:\\古月.jpg");
        
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len=inputStream.read(bytes)) != -1) {
            outputStream.write(bytes,0,len);
        }
        inputStream.close();
        outputStream.close();
    }
}


注：复制文本、图片、mp3、视频等的方式一样。
字节流一次读写一个数组的速度明显比一次读写一个字节的速度快很多，这是加入了数组这样的缓冲区效果。
java本身在设计的时候，也考虑到了这样的设计思想(装饰设计模式后面讲解)，所以提供了字节缓冲区流。
字节缓冲输出流
BufferedOutputStream
字节缓冲输入流
BufferedInputStream

BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("a.txt",true));
bos.write("hello world".getBytes());
bos.close();

BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len=bis.read(bytes)) != -1) {
    System.out.println(new String(bytes,0,len));
}
bis.close();

注：

成员方法与字节流基本一样，字节缓冲流的作用就是提高输入输出的效率。
构造方法可以指定缓冲区的大小，但是我们一般用不上，因为默认缓冲区大小就足够了。
为什么不传递一个具体的文件或者文件路径，而是传递一个OutputStream对象呢?原因很简单，字节缓冲区流仅仅提供缓冲区，为高效而设计的。但是呢，真正的读写操作还得靠基本的流对象实现。

复制文件的升级：
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
int len = 0;
byte[] bytes =new byte[1024];
while ((len=bis.read(bytes)) != -1) {
    bos.write(bytes,0,len);
}
bis.close();
bos.close();

测试：四种复制文件的效率高低
package io2;

import java.io.*;

/**
 *
 * 测试复制的时间
 * Create by stefan
 * Date on 2018-05-28  10:28
 * Convertion over Configuration!
 */
public class copy2 {
    //一个字节一个字节的复制，耗时22697毫秒
    public static  void  fun() throws IOException {
        FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
        FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
        int by = 0;
        while ((by=fis.read()) != -1) {
            fos.write(by);
        }
        fis.close();
        fos.close();
    }
    //1024字节数组复制 耗时63毫秒
    public  static void  fun1() throws IOException {
        FileInputStream fis = new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf");
        FileOutputStream fos = new FileOutputStream("E:\\modern-java.pdf");
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len=fis.read(bytes)) != -1) {
            fos.write(bytes,0,len);
        }
        fis.close();
        fos.close();
    }
    // 一个字节一个字节复制，但是用了缓冲流 耗时64毫秒
    public static   void  fun2() throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
        int by = 0;
        while ((by=bis.read()) != -1) {
            bos.write(by);
        }
        bis.close();
        bos.close();
    }
    // 1024字节数组复制并用了缓冲流 耗时7毫秒
    public  static void  fun3() throws IOException {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\modern-java.pdf"));
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("F:\\汤包\\慕课大巴\\modern-java.pdf"));
        int len = 0;
        byte[] bytes =new byte[1024];
        while ((len=bis.read(bytes)) != -1) {
            bos.write(bytes,0,len);
        }
        bis.close();
        bos.close();
    }

    public static void main(String args[]) throws IOException {
        long t1 = System.currentTimeMillis();
        fun3();
        long t2 = System.currentTimeMillis();
        System.out.println(t2-t1);
    }

}


经测试结果显示：

1024字节数组复制并用了缓冲流 的方式效率最高。
以上是本人学习笔记整理，重温java经典，欢迎各位同道中人批评指正。
源码码云地址：

https://gitee.com/stefanpy/java
梦回io流完整目录：
java基础io流——File告白（重温经典）
java基础io流——OutputStream和InputStream的故事（温故知新）
java基础io流——字符流的变革（深入浅出）
java基础io流——配角也风流（不求甚解）