Java基础-21（02）总结字符流,IO流编码问题,实用案例必做一遍

package cn.itcast_02;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：把ArrayList集合中的字符串数据存储到文本文件
 * 
 * 分析：
 *  通过题目的意思我们可以知道如下的一些内容，
 *  ArrayList集合里存储的是字符串。
 *  遍历ArrayList集合，把数据获取到。
 *  然后存储到文本文件中。
 *  文本文件说明使用字符流。
 * 
 * 数据源：
 *  ArrayList<String> -- 遍历得到每一个字符串数据
 * 目的地：
 *  a.txt -- FileWriter -- BufferedWriter
 */
public class ArrayListToFileDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据与(创建集合对象)
 ArrayList<String> array = new ArrayList<String>();
 array.add("hello");
 array.add("world");
 array.add("java");
 // 封装目的地
 BufferedWriter bw = new BufferedWriter(new FileWriter("a.txt"));
 // 遍历集合
 for (String s : array) {
 // 写数据
 bw.write(s);
 bw.newLine();
 bw.flush();
 }
 // 释放资源
 bw.close();
 }
}

package cn.itcast_02;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
 * 
 * 分析：
 *  通过题目的意思我们可以知道如下的一些内容，
 *  数据源是一个文本文件。
 *  目的地是一个集合。
 *  而且元素是字符串。
 * 
 * 数据源：
 *  b.txt -- FileReader -- BufferedReader
 * 目的地：
 *  ArrayList<String>
 */
public class FileToArrayListDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 BufferedReader br = new BufferedReader(new FileReader("b.txt"));
 // 封装目的地(创建集合对象)
 ArrayList<String> array = new ArrayList<String>();
 // 读取数据存储到集合中
 String line = null;
 while ((line = br.readLine()) != null) {
 array.add(line);
 }
 // 释放资源
 br.close();
 // 遍历集合
 for (String s : array) {
 System.out.println(s);
 }
 }
}

package cn.itcast_02;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
 * 
 * 分析：
 *  通过题目的意思我们可以知道如下的一些内容，
 *  数据源是一个文本文件。
 *  目的地是一个集合。
 *  而且元素是字符串。
 * 
 * 数据源：
 *  b.txt -- FileReader -- BufferedReader
 * 目的地：
 *  ArrayList<String>
 */
public class FileToArrayListDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 BufferedReader br = new BufferedReader(new FileReader("b.txt"));
 // 封装目的地(创建集合对象)
 ArrayList<String> array = new ArrayList<String>();
 // 读取数据存储到集合中
 String line = null;
 while ((line = br.readLine()) != null) {
 array.add(line);
 }
 // 释放资源
 br.close();
 // 遍历集合
 for (String s : array) {
 System.out.println(s);
 }
 }
}

package cn.itcast_04;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FilenameFilter;
import java.io.IOException;
/*
 * 需求：复制指定目录下的指定文件，并修改后缀名。
 * 指定的文件是：.java文件。
 * 指定的后缀名是：.jad
 * 指定的目录是：jad
 * 
 * 数据源：e:\\java\\A.java
 * 目的地：e:\\jad\\A.jad
 * 
 * 分析：
 *  A:封装目录
 *  B:获取该目录下的java文件的File数组
 *  C:遍历该File数组，得到每一个File对象
 *  D:把该File进行复制
 *  E:在目的地目录下改名
 */
public class CopyFolderDemo {
 public static void main(String[] args) throws IOException {
 // 封装目录
 File srcFolder = new File("e:\\java");
 // 封装目的地
 File destFolder = new File("e:\\jad");
 // 如果目的地目录不存在，就创建
 if (!destFolder.exists()) {
 destFolder.mkdir();
 }
 // 获取该目录下的java文件的File数组
 File[] fileArray = srcFolder.listFiles(new FilenameFilter() {
 @Override
 public boolean accept(File dir, String name) {
 return new File(dir, name).isFile() && name.endsWith(".java");
 }
 });
 // 遍历该File数组，得到每一个File对象
 for (File file : fileArray) {
 // System.out.println(file);
 // 数据源：e:\java\DataTypeDemo.java
 // 目的地：e:\\jad\DataTypeDemo.java
 String name = file.getName();
 File newFile = new File(destFolder, name);
 copyFile(file, newFile);
 }
 // 在目的地目录下改名
 File[] destFileArray = destFolder.listFiles();
 for (File destFile : destFileArray) {
 // System.out.println(destFile);
 // e:\jad\DataTypeDemo.java
 // e:\\jad\\DataTypeDemo.jad
 String name =destFile.getName(); //DataTypeDemo.java
 String newName = name.replace(".java", ".jad");//DataTypeDemo.jad
 File newFile = new File(destFolder,newName);
 destFile.renameTo(newFile);
 }
 }
 private static void copyFile(File file, File newFile) throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 file));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(newFile));
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 bos.write(bys, 0, len);
 }
 bos.close();
 bis.close();
 }
}

package cn.itcast_05;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 需求：复制多极文件夹
 * 
 * 数据源：E:\JavaSE\day21\code\demos
 * 目的地：E:\\
 * 
 * 分析：
 *  A:封装数据源File
 *  B:封装目的地File
 *  C:判断该File是文件夹还是文件
 *  a:是文件夹
 *  就在目的地目录下创建该文件夹
 *  获取该File对象下的所有文件或者文件夹File对象
 *  遍历得到每一个File对象
 *  回到C
 *  b:是文件
 *  就复制(字节流)
 */
public class CopyFoldersDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源File
 File srcFile = new File("E:\\JavaSE\\day21\\code\\demos");
 // 封装目的地File
 File destFile = new File("E:\\");
 // 复制文件夹的功能
 copyFolder(srcFile, destFile);
 }
 private static void copyFolder(File srcFile, File destFile)
 throws IOException {
 // 判断该File是文件夹还是文件
 if (srcFile.isDirectory()) {
 // 文件夹
 File newFolder = new File(destFile, srcFile.getName());
 newFolder.mkdir();
 // 获取该File对象下的所有文件或者文件夹File对象
 File[] fileArray = srcFile.listFiles();
 for (File file : fileArray) {
 copyFolder(file, newFolder);
 }
 } else {
 // 文件
 File newFile = new File(destFile, srcFile.getName());
 copyFile(srcFile, newFile);
 }
 }
 private static void copyFile(File srcFile, File newFile) throws IOException {
 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
 srcFile));
 BufferedOutputStream bos = new BufferedOutputStream(
 new FileOutputStream(newFile));
 byte[] bys = new byte[1024];
 int len = 0;
 while ((len = bis.read(bys)) != -1) {
 bos.write(bys, 0, len);
 }
 bos.close();
 bis.close();
 }
}

package cn.itcast_06;(1)
public class Student {
 // 姓名
 private String name;
 // 语文成绩
 private int chinese;
 // 数学成绩
 private int math;
 // 英语成绩
 private int english;
 public Student() {
 super();
 }
 public Student(String name, int chinese, int math, int english) {
 super();
 this.name = name;
 this.chinese = chinese;
 this.math = math;
 this.english = english;
 }
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getChinese() {
 return chinese;
 }
 public void setChinese(int chinese) {
 this.chinese = chinese;
 }
 public int getMath() {
 return math;
 }
 public void setMath(int math) {
 this.math = math;
 }
 public int getEnglish() {
 return english;
 }
 public void setEnglish(int english) {
 this.english = english;
 }
 public int getSum() {
 return this.chinese + this.math + this.english;
 }
}
package cn.itcast_06;(2)
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
/*
 * 键盘录入5个学生信息(姓名,语文成绩,数学成绩,英语成绩),按照总分从高到低存入文本文件
 * 
 * 分析：
 *  A:创建学生类
 *  B:创建集合对象
 *  TreeSet<Student>
 *  C:键盘录入学生信息存储到集合
 *  D:遍历集合，把数据写到文本文件
 */
public class StudentDemo {
 public static void main(String[] args) throws IOException {
 // 创建集合对象
 TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
 @Override
 public int compare(Student s1, Student s2) {
 int num = s2.getSum() - s1.getSum();
 int num2 = num == 0 ? s1.getChinese() - s2.getChinese() : num;
 int num3 = num2 == 0 ? s1.getMath() - s2.getMath() : num2;
 int num4 = num3 == 0 ? s1.getEnglish() - s2.getEnglish() : num3;
 int num5 = num4 == 0 ? s1.getName().compareTo(s2.getName())
 : num4;
 return num5;
 }
 });
 // 键盘录入学生信息存储到集合
 for (int x = 1; x <= 5; x++) {
 Scanner sc = new Scanner(System.in);
 System.out.println("请录入第" + x + "个的学习信息");
 System.out.println("姓名：");
 String name = sc.nextLine();
 System.out.println("语文成绩：");
 int chinese = sc.nextInt();
 System.out.println("数学成绩：");
 int math = sc.nextInt();
 System.out.println("英语成绩：");
 int english = sc.nextInt();
 // 创建学生对象
 Student s = new Student();
 s.setName(name);
 s.setChinese(chinese);
 s.setMath(math);
 s.setEnglish(english);
 // 把学生信息添加到集合
 ts.add(s);
 }
 // 遍历集合，把数据写到文本文件
 BufferedWriter bw = new BufferedWriter(new FileWriter("students.txt"));
 bw.write("学生信息如下：");
 bw.newLine();
 bw.flush();
 bw.write("姓名,语文成绩,数学成绩,英语成绩");
 bw.newLine();
 bw.flush();
 for (Student s : ts) {
 StringBuilder sb = new StringBuilder();
 sb.append(s.getName()).append(",").append(s.getChinese())
 .append(",").append(s.getMath()).append(",")
 .append(s.getEnglish());
 bw.write(sb.toString());
 bw.newLine();
 bw.flush();
 }
 // 释放资源
 bw.close();
 System.out.println("学习信息存储完毕");
 }
}

package cn.itcast_07;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;
/*
 * 已知s.txt文件中有这样的一个字符串：“hcexfgijkamdnoqrzstuvwybpl”
 * 请编写程序读取数据内容，把数据排序后写入ss.txt中。
 * 
 * 分析：
 *  A:把s.txt这个文件给做出来
 *  B:读取该文件的内容，存储到一个字符串中
 *  C:把字符串转换为字符数组
 *  D:对字符数组进行排序
 *  E:把排序后的字符数组转换为字符串
 *  F:把字符串再次写入ss.txt中
 */
public class StringDemo {
 public static void main(String[] args) throws IOException {
 // 读取该文件的内容，存储到一个字符串中
 BufferedReader br = new BufferedReader(new FileReader("s.txt"));
 String line = br.readLine();
 br.close();
 // 把字符串转换为字符数组
 char[] chs = line.toCharArray();
 // 对字符数组进行排序
 Arrays.sort(chs);
 // 把排序后的字符数组转换为字符串
 String s = new String(chs);
 // 把字符串再次写入ss.txt中
 BufferedWriter bw = new BufferedWriter(new FileWriter("ss.txt"));
 bw.write(s);
 bw.newLine();
 bw.flush();
 bw.close();
 }
}

package cn.itcast_08;
import java.io.IOException;
import java.io.Reader;
/*
 * 用Reader模拟BufferedReader的readLine()功能
 * 
 * readLine():一次读取一行，根据换行符判断是否结束，只返回内容，不返回换行符
 */
public class MyBufferedReader {
 private Reader r;
 public MyBufferedReader(Reader r) {
 this.r = r;
 }
 /*
  * 思考：写一个方法，返回值是一个字符串。
  */
 public String readLine() throws IOException {
 /*
  * 我要返回一个字符串，我该怎么办呢? 我们必须去看看r对象能够读取什么东西呢? 两个读取方法，一次读取一个字符或者一次读取一个字符数组
  * 那么，我们要返回一个字符串，用哪个方法比较好呢? 我们很容易想到字符数组比较好，但是问题来了，就是这个数组的长度是多长呢?
  * 根本就没有办法定义数组的长度，你定义多长都不合适。 所以，只能选择一次读取一个字符。
  * 但是呢，这种方式的时候，我们再读取下一个字符的时候，上一个字符就丢失了 所以，我们又应该定义一个临时存储空间把读取过的字符给存储起来。
  * 这个用谁比较和是呢?数组，集合，字符串缓冲区三个可供选择。
  * 经过简单的分析，最终选择使用字符串缓冲区对象。并且使用的是StringBuilder
  */
 StringBuilder sb = new StringBuilder();
 // 做这个读取最麻烦的是判断结束，但是在结束之前应该是一直读取，直到-1
 /*
 hello
 world
 java 
 104101108108111
 119111114108100
 1069711897
  */
 int ch = 0;
 while ((ch = r.read()) != -1) { //104,101,108,108,111
 if (ch == '\r') {
 continue;
 }
 if (ch == '\n') {
 return sb.toString(); //hello
 } else {
 sb.append((char)ch); //hello
 }
 }
 // 为了防止数据丢失，判断sb的长度不能大于0
 if (sb.length() > 0) {
 return sb.toString();
 }
 return null;
 }
 /*
  * 先写一个关闭方法
  */
 public void close() throws IOException {
 this.r.close();
 }
}

package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
import java.io.LineNumberReader;
/*
 * BufferedReader
 *  |--LineNumberReader
 *  public int getLineNumber()获得当前行号。 
 *  public void setLineNumber(int lineNumber)
 */
public class LineNumberReaderDemo {
 public static void main(String[] args) throws IOException {
 LineNumberReader lnr = new LineNumberReader(new FileReader("my.txt"));
 // 从10开始才比较好
 // lnr.setLineNumber(10);
 // System.out.println(lnr.getLineNumber());
 // System.out.println(lnr.getLineNumber());
 // System.out.println(lnr.getLineNumber());
 String line = null;
 while ((line = lnr.readLine()) != null) {
 System.out.println(lnr.getLineNumber() + ":" + line);
 }
 lnr.close();
 }
}

package cn.itcast_09;
import java.io.IOException;
import java.io.Reader;
public class MyLineNumberReader {
 private Reader r;
 private int lineNumber = 0;
 public MyLineNumberReader(Reader r) {
 this.r = r;
 }
 public int getLineNumber() {
 // lineNumber++;
 return lineNumber;
 }
 public void setLineNumber(int lineNumber) {
 this.lineNumber = lineNumber;
 }
 public String readLine() throws IOException {
 lineNumber++;
 StringBuilder sb = new StringBuilder();
 int ch = 0;
 while ((ch = r.read()) != -1) {
 if (ch == '\r') {
 continue;
 }
 if (ch == '\n') {
 return sb.toString();
 } else {
 sb.append((char) ch);
 }
 }
 if (sb.length() > 0) {
 return sb.toString();
 }
 return null;
 }
 public void close() throws IOException {
 this.r.close();
 }
}

package cn.itcast_09;
import java.io.IOException;
import java.io.Reader;
import cn.itcast_08.MyBufferedReader;
public class MyLineNumberReader2 extends MyBufferedReader {
 private Reader r;
 private int lineNumber = 0;
 public MyLineNumberReader2(Reader r) {
 super(r);
 }
 public int getLineNumber() {
 return lineNumber;
 }
 public void setLineNumber(int lineNumber) {
 this.lineNumber = lineNumber;
 }
 @Override
 public String readLine() throws IOException {
 lineNumber++;
 return super.readLine();
 }
}

package cn.itcast_09;
import java.io.FileReader;
import java.io.IOException;
public class MyLineNumberReaderTest {
 public static void main(String[] args) throws IOException {
 // MyLineNumberReader mlnr = new MyLineNumberReader(new FileReader(
 // "my.txt"));
 MyLineNumberReader2 mlnr = new MyLineNumberReader2(new FileReader(
 "my.txt"));
 // mlnr.setLineNumber(10);
 // System.out.println(mlnr.getLineNumber());
 // System.out.println(mlnr.getLineNumber());
 // System.out.println(mlnr.getLineNumber());
 String line = null;
 while ((line = mlnr.readLine()) != null) {
 System.out.println(mlnr.getLineNumber() + ":" + line);
 }
 mlnr.close();
 }
}

package cn.itcast_02;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
/*
 * 需求：从文本文件中读取数据(每一行为一个字符串数据)到集合中，并遍历集合
 * 
 * 分析：
 *  通过题目的意思我们可以知道如下的一些内容，
 *  数据源是一个文本文件。
 *  目的地是一个集合。
 *  而且元素是字符串。
 * 
 * 数据源：
 *  b.txt -- FileReader -- BufferedReader
 * 目的地：
 *  ArrayList<String>
 */
public class FileToArrayListDemo {
 public static void main(String[] args) throws IOException {
 // 封装数据源
 BufferedReader br = new BufferedReader(new FileReader("b.txt"));
 // 封装目的地(创建集合对象)
 ArrayList<String> array = new ArrayList<String>();
 // 读取数据存储到集合中
 String line = null;
 while ((line = br.readLine()) != null) {
 array.add(line);
 }
 // 释放资源
 br.close();
 // 遍历集合
 for (String s : array) {
 System.out.println(s);
 }
 }
}
 M:测试MyBufferedReader的时候，你就把它当作BufferedReader一样的使用
package cn.itcast_08;
import java.io.FileReader;
import java.io.IOException;
/*
 * 测试MyBufferedReader的时候，你就把它当作BufferedReader一样的使用
 */
public class MyBufferedReaderDemo {
 public static void main(String[] args) throws IOException {
 MyBufferedReader mbr = new MyBufferedReader(new FileReader("my.txt"));
 String line = null;
 while ((line = mbr.readLine()) != null) {
 System.out.println(line);
 }
 mbr.close();
 // System.out.println('\r' + 0); // 13
 // System.out.println('\n' + 0);// 10
 }
}