流操作的目的:完成内存数据和磁盘数据的转换。
流按照方向分:输入流和输出流,以内存作为参照物。
当从数据源中将数据读取到内存中时,叫输入流(读取流)。
当将内存中的数据写入要数据源时,叫输出流(写入流)。
流按照传输的内容分:字节流和字符流,对象流。
无论是哪一种流,底层部分都是以字节方式传输,所以,其本质都是字节流。但是为了方便程序员更好的操作字符数据和对象数据,所以在字节流基础上做了一层包装,形成了字符流和对象流。
流操作的步骤:
1. 建立流;
2. 操作流;
3. 关闭流;
流操作以后必须关闭操作,否则不仅浪费内存资源,而且写入流有可能写不进数据。
操作文件流时,如果文件不存在,那么读取流会抛出文件未找到异常,而写入流,会创建新文件。
[字节流的父类:InputStream(读取流) ][ OutputStream(写入流)]
// 读取
public void inputFile() {
InputStream input = null;
try {
//建立文件读取字节流
input = new FileInputStream("D:/a.jpg");
byte[] by = new byte[1024];
int len = 0;
//将流中的数据读取到字节数组中,返回当前读取的字节数,读取完毕,返回-1
//read()从此输入流中将最多 by.length 个字节的数据读入一个 byte 数组中
while ((len = input.read(by)) != -1) {
System.out.println(len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//写入
public void outputFile(String str) {
OutputStream out = null;
try {
//第二个参数如果是true表示追加方式写入数据
out = new FileOutputStream("D:/b.txt",true);
out.write(str.getBytes());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//拷贝
public void copyFile() {
InputStream input = null;
OutputStream out = null;
try {
input = new FileInputStream("D:/a.txt");
out = new FileOutputStream("D:/b.txt");
byte[] by = new byte[1024];
int len = 0;
while ((len = input.read(by)) != -1) {
//读取了几个字节,就写入几个字节
out.write(by, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
[字符流的父类:Reader ][ Writer]
//读取
public void reader() {
Reader read = null;
BufferedReader bu = null;
try {
//建立文件读取流
read = new FileReader("D:/a.txt");
//套接流,在一个流的基础上,再套接一个流,也称为高级流
bu = new BufferedReader(read);
String str = null;
while ((str = bu.readLine()) != null) {
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bu.close();
read.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//写入
public void writer() {
Writer wri = null;
try {
//第二个参数如果是true表示追加方式写入数据
wri = new FileWriter("D:/1.txt",true);
wri.write("bilibili");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
wri.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
对象流
序列化:当需要堆对象进行传输时由于对象中的数据很庞大,无法直接传输,那么在传输之前需要将对象打散成二进制的序列,一遍遍传输,这个过程称为序列化过程,到达目的地后,有需要将二进制序列还原成对象,这个过程称为反序列化过程。
所有需要实现对象序列化的对象必须实现Serializable接口
//transient是属性修饰符,加上transient后,表示该属性的值不进行传输
private transient int score;
流按照方向分:输入流和输出流,以内存作为参照物。
当从数据源中将数据读取到内存中时,叫输入流(读取流)。
当将内存中的数据写入要数据源时,叫输出流(写入流)。
流按照传输的内容分:字节流和字符流,对象流。
无论是哪一种流,底层部分都是以字节方式传输,所以,其本质都是字节流。但是为了方便程序员更好的操作字符数据和对象数据,所以在字节流基础上做了一层包装,形成了字符流和对象流。
流操作的步骤:
1. 建立流;
2. 操作流;
3. 关闭流;
流操作以后必须关闭操作,否则不仅浪费内存资源,而且写入流有可能写不进数据。
操作文件流时,如果文件不存在,那么读取流会抛出文件未找到异常,而写入流,会创建新文件。
[字节流的父类:InputStream(读取流) ][ OutputStream(写入流)]
// 读取
public void inputFile() {
InputStream input = null;
try {
//建立文件读取字节流
input = new FileInputStream("D:/a.jpg");
byte[] by = new byte[1024];
int len = 0;
//将流中的数据读取到字节数组中,返回当前读取的字节数,读取完毕,返回-1
//read()从此输入流中将最多 by.length 个字节的数据读入一个 byte 数组中
while ((len = input.read(by)) != -1) {
System.out.println(len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//写入
public void outputFile(String str) {
OutputStream out = null;
try {
//第二个参数如果是true表示追加方式写入数据
out = new FileOutputStream("D:/b.txt",true);
out.write(str.getBytes());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//拷贝
public void copyFile() {
InputStream input = null;
OutputStream out = null;
try {
input = new FileInputStream("D:/a.txt");
out = new FileOutputStream("D:/b.txt");
byte[] by = new byte[1024];
int len = 0;
while ((len = input.read(by)) != -1) {
//读取了几个字节,就写入几个字节
out.write(by, 0, len);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
input.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
[字符流的父类:Reader ][ Writer]
//读取
public void reader() {
Reader read = null;
BufferedReader bu = null;
try {
//建立文件读取流
read = new FileReader("D:/a.txt");
//套接流,在一个流的基础上,再套接一个流,也称为高级流
bu = new BufferedReader(read);
String str = null;
while ((str = bu.readLine()) != null) {
System.out.println(str);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
bu.close();
read.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
//写入
public void writer() {
Writer wri = null;
try {
//第二个参数如果是true表示追加方式写入数据
wri = new FileWriter("D:/1.txt",true);
wri.write("bilibili");
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
wri.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
对象流
序列化:当需要堆对象进行传输时由于对象中的数据很庞大,无法直接传输,那么在传输之前需要将对象打散成二进制的序列,一遍遍传输,这个过程称为序列化过程,到达目的地后,有需要将二进制序列还原成对象,这个过程称为反序列化过程。
所有需要实现对象序列化的对象必须实现Serializable接口
//transient是属性修饰符,加上transient后,表示该属性的值不进行传输
private transient int score;