PrintWriter:是具有自动行刷新的缓冲字符输出流，这是一个高级流。所谓的自动行刷新，意思就是说：在构造函数中指定
autoFlush的值为true时，则println()、printf()或format()方法将自动刷新输出缓冲区(自动调用flush()方法)，但是,自动行刷新无疑会增加写出次数而降低写出效率。
构造函数
//使用指定文件创建不具有自动行刷新的新 PrintWriter
public PrintWriter(File file);
//创建具有指定文件和字符集且不带自动刷行新的新 PrintWriter
public PrintWriter(File file,String csn);
//根据现有的 OutputStream 创建不带自动行刷新的新 PrintWriter
public PrintWriter(OutputStream out);
//通过现有的 OutputStream 创建新的 PrintWriter(具有自动行刷新)
public PrintWriter(OutputStream out,boolean autoFlush);
//创建具有指定文件名称且不带自动行刷新的新 PrintWriter
public PrintWriter(String fileName);
//创建具有指定文件名称和字符集且不带自动行刷新的新 PrintWriter
public PrintWriter(String fileName,String csn);
//创建新 PrintWriter(具有自动行刷新)
public PrintWriter(Writer out,boolean autoFlush);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
从PrintWeiter的构造方法中我们就可以知道，该高级流很灵活，接下来我们会介绍BufferedWriter/BufferedReader这一对字符缓冲流，但是，由于BufferedWriter没有PrintWriter使用灵活，所以在实际的操作中，我们往往会使用PrinterWriter/BufferedReader这种组合。
常用的方法
//打印boolean值
public void print(boolean b);
//打印 boolean 值，然后终止该行
public void println(boolean x);
//打印字符
public void print(char c);
//打印字符，然后终止该行
public void println(char x);
//打印字符数组
public void print(char[] s);
//打印字符数组，然后终止该行
public void println(char[] x);
//打印 double 精度浮点数
public void print(double d);
//打印 double 精度浮点数,然后终止该行
public void println(double x);
//打印一个浮点数
public void print(float f);
//打印浮点数，然后终止该行
public void println(float x);
//打印整数
public void print(int i);
//打印整数，然后终止该行
public void println(int x);
//打印 long 整数
public void print(long l);
//打印 long 整数，然后终止该行
public void println(long x);
//打印对象
public void print(Object obj);
//打印 Object，然后终止该行
public void println(Object x);
//打印字符串。如果参数为 null，则打印字符串 "null"
public void print(String s);
//打印 String，然后终止该行
public void println(String x);
//通过写入行分隔符字符串终止当前行
public void println();
//使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。如果启用自动刷新，则调用此方法将刷新输出缓冲区
public PrintWriter format(Locale l,String format,Object... args);
//使用指定格式字符串和参数将一个格式化字符串写入此 writer 中。如果启用自动刷新，则调用此方法将刷新输出缓冲区
public PrintWriter format(String format,Object... args);
//将指定字符添加到此 writer
public PrintWriter append(char c);
//将指定的字符序列添加到此 writer
public PrintWriter append(CharSequence csq);
//将指定字符序列的子序列添加到此 writer
public PrintWriter append(CharSequence csq,int start,int end);
//写入字符数组
public void write(char[] buf);
//写入字符数组的某一部分
public void write(char[] buf,int off,int len);
//写入单个字符
public void write(int c);
//写入字符串
public void write(String s);
//写入字符串的某一部分
public void write(String s,int off,int len);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
将字符串写到文件中
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
/** * PrintWriter:是具有自动行刷新的缓冲字符输出流(高级流) * @author Administrator * */
public class PWDemo01 {
public static void main(String[] args) {
try {
//打开文件
FileOutputStream fos=new FileOutputStream("pw.txt");
//设置编码集
OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
/** * 创建具有自动刷新的PrinterWriter后，每当我们使用println()/print() * 方法写出字符串后，都会自动调用flush()方法 * 但是,这个无疑会增加写出次数而降低写出效率 */
//写出数据
PrintWriter pw=new PrintWriter(osw, true);
pw.println("字符缓冲");
pw.append("测试数据");
pw.write("哈哈哈");
pw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
BufferedWriter的使用
BufferedWriter:字符缓冲输出流(高级流),将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。 可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。
构造方法
//创建一个使用默认大小输出缓冲区的缓冲字符输出流
public BufferedWriter(Writer out);
//创建一个使用给定大小输出缓冲区的新缓冲字符输出流
public BufferedWriter(Writer out,int sz);
- 1
- 2
- 3
- 4
- 5
常用的方法
//写入字符数组的某一部分
public void write(char[] cbuf,int off,int len);
//写入单个字符
public void write(int c);
//写入字符串的某一部分
public void write(String s,int off,int len);
//写入一个行分隔符
public void newLine();
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
将字符串写入到文件中
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
/** * BufferedWriter:字符缓冲输出流(高级流) * @author 作者 E-mail:1832567496@qq.com * @date 创建时间：2016年10月9日 上午11:10:21 * @version 1.0 * @parameter * @since * @return */
public class BWDemo01 {
public static void main(String[] args) {
try {
//打开文件
FileOutputStream fos=new FileOutputStream("pw.txt");
//设置编码集
OutputStreamWriter osw=new OutputStreamWriter(fos,"UTF-8");
//将字符输出流包装为字符缓冲输出流
BufferedWriter bw=new BufferedWriter(osw);
bw.write("BW测试文字");
bw.append("BWBWBWBWBW");
bw.flush();
bw.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
从BufferedWriter的构造函数和常用的方法中可以看出来，BufferedWriter的使用相比较PrinterWriter来讲就比较简单了，所以在应用中我们一般不使用BufferedWriter而是使用PrinterWriter，大家知道BufferedWriter即可。
BufferedReader的使用
BufferedReader:缓冲字符输入流，高级流。从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。可以以行为单位读取字符串。
构造函数
//创建一个使用默认大小(8192)输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in);
//创建一个使用指定大小输入缓冲区的缓冲字符输入流
public BufferedReader(Reader in,int sz);
- 1
- 2
- 3
- 4
- 5
常用的方法
//读取单个字符
public int read();
//读入字符数组中的某一部分
public int read(char[] cbuf,int off,int len);
//读取一个文本行
public String readLine();
//跳过字符
public long skip(long n);
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
从文件中读取文本数据
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.InputStreamReader;
/** * BufferedReader:缓冲字符输入流，高级流 * 从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。 * 可以以行为单位读取字符串 * @author Administrator * */
public class BRDemo01 {
public static void main(String[] args) {
try {
/** * 逐个字符的读取 */
FileInputStream fis=new FileInputStream("pw.txt");
InputStreamReader isr=new InputStreamReader(fis, "UTF-8");
BufferedReader br=new BufferedReader(isr);
int size=0;
while((size=br.read())!=-1){
char content=(char)size;
System.out.println(content);
}
/** * 整行读取 */
FileInputStream fis1=new FileInputStream("pw.txt");
InputStreamReader isr1=new InputStreamReader(fis1, "UTF-8");
BufferedReader br1=new BufferedReader(isr1);
String isNull=null;
/** * public String readLine() * 该方法的返回值如果为null，则说明已经读到文件的末尾了 */
while((isNull=br1.readLine())!=null){
System.out.println(isNull);
}
br.close();
br1.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
使用PrintWriter/BufferedReader实现文件的复制
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
public class SummaryPWAndBR {
public static void main(String[] args) {
/** * 使用字符缓冲输入流和字符缓冲输出流实现文件的复制 * 1.打开文件 * 2.设置字符集 * 3.进行读写操作 * 4.关闭流 */
try {
long begin=System.currentTimeMillis();
//打开源文件
FileInputStream fis=new FileInputStream("pwSrc.txt");
//设置字符集
InputStreamReader isr=new InputStreamReader(fis, "UTF-8");
//从源文件读入数据
BufferedReader br=new BufferedReader(isr);
//打开目标文件
FileOutputStream fos=new FileOutputStream("pwDest.txt");
//设置字符集
OutputStreamWriter osw=new OutputStreamWriter(fos, "UTF-8");
//写入数据到目标文件
PrintWriter pw=new PrintWriter(osw, true);
int size=0;
char[] buffer=new char[10240];
while((size=br.read(buffer, 0, buffer.length))!=-1){
pw.write(buffer, 0, size);
}
br.close();
pw.close();
long end=System.currentTimeMillis();
System.out.println("使用字符缓冲输入流实现文件的复制完毕！耗时："+(end-begin)+"毫秒");
} catch (Exception e) {
e.printStackTrace();
}
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
运行结果：
以上内容只代表我个人的观点，有什么错误的地方请各路大神指正！
每天进步一点点!
京公网安备 11010502036488号