1.基本概念
IO：Java对数据的操作是通过流的方式，IO流用来处理设备之间的数据传输，上传文件和下载文件，Java用于操作流的对象都在IO包中。
2.IO流的分类
图示：（主要IO流）
3.字节流
（1）.字节流基类
1）.InputStream
InputStream：字节输入流基类，抽象类是表示字节输入流的所有类的超类。
1 常用方法： 2 3 // 从输入流中读取数据的下一个字节 4 abstract int read() 5 // 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b中 6 int read(byte[] b) 7 // 将输入流中最多 len 个数据字节读入 byte 数组 8 int read(byte[] b, int off, int len) 9 10 // 跳过和丢弃此输入流中数据的 n个字节 11 long skip(long n) 12 13 // 关闭此输入流并释放与该流关联的所有系统资源 14 void close()
2）.OutputStream
OutputStream：字节输出流基类，抽象类是表示输出字节流的所有类的超类。
1 常用方法： 2 // 将 b.length 个字节从指定的 byte 数组写入此输出流 3 void write(byte[] b) 4 // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流 5 void write(byte[] b, int off, int len) 6 // 将指定的字节写入此输出流 7 abstract void write(int b) 8 9 // 关闭此输出流并释放与此流有关的所有系统资源 10 void close() 11 12 // 刷新此输出流并强制写出所有缓冲的输出字节 13 void flush()
（2）.字节文件操作流
1）.FileInputStream
FileInputStream：字节文件输入流，从文件系统中的某个文件中获得输入字节，用于读取诸如图像数据之类的原始字节流。
1 构造方法： 2 // 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的File对象file指定 3 FileInputStream(File file) 4 // 通过打开一个到实际文件的连接来创建一个FileInputStream，该文件通过文件系统中的路径name指定 5 FileInputStream(String name) 6 7 常用方法：覆盖和重写了父类的的常用方法。
1 // 读取f盘下该文件f://hell/test.txt 2 //构造方法1 3 InputStream inputStream = new FileInputStream(new File("f://hello//test.txt")); 4 int i = 0; 5 //一次读取一个字节 6 while ((i = inputStream.read()) != -1) { 7 8 // System.out.print(i + " ");// 65 66 67 68 9 //为什么会输出65 66 67 68？因为字符在底层存储的时候就是存储的数值。即字符对应的ASCII码。 10 System.out.print((char) i + " ");// A B C D 11 } 12 //关闭IO流 13 inputStream.close();
1 // 读取f盘下该文件f://hell/test.txt 2 //构造方法2 3 InputStream inputStream2 = new FileInputStream("f://hello/test.txt"); 4 // 字节数组 5 byte[] b = new byte[2]; 6 int i2 = 0; 7 // 一次读取一个字节数组 8 while ((i2 = inputStream2.read(b)) != -1) { 9 10 System.out.print(new String(b, 0, i2) + " ");// AB CD 11 } 12 //关闭IO流 13 inputStream2.close();
2）.FileOutputStream
FileOutputStream：字节文件输出流是用于将数据写入到File，从程序中写入到其他位置。
1 构造方法： 2 // 创建一个向指定File对象表示的文件中写入数据的文件输出流 3 FileOutputStream(File file) 4 // 创建一个向指定File对象表示的文件中写入数据的文件输出流 5 FileOutputStream(File file, boolean append) 6 // 创建一个向具有指定名称的文件中写入数据的输出文件流 7 FileOutputStream(String name) 8 // 创建一个向具有指定name的文件中写入数据的输出文件流 9 FileOutputStream(String name, boolean append) 10 11 常用方法：覆盖和重写了父类的的常用方法。
1 OutputStream outputStream = new FileOutputStream(new File("test.txt")); 2 // 写出数据 3 outputStream.write("ABCD".getBytes()); 4 // 关闭IO流 5 outputStream.close(); 6 7 // 内容追加写入 8 OutputStream outputStream2 = new FileOutputStream("test.txt", true); 9 // 输出换行符 10 outputStream2.write(" ".getBytes()); 11 // 输出追加内容 12 outputStream2.write("hello".getBytes()); 13 // 关闭IO流 14 outputStream2.close();
（3）.字节缓冲流（高效流）
1）.BufferedInputStream
BufferedInputStream：字节缓冲输入流，提高了读取效率。
1 构造方法： 2 // 创建一个 BufferedInputStream并保存其参数，即输入流in，以便将来使用。 3 BufferedInputStream(InputStream in) 4 // 创建具有指定缓冲区大小的 BufferedInputStream并保存其参数，即输入流in以便将来使用 5 BufferedInputStream(InputStream in, int size)
1 InputStream in = new FileInputStream("test.txt"); 2 // 字节缓存流 3 BufferedInputStream bis = new BufferedInputStream(in); 4 byte[] bs = new byte[20]; 5 int len = 0; 6 while ((len = bis.read(bs)) != -1) { 7 8 System.out.print(new String(bs, 0, len)); 9 // ABCD 10 // hello 11 } 12 // 关闭流 13 bis.close();
2）.BufferedOutputStream
BufferedOutputStream：字节缓冲输出流，提高了写出效率。
1 构造方法： 2 // 创建一个新的缓冲输出流，以将数据写入指定的底层输出流 3 BufferedOutputStream(OutputStream out) 4 // 创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流 5 BufferedOutputStream(OutputStream out, int size) 6 7 常用方法： 8 // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此缓冲的输出流 9 void write(byte[] b, int off, int len) 10 // 将指定的字节写入此缓冲的输出流 11 void write(int b) 12 // 刷新此缓冲的输出流 13 void flush()
1 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("test.txt", true)); 2 // 输出换行符 3 bos.write(" ".getBytes()); 4 // 输出内容 5 bos.write("Hello Android".getBytes()); 6 // 刷新此缓冲的输出流 7 bos.flush(); 8 // 关闭流 9 bos.close();
4.字符流
（1）.字符流基类
1）.Reader
Reader:读取字符流的抽象类.
1 常用方法： 2 // 读取单个字符 3 int read() 4 // 将字符读入数组 5 int read(char[] cbuf) 6 // 将字符读入数组的某一部分 7 abstract int read(char[] cbuf, int off, int len) 8 // 跳过字符 9 long skip(long n) 10 11 // 关闭该流并释放与之关联的所有资源 12 abstract void close()
2）.Writer
Writer:写入字符流的抽象类.
1 常用方法： 2 // 写入字符数组 3 void write(char[] cbuf) 4 // 写入字符数组的某一部分 5 abstract void write(char[] cbuf, int off, int len) 6 // 写入单个字符 7 void write(int c) 8 // 写入字符串 9 void write(String str) 10 // 写入字符串的某一部分 11 void write(String str, int off, int len) 12 13 // 将指定字符添加到此 writer 14 Writer append(char c) 15 // 将指定字符序列添加到此 writer 16 Writer append(CharSequence csq) 17 // 将指定字符序列的子序列添加到此 writer.Appendable 18 Writer append(CharSequence csq, int start, int end) 19 20 // 关闭此流，但要先刷新它 21 abstract void close() 22 // 刷新该流的缓冲 23 abstract void flush()
（2）.字符转换流
1）.InputStreamReader
InputStreamReader：字节流转字符流，它使用的字符集可以由名称指定或显式给定，否则将接受平台默认的字符集。
1 构造方法： 2 // 创建一个使用默认字符集的 InputStreamReader 3 InputStreamReader(InputStream in) 4 // 创建使用给定字符集的 InputStreamReader 5 InputStreamReader(InputStream in, Charset cs) 6 // 创建使用给定字符集解码器的 InputStreamReader 7 InputStreamReader(InputStream in, CharsetDecoder dec) 8 // 创建使用指定字符集的 InputStreamReader 9 InputStreamReader(InputStream in, String charsetName) 10 特有方法： 11 //返回此流使用的字符编码的名称 12 String getEncoding()
1 //使用默认编码 2 InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt")); 3 int len; 4 while ((len = reader.read()) != -1) { 5 System.out.print((char) len);//爱生活，爱Android 6 7 } 8 reader.close(); 9 10 //指定编码 11 InputStreamReader reader = new InputStreamReader(new FileInputStream("test.txt"),"utf-8"); 12 int len; 13 while ((len = reader.read()) != -1) { 14 System.out.print((char) len);//????????Android 15 } 16 reader.close();
2）.OutputStreamWriter
OutputStreamWriter：字节流转字符流。
1 构造方法： 2 // 创建使用默认字符编码的 OutputStreamWriter 3 OutputStreamWriter(OutputStream out) 4 // 创建使用给定字符集的 OutputStreamWriter 5 OutputStreamWriter(OutputStream out, Charset cs) 6 // 创建使用给定字符集编码器的 OutputStreamWriter 7 OutputStreamWriter(OutputStream out, CharsetEncoder enc) 8 // 创建使用指定字符集的 OutputStreamWriter 9 OutputStreamWriter(OutputStream out, String charsetName) 10 特有方法： 11 //返回此流使用的字符编码的名称 12 String getEncoding()
（3）.字符缓冲流（高效流）
1）.BufferedReader
BufferedReader：字符缓冲流，从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。
1 构造方法： 2 // 创建一个使用默认大小输入缓冲区的缓冲字符输入流 3 BufferedReader(Reader in) 4 // 创建一个使用指定大小输入缓冲区的缓冲字符输入流 5 BufferedReader(Reader in, int sz) 6 特有方法： 7 // 读取一个文本行 8 String readLine()
1 //生成字符缓冲流对象 2 BufferedReader reader = new BufferedReader(new InputStreamReader(new FileInputStream("test.txt"))); 3 String str; 4 //一次性读取一行 5 while ((str = reader.readLine()) != null) { 6 System.out.println(str);// 爱生活，爱Android 7 } 8 9 //关闭流 10 reader.close();
2）.BufferedWriter
BufferedWriter：字符缓冲流，将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。
1 构造方法： 2 // 创建一个使用默认大小输出缓冲区的缓冲字符输出流 3 BufferedWriter(Writer out) 4 // 创建一个使用给定大小输出缓冲区的新缓冲字符输出流 5 BufferedWriter(Writer out, int sz) 6 特有方法： 7 // 写入一个行分隔符 8 void newLine()
（4）.FileReader、FileWriter
1 FileReader：InputStreamReader类的直接子类，用来读取字符文件的便捷类，使用默认字符编码。 2 FileWriter：OutputStreamWriter类的直接子类，用来写入字符文件的便捷类，使用默认字符编码。
#5.高效流效率比对
读取f盘下的一个视频文件到项目中：文件大小29.5 MB
读取方式一：
1 FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4"); 2 FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4"); 3 int len; 4 // 开始时间 5 long begin = System.currentTimeMillis(); 6 // 一次读取一个字节 7 while ((len = inputStream.read()) != -1) { 8 outputStream.write(len); 9 } 10 // 用时毫秒 11 System.out.println(System.currentTimeMillis() - begin);// 213195 12 //关闭流释放资源 13 inputStream.close(); 14 outputStream.close();
读取方式二：
1 FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4"); 2 FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4"); 3 int len; 4 byte[] bs = new byte[1024]; 5 // 开始时间 6 long begin = System.currentTimeMillis(); 7 // 一次读取一个字节数组 8 while ((len = inputStream.read(bs)) != -1) { 9 outputStream.write(bs, 0, len); 10 } 11 // 用时毫秒 12 System.out.println(System.currentTimeMillis() - begin);// 281 13 14 inputStream.close(); 15 outputStream.close();
读取方式三：
1 FileInputStream inputStream = new FileInputStream("f://滑板//HEEL_FLIP.mp4"); 2 BufferedInputStream bis = new BufferedInputStream(inputStream); 3 FileOutputStream outputStream = new FileOutputStream("HEEL_FLIP.mp4"); 4 BufferedOutputStream bos = new BufferedOutputStream(outputStream); 5 int len; 6 byte[] bs = new byte[1024]; 7 // 开始时间 8 long begin = System.currentTimeMillis(); 9 while ((len = bis.read(bs)) != -1) { 10 bos.write(bs, 0, len); 11 } 12 // 用时毫秒 13 System.out.println(System.currentTimeMillis() - begin);// 78 14 15 bis.close(); 16 bos.close();
实例：读取本地文件
1 public class Reader { 2 public static void main(String[]args) throws IOException { 3 4 //FileReader fr=new FileReader("C:\Users\Administrator\Desktop\新建文本文档.txt"); 5 6 7 /*FileInputStream fs=new FileInputStream("C:\Users\Administrator\Desktop\新建文本文档.txt"); 8 InputStreamReader fr=new InputStreamReader(fs);*/ 9 //以上两种方式读取 10 char[] buffer=new char[1024]; 11 int ch=0; 12 while ((ch=fr.read())!=-1){ 13 System.out.print((char)ch); 14 } 15 } 16 }
1 public class Stream { 2 public static void main(String[]args) throws IOException { 3 FileInputStream fis=new FileInputStream("C:\Users\Administrator\Desktop\新建文本文档.txt"); 4 InputStreamReader fin=new InputStreamReader(fis,"UTF-8"); 5 BufferedReader br=new BufferedReader(fin); 6 String s=""; 7 while ((s=br.readLine())!=null){ 8 System.out.println(s); 9 } 10 br.close(); 11 } 12 }
写入文件
1 public class Write { 2 public static void main(String[]args) throws IOException { 3 File filename=new File("C:\Users\Administrator\Desktop\新建文本文档.txt"); 4 FileReader fr=new FileReader(filename); 5 BufferedReader br=new BufferedReader(fr); 6 7 File file=new File("C:\Users\Administrator\Desktop\1.txt"); 8 file.createNewFile(); //创建新文件,有同名的话直接覆盖 9 FileWriter fw=new FileWriter(file); 10 BufferedWriter bw=new BufferedWriter(fw); 11 12 /*FileOutputStream fs=new FileOutputStream(file); 13 OutputStreamWriter ow=new OutputStreamWriter(fs); 14 BufferedWriter bw=new BufferedWriter(ow);*/ 15 16 String s="123"; 17 bw.write(s+" "); 18 bw.write("dhsadhaskjd "); 19 bw.close(); 20 } 21 }
实例详解：现读取本地桌面一个后缀为.mod的文件，获取前5行数据并匹配每行内的6个数据，其意义代表角度，将该数据转化成弧度并输出到新文件
本地文件：
其格式特点为，需要截取的数据都是以target1开始的，只截取前五行的数据，处理成以下格式文件，要求获取的6个角度放进一行，并在最前面加上固定格式0,0,0,1,0,0,
1 public class Buffered { 2 3 //读取文件并追加写入文件 4 public static void writeFile(String pathname, String content) { 5 try { 6 File writeName = new File(pathname); 7 try (FileWriter writer = new FileWriter(writeName, true); 8 BufferedWriter out = new BufferedWriter(writer) 9 ) { 10 out.write(content); 11 out.flush(); 12 } 13 } catch (IOException e) { 14 e.printStackTrace(); 15 } 16 } 17 18 public static void main(String[]args) throws IOException { 19 20 File filename=new File("C:\Users\Administrator\Desktop\新建文本文档.mod"); 21 FileReader fr=new FileReader(filename); 22 BufferedReader br=new BufferedReader(fr); 23 24 /*FileInputStream fs=new FileInputStream(filename); 25 InputStreamReader isr=new InputStreamReader(fs); 26 BufferedReader br=new BufferedReader(isr);*/ 27 File file=new File("C:\Users\Administrator\Desktop\1.txt"); 28 file.createNewFile(); //创建新文件 29 30 31 int line=0; 32 String s=""; 33 //逐行读取 34 while ((s=br.readLine())!=null){ 35 36 //判断以target开始的行，并计数 37 if(s.startsWith("target1 := CalcRobT([[")==true){ 38 line++; 39 40 //只截取前5行 41 if (line<=5){ 42 String []a=s.split("\[|,|]"); //分隔符：以[和,为分隔符 43 //每行前面加一串数字 44 writeFile("C:\Users\Administrator\Desktop\1.txt",0+","+0+","+0+","+1+","+0+","+0+","+0+","); 45 //开始循环，截取数据并转换成double类型以便计算 46 for(int i=2;i<8;i++){ 47 double value=Double.valueOf(a[i].toString()); 48 DecimalFormat df = new DecimalFormat("0.000000000000"); 49 String num = df.format((float)value*3.14/180); 50 System.out.println(num); 51 52 //将处理后的数据写入文件 53 writeFile("C:\Users\Administrator\Desktop\1.txt",num); 54 55 //每次写进一个数据后添加一个","，最后一个结尾数据不加 56 if(i<7){ 57 writeFile("C:\Users\Administrator\Desktop\1.txt",","); 58 } 59 } 60 //每输完一组数据后换行再次操作 61 writeFile("C:\Users\Administrator\Desktop\1.txt"," "); 62 } 63 } 64 } 65 } 66 }