IO基本的字节字符

一 文件的字节输入流
1 FileInputStream
1.1 说明：直接继承自InputStream 所以无法对此进行包装
1.2 构造方法
FileInputStream(String name)
FileInputStream(File file)
1.3方法
1)public int read():一次读取一个字节
2)public int read(byte[] b):一次读取一个字节数组 实际就是把读到的数据保存到字节数组里面
–返回的是实际读取的字节数–
3)read(byte[] b, int off, int len) 只要有该方法 一定有读取这个数组方法
实例1：一次读一个字节
FileInputStream fis=new FileInputStream(“a.txt”);
int len;//两个作用 1)实际读到的字节数目 2)读到的字节 可以利用char强转
while((len=fis.read())!=-1){
System.out.print((char)len+” “);
}
说明：如果a.txt有数据52 就会输出5 2
实例2 一次读字节数组 字节数组存放的是每一次读到的字节
FileInputStream fis=new FileInputStream(“SelfDemo.java”);
byte b[]=new byte[1024];//经常是1024的整数倍
int len;
while((len=fis.read(b))!=-1){
System.out.println(len);
System.out.println(new String(b));
}
说明：1有乱码:
原因：因为是一次读一个数组，每一个字节是独立的，一个汉字可能有2个或者多个字节组成，
所以对读到的字节进行合并（GBK 一个汉字2 utf-8 3个字节）
说明2 ：当读到的字节不足1024时候，读到的字节无法覆盖上一次的整个1024字节，所以
有输出上一次1024-这一次读到的字节数目，要想输出本次实际读到的字节数组可以利用
System.out.println(new String(b, 0, len));
实例3 a.txt hello
FileInputStream fis=new FileInputStream(“a.txt”);
byte b[]=new byte[3];//经常是1024的整数倍
int len;
while((len=fis.read(b))!=-1){
//System.out.println(new String(b, 0, len));输出hello
System.out.print(new String(b));
//输出：hellol 最后一个l是上一次读到的，因为最后一次读到2个无法覆盖字节数组3个字节
//其实读字节数组 就是读取规定字节数组大小 每次进行字节数组内容的覆盖
System.out.print(” “);
}
1.4 结合 输出流 对文件进行Copy
实例1 对文件进行Copy
FileInputStream fis = new FileInputStream(“a.txt”) ;
FileOutputStream fos = new FileOutputStream(“b.txt”) ;
int by = 0 ;
while((by=fis.read())!=-1){
//一次读一个字节,使用输出流给b.txt文件写一个字节
fos.write(by) ;
}

    //释放资源    fos.close() ;    fis.close() ;}

实例2：图片进行copy 字节数组
FileInputStream fis = new FileInputStream(“E:\高圆圆.jpg”) ;
FileOutputStream fos = new FileOutputStream(“mm.jpg”) ;

    //一次读取一个字节数组    byte[] bys = new byte[1024] ;    int len = 0 ;    while((len=fis.read(bys))!=-1){        //写数据的        fos.write(bys, 0, len) ;//把实际读到的字节数组写出去    }    //释放资源    fis.close() ;    fos.close() ;} 写出回车换行 write("\r\n".getBytes()); **流的标准异常处理   1.6以前**    FileInputStream fis = null;    FileOutputStream fos = null;    try {        fis = new FileInputStream("aaa.txt");        fos = new FileOutputStream("bbb.txt");        int b;        while((b = fis.read()) != -1) {            fos.write(b);        }    } finally {        try {            if(fis != null)                fis.close();        }finally {            if(fos != null)                fos.close();        }    }    流的异常处理1.7    try(        FileInputStream fis = new FileInputStream("aaa.txt");        FileOutputStream fos = new FileOutputStream("bbb.txt");        MyClose mc = new MyClose();    ){        int b;        while((b = fis.read()) != -1) {            fos.write(b);        }    }    原理

在try()中创建的流对象必须实现了AutoCloseable这个接口,基本的流已经都实现了
如果实现了,在try后面的{}(读写代码)执行后就会自动调用,流对象的close方法将流关掉
2BufferedInputStream 带缓冲的字节输出/输入流
原理： BufferedInputStream会一次性从文件中读取自己数组大小个, 存在缓冲区中, 返回给程序
程序再次读取时, 就不用找文件了, 直接从缓冲区中获取
直到缓冲区中所有的都被使用过, 才重新从文件中读取8192个
2.1 构造方法
BufferedInputStream(InputStream in) //只要构造方法带有输出输入流 就要new 相应的字节/字符子实现类
实例1
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(“bis.txt”)) ;
//一次读取一个字节数组或者一次读取一个字节都可以
byte[] bys = new byte[1024] ;
int len = 0 ;
while((len=bis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
说明：带缓冲的字节输出/输入方法 和不带缓冲的基本一样
flush()和close()方法的区别?
flush():刷新缓冲区的流,强迫将缓冲字节都写到该流中,刷新之后是可以写数据的.
close():关闭流对象所指向指向的这个资源文件,一旦关闭,写数据,写不进去的!
3 编码和解码
String s = “爱你” ;
//编码
// byte[] bys = s.getBytes(“utf-8”)
// 解码
String(byte[] bytes, Charset charset) 实例 new String(bys,”utf-8”);
**4InputStreamReader OutputStreamWriter字符和字节转换的桥梁 实际是字符流 开始了对字符的操作
父类是字符流的基类**
提示：字符输入流:字节输入流+编码格式(默认GBK)
构造方法：InputStreamReader isr = new InputStreamReader(new FileInputStream(
“filename”), “GBK”);
write(String str, int off, int len) 写出字符串

            方法差不多.......就是现在是对字符的操作

实例1：InputStreamReader isr=new InputStreamReader(new FileInputStream(“b.txt”),”GBK”);
OutputStreamWriter osw=new OutputStreamWriter(new FileOutputStream(“c.txt”), “GBK”);
char by[]=new char[1024];//不可以继续写字节流，应该是字符数组了
int len;
while((len=isr.read(by))!=-1){
System.out.println(new String(by));
osw.write(by);
}
osw.close();
isr.close();
说明：编码方式GBK可以省略，使用默认的编码方式
5FileReader/FileWriter 更加好用便捷的字符流 继承自字符字节桥梁
构造函数 FileReader(String fileName)….
6带缓冲的字符流
BufferedReader:字符缓冲输入流
BufferedWriter:字符缓冲输出流
构造函数： public BufferedWriter(Writer out)
实例：BufferedWriter bw = new BufferedWriter(new FileWriter(“bw.txt”)) ;
BufferedReader br=new BufferedReader(new FileReader(“c.txt”));
BufferedWriter bw=new BufferedWriter(new FileWriter(“d.txt”));

    char ch[]=new char[3];//和字节流差不多，你好我也好我  多余我    int len;    while((len=br.read(ch))!=-1){        System.out.println(new String(ch));        bw.write(ch);    }    br.close();    bw.close();

特有的方法：String readLine() 读取一个文本行。 void newLine() 写入一个行分隔符
实例 字符流的while 循环方法
String line = null ;
while((line=br.readLine())!=null){
System.out.println(line);
7使用带缓冲的流对System.in进行包装 实现键盘录入对象的原理
InputStream is = System.in;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)) ;//使用桥梁连接字节 字符

    System.out.println("请输入一个整数:");    String str = br.readLine() ;//返回值是一个字符串    int number = Integer.parseInt(str) ;    System.out.println("您输入的整数是:"+number);

提示：FileWriter fw =new FileWriter(“fw.txt”,true);只要对文件进行追加写入 就在相应的构造函数写入true

补充
1 FileInputStream fis = new FileInputStream(“致青春.mp3”);
byte[] arr = new byte[fis.available()]; 创建与致青春一样大小的文件
2 read()方法读取的是一个字节,为什么返回是int,而不是byte
byte 是1一个字节，即8位，如果取到连续11111111 (8个1)
为了避免读到连续8个1(就是-1)和定义的结束标记-1相同(read()返回-1就是读到末尾)。
所以在保留11111111的基础上，在转成int类型时，前面24位补0而不补1.
如果是补1
11111111 11111111 11111111 11111111
不还是-1？是-1的原因是因为前面24位补的是1，只要在前面补0，
既可以保留原字节数据不变(最低8位)，又可以避免-1的出现。
3 使用字符流 放心对任何符号 字符操作
4Writer类中有一个2k的小缓冲区,如果不关流,就会将内容写到缓冲区里,
无法写到目标文件里面，关流会将缓冲区内容刷新,再关闭
5LineNumberReader
主要方法：
int getLineNumber() 获得当前行号。
void setLineNumber(int lineNumber) 设置当前行号。

`LineNumberReader lnr = new LineNumberReader(new FileReader(“SelfDemo.java”));

    String line;    lnr.setLineNumber(100);//设置当前行号    while((line = lnr.readLine()) != null) {        System.out.println(lnr.getLineNumber() + ":" + line);//取得当前行号    }    lnr.close();`