java中的输入输出流3
一.常用的字符输入与字符输出流类
1.字符输出流—顶级类Writer
public abstract class Writer—不能new
1.1 FileWriter — 方便写字符文件
构造方法：
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
FileWriter(String fileName, boolean append) 给一个String对象构造一个是否允许追加FileWriter对象。
例如：
package com.wangxing.Test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestWriter {
public static void main(String[] args)throws Exception {
//字符输出流
//由于Writer---不能new 所以需要FileWriter子类
//FileWriter构造方法：
/*
FileWriter(File file) 给一个File对象构造一个FileWriter对象。
FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
FileWriter(String fileName, boolean append) 给一个String对象构造一个是否允许追加FileWriter对象。
*/
//FileWriter(File file) 给一个File对象构造一个FileWriter对象。
String stu="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(stu);
FileWriter out1=new FileWriter(file);
// ||
FileWriter out11=new FileWriter(new File("D:"+File.separator+"Develop"+File.separator+"test1.txt"));
// 上转型
Writer out111=new FileWriter(file);
//FileWriter(String fileName) 给一个String对象构造一个FileWriter对象。
FileWriter out2=new FileWriter(stu);
FileWriter out22=new FileWriter("D:"+File.separator+"Develop"+File.separator+"test1.txt");
Writer out222=new FileWriter(stu);
//FileWriter(File file, boolean append) 给一个File对象构造一个是否允许追加FileWriter对象。
String stu1="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file2=new File(stu);
FileWriter out3=new FileWriter(file,true);
// ||
FileWriter out33=new FileWriter(new File("D:"+File.separator+"Develop"+File.separator+"test1.txt"),true);
// 上转型
Writer out333=new FileWriter(file,true);
//FileWriter(String fileName, boolean append) 给一个String对象构造一个是否允许追加FileWriter对象。
FileWriter out4=new FileWriter(stu,true);
FileWriter out44=new FileWriter("D:"+File.separator+"Develop"+File.separator+"test1.txt",true);
Writer out444=new FileWriter(stu,true);
}
}
实例方法
void write(char[] cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分。
void close() 关闭流，先刷新。
void flush() 刷新流。
例如：
package com.wangxing.Test1;
import java.io.File;
import java.io.FileWriter;
import java.io.Writer;
public class TestWriter2 {
public static void main(String[] args)throws Exception {
//FirleWriter实例方法:
/*
* void write(char[] cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分。
void close() 关闭流，先刷新。
void flush() 刷新流。
*/
//创建输入流：
String stu="D:"+File.separator+"Develop"+File.separator+"test1.txt";
FileWriter out1=new FileWriter(stu,true);
//准备要写入的数据
String info="Hello,World";
//void write(char[] cbuf) 写入一个字符数组。
//char[]数组
char ch[]=info.toCharArray();
out1.write(ch);
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
out1.write(ch,5,6);//数组第五个元素开始写6个
//void write(int c) 写一个字符
out1.write(97);//a
//void write(String str) 写一个字符串
String stu2="你好2021,再见2020";
out1.write(stu2);
//void write(String str, int off, int len) 写一个字符串的一部分。
out1.write(stu2,7,6);
//刷新，关流
out1.flush();
out1.close();
}
}
2.字符输入流—顶级类Reader
public abstract class Reader—不能new
2.1 FileReader—读取字符文件的
构造方法
FileReader(File file) 创建一个新的 FileReader ，给出 File读取。
FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。
例如：
package com.wangxing.Test1;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
public class TestFileReader1 {
public static void main(String[] args)throws Exception{
//字符输入流
//public abstract class Reader---不能new
//所以运用子类FileReader
//构造方法：
/*
FileReader(File file) 创建一个新的 FileReader ，给出 File读取。
FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。
*/
String path="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(path);
FileReader in1=new FileReader(file);
FileReader in11=new FileReader(new File("D:"+File.separator+"Develop"+File.separator+"test1.txt"));
Reader in111=new FileReader(file);
//FileReader(String fileName)创建一个新的 FileReader ，给定要读取的文件的名称。
FileReader in2=new FileReader(path);
FileReader in22=new FileReader("D:"+File.separator+"Develop"+File.separator+"test1.txt");
Reader in222=new FileReader(path);
}
}
实例方法：
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
例如：
package com.wangxing.Test1;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class TestFileReader2 {
public static void main(String[] args) throws Exception {
//FileReader的实例方法：
/*
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
*/
//创建对象
String path="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(path);
FileReader in1=new FileReader(file);
//int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
//创建char数组
char ch[]=new char[(int) file.length()];
int len=in1.read(ch);
System.out.println(len);
//打印在Console
String info=new String(ch, 0, len);
System.out.println(info);
//关流
in1.close();
// //int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
// char cha[]=new char[(int) file.length()];
// //保存每一次读取的字符数据
// int data=0;
// //定义数据访问下标
// int len1=0;
// while((data=in1.read())!=-1){
// cha[len1]=(char) data;
// len1++;
// }
// //关流
// in1.close();
// //输出
// String info2=new String(cha,0,len1);
// System.out.println(info2);
}
}
1.2 public class BufferedWriter—将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
构造方法：
BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
例如：
package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedWriter1 {
public static void main(String[] args) throws IOException {
//BufferedWriter---将文本写入字符输出流，缓冲字符，以提供单个字符，数组和字符串的高效写入。
//构造方法：
/*
* BufferedWriter(Writer out) 创建使用默认大小的输出缓冲区的缓冲字符输出流。
* BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
*/
//FileWriter(File file) 给一个File对象构造一个FileWriter对象。
String stu="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(stu);
FileWriter out1=new FileWriter(file);//底层字符输出流
BufferedWriter bout1=new BufferedWriter(out1);//高级字符输出流
//BufferedWriter(Writer out, int sz) 创建一个新的缓冲字符输出流，使用给定大小的输出缓冲区。
BufferedWriter bout2=new BufferedWriter(out1,100);//高级字符输出流
}
}
实例方法：
void close() 关闭流，先刷新。
void flush() 刷新流。
void newLine() 写一行行分隔符。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String s, int off, int len) 写一个字符串的一部分。
例如：
package com.wangxing.test2;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedWriter2 {
public static void main(String[] args) throws IOException {
//BufferedWriter实例方法：
/*
void close() 关闭流，先刷新。
void flush() 刷新流。
void newLine() 写一行行分隔符。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String s, int off, int len) 写一个字符串的一部分。
*/
//创建字符输出流对象
String path="D:"+File.separator+"Develop"+File.separator+"msg.txt";
File file=new File(path);
FileWriter out=new FileWriter(file); //底层字符输出流
BufferedWriter bout1=new BufferedWriter(out);//高级字符输出流
//准备输出的数据
String info1="hello,world";
String info2="hello,world";
//void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
char[] ch=info1.toCharArray();
bout1.write(ch,0,5);
//void write(int c) 写一个字符
bout1.write(97);
//void write(String s, int off, int len) 写一个字符串的一部分。
bout1.write(info2,6,5);
//void newLine() 写一行行分隔符。
bout1.newLine();
bout1.write(info2, 0, info2.length());
//刷新，关流
bout1.flush();
bout1.close();
out.close();
}
}
2.2 public class BufferedReader–从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
构造方法:
BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
例如：
package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
public class TestBufferedReader1 {
public static void main(String[] args)throws Exception {
// 从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。
//BufferedReader构造方法:
/*
* BufferedReader(Reader in) 创建使用默认大小的输入缓冲区的缓冲字符输入流。
* BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
*/
String path="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(path);
FileReader in=new FileReader(file);
BufferedReader bin1=new BufferedReader(in);
//BufferedReader(Reader in, int sz) 创建使用指定大小的输入缓冲区的缓冲字符输入流。
BufferedReader bin2=new BufferedReader(in,100);
}
}
实例方法：
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
String readLine() 读一行文字。
例如：
package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
public class TestBufferedReader2 {
public static void main(String[] args) throws Exception {
// BufferedReader的实例方法：
/*
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
String readLine() 读一行文字。
*/
String path="D:"+File.separator+"Develop"+File.separator+"test1.txt";
File file=new File(path);
FileReader in=new FileReader(file);
BufferedReader bin1=new BufferedReader(in);
// //int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
// char ch[]=new char[(int) file.length()];
// int len=bin1.read(ch);
// String info=new String(ch,0,len);
// System.out.println(info);
// //关流
// bin1.close();
// //int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
// //保存每一次读取的字符数据
// char cha[]=new char[(int) file.length()];
// int data=0;
// //下标/索引
// int len2=0;
// while((data=bin1.read())!=-1){
// cha[len2]=(char) data;
// len2++;
// }
// bin1.close();
// String info1=new String(cha, 0, len2);
// System.out.println(info1);
//String readLine() 读一行文字。
//定义保存每一行数据的字符串变量
String line=null;
while((line=bin1.readLine())!=null) {
System.out.println(line);
}
bin1.close();
in.close();
}
}
使用BufferedReader的readLine方法来代替Scanner类的nextLine方法从控制台不去数据
package com.wangxing.test2;
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestBufferedReader3 {
public static void main(String[] args) throws Exception{
// 使用bufferedReader的leadLine方法替代Scanner
BufferedReader bin1=new BufferedReader(new InputStreamReader(System.in));
System.out.println("请输入姓名:");
String name=bin1.readLine();
System.out.println("你输入的姓名是==="+name);
}
}
1.3 public class OutputStreamWriter—将字节输出流转换成字符输出流
构造方法：
OutputStreamWriter(OutputStream out) 将字节输出流转换成字符输出流
实例方法：
void write(char[] cbuf) 写入一个字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
void write(int c) 写一个字符
void write(String str) 写一个字符串
void write(String str, int off, int len) 写一个字符串的一部分。
void close() 关闭流，先刷新。
void flush() 刷新流。
package com.wangxing.test3;
import java.io.File;
import java.io.FileOutputStream;
import java.io.OutputStreamWriter;
public class OutputStreamWritertest1 {
public static void main(String[] args)throws Exception {
// OutputStreamWriter---将字节输出流转换成字符输出流
//构造方法：
//OutputStreamWriter(OutputStream out) 将字节输出流转换成字符输出流
//创建OutputStream对象
String path="D:"+File.separator+"Develop"+"mas.txt";
File file=new File(path);
FileOutputStream out1=new FileOutputStream(file);
//创建OutputStreamWriter对象
OutputStreamWriter owtiter=new OutputStreamWriter(out1);
//创建数据
String stu="Hello,World";
//实例方法：
/*
* void write(char[] cbuf) 写入一个字符数组。
* void write(char[] cbuf, int off, int len) 写入字符数组的一部分。
* void write(int c) 写一个字符
* void write(String str) 写一个字符串
* void write(String str, int off, int len) 写一个字符串的一部分。
* void close() 关闭流，先刷新。
* void flush() 刷新流。
*/
owtiter.write(stu);
//刷新,关流
owtiter.flush();
owtiter.close();
out1.close();
}
}
2.3 public class InputStreamReader—将字节输入流转换成字符输入流
构造方法：
InputStreamReader(InputStream in) 将字节输入流转换成字符输入流
实例方法：
int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
void close() 关闭流并释放与之相关联的任何系统资源。
例如：
package com.wangxing.test3;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
public class InputStreamReadertest1 {
public static void main(String[] args) throws Exception{
// InputStreamReader将字节输入流转换成字符输入流
//构造方法：
//InputStreamReader(InputStream in) 将字节输入流转换成字符输入流
//创建InputStream对象
String path="D:"+File.separator+"Develop"+"mas.txt";
FileInputStream in=new FileInputStream(path);
//创建InputStreamReader对象
InputStreamReader ireader=new InputStreamReader(in);
BufferedReader bin=new BufferedReader(ireader);
//实例方法：
/*
* int read() 读一个字符。返回值是读取的真实字符数据的整数值，如果已经达到流的末尾，则为-1。
* int read(char[] cbuf) 将字符读入数组。返回总字符数，如果到达文件末尾返回-1
* void close() 关闭流并释放与之相关联的任何系统资源。
*/
//保存数据的字符串
String stu=null;
while ((stu=bin.readLine())!=null) {
System.out.println(stu);
}
bin.close();
ireader.close();
}
}
输入输出流的操作步骤
输入输出的操作步骤:
1.创建文件对象【File对象】，指定输入输出的位置
2.创建输入输出流对象
- 1.文本选字符流，其他的选字节
- 2.读取选输入，保存选输出
- 3.调用read()/write()方法
- 4.关闭流
javaSE---输入输出流3