JavaCore IOStream字符流

Reader         所有字符输入流统一的父类   抽象类

        int read()

        int read(char[] data)

        int read(char[] data,int off,int len)

Writer                 所有字符输出流统一的父类   抽象类

        write(int data)

        write(char[] data)

        write(char[] data,int off,int len)

FileReader        输入流 字符流 节点流

FileWriter        输出流   字符流  节点流

import java.io.*;
public class TestFileReader{
	public static void main(String[] args)throws Exception{
		FileReader fis = new FileReader("abc.txt");
		int data;
		while((data = fis.read())!=-1){
			System.out.print((char)data);
		}
		fis.close();
	}
}

BufferedReader  输入流 字符流  过滤流

BufferedWriter    输出流 字符流  过滤流

        *：作为过滤流的它们给原本的流添加了变长的缓冲空间    从而实现以行为单位 的读写

        *：作为过滤流的它们   不能直接连文件  只能连接其它的流

        *：BufferedReader  String        readLine()

        *:   BufferedWriter        write(String str) + newLine()

        *:BufferedReader          以null作为读取结束的标识

import java.io.*;
public class TestBufferedWriter{
	public static void main(String[] args)throws Exception{
		BufferedWriter bw = new BufferedWriter(new FileWriter("鹅鹅鹅.txt"));
		bw.write("鹅鹅鹅");
		bw.newLine();
		bw.write("鹅项向天歌");
		bw.newLine();
		bw.write("鹅毛浮绿水");
		bw.newLine();
		bw.write("鹅可能死了");
		bw.close();
	}
}

import java.io.*;
public class ExecPrintWriter{
	public static void main(String[] args)throws Exception{
		String[] data = {"我错了","我真的错了","再也不敢了","原谅我吧"};
		PrintWriter pw = new PrintWriter("sorry.txt");
		for(int i = 0;i<9999;i++){
			int lucky = (int)(Math.random()*data.length);
			pw.println(data[lucky]);
		}
		pw.close();
	}
}

import java.io.*;
import java.util.*;
public class TestBufferedReader{
	public static void main(String[] args)throws Exception{
		Map<String,Integer> map = new HashMap<>();
		BufferedReader br = new BufferedReader(new FileReader("sorry.txt"));
		String str;
		while((str = br.readLine())!=null){
			//请统计每句话出现的次数 并且降序排列
			if(map.containsKey(str)){
				Integer v = map.get(str);
				map.put(str,v+1);
			}else{
				map.put(str,1);
			}
		}
		br.close();

		Map<Integer,String> temp = new TreeMap<>((a,b) -> a.equals(b) ? 1 : b.compareTo(a));
		map.forEach((k,v) -> temp.put(v,k));
		temp.forEach((cs,yj) -> System.out.println(yj + " : " + cs));

	}
}

BufferedWriter 比 PrintWriter要弱很多

        1.PrintWriter 既可以作为节点流 又可以作为过滤流    构造方法既可以传入File/String/流

        2.PrintWriter 既可以连接字节流  又可以连接字符流   构造方法允许传入OutputStream/Writer

        3.作为节点流使用的时候 构造方法第二个参数可以指定字符编码   new PrintWriter("a.txt","utf-8")

        4.作为过滤流使用的时候  构造方法第二个参数可以指定自动清空缓存区

        new PrintWriter(new FileWriter("a.txt",true),true);

        5.println() = write() + newLine()

       

/*
	还记得src目录吗？
		01.请统计所有的.java文件 总共有多少行~
		02.请统计Josh Bloch贡献了多少个类
		03.请统计Doug Lea贡献了多少个类

		*：
		public  class  interface  boolean  int  return

		请统计上述五个关键字 出现的次数 并且由多到少降序排列~

		//请问其中有效代码有多少行    注释不算
*/
import java.util.*;
import java.io.*;
public class BigOne{
	static int lineCount;
	static int joshCount;
	static int dougCount;
	static Map<String,Integer> map = new HashMap<>();
	static{
		map.put("public",0);
		map.put("class",0);
		map.put("interface",0);
		map.put("boolean",0);
		map.put("int",0);
		map.put("return",0);
	}
	public static void main(String[] args){
		File dir = new File("d:\\src");
		kill(dir);

		System.out.println(lineCount);
		System.out.println(joshCount);
		System.out.println(dougCount);

		map.forEach((k,v) -> System.out.println(k+":"+v));
	}
	public static void kill(File tar){
		File[] ds = tar.listFiles((x) -> x.isDirectory());
		File[] js = tar.listFiles((x) -> x.isFile() && x.getName().toLowerCase().endsWith(".java"));
		for(File d : ds){
			kill(d);
		}
		for(File j : js){
			boolean isJoshFirst = true;
			boolean isDougFirst = true;
			try(BufferedReader br = new BufferedReader(new FileReader(j))){
				String str;
				while((str = br.readLine())!=null){
					lineCount++;
					if(isJoshFirst && str.contains("Josh Bloch")){
						joshCount++;
						isJoshFirst = false;
					}
					if(isDougFirst && str.contains("Doug Lea")){
						dougCount++;
						isDougFirst = false;
					}
					//我们 应该判断 Map当中每个键 在str当中出现了几次
					Set<String> ks = map.keySet();
					for(String k : ks){
						//str包含多少次k
						while(str.contains(k)){
							Integer v = map.get(k);
							map.put(k,v+1);
							str = str.replaceFirst(k,"7");
						}
					}
				}
			}catch(Exception e){
				e.printStackTrace();
			}
		}
	}
}