28.IO流

1. 流根据读取数据的方式分为：字节流和字符流（Java中一个字符占两个字节）
 字节流：适合读取视频，声音，图片等二进制文件
 字符流：纯文本文件
 Java语言中所有字节流都以Stream结尾，所有字符流都含有Read或Write
 
2. 需要掌握的16个流：
 java.io.*;
 
 FileReader
 FileWriter
 FileInputStream
 FileOutputStream


 
 BufferedReader
 BufferedWriter
 BufferedInputStream
 BufferedOutputStream
 
 DataInputStream
 DataOutputStream
 
 ObjectInputStream
 ObjectOutputStream
 
 (转换流   字节流————>字符流)
 InputStreamReader
 OutputStreamWriter
 
 PrintWriter

 PrintStream//标准输出流（默认输出到控制台）

3.

Input_OutputStream继承结构图

.

Reader和Writer集成结构图

4. FileInputStream;文件字节输入流  ：按照字节方式读取文件
 

import java.io.*;public class HelloWorld {public static void main(String[] args) {FileInputStream fis = null;try {//String path = "D:\\java程序\\text.txt";String path = "D:/java程序/text.txt";   // (两种方式均可)//1.要读取某文件，先与这个文件创建一个"输入流"    fis = new FileInputStream(path);    System.out.println(fis.available());//文件估计剩余字节数/*int i1 = fis.read();//均以字节方式读取int i2 = fis.read();int i3 = fis.read();System.out.print(i1);System.out.print(i2);System.out.print(i3);文件字节输入流  ：按照字节方式读取文件      缺点：一次读取一字节，频繁访问磁盘，伤害磁盘     访问效率低*/    //改进读取方式  int read(byte[] bytes);    //读取之前在内存中准备一个byte数组，每次读取多个字节存储到byte数组中     byte[] bytes = new byte[3];    int temp =0;    while((temp = fis.read(bytes))!= -1) { //当文件读取完后，返回值为-1    System.out.print(new String(bytes,0,temp));//String(byte[] bytes, int offset, int length)参数： bytes：要解码为字符的 byte 
             offset： 要解码的第一个 byte 的索引 
             length： 要解码的 byte 数 的长度    /* int read(byte[] bytes);                     读取之前在内存中准备一个byte数组，每次读取多个字节存储到byte数组中           */    }}catch(IOException e) {e.printStackTrace();}finally {//为保证流一定被释放，所以在finally语句块中执行if (fis !=null) {try {fis.close();}catch(IOException e) {e.printStackTrace();}}}}}

FileOutputStream;文件字节输出流 ：将计算机内存中的数据写入到硬盘文件中

import java.io.*;public class HelloWorld {public static void main(String[] args) {FileOutputStream fos = null;try {//String path = "D:\\java程序\\text.txt";String path = "D:/java程序/text.txt";   // (两种方式均可)//创建文件字节输出流    fos = new FileOutputStream(path,true);//不写true会把源文件覆盖//开始写    String msg = " hello world!";    //将 String转换成byte数组    byte[] bytes = msg.getBytes();    fos.write(bytes);        fos.flush();//强制写入（为保证数据完全写入硬盘，所以要刷新）    }catch(IOException e) {e.printStackTrace();}finally {//为保证流一定被释放，所以在finally语句块中执行if (fos !=null) {try {fos.close();}catch(IOException e) {e.printStackTrace();}}}}}

FileInputStream; FileOutputStream实现复制

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception {//创建输入流FileInputStream fis = new FileInputStream("D:/java程序/text.txt");//创建输出流FileOutputStream fos = new FileOutputStream("D:/java程序/text2.txt");//一边读，一边写byte[] bytes = new byte[1024];int temp = 0;while((temp = fis.read(bytes)) != -1) {fos.write(bytes,0,temp);}//刷新fos.flush();//关闭fis.close();fos.close();}}

FileReader

/*java.io.Reader;java.io.InputStreamReader;转换流（字节输入流-->字符输入流）Java.io.FileReader;文件字符输入流   */import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception {//创建字符输入流FileReader fr = new FileReader("D:/java程序/text.txt");//开始读char[] chars = new char[512] ;//1KBint temp = 0;while((temp = fr.read(chars)) != -1) {//将char数组有效数组转换成字符串System.out.print(new String(chars,0,temp));}}}

FileReader FileWriter实现文件赋值（只能复制字符文件）

/*java.io.Reader;java.io.InputStreamReader;转换流（字节输入流-->字符输入流）Java.io.FileReader;文件字符输入流 java.io.Writer; java.io.OutputStream;转换流（字节输出流-->字符串输出流） java.io.FileWriter;文件字符输出流 */import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception {FileReader fr = new FileReader("D:/java程序/text2.txt");//创建文件字符输出流FileWriter fw = new FileWriter("D:/java程序/text.txt",true);char[] chars = new char[512];int temp = 0;while((temp = fr.read(chars)) != -1) {fw.write(chars,0,temp);}//刷新fw.flush();//关闭fr.close();fw.close();}}

字节：
BufferedInputStream
BufferedOutputStream
 字符：
BufferedReader：带有缓冲区的字符输入流
BufferedWriter：带有缓冲区的字符输出流

BufferedReader

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception {//创建一个带有缓冲区的字符输入流BufferedReader br= new BufferedReader(new FileReader("D:/java程序/text.txt"));//将文件字符输入流包装成带有缓冲区的字符输入流//BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("D:/java程序/text.txt")));//读取字节流时应先用InputStreamReader（转换流）转化为字符流//根据流出现的位置，流又可以分为：包装流或者处理流 和 节点流//FileReader fr 是一个节点流//BufferedReader br 是一个包装流或者处理流//开始读String temp = null;while((temp = br.readLine()) != null) {//br.readLine()读取一行，但是方尾不带换行符System.out.println(temp);//输出一行}//关闭//注意：关闭的时候只要关闭最外层包装流（这里有一个装饰者模式）br.close();}}

接收用户键盘输入

import java.util.*;import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{//以前的方式/*Scanner s = new Scanner(System.in);//System.in是一个标准输入流，接收键盘输入//执行到此处停下来，等待用户输入String str = s.next();System.out.println("请输入"+str);*///使用BufferedReader用来接收用户输入BufferedReader br = new BufferedReader(new InputStreamReader(System.in));//接收输入（每一次都接收一行）String str = br.readLine();System.out.println("您输入了"+str);br.close();}}

BufferedWriter

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{//创建带有缓冲区的字符输出流BufferedWriter bw = new BufferedWriter(new FileWriter("D:/java程序/text.txt",true));bw.write("China");bw.newLine();bw.write("Number One");//刷新bw.flush();bw.close();}}

BufferedReade BufferedWriter实现文件复制

import java.util.*;import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{BufferedReader br = new BufferedReader(new FileReader("D:/java程序/text2.txt"));BufferedWriter bw = new BufferedWriter(new FileWriter("D:/java程序/text.txt",true));String temp = null;while((temp = br.readLine())!= null) {bw.write(temp);bw.newLine();}//刷新,关闭bw.flush();br.close();bw.close();}}

DataInputStream

import java.io.*;public class test02 {public static void main(String[] args) throws Exception{//创建输出流DataInputStream dis = new DataInputStream(new FileInputStream("D:/java程序/text.txt"));//读（注意：要使用该流读取数据，必须提前知道该文件中数据存储格式，顺序）     //读的顺序必须和写入顺序相同byte b = dis.readByte();short s = dis.readShort();int i = dis.readInt();long l = dis.readLong();System.out.println(b);System.out.println(s);System.out.println(i);System.out.println(l);//关闭dis.close();}}

DataOutputStream

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{//创建数据字节输出流DataOutputStream dos = new DataOutputStream(new FileOutputStream("D:/java程序/text.txt"));//准备数据byte b = 10;short s = 11;int i = 12;long l = 1000L;//写dos.writeByte(b);dos.writeShort(s);dos.writeInt(i);dos.writeLong(l);//刷新dos.flush();//关闭dos.close();}}

PrintStream 标准输出流，默认打印到控制台，以字节方式
PrinteWriter 以字符方式

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{System.out.println("hello world!");//改变输出方向(输出到文件):通常使用这种方法记录日志System.setOut(new PrintStream(new FileOutputStream("D:/java程序/text.txt")));System.out.println("biu biu biu");}}

java.io.ObjectOutputStream:序列化Java对象到硬盘
java.io.ObjectInputStream:将硬盘中的数据"反序列化到JVM内存"

（序列化）

import java.io.*;public class HelloWorld {public static void main(String[] args)throws Exception{//创建Java对象User u1 = new User("刘德华");//创建输出流（序列化流）(JVM中的Java对象状态保存到硬盘中)ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/java程序/text.txt"));//写oos.writeObject(u1);oos.flush();oos.close();}}//java.io.Serializable 该接口是一个可序列化的 没有任何方法，是一个标识接口 //标志接口的作用：起到标志接口的作用//JVM如果看到该对象实现某个接口，会对它特殊待遇class User implements Serializable{String name;User(String name){this.name = name;}public String toString() {return "User[name="+name+"]";}}

(反序列化)

import java.io.*;public class test2 {public static void main(String[] args)throws Exception{//创建反序列化流ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:/java程序/text.txt"));//反序列化Object o = ois.readObject();System.out.println(o);//User[name=刘德华]ois.close();}}