IO(字符流)
字符流FileReader：
1、字符流是什么？
字符流是可以直接读写字符的IO流
字符流读取字符，就要先读取到字节数据，然后转为字符。如果要写出字符，需要吧字符转为字节再写出
2、FileReader
FileReader类的read（）方法可以按照字符大小读取
package com.chario; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class Demo1 { public static void main(String[] args) throws IOException { // demo1(); FileReader fr = new FileReader("xxx.txt"); int c; while((c = fr.read()) != -1){ //通过项目默认的码表一次读取一个字符 System.out.print((char)c); } } public static void demo1() throws FileNotFoundException, IOException { FileReader fr = new FileReader("xxx.txt"); int x = fr.read(); System.out.println(x); char c = (char)x; System.out.println(c); fr.close(); } }
字符流FileWriter：
FileWriter类的writer（）方法可以自动吧字符转为字节写出
package com.chario; import java.io.FileWriter; import java.io.IOException; public class Demo2 { public static void main(String[] args) throws IOException { FileWriter fw = new FileWriter("yyy.txt"); fw.write("努力，坚持"); fw.write(99); fw.close(); } }
字符流的拷贝：
package com.chario; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Demo3 { public static void main(String[] args) throws IOException { FileReader fr1 = new FileReader("xxx.txt"); FileWriter fw1 = new FileWriter("zzz.txt"); int c; while ((c = fr1.read()) != -1) { fw1.write(c); } fr1.close(); fw1.close(); //Writer类中有一个2k的小缓冲区，如果不关流，就会将内容写到缓冲区里，关流会将缓冲区内容刷新，再关闭 } }
什么情况下使用字符流：
字符流也可以拷贝文本文件，但不推荐使用。因为读取时会把字节转为字符，写出时还有把字符转回字节。
程序需要读取一段文本，或者需要写出一段文本的时候可以使用字符流
读取的时候是按照字符的大小读取的，不会出现半个中文
写出的时候可以直接将字符串写出，不用转换成字节数组
字符流是否可以拷贝非纯文本的文件：
不可以拷贝非纯文本的文件
因为在读的时候会将字节转换为字符，在转换过程中，可能找不到对应的字符，就会用？代替，
写出的时候会将字符转换成字节写出去
如果是？，直接写出，这样写出之后的文件就乱了，不用转换为字节数组
自定义字符数组的拷贝:
public static void demo2() throws FileNotFoundException, IOException { FileReader fr1 = new FileReader("xxx.txt"); FileWriter fw1 = new FileWriter("yyy.txt"); char[] arr = new char[1024]; int len; while ((len = fr1.read(arr)) != -1) { //将文件上的数据读取到字符数组中 fw1.write(arr,0,len); //将字符数组中的数据写到文件上 } fr1.close(); fw1.close(); }
带缓冲的字符流：
BufferedReader的read（）方法读取字符时会一次读取若干字符到缓冲区，然后逐个返回给程序，降低读取文件的次数，提高效率
BufferedWriter（）方法写出字符时会先写到缓冲区，缓冲区写满时才会写到文件，降低写文件的次数，提高效率
public static void demo3() throws FileNotFoundException, IOException { BufferedReader bReader = new BufferedReader(new FileReader("xxx.txt")); BufferedWriter bWriter = new BufferedWriter(new FileWriter("yyy.txt")); int c; while ((c = bReader.read()) != -1) { bWriter.write(c); } bReader.close(); bWriter.close(); }
readLine（）和newLine（）方法：
BufferedReader的readLine（）方法可以读取一行字符（不包含换行符号）
BufferedWriter的newLine（）可以输出一个跨平台的换行符号" ";
package com.chario; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Demo4 { /** * 带缓冲区的流中的特殊方法 * readLine（） * newLine（） * * newLine（） 的区别 * newLine（）是跨平台的方法 * 值支持的是windows系统 * */ public static void main(String[] args) throws IOException { // demo1(); BufferedReader bReader = new BufferedReader(new FileReader("zzz.txt")); BufferedWriter bWriter = new BufferedWriter(new FileWriter("aaa.txt")); String line; while((line = bReader.readLine()) != null){ bWriter.write(line); //bWriter.newLine(); //写出回车换行符 bWriter.write(" "); } bReader.close(); bWriter.close(); } public static void demo1() throws FileNotFoundException, IOException { BufferedReader bReader = new BufferedReader(new FileReader("zzz.txt")); String line; while ((line = bReader.readLine()) != null) { System.out.println(line); } bReader.close(); } }
将文本反转：
将一个文本文档上的文本反转，第一行和倒数第一行交换，第二行和倒数第二行交换
package com.chario; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; public class Test1 { /** * 需求：将一个文本文档上的文本反转，第一行和倒数第一行交换，第二行和倒数第二行交换 * * 分析： * 1、创建输入输出流对象 * 2、创建集合对象 * 3、将读到的数据存储在集合中 * 4、倒着遍历集合将数据写到文件上 * 5、关流 * * 注意事项：流对象尽量晚开早关 * @throws IOException * */ public static void main(String[] args) throws IOException { //1、创建输入输出流对象 BufferedReader bReader = new BufferedReader(new FileReader("zzz.txt")); //2、创建集合对象 ArrayList<String> list = new ArrayList<>(); //3、将读到的数据存储在集合中 String line; while((line = bReader.readLine()) != null){ list.add(line); } bReader.close(); //关流 //4、倒着遍历集合将数据写到文件上 BufferedWriter bWriter = new BufferedWriter(new FileWriter("revzzz.txt")); for (int i = list.size() - 1; i >= 0; i--) { bWriter.write(list.get(i)); bWriter.newLine(); } //5、关流 bWriter.close(); } }
LineNumberReader：
LineNumberReader是BufferedReader的子类，具有相同的功能，并且可以统计行号
调用getLineNumber（）方法可以获取当前行号
调用setLineNumber（）方法可以设置当前行号
package com.chario; import java.io.FileReader; import java.io.IOException; import java.io.LineNumberReader; public class Demo5 { public static void main(String[] args) throws IOException { LineNumberReader lnr1 = new LineNumberReader(new FileReader("zzz.txt")); String line; lnr1.setLineNumber(100); while((line = lnr1.readLine()) != null){ System.out.println(lnr1.getLineNumber() + ":" + line); } lnr1.close(); } }
装饰设计模式：
package com.chario; public class Demo6 { /** *装饰设计模式的好处是： *耦合性不强，被装饰类的变化与装饰类的变化无关 */ public static void main(String[] args) { HeiMaStudent heiMaStudent = new HeiMaStudent(new Student()); heiMaStudent.code(); } } interface coder{ public void code(); } class Student implements coder { @Override public void code() { System.out.println("javase"); System.out.println("javaweb"); } } class HeiMaStudent implements coder { //1、获取被装饰类的引用 private Student s; //获取学生引用 //2、在构造方法中传入被装饰类的对象 public HeiMaStudent(Student s) { this.s = s; } //3、对原有的功能进行升级 @Override public void code() { s.code(); System.out.println("ssh"); System.out.println("数据库"); System.out.println("大数据"); System.out.println("..."); } }
使用指定的码表读写字符：
FileReader是使用默认码表读取文件，如果需要使用指定码表读取，那么可以使用InputStreamReader（字节流，编码表）
FileWriter是使用默认码表写出文件，如果需要使用指定码表写出，那么可以使用OutputStreamReader（字节流，编码表）
package com.chario; import java.io.BufferedReader; import java.io.BufferedWriter; 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.OutputStreamWriter; import java.io.UnsupportedEncodingException; public class Demo7 { public static void main(String[] args) throws IOException { // demo1(); // demo2(); 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(); } public static void demo2() throws UnsupportedEncodingException, FileNotFoundException, IOException { InputStreamReader isr1 = new InputStreamReader(new FileInputStream("utf-8.txt"),"utf-8"); //指定码表读字符 OutputStreamWriter osw1 = new OutputStreamWriter(new FileOutputStream("gbk.txt"), "gbk"); //指定码表写字符 int c; while((c = isr1.read()) != -1) { osw1.write(c); } isr1.close(); osw1.close(); } public static void demo1() throws FileNotFoundException, IOException { //用默认的编码表读写，出现乱码 FileReader fReader = new FileReader("utf-8.txt"); FileWriter fWriter = new FileWriter("gbk.txt"); int c; while((c = fReader.read()) != -1) { fWriter.write(c); } fReader.close(); fWriter.close(); } }
获取文本上字符出现的次数：
获取一个文本上每个字符出现的次数，将结果写在times.txt上
package com.chario; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.util.TreeMap; public class Test2 { /** * 需求：获取一个文本上每个字符出现的次数，将结果写在times.txt上 * * 分析： * 1、创建带缓冲区的输入流对象 * 2、创建双列集合对象TreeMap * 3、将读到的字符存储在双列集合中，存储的时候要做判断，如果不包含这个键，就将键和1存储，如果包含这个键，就将该键和值加1存储 * 4、关闭输入流 * 5、创建输出流对象 * 6、遍历集合将集合中的内容写到times.txt中 * 7、关闭输出流 * @throws IOException */ public static void main(String[] args) throws IOException { //1、创建带缓冲区的输入流对象 BufferedReader br = new BufferedReader(new FileReader("zzz.txt")); //2、创建双列集合对象TreeMap TreeMap<Character, Integer> tm = new TreeMap<>(); // 3、将读到的字符存储在双列集合中，存储的时候要做判断，如果不包含这个键，就将键和1存储，如果包含这个键，就将该键和值加1存储 int ch; while((ch = br.read()) != -1) { char c = (char)ch; //强制类型转换 /*if (!tm.containsKey(c)) { tm.put(c, 1); }else { tm.put(c, tm.get(c) + 1); }*/ tm.put(c, !tm.containsKey(c) ? 1 : tm.get(c) + 1); } //4、关闭输入流 br.close(); //5、创建输出流对象 BufferedWriter bw = new BufferedWriter(new FileWriter("times.txt")); //6、遍历集合将集合中的内容写到times.txt中 for (Character key : tm.keySet()) { switch (key) { case ' ': bw.write("\t" + "=" + tm.get(key)); break; case ' ': bw.write("\r" + "=" + tm.get(key)); break; case ' ': bw.write("\n" + "=" + tm.get(key)); break; default: bw.write(key + "=" + tm.get(key)); //写出键和值 break; } bw.newLine(); } // 7、关闭输出流 bw.close(); } }
试用版软件：
package com.chario; import java.io.BufferedReader; import java.io.FileNotFoundException; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; public class Test3 { /** *需求：模拟试用版软件，试用10次机会 * *分析： *1、创建带缓冲区的输入流对象，因为要使用readLine方法，可以保证数据的原样性 *2、将读到的字符串转换为int数 *3、对int数进行判断，如果大于0，就将其--写回去，如果不大于0，就提示请购买正版 *4、在if判断中要将--的结果打印，并将结果通过输出流写到文件 * @throws IOException */ public static void main(String[] args) throws IOException { //1、创建带缓冲区的输入流对象，因为要使用readLine方法，可以保证数据的原样性 BufferedReader br = new BufferedReader(new FileReader("config.txt")); //2、将读到的字符串转换为int数 String line = br.readLine(); int times = Integer.parseInt(line); //将数字字符串转换成数字 //3、对int数进行判断，如果大于0，就将其--写回去，如果不大于0，就提示请购买正版 if (times > 0) { //4、在if判断中要将--的结果打印，并将结果通过输出流写到文件 System.out.println("您还有" + times-- + "次试用机会！"); FileWriter fw = new FileWriter("config.txt"); fw.write(times + ""); fw.close(); }else { System.out.println("您的试用机会已用完，请购买正版！"); } //关闭流 br.close(); } }
递归
5的阶乘：
package com.chario; public class Demo8 { /** * 递归的弊端：不能调用次数过多，容易导致栈内存溢出 * 递归的好处：不用知道循环次数 * * 构造方法是否可以使用递归调用？ * 不能 * * 递归调用是否必须有返回值？ * 不一定（可以有，也可以没有） * */ public static void main(String[] args) { System.out.println(fun(5)); } public static int fun(int num){ if (num == 1) { return 1; }else { return num * fun(num - 1); } } }
Test:
需求：从键盘输入接收一个文件夹路径，打印出该文件夹下所有的.java文件名
package com.chario; import java.io.File; import java.util.Scanner; public class Test4 { /** * 需求：从键盘输入接收一个文件夹路径，打印出该文件夹下所有的.java文件名 * * 分析： * 从键盘输入接收一个文件夹路径 * 1、如果录入的是不存在的，给予提示 * 2、如果录入的是文件路径，给予提示 * 3、如果是文件夹路径，直接返回 * * 打印出该文件夹下所有的.java文件名 * 1、获取到该文件夹路径下的所有的文件和文件夹，存储在File数组中 * 2、遍历数组，对每一个文件或文件夹做判断 * 3、如果是文件，并且后缀是.java的，就打印 * 4、如果是文件夹，就递归调用 */ public static void main(String[] args) { File dir = getDir(); printJavaFile(dir); } /** * 获取键盘录入的文件夹路径 * 1、返回值类型File * 2、不需要有参数 */ public static File getDir(){ Scanner sc = new Scanner(System.in); //创建键盘录入对象 System.out.println("请输入一个文件夹路径："); while(true){ String line = sc.nextLine(); //将键盘录入的文件夹路径存储 File dir = new File(line); //封装成File对象 if (!dir.exists()) { System.out.println("您录入的文件夹路径不存在，请重新录入"); }else if (dir.isFile()) { System.out.println("您录入的是文件路径，请重新录入文件夹路径"); }else { return dir; } } } /** * 打印出该文件夹下所有的.java文件名 * 1、返回值类型Void * 2、参数列表File dir */ public static void printJavaFile(File dir) { //1、获取到该文件夹路径下的所有的文件和文件夹，存储在File数组中 File[] subFiles = dir.listFiles(); //2、遍历数组，对每一个文件或文件夹做判断 for (File subFile : subFiles) { //3、如果是文件，并且后缀是.java的，就打印 if (subFile.isFile() && subFile.getName().endsWith(".java")) { System.out.println(subFile); //4、如果是文件夹，就递归调用 }else if (subFile.isDirectory()) { printJavaFile(subFile); } } } }