缓冲流
提高读写效率。四个基本的流的增强，分为：
字节缓冲流：BufferedInputStream，BufferedOutputStream
字符缓冲流：BufferedReader，BufferedWriter
原理：
创建流对象时，创建一个内置的默认大小的缓冲区，通过缓冲区读写，减少系统IO次数，提高读写效率。
1.字节缓冲流
构造方法：
public BufferedInputStream(InputStream in):创建一个新的缓冲输入流。
public BufferedOutputStream(OutputStream out):创建一个新的缓冲输出流。
import java.io.*;
public class Main {
public static void main(String[] args){
//普通方法
copy1();
//字节缓冲流
copy2();
//带数组的字节缓冲流
copy3();
}
/*1--普通方法*/
private static void copy1(){
long start = System.currentTimeMillis();
try (FileInputStream fis = new FileInputStream("D:\\测试文件夹\\1\\西游记.txt");
FileOutputStream fos = new FileOutputStream("D:\\测试文件夹\\1\\西游记1.txt");
){
int b;
while ((b = fis.read())!=-1){
fos.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--字节缓冲流*/
private static void copy2() {
long start = System.currentTimeMillis();
try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\测试文件夹\\1\\西游记.txt"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\测试文件夹\\1\\西游记2.txt"));
){
int b;
while ((b = fis.read())!=-1){
fos.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("字节缓冲流复制时间:"+(end - start)+" 毫秒");
}
/*3--带数据的字节缓冲流*/
private static void copy3() {
long start = System.currentTimeMillis();
try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\测试文件夹\\1\\西游记.txt"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\测试文件夹\\1\\西游记3.txt"));
){
int b;
byte[] bytes = new byte[100];
while ((b = fis.read(bytes))!=-1){
fos.write(bytes,0,b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("带数组的字节缓冲流复制时间:"+(end - start)+" 毫秒");
}
}
2.字符缓冲流
构造方法：
public BufferedReader(Reader in):创建一个闲的缓冲流。
public BufferedWriter（Writer out）：创建一个新的缓冲输出流。
特有方法：
BufferedReader：public String readLine():读一行文字。
BufferedWriter：public void newLine():写一行分隔符，由系统属性定义符号。
特殊方法：
1.BufferedReader：public String readLine():读一行文字。
2.BufferedWriter：public void newLine():写一行行分割符，由系统属性定义符号。
import java.io.*;
public class Main {
public static void main(String[] args){
// //字节-普通方法
// copy1();
// //字节-缓冲流
// copy2();
// //带数组的字节-缓冲流
// copy3();
//字符-普通方法
// copy2_1();
// copy2_2();
// copy2_3();
//特殊
//BufferedReader： public String readLine() : 读一行文字。
//BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。
readLine();
}
/*2--字符-普通方法*/
private static void copy2_1() {
long start = System.currentTimeMillis();
try (FileReader fr = new FileReader("D:\\测试文件夹\\1\\西游记.txt");
FileWriter fw = new FileWriter("D:\\测试文件夹\\1\\西游记4.txt");
){
int b;
while ((b = fr.read())!=-1){
// System.out.println("---"+(char)b);
fw.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--字符-缓冲流*/
private static void copy2_2() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记5.txt"));
){
int b;
while ((b = fr.read())!=-1){
// System.out.println("---"+(char)b);
fw.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--带数组的字符-缓冲流*/
private static void copy2_3() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记6.txt"));
){
int b;
char[] chars = new char[100];
while ((b = fr.read(chars)) != -1){
// System.out.println("---"+new String(chars,0,b));
fw.write(chars,0,b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*3--readLine-读取一行,和一行分割符*/
private static void readLine() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记7.txt"));
){
String line = null;
while ((line = fr.readLine())!= null){
// System.out.println(line);
fw.write(line);
fw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
}
合
import java.io.*;
public class Main {
public static void main(String[] args){
// //字节-普通方法
// copy1();
// //字节-缓冲流
// copy2();
// //带数组的字节-缓冲流
// copy3();
//字符-普通方法
// copy2_1();
// copy2_2();
// copy2_3();
//特殊
//BufferedReader： public String readLine() : 读一行文字。
//BufferedWriter： public void newLine() : 写一行行分隔符,由系统属性定义符号。
readLine();
}
/*1--字节-普通方法*/
private static void copy1(){
long start = System.currentTimeMillis();
try (FileInputStream fis = new FileInputStream("D:\\测试文件夹\\1\\西游记.txt");
FileOutputStream fos = new FileOutputStream("D:\\测试文件夹\\1\\西游记1.txt");
){
int b;
while ((b = fis.read())!=-1){
fos.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--字节-缓冲流*/
private static void copy2() {
long start = System.currentTimeMillis();
try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\测试文件夹\\1\\西游记.txt"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\测试文件夹\\1\\西游记2.txt"));
){
int b;
while ((b = fis.read())!=-1){
fos.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("字节缓冲流复制时间:"+(end - start)+" 毫秒");
}
/*3--带数组的字节-缓冲流*/
private static void copy3() {
long start = System.currentTimeMillis();
try (BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\测试文件夹\\1\\西游记.txt"));
BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\测试文件夹\\1\\西游记3.txt"));
){
int b;
byte[] bytes = new byte[100];
while ((b = fis.read(bytes))!=-1){
fos.write(bytes,0,b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("带数组的字节缓冲流复制时间:"+(end - start)+" 毫秒");
}
/*2--字符-普通方法*/
private static void copy2_1() {
long start = System.currentTimeMillis();
try (FileReader fr = new FileReader("D:\\测试文件夹\\1\\西游记.txt");
FileWriter fw = new FileWriter("D:\\测试文件夹\\1\\西游记4.txt");
){
int b;
while ((b = fr.read())!=-1){
// System.out.println("---"+(char)b);
fw.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--字符-缓冲流*/
private static void copy2_2() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记5.txt"));
){
int b;
while ((b = fr.read())!=-1){
// System.out.println("---"+(char)b);
fw.write(b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*2--带数组的字符-缓冲流*/
private static void copy2_3() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记6.txt"));
){
int b;
char[] chars = new char[100];
while ((b = fr.read(chars)) != -1){
// System.out.println("---"+new String(chars,0,b));
fw.write(chars,0,b);
}
}catch (IOException e){
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
/*3--readLine-读取一行,和一行分割符*/
private static void readLine() {
long start = System.currentTimeMillis();
try (BufferedReader fr = new BufferedReader(new FileReader("D:\\测试文件夹\\1\\西游记.txt"));
BufferedWriter fw = new BufferedWriter(new FileWriter("D:\\测试文件夹\\1\\西游记7.txt"));
){
String line = null;
while ((line = fr.readLine())!= null){
// System.out.println(line);
fw.write(line);
fw.newLine();
}
} catch (IOException e) {
e.printStackTrace();
}
// 记录结束时间
long end = System.currentTimeMillis();
System.out.println("普通流复制时间:"+(end - start)+" 毫秒");
}
}
转换流
字符编码
编码：计算机中储存的信息都是用二进制数表示的，而我们在屏幕上看到的数字、英文、标点符号、汉字等字符是二进制 数转换之后的结果。按照某种规则，将字符存储到计算机中，称为编码 。
解码：将存储在计算机中的二进制数按照 某种规则解析显示出来，称为解码 。
字符编码 Character Encoding : 就是一套自然语言的字符与二进制数之间的对应规则。
字符集
字符集 Charset ：也叫编码表。是一个系统支持的所有字符的集合，包括各国家文字、标点符号、图形符 号、数字等。
计算机要准确的存储和识别各种字符集符号，需要进行字符编码，一套字符集必然至少有一套字符编码。常见字符 集有ASCII字符集、GBK字符集、Unicode字符集等。
InputStreamReader类
转换流java.io.InputStreamReader ，是Reader的子类，是从字节流到字符流的桥梁。它读取字节，并使用指定 的字符集将其解码为字符。它的字符集可以由名称指定，也可以接受平台的默认字符集。
构造方法：
InputStreamWriter(InputStream in):创建一个使用默认字符集的字符流。
InputStreamReader(InputStream in,String charsetName):创建一个指定字符集的字符流。
OutputStreamWriter类：
转换流 java.io.OutputStreamWriter ，是Writer的子类，是从字符流到字节流的桥梁。使用指定的字符集将字符 编码为字节。它的字符集可以由名称指定，也可以接受平台的默认字符集。
构造方法：
OutputStreamWriter(OutputStream in):创建一个使用默认字符集的字符流。
OutputStreamWriter(OutputStream in,String charsetName):创建一个指定字符集的字符流。
import java.io.*;
public class Main {
public static void main(String[] args) {
//输入转换流
inputStreamReader();
//输出转换流
outputStreamWriter();
}
/*输入转换流*/
private static void inputStreamReader() {
try (InputStreamReader isr1 = new InputStreamReader(new FileInputStream("D:\\测试文件夹\\1\\ff.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("D:\\测试文件夹\\1\\ff.txt"),"GBK");
){
//UTF-8解码
int read;
while ((read = isr1.read())!=-1){
System.out.println("UTF-8:"+(char)read);
}
//GBK解码
int read2;
while ((read2 = isr2.read())!=-1){
System.out.println("GBK:"+(char)read2);
}
} catch (IOException e) {
e.printStackTrace();
}
}
/*输出转换流*/
private static void outputStreamWriter() {
try (OutputStreamWriter osr1 = new OutputStreamWriter(new FileOutputStream("D:\\测试文件夹\\1\\转换流.txt"),"UTF-8");
OutputStreamWriter osr2 = new OutputStreamWriter(new FileOutputStream("D:\\测试文件夹\\1\\转换流2.txt"),"GBK");
){
String wenzi = "氨基酸困难111111及纳税登记时看的见女浮动反馈等方面都开了个贷款房管局";
//UTF-8解码
osr1.write(wenzi);
//GBK解码
osr2.write(wenzi);
} catch (IOException e) {
e.printStackTrace();
}
}
}
序列化
Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象，该字节序列包含该 对象的数据 、 对象的 类型 和 对象中存储的属性 等信息。字节序列写出到文件之后，相当于文件中持久保存了一个对象的信息。
反之，该字节序列还可以从文件中读取回来，重构对象，对它进行反序列化。 对象的数据 、 对象的类型 和 对象中 存储的数据 信息，都可以用来在内存中创建对象。看图理解序列化：
ObjectOutputStream类，序列化
java.io.ObjectOutputStream 类，将Java对象的原始数据类型写出到文件,实现对象的持久存储。
构造方法：
public ObjectOutputStream(OutputStream out):创建一个指定OutputStream的ObjectOutputStream。
条件：
①该类必须实现 java.io.Serializable 接口， Serializable 是一个标记接口，不实现此接口的类将不会使任 何状态序列化或反序列化，会抛出 NotSerializableException 。
② 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用 transient 关键字修饰。
public class Employee implements java.io.Serializable {
}
方法：
public final void writeObject (Object obj)
ObjectInputStream类，反序列化
ObjectInputStream反序列化流，将之前使用ObjectOutputStream序列化的原始数据恢复为对象。
构造方法：
public ObjectInputStream(InputStream in):创建一个指定InputStream的ObjectInputStream。
注：
对于JVM可以反序列化对象，它必须是能够找到class文件的类。如果找不到该类的class文件，则抛出一个 ClassNotFoundException 异常。
import java.io.*;
import java.util.ArrayList;
public class Main {
public static void main(String[] args) {
//序列化
xulihua();
//反序列化
fanxuliehua();
}
/*序列化*/
private static void xulihua() {
Stu stu = new Stu("张三","nan",20);
Stu stu2 = new Stu("李四","女",11);
Stu stu3 = new Stu("王五","男",33);
Stu stu4 = new Stu("赵六","女",22);
try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\测试文件夹\\1\\序列化.txt"))
){
out.writeObject(stu);
// out.writeObject(stu2);
// out.writeObject(stu3);
// out.writeObject(stu4);
} catch (IOException e) {
e.printStackTrace();
}
}
/*反序列化*/
private static void fanxuliehua() {
// ArrayList<Stu> stuList = null;
Stu stu = null;
try (ObjectInputStream out = new ObjectInputStream(new FileInputStream("D:\\测试文件夹\\1\\序列化.txt"))
){
// ArrayList<Stu> stu = (ArrayList<Stu>) out.readObject();
stu = (Stu) out.readObject();
System.out.println("学生："+stu);
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
PrintStream类 打印流
构造方法：
public PrintStream(String fileName) ： 使用指定的文件名创建一个新的打印流。
700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
