Java--IO流(FileReader，FileWriter)

最新推荐文章于 2024-03-17 08:58:09 发布

MinggeQingchun

最新推荐文章于 2024-03-17 08:58:09 发布

阅读量664

点赞数 1

分类专栏： JavaSE 文章标签： IO流FileReader FileWriter

本文链接：https://blog.csdn.net/MinggeQingchun/article/details/60876312

版权

JavaSE 专栏收录该内容

154 篇文章 38 订阅

订阅专栏

一、字符流FileReader

字符流是可以直接读写字符的IO流

字符流读取字符, 就要先读取到字节数据, 然后转为字符

如果要写出字符, 需要把字符转为字节再写出

二、字符流使用场景

1、字符流也可以拷贝文本文件, 但不推荐使用。因为读取时会把字节转为字符, 写出时还要把字符转回字节。

程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流

读取的时候是按照字符的大小读取的,不会出现半个中文

写出的时候可以直接将字符串写出,不用转换为字节数组

2、字符流不可以拷贝非纯文本的文件

因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,

写出的时候会将字符转换成字节写出去；如果是?,直接写出,这样写出之后的文件就乱了,看不了了

三、带缓冲的字符流

1、BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区, 然后逐个返回给程序,

降低读取文件的次数, 提高效率

2、BufferedWriter的write()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件,

降低写文件的次数, 提高效率

四、readLine()和newLine()方法

BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)

BufferedWriter的newLine()可以输出一个跨平台的换行符号"\r\n"

newLine()与\r\n区别：

newLine()是跨平台方法

\r\n只支持Windows系统

五、递归好处：不需要知道循环次数

递归坏处：如果调用次数过多，导致栈内存溢出

构造方法不能使用递归调用

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.LineNumberReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.TreeMap;

public class FileReaderAndWriter {
	public static void main(String[] args) throws IOException {
		/*
		 * 一、字符流FileReader
		 		字符流是可以直接读写字符的IO流
				字符流读取字符, 就要先读取到字节数据, 然后转为字符
				如果要写出字符, 需要把字符转为字节再写出
		        二、字符流使用场景
		   1、字符流也可以拷贝文本文件, 但不推荐使用。因为读取时会把字节转为字符, 写出时还要把字符转回字节。
			           程序需要读取一段文本, 或者需要写出一段文本的时候可以使用字符流
				读取的时候是按照字符的大小读取的,不会出现半个中文
				写出的时候可以直接将字符串写出,不用转换为字节数组
		   2、字符流不可以拷贝非纯文本的文件
				因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,
				写出的时候会将字符转换成字节写出去；如果是?,直接写出,这样写出之后的文件就乱了,看不了了
		   二、带缓冲的字符流
		   1、BufferedReader的read()方法读取字符时会一次读取若干字符到缓冲区, 然后逐个返回给程序, 
		   降低读取文件的次数, 提高效率
		   2、BufferedWriter的write()方法写出字符时会先写到缓冲区, 缓冲区写满时才会写到文件, 
		   降低写文件的次数, 提高效率
		   三、readLine()和newLine()方法
		   BufferedReader的readLine()方法可以读取一行字符(不包含换行符号)
		   BufferedWriter的newLine()可以输出一个跨平台的换行符号"\r\n"
		   newLine()与\r\n区别：
		    		newLine()是跨平台方法
		    		\r\n只支持Windows系统
		   四、递归好处：不需要知道循环次数
		   递归坏处：如果调用次数过多，导致栈内存溢出
		   构造方法不能使用递归调用
		 * */
		fileReader();
		fileWrite();
		fileCopy();
		imageCopy();
		customArr();//自定义数组
		buffer();//缓冲区
		readerLine();
		newerLine();
		reverseText();//反转文本
		lineNumber();
		design();//装饰设计模式好处：耦合性不强，被装饰的类的变化与装饰类的变化无关
		codeStyle();//指定编码表
		countChar();//统计字符
		deCount();
		System.out.println("===============递归================");
		System.out.println("递归:" + digui(4));
//		System.out.println("递归:" + digui(1000000));
		//java.lang.StackOverflowError;如果调用次数太多导致栈内存溢出
		System.out.println("===============获取.java文件路径(递归)================");
		File dir = getDir();
		printJavaFile(dir);
	}

	public static void printJavaFile(File dir) {
		File[] fileArr = dir.listFiles();
		for (File subFile : fileArr) {
			if(subFile.isFile() && subFile.getName().endsWith(".java")){
				System.out.println(subFile);
			}else if(subFile.isDirectory()){
				printJavaFile(subFile);
			}
		}
	}

	public static File getDir() {
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入一个文件夹路径：");
		while(true){
			String line = sc.nextLine();
			File dir = new File(line);
			if(!dir.exists()){
				System.out.println("您输入的文件夹不存在，请重新录入：");
			}else if(dir.isFile()){
				System.out.println("您输入的是一个文件，请重新录入一个文件夹：");
			}else{
				return dir;
			}
		}
	}

	private static int digui(int num) {
		if (num == 1){
			return 1;
		}else{
			return num * digui(num - 1);
		}
	}

	private static void deCount() throws IOException {
		System.out.println("===============数减少================");
		BufferedReader br = new BufferedReader(new FileReader("c.txt"));
		String line = br.readLine();
		int count = Integer.parseInt(line);
		if(count > 0){
			System.out.println("您还有" + count-- + "次机会");
			FileWriter fw = new FileWriter("c.txt");
			fw.write(count + "");
			fw.close();
		}else{
			System.out.println("请购买正版");
		}
	}

	private static void countChar() throws IOException {
		System.out.println("===============统计字符个数================");
		BufferedReader br = new BufferedReader(new FileReader("aa.txt"));
		TreeMap<Character, Integer> tr = new TreeMap<>();
		int b;
		while((b = br.read()) != -1){
			char c = (char)b;
			if(!tr.containsKey(c)){
				tr.put(c, 1);
			}else{
				tr.put(c, tr.get(c) + 1);
			}
		}
		br.close();
		for (Character key : tr.keySet()) {
			System.out.println(key + "--" + tr.get(key));
		}
	}

	private static void codeStyle() throws IOException, FileNotFoundException {
		System.out.println("===============指定编码表================");
		BufferedReader br = 
				new BufferedReader(new InputStreamReader(new FileInputStream("utf-8.txt"),"UTF-8"));
		BufferedWriter bw = 
				new BufferedWriter(new OutputStreamWriter(new FileOutputStream("gbk.txt"),"gbk"));
		int c;
		while((c = br.read()) != -1){
			bw.write(c);
		}
		br.close();
		bw.close();
	}

	private static void design() {
		System.out.println("===============装饰设计模式================");
		SocialStudent s = new SocialStudent(new Student());
		s.code();
	}

	private static void lineNumber() throws IOException {
		System.out.println("===============设置行号================");
		LineNumberReader lnr = new LineNumberReader(new FileReader("aa.txt"));
		String line;
		lnr.setLineNumber(100);
		while((line = lnr.readLine()) != null){
			System.out.println(lnr.getLineNumber() + ":" + line);
		}
		lnr.close();
	}

	private static void reverseText() throws IOException {
		System.out.println("===============反转文本================");
		BufferedReader br = new BufferedReader(new FileReader("aa.txt"));
		String line;
		ArrayList<String> list = new ArrayList<>();
		while((line = br.readLine()) != null){
			list.add(line);
		}
		br.close();
		BufferedWriter bw = new BufferedWriter(new FileWriter("aaRever.txt"));
		for (int i = list.size() - 1;i >= 0;i--) {
			bw.write(list.get(i));
			bw.newLine();
		}
		bw.close();
	}

	private static void newerLine() throws IOException {
		System.out.println("===============newLine================");
		BufferedReader br = new BufferedReader(new FileReader("aa.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));
		String line;
		while((line = br.readLine()) != null){
			bw.write(line);
			bw.newLine();//newLine()是跨平台方法,\r\n只支持Windows系统
		}
		br.close();
		bw.close();
	}

	private static void readerLine() throws IOException {
		System.out.println("===============readLine================");
		BufferedReader br = new BufferedReader(new FileReader("aa.txt"));
		String line;
		while((line = br.readLine()) != null){
			System.out.println(line);
		}
		br.close();
	}

	private static void buffer() throws IOException {
		BufferedReader br = new BufferedReader(new FileReader("aaa.txt"));
		BufferedWriter bw = new BufferedWriter(new FileWriter("bbb.txt"));
		int c;
		while((c = br.read()) != -1){
			bw.write(c);
		}
		br.close();
		bw.close();
	}

	private static void customArr() throws IOException {
		FileReader fr = new FileReader("aaa.txt");
		FileWriter fw = new FileWriter("bbb.txt");
		char[] arr = new char[1024 * 8]; 
		int len;
		while((len = fr.read(arr)) != -1){
			fw.write(arr, 0, len);
		}
		fr.close();
		fw.close();
	}

	private static void imageCopy() throws IOException {
		/*
		 * 字符流不可以拷贝非纯文本的文件
			因为在读的时候会将字节转换为字符,在转换过程中,可能找不到对应的字符,就会用?代替,
			写出的时候会将字符转换成字节写出去；如果是?,直接写出,这样写出之后的文件就乱了,看不了了
		 * */
		FileReader fr = new FileReader("11.jpg");
		FileWriter fw = new FileWriter("22.jpg");
		int c;
		while((c = fr.read()) != -1){
			fw.write(c);
		}
		fr.close();
		fw.close();
	}

	private static void fileCopy() throws IOException {
		FileReader fr = new FileReader("b.txt");
		FileWriter fw = new FileWriter("bbb.txt");
		int c;
		while((c = fr.read()) != -1){
			fw.write(c);
		}
		fr.close();
		fw.close();
		//Write类中有一个2K的小缓冲区，如果不关闭，就会将内容写到缓冲区里，关流会将缓冲区内容刷新再关闭
	}

	private static void fileWrite() throws IOException {
		FileWriter fw = new FileWriter("aaa.txt");
		fw.write("我读书少啊，千万别骗我啊");
		fw.close();
	}

	public static void fileReader() throws FileNotFoundException, IOException {
		FileReader fr = new FileReader("aa.txt");
		int c;
		while((c = fr.read()) != -1){
			System.out.print((char)c);
		}
		fr.close();
	}
}

/*---------------------装饰设计模式-----------------------*/
interface Coder{
	public void code();
}

class Student implements Coder{
	public void code(){
		System.out.println("C");
		System.out.println("C++");
		System.out.println("Java");
	}
}

class SocialStudent implements Coder{
	//1、获取被装饰类的引用
	private Student s;
	
	//2、在构造方法中传入被装饰类的对象
	public SocialStudent(Student s){
		this.s = s;
	}
	
	//3、对原有功能进行升级
	public void code(){
		s.code();
		System.out.println("iOS");
		System.out.println("Android");
		System.out.println("JavaEE");
	}
}