流动的是数据—用于传输数据的一套API—IO->Input和Output—输入流和输出流—当数据是从外部流向程序的时候，输入流；数据是从程序流向外部的时候，输出流。读取文件—将数据从文件读到程序中—输入流；向文件中写入数据—数据从程序流向了文件—输出流。
根据数据的传输方向：输入流、输出流
根据数据的传输形式：字节流、字符流
这四个基本流都是抽象类。
数据来源(目的地)：硬盘，网络，输入设备，内存
FileWriter
向txt文件写入一个字符串—输出流，字符流，和文件有关的流—FileWriter
FileWriter(String path)—创建一个新文件。如果文件不存在，会创建一个新文件。
FileWriter继承了OutputStreamWriter。
流操作的过程:
创建流→流出数据→冲刷缓冲区→关闭流。
最后将流对象赋值为null标记为一个垃圾对象。
构造函数:
①FileWriter(File file);
无论文件是否存在，都会创建一个新的文件覆盖原来的文件。
②FileWriter(File file,boolean append);
是否追加内容。如果存在目标文件，不会删除原文件。
③FileWriter(String fileName);
根据给定的文件名fileName构造一个对象。
④FileWriter(String fileName,boolean append);
判断是否追加数据。
重要方法:
①write(String s);
写入数据。
数据不是直接写到文件中个，而是先写到缓冲区，缓冲区满了之后，才会将数据挪到文件中。如果缓冲区没有满而程序已经结束了，那么数据就死在来缓冲区。
②flush();
冲刷缓冲区。
③close();
关流。为了释放文件。流在关闭之前会自动的冲刷一次缓冲区，以防有数据死在缓冲区中。流关闭了，流对象依然存在。
流中的异常处理
1.将流对象放在try外定义并且赋值为null，放在try中初始化
2.在关流之前需要判断流对象是否初始化成功
3.需要将流强制置为null以防关流失败产生数据丢失
4.需要在写完数据之后手动添加flush操作以防关流失败产生数据丢失
FileWriter fw = null;
try {
// 创建对象
fw = new FileWriter("D:\\b.txt");
fw.write("稻香村");
// 尽量防止数据丢失
// 因为可能关闭不成功，那么就不会冲刷缓冲区
fw.flush();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
// 关闭资源
// fw可能创建失败,会出现空指针异常
if (fw!= null){
try {
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
// 如果关闭成功，那么释放内存
// 如果关闭失败，依然需要释放内存
fw = null;
}
}
}
FileReader
读取一个txt文件—输入流 字符流 和文件有关的流—FileReader，FileReader继承了InputStreamReader。是缓冲流的一个子类
流操作的过程
创建流→读取数据→关闭流
在输入流中没有缓冲区，可以自己指定缓冲区。
构造函数
①FileReader(File file);
读取给定的文件。
②FileReader(String fileName);
读取给定的文件名称的文件。
重要方法
①read();
每次只读取一个字符。返回值是一个int类型，表示的是这个字符对应的编码。
复制文件
import java.io.FileReader;
import java.io.FileWriter;
public class CopyFileDemo {
public static void main(String[] args) {
// 创建一个输入流指向要复制的文件
FileReader reader = null;
// 创建一个输出流指向要存储的文件
FileWriter writer = null;
try {
reader = new FileReader("E:\\a.txt");
writer = new FileWriter("F:\\a.txt");
// 定义一个变量来记录读取的字符个数
int i = -1;
// 定义一个数组作为缓冲区使用
char[] cs = new char[4];
// 读取文件
while ((i = reader.read(cs)) != -1) {
// 将读取的数据写出
writer.write(cs, 0, i);
}
// 需要手动冲刷缓冲区
writer.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
if (reader != null) {
try {
reader.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
reader = null;
}
}
if (writer != null) {
try {
writer.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
writer = null;
}
}
}
}
}
缓冲流
BufferedReader
BufferedReader—需要传入字符输入流，真正读取数据的是传入的这个字符输入流，缓冲流仅仅提供了一个缓冲区。
继承了Reader
在读取文件的过程中，考虑到FileReader没有缓冲区，读取效率比较低，就利用bufferedReader包装上一层缓冲区。关闭的时候只关闭外层流即可，因为关闭外层流的时候，会自动关闭里层的流。也可以手动关闭，关闭顺序要从里往外关闭。
构造函数
①BufferedReader(Reader in);
使用默认大小输入缓冲区的缓冲字符输入流。
②BufferedReader(Reader in ,int sz)
创建一个使用指定大小输s入缓冲区的缓冲字符输入流。
重要方法
①readLine();
读取一行（以回车换行作为一行的结束），返回的是String类型。
BufferedWriter
用其他字符输出流来写出数据，提供来一个更大的缓冲区，同时提供来newLine();能够屏蔽不同系统之间换行的差异性。
构造函数
①BufferedWriter(Writer out);
②BufferedWriter(Writer out , int sz)
重要方法
①newLine();
换行。在不同的系统中，转换为对应的换行。
统计Java代码的行数
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
public class GetRowCountDemo {
// 记录行数
static int count = 0;
public static void main(String[] args) {
// 创建一个File对象指向工作空间
File file = new File("E:\\workspace");
count(file);
System.out.println(count);
}
private static void count(File file) {
// 判断file是否为空
if (file == null) {
throw new NullPointerException("亲，文件不能为空哦~~~");
}
// 判断是否是一个目录
if (file.isDirectory()) {
// 获取子文件和子目录
File[] fs = file.listFiles();
for (File f : fs) {
count(f);
}
} else if (file.getName().endsWith(".java")) {
// 统计代码行数---按行读取
BufferedReader br = null;
try {
// 创建一个缓冲流指向要统计的文件
br = new BufferedReader(new FileReader(file));
// 按行读取
while (br.readLine() != null) {
count++;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (Exception e) {
e.printStackTrace();
} finally {
br = null;
}
}
}
}
}
}
public class BufferedWriterDemo {
public static void main(String[] args) throws IOException {
// 创建对象
FileWriter fw = new FileWriter("D:\\c.txt");
// 底层本质上还是使用FileWriter进行写入
BufferedWriter bw = new BufferedWriter(fw);
// 写入数据
bw.write("你好，2019！");
// 换行 会自动根据当前操作系统调整换行符
bw.newLine();
bw.write("你好，2019！");
// 冲刷缓冲区
bw.flush();
// 关闭流
bw.close();
}
}
StringReader
读取字符串的流
字节流
以字节形式来读写文件。
FileOutputStream
FileOutputStream class 继承了OutputStream class。
创建一个字节流→写入数据→关流
构造函数
①FileOutputStream(File file);
②FileOutputStream(String name);
③FileOutputStream(String name,boolean append)
重要方法
①write(int b);
②write(byte[] b);
③write(byte[] b,int off,int len);
FileInputStream
FileInputStream class继承了InputStream class。
创建一个字节流→创建缓冲区→读出数据→关流
构造函数
①FileInputStream(File file);
②FileInputStream(String name);
重要方法
①read();
②read(byte[] b);
③read(byte[] b ,int off,int len);
复制文件
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class CopyFileExer {
public static void main(String[] args) throws IOException {
long begin = System.currentTimeMillis();
// 创建一个字节流来读取指定的文件
FileInputStream in = new FileInputStream("E:\\aaa.zip");
// 创建有一个字节流来指向存储的文件
FileOutputStream out = new FileOutputStream("F:\\b.zip");
// 构建一个字节数组作为缓冲区
byte[] bs = new byte[1024 * 1024 * 15];
// 定义一个变量来记录读取到的字节个数
int len = -1;
// 读取数据
while ((len = in.read(bs)) != -1) {
// 将读取到的数据写出
out.write(bs, 0, len);
}
// 关流
out.close();
in.close();
long end = System.currentTimeMillis();
System.out.println(end - begin);
}
}
转换流
InputStreamReader
转换输入流—将字节流转化为字符流—底层是以字节流形式读取，但是表层是以字符流形式操作
构造函数
①InputStreamReader(InputStream in);
创建一个使用默认编码参数为字节流的对象。
②InputStreamReader(InputStream in,Charset cs);
创建一个使用指定编码参数为字节流的对象。
③InputStreamReader(InputStream in,String charsetName);
④InputStreamReader(InputStream in,CharsetDecoder dec);
重要方法
①read();
读取单个字符。
②read(char[] cbuf,int offset,int length);
读入字符数组中的某一部分。
OutputStreamWriter
转换输出流—将字符流转化为字节流—表层是以字符流形式写出，底层是以字节流形式来传输
构造函数
①OutputStreamWriter(OutputStream out);
创建一个使用默认编码参数为字节流的对象。
②OutputStreamWriter(OutputStream out,Charset cs);
③OutputStreamWriter(OutputStream out,CharsetEncoder enc);
④OutputStreamWriter(OutputStream out,String charsetName);
转换文件编码
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
public class ChangeEncodeExer {
public static void main(String[] args) throws Exception {
// 创建一个File对象指向源文件
File old = new File("F:\\java基础增强.txt");
// 创建一个File对象作为临时文件
File temp = new File("F:\\temp");
// 准备缓冲流对象以实现按行读取
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream(old), "utf-8"));
// 创建一个缓冲流对象将读取的数据写到临时文件中
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(temp), "gbk"));
// 定义一个字符串记录每行的数据
String line = null;
// 读取数据
while ((line = br.readLine()) != null) {
// 将读取的数据写出
bw.write(line);
bw.newLine();
}
// 关流
br.close();
bw.close();
// 删除源文件
old.delete();
// 将临时文件命名为原文件的名字
temp.renameTo(old);
}
}
系统流/标准流
都是字节流，系统一旦关闭无法二次使用。
System.in 标准输入流
System.out 标准输出流，线程不安全的。
System.err 标准错误流，线程不安全的。
从控制台获取一行数据
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = br.readLine();
System.out.println(str);
Br.close;
打印流
PrintStream
打印流只有输出流，没有输入流。
构造方法
①PrintStream(File file);
②PrintStream(OutputStream out);
重要方法
①print(int/long/float/double/char/char[]/boolean/String/Object s);
打印。
②println(/int/long/float/double/char/char[]/boolean/String/Object s);
打印换行。
PrintWriter
是一个字符流。
构造方法
①PrintWriter(File file);
②PrintWriter(OutputStream out);
③PrintWriter(String fileName);
④PrintWriter(Writer out);
重要方法
①print();
②println();
③write();
public static void main(String[] args) {
// 表示将数据打印到控制台上
PrintStream ps = new PrintStream(System.out);
// ps.print(new Object());
ps.print(new char[] { ‘a’, ‘b’, ‘c’ });
// BufferedWriter—newLine()
ps.println(“abc”);
ps.close();
}
```合并流
SequenceInputStream
字节流—可以合并多个字节输入流，将这多个字节输入流进行合并的时候，需要将这个多个流放到一个Vector集合，利用Vector集合产生一个Enumeration对象，利用Enumeration对象来构造合并流对象—合并流只有输入没有输出
构造函数
①SequenceInputStream(Enumeration<? extends InputStream> e);
②SequenceInputStream(InputStream s1,InputStream s2);
按照参数顺序来读取参数对象。
重要方法
①read();
②read(byte[] b,int off,int len);
public static void main(String[] args) throws Exception {
// 创建一个输出流，将读取的数据写出
FileOutputStream out = new FileOutputStream("E:\\test.txt");
// 创建一个输入流指向a.txt
FileInputStream in1 = new FileInputStream("E:\\a.txt");
FileInputStream in2 = new FileInputStream("E:\\b.txt");
FileInputStream in3 = new FileInputStream("E:\\c.txt");
// 创建一个Vector对象来存储这三个输入流
Vector<InputStream> v = new Vector<>();
v.add(in1);
v.add(in2);
v.add(in3);
// 获取Enumeration对象
Enumeration<InputStream> e = v.elements();
// 创建合并流对象
SequenceInputStream sis = new SequenceInputStream(e);
// 利用合并流来读取数据
byte[] bs = new byte[4];
int len = -1;
while ((len = sis.read(bs)) != -1) {
out.write(bs, 0, len);
}
}
// 关流
out.close();
sis.close();
}
-
如果一个对象要想被序列化，这个对象对应的类必须实现一个接口—Serializable—这个接口中没有任何的方法和属性，仅仅用来标识这个类产生的对象可以被序列化
-
被static/transient修饰的属性不会被序列化
-
每一个类在序列化的时候都会有一个版本号。如果没有手动指定版本号，那么在编译的时候会根据当前类
中的方法和属性自动计算一个版本号。对象在反序列化的时候会比较对象中的版本号和当前类中的版本号是否一致。如果手动指定了版本号，就不再自动计算。—版本号serialVersionUID—默认用private static final long修饰 -
集合/数组不能被序列化
代表序列化的类
ObjectOutputStream
①构造函数
1)ObjectOutputStream();
2)ObjectOutputStream(OutputStream out);
②重要方法
1)writeObject();
// 准备一个对象
Person p = new Person();
p.setName("雪花");
p.setAge(15);
p.setHeight(150);
p.setGender('女');
// 静态属性没有被序列化出去，为什么？
// p.hobby = "睡觉~~~";
// 创建一个序列化流
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("E:\\p.data"));
// 将对象序列化出去
oos.writeObject(p);
// 关流
oos.close();
ObjectInputStream
①构造函数
1)ObjectInputStream();
2)ObjectInputStream(InputStream in);
②重要方法
1)readObject();
// 创建反序列化流对象
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("E:\\p.data"));
// 将对象反序列化回来
Person p = (Person) ois.readObject();
// 关流
ois.close();
System.out.println(p.getName());
System.out.println(p.getAge());
// 如果一个属性没有被序列化出去，那么在反序列化的时候会给一个默认值
System.out.println(p.getHeight());
2649
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
