/*一，FileWriter
*1.字节流的两个基类
*Inputstream
*OutputStream
* 字符流的两个基类
*Reader
*Writer
*如果操作文字数据，优先字符流
*实例
import java.io.FileWriter;
import java.io.IOException;
public class 字符流 {
public static void main(String []args) throws IOException {
//创建FileWriter实例对象，若此对象已经存在，则覆盖其中内容,如果文件不存在则创建文件
FileWriter file=new FileWriter("demo1.txt",true);
//数据写入被临时存储到流中,临时存储缓冲区
file.write("haaavcasfcsdfsfdsfdsf");
//进行刷新将字符写入到目标文件中
file.flush();//刷新该流的缓冲，立即将缓冲区中的数据存储的目标文件中
//关闭此流后不再进行操作，在关闭前会调用flush刷新缓冲中的数据到目标文件
file.close();//关闭流，将无法再进行一系列的流操作
}
}
2.细节(换行，续写)
*FileWriter file=new FileWriter("demo1.txt",true);//续写构造方式,在原来文件不改变的情况下，添加内容
*file.writer("aaaaa\r\nbbbbbbbbb");//windows系统中的换行
*另一种适用于所有操作系统的换行方式
*定义：private static final String LINE_SEPARATOR=System.getProperty("line.separator");
*实例
import java.io.FileWriter;
import java.io.IOException;
public class 字符流 {
private static final String LINE_SEPARATOR=System.getProperty("line.separator");
public static void main(String []args) throws IOException {
//向已经存在的demo1.txt文件中续写
FileWriter file=new FileWriter("demo1.txt",true);
//续写并且实现了换行
file.write("haaavcasfcsdfsfdsfdsf"+LINE_SEPARATOR+"zhaozhaozhaio");
file.close();
}
}
3.IO异常处理
import java.io.FileWriter;
import java.io.IOException;
public class 字符流 {
private static final String LINE_SEPARATOR=System.getProperty("line.separator");
public static void main(String []args) {
FileWriter file=null;//try的外面创建流引用
try {
file = new FileWriter("c://demo1.txt");//由与不存在该文件，抛出FileNotFoundException异常
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
file.write("haaavcasfcsdfsfdsfdsf"+LINE_SEPARATOR+"zhaozhaozhaio");
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
file.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
finally {
if(file!=null)
try {
file.close();
} catch (IOException e) {
throw new RuntimeException("关闭失败");
}//此处可能出现空指针异常
}
}
}
*/
/*二，FileReader
* 1.读取方式一(读取单个字符)
* (1)用于读取字符文件的便捷类
* (2)使用read读取文件内容时， 若读取结束返回-1
*实例：
import java.io.*;
public class 字符流
{
public static void main(String[]args) throws IOException {
//创建读取字符对象的流对象，在创建读取流对象时，必须确定该文件是存在的
FileReader file=new FileReader("demo1.txt");
int num;
while((num=file.read())!=-1) {
System.out.print((char)num);
}
file.close();
}
}*2，读取方式二(读取字符数组)
*(1)使用read(char[]arr)读取文本数据
*(2)读取过程中， 将字符存储到字符数组数组,返回读取的字符的个数，如果返回值为-1则表明已经读取完成
*
import java.io.*;
//i//mport com.sun.org.apache.bcel.internal.generic.NEW;
public class 字符流
{
public static void main(String []args) throws IOException {
//建立FileWriter实例对象
FileReader file=new FileReader("demo1.txt");//该文件中存储的内容为"aabbcc"
//创建字符数组
char []s=new char[4];
int num = file.read(s);//返回读取个数，此时已经读取完前四个
System.out.println(num);//输出为4
System.out.println(new String(s));//输出为aabb
int num1 = file.read(s);//返回读取的个数
System.out. println(num1);//输出为2，因为第一次读取已经读取完前四个
System.out.println(new String(s));//输出为ccbb第一次读取完成后s为aabb第二次读取读取到两个字符，前两个字符被新读取的字符取代
int num2=file.read(s);
System.out.println(num2);输出为-1，因为所有的字符已经被读取
System.out.println(new String(s));//输出为ccbb因为没有新的字符读入
FileReader file1=new FileReader("demo2.txt");//该文件中存储的内容为"aabbcc"
//创建字符数组
char []ss=new char[4];
int len=0;
while((len=file1.read(ss))!=-1) {
System.out.println(len);
System.out.println(new String(ss,0,len));
}
}
}
* */
/*三，练习:将e盘中的数据写入到d盘中
* 1.读取方式一（按字符读入，读出）
*代码
public class 字符流
{
public static void main(String []args) throws IOException {
FileReader filein=new FileReader("E:\\ACM入门习题一百道.doc");//文件读取源
FileWriter fileout=new FileWriter("D:\\Hello.java");//创建数据存储目的地
int id=0;
while((id=filein.read())!=-1) {
fileout.write((char)id);
}//进行数据存储
filein.close();//关闭输入流
fileout.close();//关闭输出流
}
}*2.读取方式二（按照字符串读入，读出·）
*代码
public class 字符流
{
public static void main(String []args) throws IOException {
FileReader filein=null;
FileWriter fileout=null;
try {
filein=new FileReader("E:\\ACM入门习题一百道.doc");
fileout=new FileWriter("D:\\Hello.java");
}catch(IOException e){
System.out.println("无法找到文件");
}
int len=0;
char []s=new char[1024];
try {
while((len=filein.read(s))!=-1) {
fileout.write(s);
}
}catch(IOException e) {
System.out.println("文件读取过程异常");
}finally {
try {
filein.close();
fileout.close();
}catch(IOException e) {
System.out.println("流关闭异常");
}
}
}
}
*/
/*四，缓冲流的使用
* 1.字符流的缓冲区(处理流)
* (1).对于读写都有缓冲
* (2).提高了对数据读写效率
* (3).对应类
* BufferedWriter
* BufferedReader
* (4).缓冲区要结合流才能使用，在流的基础上对流的功能进行了增强
* 2.BufferedWriter
* (1)将文本写入字符输出流，缓冲各个字符，从而提供的单个字符，数组，字符串的高效写入,可以指定缓冲区大小，通常默认情况下就足够
* (2)BufferedWriter(Writer out)//创建一个默认大小输出缓冲区的缓冲字符输出流，out为被缓冲对象
* BufferedWriter(Writer out,int size)//创建一个指定大小输出缓冲区的缓冲字符输出流
* (3)代码
public class 字符流
{
private static final String LINE_SEPERATOR = System.getProperty("line.separator");//换行
public static void main(String []args) throws IOException {
FileWriter file=new FileWriter("Buffered.txt");
//为了提高写入效率，使用字符流的缓冲区
BufferedWriter buffout=new BufferedWriter(file);//仅仅提到了提高效率的作用
//使用缓冲区的方法对数据进行一系列操作能够大大提高效率
buffout.write("aaahahahahah");
buffout.newLine();//缓冲输出流的换行函数
buffout.write("haheihei");
buffout.write("sdsdsadsadsadsadsa"+LINE_SEPERATOR+"hahahahah");//将数据写入到缓冲区中
for(int i=0;i<5;i++) {
buffout.write("aaaaaaaaaa"+"............."+i);
buffout.newLine();
buffout.flush();
}
buffout.flush();//刷新缓冲区的内容，把数据全部存储到目标文件中
buffout.close();//关闭缓冲区
//file.write(1);buffout关闭，file流也会关闭,缓冲流的关闭底层是通过关闭file流实现的
}
}
*3.BufferedReader
*(1)从字符流中输入文本，缓冲各字符，从而实现字符，数组，行的高效读取
*(2)readLine()
*(3)代码
public class 字符流
{
public static void main(String []args) throws IOException {
FileReader fileReader=new FileReader("Buffered.txt");
BufferedReader fileBufferedReader=new BufferedReader(fileReader);
int len=0;
String string=null;
while((string=fileBufferedReader.readLine())!=null) {
System.out.println(string);//每次读一行
}
fileBufferedReader.close();
}
}*4.文本复制
public class 字符流
{
public static void main(String []args) throws IOException {
FileWriter fileWriter=new FileWriter("out.txt");
BufferedWriter fileBufferedWriter=new BufferedWriter(fileWriter);
FileReader fileReader=new FileReader("in.txt");
BufferedReader fileBufferedReader=new BufferedReader(fileReader);
// int ch=0;
// while((ch=fileBufferedReader.read())!=-1) {
// fileBufferedWriter.write((char)ch);
// }
String ssString=null;
while((ssString=fileBufferedReader.readLine())!=null) {
fileBufferedWriter.write(ssString);
fileBufferedWriter.newLine();
}
fileBufferedReader.close();
fileBufferedWriter.close();
}
}
*5.自定义MyBufferedReader的read方法
* (1)自定义缓冲区模拟BufferedReader
* (2)代码实现
* (3)代码
public class 字符流
{
private static final String LINE_SEPERATOR = System.getProperty("line.separator");//换行
public static void main(String []args)throws IOException {
FileReader reader=new FileReader("in.txt");
MyBufferedReader bufferedReader=new MyBufferedReader(reader);
// int ch=0;
// while((ch=bufferedReader.Myread())!=-1) {
// System.out.println((char)ch);
// }//每次读取一个字符
//每次读取一行
String string=null;
string=bufferedReader.MyreadLine();
System.out.print(string);
string=bufferedReader.MyreadLine();
System.out.print(string);
string=bufferedReader.MyreadLine();
System.out.print(string);
string=bufferedReader.MyreadLine();
System.out.print(string);
bufferedReader.Myclose();
}
}
class MyBufferedReader
{
private static final String LINE_SEPERATOR = System.getProperty("line.separator");//换行
//缓冲原理:将数据暂时存储到数组里，使用时再取出，
//定义一个reader对象
private Reader reader;
//定义一个字符数组作为缓冲区
private char[]buff=new char[1024];
//记录当前缓冲数组已到达哪个位置，当操作到最后一个元素后，归零
private int pos=0;
//计数器，记录缓冲区中的数据个数，当该数据为零时，从源中继续获取数据到缓冲区中
private int count=0;
public MyBufferedReader(Reader reader) {
this.reader=reader;
}
//读取单个字节,从缓冲区中获取
public int Myread() throws IOException {
if(count==0) {
//缓冲区中没有数据时，获取数据
count=reader.read(buff);
// System.out.println("buff..........."+count);
//每次获取数据到缓冲去pos=0
pos=0;
}
if(count<0)
return -1;
//每获取一个字符pos++，count--
char c=buff[pos];
pos++;
count--;
return c;
}
//读取一行
public String MyreadLine() throws IOException {
//储存一行的数据，暂时存储在StringBuilder
StringBuilder stringBuilder=new StringBuilder();
int ch=0;
int flag=0;
while((ch=Myread())!=-1) {
//遇到换行则说明已经读一行
if((char)ch=='\r') {
flag=1;
}
if((char)ch=='\n'&&flag==1) {
return stringBuilder.toString();
}
stringBuilder.append((char)ch);
}
if(stringBuilder.length()!=0)
return stringBuilder.toString();
return null;
}
public void Myclose() throws IOException{
reader.close();
}
}
* */
扫一扫
214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
