本文主要介绍，字符，字节流，缓冲流，转换流，打印流。
一，字节流（输出，输入）：
1，输出流（字节输出流），写入方法写入，可以写一个字节，字节片段，也可以规定写入一部分字节的一部分。
2，InputStream（字节输入流），读取方法读取，可以读一个字节，字节片段，也可以规定读取某些字节片段的一部分。字符
流（Reader，Writer）：
1，FileWriter（字符输出流），写入方法写入，可以写一个字符，字符数组，也可以规定写入某些字符数组的一部分。
1，FileReader（字符输入流），读取方法read，可以读一个字符，字符数组，也可以规定读取某些字符片段的一部分。
注：字符流在写入的时候要刷新刷新一下，关闭方法中包含了刷新，但是一般还是写入部分刷新一下好。字符流和字节流的用法区别：
一般文本操作的时候用字符流，其他文件操作的时候用字节流。因为汉字不管用什么编码表，都不止一个字节，用字节流来一个个读取会破坏汉字的特性。而用字符流来都其他文件（图片，音乐，视频），也会破坏本来的文件。
字符流，字节流，对文件的复制操作。（复制包含了读取和写入）
package note.basics.demo;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
/*
* 分别用字符流和字节流来对文件的Copy
*/
public class Copy_1 {
public static void main(String[] args) throws IOException {
fun();
}
//字节流的操作
public static void fun() throws IOException{
//创建一个操作文件
File file = new File("d:\\copy.txt");
//把文件进行流的捆绑
FileInputStream fis = new FileInputStream(file);
FileOutputStream fos = new FileOutputStream(new File("d:\\aa.txt"));
//当文件读取完了，返回-1,每次返回的是相对于的ASCII
int read = -1;
while( (read = fis.read()) != -1){
fos.write(read);
//如果存的是汉字打印出来的是乱码
// System.out.println((char)read);
}
fis.close();
fos.close();
}
//字符流的操作
public static void fun2() throws IOException{
//创建字符输入输出流，并捆绑文件
FileReader fr = new FileReader(new File("d:\\copy2.txt"));
FileWriter fw = new FileWriter(new File("d:\\bb.txt"));
int read = -1;
while( (read = fr.read()) != -1){
fw.write(read);
//不管存的是什么，都照样输出
// System.out.println((char)read);
}
fr.close();
fw.close();
}
} 二，缓冲流：
1，字节缓冲流（BufferedInputStream，BufferedOutputStream）
1）BufferedOutputStream（字节输出缓冲流）：写入数据到流中，作用：提高写入输出流的写入效率。
2）BufferedInputStream（字节输出缓冲流）：读取流中的数据，作用：提高内置输入流的读取效率。
2，字符缓冲流（BufferedReader，BufferedWriter）
1）BufferedReader（字符读取缓冲流）：从字符输入流中读取文本，缓冲多个字符，从而实现字符，数组和行的高效读取。
2）BufferedWriter（字符写入缓冲流）：将文本写入字符串输出流，缓冲多个字符，从而提供字符串，字符串和字符串的高效写入。
注：它们的构造方法都有两个，一个是一个参数的，一个是两个参数的。
1）一个参数的，都是传递相对应的流，进行效率的提高。（以下会代码演示）
2）两个参数的，第一个参数和（1）一样，第二个参数是输入的大小。一般尺寸大小也够，看实际情况来选择方法。
缓冲流对文件复制（复制包含文件的读取，和写入）
package note.basics.demo;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class Copy_2 {
public static void main(String[] args) throws IOException{
fun();
fun1();
}
//字节缓冲流复制
public static void fun() throws IOException{
//创建字节输入输出并为其绑定文件
FileInputStream fis = new FileInputStream(new File("d:\\copy.txt"));
FileOutputStream fos = new FileOutputStream(new File("d:\\aa.txt"));
//创建字节缓冲流并绑定相对应的字节流
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
//read方法可以读取一个字节或字节数组,或读取字节数组的一部分
int line = -1;
while((line = bis.read()) != -1){
//write方法可以写入一个字节或字节数组,或写入字节数组的一部分
bos.write(line);
}
//关闭流
//直接关闭缓冲流就可以了，它会把相对应的字节流也关闭
bis.close();
bos.close();
}
//字符缓冲流复制
public static void fun1() throws IOException{
//直接一步创建字符缓冲流并绑定文件
BufferedReader br = new BufferedReader(new FileReader("d:\\copy2.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\bb.txt"));
int line = -1;
while((line = br.read()) != -1){
bw.write(line);
//字符流写入的时候要刷新
bw.flush();
}
br.close();
bw.close();
//这里介绍两个比较好用的方法
//读取文本中的一行，返回String 结束返回null
String readLine = br.readLine();
//向文本中写入换行
bw.newLine();
bw.write("\r\n");//这个也是向文本中写入换行
//但是 newLine更好，因为它可以跨平台
//\r\n是win系统的换行 Linux下是 \r
}
}
三，转换流：
1，InputStreamReader是字节流通向字符流的轴向，读取字节相连其解码为字符。
2，OutputStreamWriter是字符流通向字节流的轴向，将要写入流中的字符编码成字节。
总结：有了这两个转换流就可以完成所有的转换。
1，读取字符转换成字节
2，读取字节转换成字符
用代码展示这两种转换：
package note.basics.demo;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
/*
* 这两个转换流都有两个构造方法：
* 1、一个是一个参数的，是相对应的流
* 2、另一个是两个参数的，第一个参数是相对应的流，第二个参数是指定编码
* 默认编码是GBK，只有GBK和utf-8两种，不区分大小写
*
* 它们都有一个方法 getEncoding(),返回当前转换流使用的编码
*
*/
public class Demo {
public static void main(String[] args) throws IOException {
fun();
fun1();
}
//向文件中写入字符
public static void fun() throws IOException{
FileWriter fw = new FileWriter("d:\\aa.txt");
fw.write("你好");
fw.close();
}
//将写入的字符变成字节
public static void fun1() throws IOException{
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d:\\bb.txt"),"UTF-8");
osw.write("你好");
osw.close();
}
//读取字节转换成字符
public static void fun2() throws IOException{
InputStreamReader isr = new InputStreamReader(new FileInputStream("d:\\bb.txt"),"utf-8");
int line = -1;
while((line = isr.read()) != -1){
System.out.print((char)line);
}
isr.close();
}
/*
* 结果：
* fun2()函数去读aa.txt文件的时候打印出来的结果是 ???
* fun2()函数去读bb.txt文件的时候打印出来的结果是 你好
*
* 结论：
* OutputStreamWriter流成功把字符转换成了字节
* OutputStreamWriter流成功把字节转换成了字符
*
*/
} 四，打印流
1，PrintStream继承OutputStream
2，PrintWriter继承Writer
特点：
1，此流不负责数据源，只负责数据目的
2，为其他输出流，添加功能
3，永远不会引发IOException，但是可能引发别的异常
package note.basics.io;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
/*
* 打印流
* PrintStream
* PrintWriter
*
* 两个打印流的方法，完全一致
* 构造方法就是打印流的输出目的端
* PrintStream
* 构造方法：接受File类型，接受字符串文件名，接受字节输出流OutputStream
* PrintWriter
* 构造方法：接受File类型，接受字符串文件名，接受字节输出流OutputStream，接受字符输出流Writer
*/
public class io15 {
public static void main(String[] args) throws IOException {
fun3();
}
/*
* 打印流，向File对象的数据目的写入数据
* 方法print println 原样输出
* write 走码表
*/
public static void fun() throws FileNotFoundException{
File file = new File("d:\\1.txt");
PrintWriter pw = new PrintWriter(file);
pw.print(100);
pw.close();
}
/*
* 打印流，输出目的，String文件名
*/
public static void fun1() throws FileNotFoundException{
PrintWriter pw = new PrintWriter("d:\\2.txt");
pw.println(3.5);
pw.close();
}
/*
* 打印流，输出目的，是流对象
* 可以是字节输出流，可以是字符的输出流
* OutputStream Writer
*/
public static void fun2() throws FileNotFoundException{
FileOutputStream fos = new FileOutputStream("d:\\3.txt");
PrintWriter pw = new PrintWriter(fos);
pw.print("dada");
pw.close();
}
/*
* 打印流，可以开启自动刷新功能
* 满足2个条件：
* 1、输出的数据目的必须是流对象
* OutputStream Writer
* 2、必须调用println，printf，format三个方法中的一个，启用自动刷新
*
*/
public static void fun3() throws IOException{
FileOutputStream fos = new FileOutputStream("d:\\5.txt");
PrintWriter pw = new PrintWriter(fos,true);
pw.println("d");
pw.println("a");
pw.println("s");
pw.println("f");
pw.close();
}
}
京公网安备 11010502036488号