20201016冯强
学习总结：
1 字符流
当使用字节流读取文本文件时，可能会有一个小问题。就是遇到中文字符时，可能不会显示完整的字符，那是因为一个中文字符可能占用多个字节存储。所以Java提供一些字符流类，以字符为单位读写数据，专门用于处理文本文件。
2 输入流
2.1 输入字符流（Reader）
java.io.Reader 抽象类是表示用于读取字符流的所有类的超类，可以读取字符信息到内存中。下面是 Reader 的体系：
public abstract class Reader implements Readable, Closeable{
protected Reader();
protected Reader(Object lock)
//它是个抽象类，因此不能被实例化。
}
2.2实例方法
public void close() ：关闭此流并释放与此流相关联的任何系统资源。
public int read() ： 从输入流读取一个字符。
public int read(char[] cbuf) ： 从输入流中读取一些字符
public abstract int read(char[] cbuf, int off, int len) : 从输入流中读取一些字符
public int read(CharBuffer target) :将字符读入指定的字符缓冲区
public void mark(int readAheadLimit) :标记流中的位置
public boolean ready() : 流是否准备好被读取
public void reset() : 重置流
public long skip(long n) : 跳过字符
2.3 FileReader
java.io.FileReader 类是读取字符文件的便利类。构造时使用系统默认的字符编码和默认字节缓冲区。
2.3.1 构造方法
FileReader(File file) ： 创建一个新的 FileReader ，给定要读取的File对象。
FileReader(String fileName) ： 创建一个新的 FileReader ，给定要读取的文件的名称。
File file = new File("D:\\temp\\a.txt");
FileReader reader = new FileReader(file);
FileReader reader1 = new FileReader("D:\\temp\\a.txt");
构造方法内部都是调用了父类的构造方法，传入一个 FileInputStream 对象。
2.3.2 实例方法
FileReader 中的所有方法都来自其父类 InputStreamReader ,没有重写任何方法同时也没有扩展的方法。也就是说，学习了 FileReader 同时也学习了 InputStreamReader .
2.2.4 读取多个字符
// 使用文件名称创建流对象
FileReader fr = new FileReader("D:/temp/reader2.txt");
// 定义变量，保存有效字符个数
int len; // 定义字符数组，作为装字符数据的容器
char[] cbuf = new char[2];
// 循环读取
while ((len = fr.read(cbuf)) != -1)
{
System.out.println(new String(cbuf));
}// 关闭资源 fr.close();
2.4 BufferedReader
java.io.BufferedReader 从字符输入流读取文本，缓冲字符，以提供字符，数组和行的高效读取。可以指定缓冲区大小，或者可以使用默认大小。 默认值足够大，可用于大多数用途。 它是一个缓冲流。
BufferedReader 继承了 Reader 中所有 public 方法，还扩展了一个方法：
public String readLine()//读取一行文字
当 readLine() 读取完毕时，返回 null
2.5增强try
public static void main(String[] args) throws IOException {
FileOutputStream out = null;
OutputStreamWriter writer = null;
try {
out = new FileOutputStream("d:/temp/outStreamWriter.txt"); Charset set = Charset.forName("utf-8");
writer = new OutputStreamWriter(out, set);
System.out.println("编码格式为： " + writer.getEncoding());
writer.write("站在那别动，我去买橘子");
} catch (IOException e) {
e.printStackTrace();
}finally {
//关闭资源
writer.close(); out.close();
}
}
3.序列化（Serializable）
public interface Serializable {
}
3.1例子
package com.ittzb.demo;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Demo {
public static void main(String[] args) {
Student student =new Student(11,"zs","女");
try(FileOutputStream fs = new FileOutputStream("D:\\lol\\temp.txt");
ObjectOutputStream oss = new ObjectOutputStream(fs)) {
oss.writeObject(student);
}
catch (IOException e) {
}
}
}
class Student implements Serializable{
/**
*
*/
private static final long serialVersionUID = 1L;
private Integer age;
private String name;
private String gender;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Student [age=" + age + ", name=" + name + ", gender=" + gender + "]";
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public Student(Integer age, String name, String gender) {
super();
this.age = age;
this.name = name;
this.gender = gender;
}
}
package com.ittzb.demo;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class Demo02 {
public static void main(String[] args) {
try(FileInputStream fs = new FileInputStream("D:\\lol\\temp.txt");
ObjectInputStream oss = new ObjectInputStream(fs)
){
Object o =oss.readObject();
System.out.println(o.getClass());
if(o instanceof Student) {
Student stu = (Student)o;
System.out.println(stu);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
作业：
package com.ittzb.demo;
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.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
public class Exam {
public static void main(String[] args) {
Exam ex =new Exam();
Map<Integer,String> map = ex.getMap("D:\\lol\\temp.txt");
Set<Map.Entry<Integer, String>> entrys =map.entrySet();
Iterator<Map.Entry<Integer, String>> iter = entrys.iterator();
while (iter.hasNext()) {
Map.Entry<Integer, String> en =iter.next();
System.out.println(en.getValue());
}
ex.sort(map,"D:\\\\lol\\\\temp1.txt");
}
public Map<Integer,String> getMap(String path) {
Map<Integer,String> map =new TreeMap<Integer,String>(
(c1,c2)->{
return c1-c2;
}
);
try( FileReader fis = new FileReader(path);
BufferedReader br = new BufferedReader(fis)){
String line = null;
int breakWhile= br.read();
while((line = br.readLine()) != null) {
map.put(breakWhile,line);
breakWhile= br.read();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return map;
}
public void sort(Map<Integer,String> map,String path) {
try(FileWriter fw = new FileWriter(path);
BufferedWriter bf = new BufferedWriter(fw)
){
Set<Map.Entry<Integer, String>> entrys =map.entrySet();
Iterator<Map.Entry<Integer, String>> iter = entrys.iterator();
while (iter.hasNext()) {
Map.Entry<Integer, String> en =iter.next();
bf.write(en.getKey());
bf.write(en.getValue());
bf.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
近期评论