java基础-io(字符流)
1. 编码问题
java的文本(char)是16位无符号整数，是字符的unicode编码(双字节编码)
文本是byte byte byte..的数据序列
文本文件是文本(char)序列按照某种编码方案(utf-8,utf-16be,gbk)序列化为byte的存储
2.字符流 Reader/Writer --操作的是文本文本文件(gbk编码)
字符的处理，一个字符一个字符的处理
字符的底层依旧是字节序列
InputStreamReader 完成byte流解析为char流，按照编码解析
OutputStreamWriter 提供char流到byte流，按照编码处理
public static void main(String[] args) {
InputStreamReader inputStreamReader = null;
OutputStreamWriter outputStreamWriter = null;
try {
inputStreamReader = new InputStreamReader(new FileInputStream("demo/demo.dat"), "utf-8"); //默认项目的编码就是
// int c;
// while ((c = inputStreamReader.read()) != -1){
// System.out.println((char)c);
// }
outputStreamWriter = new OutputStreamWriter(new FileOutputStream("demo/dos.dat"), "utf-8");
char[] buffer = new char[8 * 1024];
int c;
while ((c = inputStreamReader.read(buffer, 0, buffer.length)) != -1) {
String s = new String(buffer, 0, c);
System.out.println(s);
outputStreamWriter.write(buffer, 0, c);
}
outputStreamWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (inputStreamReader != null) {
inputStreamReader.close();
}
if (outputStreamWriter != null) {
outputStreamWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
3. FileReader/FileWriter
public class FileReaderAndWriter {
public static void main(String[] args) {
FileReader fileReader = null;
FileWriter fileWriter = null;
try {
fileReader = new FileReader("demo/raf.dat");
fileWriter = new FileWriter("demo/dos.dat", true); //true追加
char[] buffer = new char[8 * 1024];
int c;
while ((c = fileReader.read(buffer, 0, buffer.length)) != -1) {
fileWriter.write(buffer, 0, c);
}
fileWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileReader != null) {
fileReader.close();
}
if (fileWriter != null) {
fileWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
4. 字符流过滤器
public static void main(String[] args) {
//对文件进行操作
BufferedReader bufferedReader = null;
BufferedWriter bufferedWriter = null;
PrintWriter printWriter = null;
try {
bufferedReader = new BufferedReader(new InputStreamReader(new FileInputStream("demo/demo.dat")));
bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("demo/dos.dat", true)));
printWriter = new PrintWriter("demo/dos.dat");
String line;
while ((line = bufferedReader.readLine()) != null) {
// System.out.println(line);
// bufferedWriter.write(line);
// bufferedWriter.newLine(); //识别换行
printWriter.println(line);
}
bufferedWriter.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bufferedReader != null) {
bufferedReader.close();
}
if (bufferedWriter != null) {
bufferedWriter.close();
}
if (printWriter != null) {
printWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
5.序列化
5.1 对象的序列化与反序列化
就是将object对象转换成byte序列，反之就是反序列化
序列化流(ObjectOutputStream)是过滤流----->writeObject
反序列化流(ObjectInputStream)---->readObject
5.2 序列化接口(Serializable)
对象必须实现序列化接口，才能进行序列化，否则将出现异常
这个接口没有任何方法，只是一个规定
序列化
public class ObjectSeriDemo {
public static void main(String[] args) {
String file = "demo/obj.dat";
ObjectOutputStream objectOutputStream = null;
//1.对象的序列化
try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(file));
Student student = new Student(1,"张三");
objectOutputStream.writeObject(student);
objectOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (objectOutputStream != null) {
objectOutputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
反序列化
public class ObjectSeriDemo {
public static void main(String[] args) {
String file = "demo/obj.dat";
ObjectInputStream objectInputStream = null;
try {
objectInputStream = new ObjectInputStream(new FileInputStream(file));
Student student = (Student) objectInputStream.readObject();
System.out.println(student.toString());
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
if (objectInputStream != null) {
objectInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
5.3 transient
该关键字的作用是当序列化对象时，其中有不想要jvm序列化元素的时候，就需要在元素前加上该关键字。
也可以自己完成序列化工作
自定义序列化
在需要序列化的model类中增加这两个方法，首先反/序列化jvm能序列化的元素，再序列化自己需要自定义序列化的元素
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException{
s.defaultWriteObject(); //序列化jvm能默认序列化的元素
s.writeObject(name);
}
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
s.defaultReadObject(); //把jvm默认反序列的元素进行反序列化操作
this.name = (String) s.readObject();
}
