IO 流(输入流, 输出流)
字节流, 字符流
1. 字节流:
InputStream,OutputStream
InputStream 抽象了应用程序读取数据的方式;
OutputStream 抽象了应用程序写出数据的方式;
2.EOF=End 读到 - 1 就读到结尾
3. 输入流的基本方法:
int b=in.read(); 读取一个字节无符号填充到 int 低八位;-1 是 EOF;
- in.read(byte[] buf)
- in.read(byte[] buf,int start,int size)
4. 输出流基本方法:
out.write(int b) 写出一个 byte 到流, b 的低 8 位;
out.write(byte[] buf) 将 buf 字节数组都写入到流;
out.write(byte[] buf,int start,int size)
5.FileInputStream--->具体实现了在文件上读取数据, 下面请看最简单的文件读取:
- package com.wxd.test2;
- import java.io.FileInputStream;
- import java.io.IOException;
- public class IOUtil {
- /**
- * 读取指定文件内容, 按照 16 进制输出到控制台
- * 并且每输出 10 个 byte 换行
- * @param fileName
- */
- public static void printHex(String fileName) throws IOException {
- // 把文件作为字节流进行读操作
- FileInputStream in =new FileInputStream(fileName);
- int b;
- int i=1;
- while ((b=in.read())!=-1){
- if(b<=0xf){
- // 单位数前面补 0
- System.out.print(0);
- }
- System.out.print(Integer.toHexString(b)+" ");
- if(i++%10==0){
- System.out.println();
- }
- }
- in.close();
- }
- }
6.FileOutputStream 实现了向文件中写出 byte 数据的方法:
- package com.wxd.test2;
- import java.io.FileOutputStream;
- import java.io.IOException;
- public class FileOutDemo1 {
- public static void main(String[] args) throws IOException{
- // 如果该文件不存在则直接创建, 如果存在删除后创建
- FileOutputStream out=new FileOutputStream("demo/out.dat");
- out.write('A');// 写出了'A'字符的低八位
- out.write('B');// 写出了'B'字符的低八位
- int a=10;//write 只能写低八位写一个 int 需要写四次每次 8 位
- out.write(a>>>24);
- out.write(a>>>16);
- out.write(a>>>8);
- out.write(a);
- byte[] zg="中国".getBytes("UTF-8");
- out.write(zg);
- out.close();
- IOUtil.printHex("demo/out.dat");
- }
- }
7.DataOutputStream/DataInputStream 对 "流" 功能的扩展, 可以更加方便的读取 int,long, 字符等类型数据:
- writeInt()/writeDouble()/writeUTF()
- package com.wxd.test2;
- import java.io.DataOutputStream;
- import java.io.FileOutputStream;
- import java.io.IOException;
- public class DosDemo {
- public static void main(String[] args) throws IOException {
- String file="demo/dos.dat";
- DataOutputStream dos=new DataOutputStream(new FileOutputStream(file));
- dos.writeInt(10);
- dos.writeInt(-10);
- dos.writeLong(10l);
- dos.writeDouble(10.5);
- // 采用 UTF-8 编码写出
- dos.writeUTF("中国");
- // 采用 utf-16be 编码写出
- dos.writeChars("中国");
- dos.close();
- }
- }
- package com.wxd.test2;
- import java.io.DataInputStream;
- import java.io.FileInputStream;
- import java.io.IOException;
- public class DisDemo {
- public static void main(String[] args) throws IOException {
- String file="demo/dos.dat";
- DataInputStream dis=new DataInputStream(new FileInputStream(file));
- int i=dis.readInt();// 其实做了 4 次 read, 因为 int 是 32 位
- System.out.println(i);
- i=dis.readInt();
- System.out.println(i);
- long l=dis.readLong();// 其实做了 8 次 read, 应为 long 是 64 位
- System.out.println(l);
- double d=dis.readDouble();
- System.out.println(d);
- String s=dis.readUTF();
- System.out.println(s);
- dis.close();
- }
- }
7.BufferedInputStream&BufferedOutputStrean 这两个流为 IO 提供了带缓冲区的操作, 一般打开文件进行写入或读取操作时, 都会加上缓冲, 这种流模式提高了 IO 性能
从应用程序中把数据放入文件, 相当于将一缸水倒入到另一个缸中:
FileOutputStream--->write()方法相当于一滴一滴地把水转移过去
DataOutputStream--->writeXxx()方法会方便一些, 相当于一瓢一瓢的把水转移过去
BufferedOutputStream--->write()方法相当于一瓢一瓢先放入桶中, 再从桶中倒入缸中
- /***
- * 进行文件的拷贝, 利用带缓冲的字节流
- * @param srcFile
- * @param destFile
- * @throws IOException
- */
- public static void copyFileByBuffer(File srcFile,File destFile) throws IOException{
- if(!srcFile.exists()){
- throw new IllegalArgumentException("文件:"+srcFile+"不存在");
- }
- if(!srcFile.isFile()){
- throw new IllegalArgumentException(srcFile+"不是文件!");
- }
- BufferedInputStream bis=new BufferedInputStream(new FileInputStream(srcFile));
- BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(destFile));
- int c;
- while ((c=bis.read())!=-1){
- bos.write(c);
- bos.flush();// 刷新缓冲区, 否则写入不到;
- }
- bis.close();
- bos.close();
- }
字符流
1. 编码问题
2. 认识文本和文本文件
3.Java 的文本 (char) 是 16 位无符号的整数, 是字符的 unicode 编码 (双字节编码) 文件是 byte byte byte... 的数据序列
文本文件是文本 (char) 序列按照某种编码方案 (utf-8,utf-16be,gbk) 序列化为 byte 的存储
4. 字符流 (Reader Writer):---> 操作的是文本文件
字符的处理, 一次处理一个字符
字符的底层任然是基本的字节序列
字符流的基本实现
InputStreamReader 完成 byte 流解析为 char 流, 按照编码解析
OutputStreamWriter 提供 char 流到 byte 流, 按照编码处理
- package com.wxd.test2;
- import java.io.*;
- public class IsrAndOswDemo {
- public static void main(String[] args) throws IOException{
- //InputStreamReader 被称为桥梁流
- FileInputStream in=new FileInputStream("demo\\test.txt");// 默认项目的编码, 操作的时候要写文件本身的编码
- InputStreamReader isr=new InputStreamReader(in,"utf-8");
- FileOutputStream out=new FileOutputStream("demo\\test2.txt");
- OutputStreamWriter osw=new OutputStreamWriter(out,"utf-8");
- // int c;
- // while ((c=isr.read())!=-1){
- // System.out.print((char)c);
- // }
- char[] buffer=new char[8*1024];
- int c;
- // 批量读取, 放入 buffer 这个字符数组, 从第 0 个位置开始放置, 最多放 buffe.length 个
- // 返回的是读到的字符的个数
- while ((c=isr.read(buffer,0,buffer.length))!=-1){
- String s=new String(buffer,0,c);
- System.out.println(s);
- osw.write(buffer,0,c);
- osw.flush();
- }
- isr.close();
- osw.close();
- }
- }
- 5.FileReader/FileWriter(这种方式 bu)
- package com.wxd.test2;
- import java.io.FileReader;
- import java.io.FileWriter;
- import java.io.IOException;
- public class FrAndFwDemo {
- public static void main(String[] args) throws IOException{
- FileReader fr=new FileReader("demo\\test.txt");
- FileWriter fw=new FileWriter("demo\\text2.txt",true);// 设置为 true 在后面追加
- char[] buffer=new char[2056];
- int c;
- while ((c=fr.read(buffer,0,buffer.length))!=-1){
- fw.write(buffer,0,c);
- fw.flush();
- }
- fr.close();
- fw.close();
- }
- }
6. 字符流的过滤器
BufferedReader ----->readLine 一次读一行
BufferedWriter/PrintWriter ---->写一行
- package com.wxd.test2;
- import java.io.*;
- public class BrAndBwOrPwDemo {
- public static void main(String[] args) throws IOException {
- // 对文件进行读写操作
- BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("demo\\test.txt")));
- /*BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo\\test3.txt")));*/
- PrintWriter pw = new PrintWriter("demo\\test3.txt");
- String line;
- while ((line = br.readLine()) != null) {
- System.out.println(line);// 一次读一行, 并不能识别换行
- /*bw.write(line);
- // 单独写出换行操作
- bw.newLine();
- bw.flush();*/
- pw.println(line);
- pw.flush();
- }
- br.close();
- // bw.close();
- pw.close();
- }
- }
来源: https://www.cnblogs.com/MrXiaoAndDong/p/IO.html