public class FileWriter extends OutputStreamWriter
public class OutputStreamWriter extends Writer
public abstract class Writer extends Object implements Appendable, Closeable, Flushable //能够被添加 char 序列和值的对象，如果某个类的实例打算接收取自 Formatter 的格式化输出 //那么该类必须实现 Appendable 接口 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
FileWriter(String fileName)，根据参数指定的文件名构造对象 FileWriter(String fileName, boolean append)，以追加的方式根据参数指定的文件名来构造对象 void write(int c)，写入单个字符 void write(char[] cbuf, int off, int len)，将指定字符数组中从偏移量off开始的len个字符写入此文件输出流 void write(char[] cbuf)，将cbuf.length个字符从指定字符数组写入此文件输出流中 void flush()，刷新流 void close()，关闭流对象并释放有关的资源，自带刷新功能
package com.lagou.task17;
import java.io.FileWriter;
import java.io.IOException;
public class FileWriterTest {
public static void main(String[] args) {
// 选中代码后可以使用 ctrl+alt+t 来生成异常的捕获代码等
FileWriter fw = null;
try {
// 1.构造FileWrite类型的对象与d:/a.txt文件关联
// 若文件不存在，该流会自动创建新的空文件
// 若文件存在，该流会清空文件中的原有内容
//FileWriter(String fileName)，根据参数指定的文件名构造对象
//fw = new FileWriter("d:/ggg/a.txt");
//用fw流指向这个文件，称fw为管道(流)
// 以追加的方式创建对象去关联文件
// 若文件不存在则自动创建新的空文件，若文件存在则保留原有数据内容
//FileWriter(String fileName, boolean append)，以追加的方式根据参数指定的文件名来构造对象
fw = new FileWriter("d:/ggg/a.txt", true); //设置false就不会追加了
// 而是清空文件中的原有内容，在写入数据，而true就不会而是清空文件中的原有内容
// 2.通过流对象写入数据内容 每当写入一个字符后则文件中的读写位置向后移动一位
//给管道倒水(自己放入一个数据)，即给流数据'a'，流将数据，流(写)到文件里
//void write(int c)，写入单个字符
fw.write('a');
// 准备一个字符数组
char[] cArr = new char[]{'h', 'e', 'l', 'l', 'o'};
// 将字符数组中的一部分内容写入进去
//void write(char[] cbuf, int off, int len)
//将指定字符数组中从偏移量off开始的len个字符写入此文件输出流
fw.write(cArr, 1, 3); // ell
// 将整个字符数组写进去
//void write(char[] cbuf)，将cbuf.length个字符从指定字符数组写入此文件输出流中
fw.write(cArr); // hello
// 刷新流
//往文件写数据时，要通过流，在流的内部还会残留一部分数据
//而他可以将该数据控干净，即刷新出去，扔到文件里
//即将上一次没过去的数据放入文件
//void flush()，刷新流
fw.flush();
System.out.println("写入数据成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != fw) {
try {
//断开流与文件的联系，自带刷新功能，但有可能会关不了，即还会用刷新流flush()
//void close()，关闭流对象并释放有关的资源，自带刷新功能
fw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileReader类------------------------------
java.io.FileReader类主要用于从文本文件读取文本数据内容
public class FileReader extends InputStreamReader
public class InputStreamReader extends Reader
public abstract class Reader extends Object implements Readable, Closeable //Readable接口就是为了Scanner类专门创建的一个接口，使得Scanner的入口参数不必限于某个类 //实现Readable接口要只需是实现public int read(CharBuffer cb)方法，当方法返回-1时候Scanner类停止读取 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
FileReader(String fileName)，根据参数指定的文件名构造对象 int read()，读取单个字符的数据并返回，返回-1表示读取到末尾 int read(char[] cbuf, int offset, int length)，从输入流中将最多len个字符的数据读入一个字符数组中 返回读取到的字符个数，返回-1表示读取到末尾，offset是数组的下标，依次往下放 int read(char[] cbuf)，从此输入流中将最多 cbuf.length 个字符的数据读入字符数组中 返回读取到的字符个数，返回-1表示读取到末尾 void close()，关闭流对象并释放有关的资源
package com.lagou.task17;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
public class FileCharCopyTest {
public static void main(String[] args) {
FileReader fr = null;
FileWriter fw = null;
//try,catch,finally里面创建的变量，不能用于他们之外，但之外的变量可以用
//即可以说是他们三个空间不与其他人共享，就是相当于if语句的变量一样
// 那么就可以说finally的值也影响不到他们两个
try {
// 1.创建FileReader类型的对象与d:/a.txt文件关联
fr = new FileReader("d:/a.txt");
//fr = new FileReader("d:/03 IO流的框架图.png");
// 2.创建FileWriter类型的对象与d:/b.txt文件关联
fw = new FileWriter("d:/b.txt");
//fw = new FileWriter("d:/IO流的框架图.png"); 拷贝图片文件失败！！！
//虽然拷贝成功，但还是有些会损失，因为对于图片或视频等，字符流无法将他们变为可以知道的字符
//即会有损失
// 3.不断地从输入流中读取数据内容并写入到输出流中
System.out.println("正在玩命地拷贝...");
int res = 0;
while ((res = fr.read()) != -1) {
fw.write(res);
}
System.out.println("拷贝文件成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != fw) {
try {
fw.close();
//先创建后关闭，先创建的一般用到最后
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != fr) {
try {
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.lagou.task17;
import java.io.FileReader;
import java.io.IOException;
public class FileReaderTest {
public static void main(String[] args) {
FileReader fr = null;
try {
// 1.构造FileReader类型的对象与d:/a.txt文件关联
//fr = new FileReader("d:/a.txt");
//FileReader(String fileName)，根据参数指定的文件名构造对象
//若文件存在，该流会清空文件中的原有内容b
fr = new FileReader("d:/b.txt");
// 2.读取数据内容并打印
int res = 0;
while ((res = fr.read()) != -1) {
System.out.println("读取到的单个字符是：" + (char)res + "，对应的编号是：" + res);
}
// 准备一个字符数组来保存读取到的数据内容
// char[] cArr = new char[5];
// 期望读满字符数组中的一部分空间，也就是读取3个字符放入数组cArr中下标从1开始的位置上
//int read(char[] cbuf, int offset, int length)
//从输入流中将最多len个字符的数据读入一个字符数组中
//返回读取到的字符个数，返回-1表示读取到末尾，offset是数组的下标，依次往下放
// 期望读满整个字符数组
//int read(char[] cbuf)，从此输入流中将最多 cbuf.length 个字符的数据读入字符数组中
//返回读取到的字符个数，返回-1表示读取到末尾
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != fr) {
try {
//void close()，关闭流对象并释放有关的资源
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileOutputStream类------------------------------
java.io.FileOutputStream类主要用于将图像数据之类的原始字节流写入到输出流中
public class FileOutputStream extends OutputStream
public abstract class OutputStream extends Object implements Closeable, Flushable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
FileOutputStream(String name)，根据参数指定的文件名来构造对象 FileOutputStream(String name,boolean append)，以追加的方式根据参数指定的文件名来构造对象 void write(int b)，将指定字节写入此文件输出流 void write(byte[] b, int off, int len)，将指定字节数组中从偏移量off开始的len个字节写入此文件输出流 void write(byte[] b)，将 b.length 个字节从指定字节数组写入此文件输出流中 void flush()，刷新此输出流并强制写出任何缓冲的输出字节 void close()，关闭流对象并释放有关的资源FileInputStream类------------------------------ java.io.FileInputStream类主要用于从输入流中以字节流的方式读取图像数据等
public class FileInputStream extends InputStream
public abstract class InputStream extends Object implements Closeable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
FileInputStream(String name)，根据参数指定的文件路径名来构造对象 int read()，从输入流中读取单个字节的数据并返回，返回-1表示读取到末尾 int read(byte[] b, intoff, int len)，从此输入流中将最多len个字节的数据读入字节数组中 返回读取到的字节个数，返回-1表示读取到末尾 int read(byte[] b)，从此输入流中将最多 b.length 个字节的数据读入字节数组中 返回读取到的字节个数，返回-1表示读取到末尾 void close()，关闭流对象并释放有关的资源 int available()，获取输入流所关联文件的大小案例题目------------------------------ 编程实现两个文件之间的拷贝功能
package com.lagou.task17;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileByteCopyTest {
public static void main(String[] args) {
// 获取当前系统时间距离1970年1月1日0时0分0秒的毫秒数
long g1 = System.currentTimeMillis();
FileInputStream fis = null;
FileOutputStream fos = null;
try {
//FileInputStream(Stringname)，根据参数指定的文件路径名来构造对象
// 1.创建FileInputStream类型的对象与d:/03 IO流的框架图.png文件关联
fis = new FileInputStream("d:/03 IO流的框架图.png");
//fis = new FileInputStream("d:/02_IO流的框架结构.mp4");
// 2.创建FileOutputStream类型的对象与d:/IO流的框架图.png文件关联
fos = new FileOutputStream("d:/IO流的框架图.png");
//fos = new FileOutputStream("d:/IO流的框架结构.mp4");
// 3.不断地从输入流中读取数据内容并写入到输出流中
//若拷贝一半停止，那么有可能会播放，但有些损坏，也有可能播放不了，因为损坏到关键位置
//而拷贝不同类型的，那么就会出错，因为解析不了
System.out.println("正在玩命地拷贝...");
// 方式一：以单个字节为单位进行拷贝，也就是每次读取一个字节后再写入一个字节
// 缺点：文件稍大时，拷贝的效率很低
// 方式二：准备一个和文件大小一样的缓冲区，一次性将文件中的所有内容取出到缓冲区然后一次性写入进去
// 缺点：若文件过大时，无法申请和文件大小一样的缓冲区，真实物理内存不足
// 方式三：准备一个相对适当的缓冲区，分多次将文件拷贝完成
byte[] bArr = new byte[1024];
int res = 0;
while ((res = fis.read(bArr)) != -1) {
fos.write(bArr, 0, res);
}
System.out.println("拷贝文件成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != fos) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != fis) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long g2 = System.currentTimeMillis();
System.out.println("使用文件流拷贝视频文件消耗的时间为：" + (g2-g1)); // 165
}
}
字节流读取和写入一个字节，看时都会解码为二进制，而字符是看自己的图案和编码表里图案有没有匹配，若没有，则写入相似的
如当一个字节表示图案时，该图案找不到相同的（编码方式不同，可能图案会不相同，如乱码的出现）
那么就用相似的来补充，由于图片，和音频等，都是单字节存储
那么在比较时，有可能会变成两个字节的图案，那么就会造成拷贝时，可能会使得文件变大，但若都相同，则不会
即还是看你编码的方式，即可以说：字符流 = 字节流 + 编码方式
BufferedOutputStream类------------------------------
java.io.BufferedOutputStream类主要用于描述缓冲输出流，此时不用为写入的每个字节调用底层系统
public class BufferedOutputStream extends FilterOutputStream
public class FilterOutputStream extends OutputStream
public abstract class OutputStream extends Object implements Closeable, Flushable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
BufferedOutputStream(OutputStream out)，根据参数指定的引用来构造对象 BufferedOutputStream(OutputStream out, int size)，根据参数指定的引用和缓冲区大小来构造对象 void write(int b)写入单个字节 void write(byte[] b, int off, int len)，写入字节数组中的一部分数据 void write(byte[] b)，写入参数指定的整个字节数组 void flush()，刷新流 void close()，关闭流对象并释放有关的资源BufferedInputStream类------------------------------ java.io.BufferedInputStream类主要用于描述缓冲输入流
public class BufferedInputStream extends FilterInputStream
public class FilterInputStream extends InputStream
public abstract class InputStream extends Object implements Closeable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
BufferedInputStream(InputStream in)，根据参数指定的引用构造对象 BufferedInputStream(InputStream in, int size)，根据参数指定的引用和缓冲区大小构造对象 int read()，读取单个字节 int read(byte[] b, int off, int len)，读取len个字节 int read(byte[] b)，读取b.length个字节 void close()，关闭流对象并释放有关的资源
package com.lagou.task17;
import java.io.*;
public class BufferedByteCopyTest {
public static void main(String[] args) {
// 获取当前系统时间距离1970年1月1日0时0分0秒的毫秒数
long g1 = System.currentTimeMillis();
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
// 1.创建BufferedInputStream类型的对象与d:/02_IO流的框架结构.mp4文件关联
//BufferedOutputStream(OutputStream out)，根据参数指定的引用来构造对象
bis = new BufferedInputStream(new FileInputStream("d:/03 IO流的框架图.png"));
// 2.创建BufferedOuputStream类型的对象与d:/IO流的框架结构.mp4文件关联
bos = new BufferedOutputStream(new FileOutputStream("d:/IO流的框架结构.png"));
// 3.不断地从输入流中读取数据并写入到输出流中
System.out.println("正在玩命地拷贝...");
byte[] bArr = new byte[1024];
int res = 0;
while ((res = bis.read(bArr)) != -1) {
bos.write(bArr, 0, res);
}
//缓冲区自带8192，若你设置的字节数组长度没有超过这个数，那么就用8192覆盖掉
//若超过了，就用超过的
System.out.println("拷贝文件成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != bos) {
try {
bos.close();
//带着参数一起关闭
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != bis) {
try {
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
long g2 = System.currentTimeMillis();
System.out.println("使用缓冲区拷贝视频文件消耗的时间为：" + (g2-g1)); // 44
}
}
可以知道，不用缓冲流要比用缓冲流慢，即我们最好用缓冲流
BufferedWriter类------------------------------
java.io.BufferedWriter类主要用于写入单个字符、字符数组以及字符串到输出流中
public class BufferedWriter extends Writer
public abstract class Writer extends Object implements Appendable, Closeable, Flushable //能够被添加 char 序列和值的对象，如果某个类的实例打算接收取自 Formatter 的格式化输出 //那么该类必须实现 Appendable 接口 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
BufferedWriter(Writer out)，根据参数指定的引用来构造对象 BufferedWriter(Writer out, int sz)，根据参数指定的引用和缓冲区大小来构造对象 void write(int c)，写入单个字符到输出流中 void write(char[] cbuf, int off, intlen)，将字符数组cbuf中从下标off开始的len个字符写入输出流中 void write(char[] cbuf)，将字符串数组cbuf中所有内容写入输出流中 void write(String s, int off, int len)，将参数s中下标从off开始的len个字符写入输出流中 void write(String str)，将参数指定的字符串内容写入输出流中 void newline()，用于写入行分隔符到输出流中，可以到下一行 void flush()，刷新流 void close()，关闭流对象并释放有关的资源BufferedReader类------------------------------ java.io.BufferedReader类用于从输入流中读取单个字符、字符数组以及字符串
public class BufferedReader extends Reader
public abstract class Reader extends Object implements Readable, Closeable //Readable接口就是为了Scanner类专门创建的一个接口，使得Scanner的入口参数不必限于某个类 //实现Readable接口要只需是实现public int read(CharBuffer cb)方法，当方法返回-1时候Scanner类停止读取 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
BufferedReader(Reader in)，根据参数指定的引用来构造对象 BufferedReader(Reader in, int sz)，根据参数指定的引用和缓冲区大小来构造对象 int read()，从输入流读取单个字符，读取到末尾则返回-1，否则返回实际读取到的字符内容 int read(char[] cbuf, intoff, int len)，从输入流中读取len个字符放入数组cbuf中下标从off开始的位置上 若读取到末尾则返回-1，否则返回实际读取到的字符个数 int read(char[] cbuf)，从输入流中读满整个数组cbuf String readLine()，读取一行字符串并返回，返回null表示读取到末尾，读取一行字符串 void close()，关闭流对象并释放有关的资源
package com.lagou.task17;
import java.io.*;
public class BufferedCharCopyTest {
public static void main(String[] args) {
BufferedReader br = null;
BufferedWriter bw = null;
try {
// 1.创建BufferedReader类型的对象与d:/a.txt文件关联
//BufferedReader(Readerin)，根据参数指定的引用来构造对象
br = new BufferedReader(new FileReader("d:/a.txt"));
// 2.创建BufferedWriter类型的对象与d:/b.txt文件关联
//BufferedWriter(Writer out)，根据参数指定的引用来构造对象
bw = new BufferedWriter(new FileWriter("d:/b.txt"));
// 3.不断地从输入流中读取一行字符串并写入到输出流中
System.out.println("正在玩命地拷贝...");
String str = null;
while ((str = br.readLine()) != null) {
bw.write(str);
bw.newline(); // 当前系统中的行分隔符是：rn
}
System.out.println("拷贝文件成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != bw) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
n和r的区别，前者n可以理解为换行，后者，就将回到当前的开头，若在回到开头之前，有其他数，那么就会清除
案例------------------------------
System.out.print("啊n和");
System.out.print("奖金r哦");
//输出结果
//啊
//哦
//"哦"前面的"和奖金"都没了，并且你到下一行时，是开头，通常都会以为与n没区别，但其实清除东西了
PrintStream类------------------------------
java.io.PrintStream类主要用于更加方便地打印各种数据内容
public class PrintStream extends FilterOutputStream implements Appendable, Closeable
public class FilterOutputStream extends OutputStream
public abstract class OutputStream extends Object implements Closeable, Flushable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
PrintStream(OutputStream out)，根据参数指定的引用来构造对象 void print(String s)，用于将参数指定的字符串内容打印出来 void println(String x)，用于打印字符串后并终止该行 void flush()，刷新流 void close()，用于关闭输出流并释放有关的资源PrintWriter类------------------------------ java.io.PrintWriter类主要用于将对象的格式化形式打印到文本输出流
public class PrintWriter extends Writer
public abstract class Writer extends Object implements Appendable, Closeable, Flushable //能够被添加 char 序列和值的对象，如果某个类的实例打算接收取自 Formatter 的格式化输出 //那么该类必须实现 Appendable 接口 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
PrintWriter(Writer out)，根据参数指定的引用来构造对象 void print(String s)，将参数指定的字符串内容打印出来 void println(String x)，打印字符串后并终止该行 void flush()，刷新流 void close()，关闭流对象并释放有关的资源案例题目------------------------------ 不断地提示用户输入要发送的内容，若发送的内容是"bye"则聊天结束，否则将用户输入的内容写入到文件d:/a.txt中 要求使用BufferedReader类来读取键盘的输入 System.in代表键盘输入 要求使用PrintStream类负责将数据写入文件
package com.lagou.task17;
import java.io.*;
import java.text.SimpleDateFormat;
import java.util.Date;
public class PrintStreamChatTest {
public static void main(String[] args) {
// 由手册可知：构造方法需要的是Reader类型的引用，但Reader类是个抽象类
//实参只能传递子类的对象 字符流
// 由手册可知： System.in代表键盘输入， 而且是InputStream类型的 字节流
//public static final InputStream in = null;
BufferedReader br = null;
PrintStream ps = null;
try {
//转换流
//Reader a = new InputStreamReader(System.in);
//public class InputStreamReader extends Reader{...}
//FileReader b = (FileReader)a;
//InputStreamReader(InputStream in)，根据参数指定的引用来构造对象
br = new BufferedReader(new InputStreamReader(System.in));
//PrintWriter(Writer out)，根据参数指定的引用来构造对象
ps = new PrintStream(new FileOutputStream("d:/a.txt", true));
// 声明一个boolean类型的变量作为发送方的代表
boolean flag = true;
while(true) {
// 1.提示用户输入要发送的聊天内容并使用变量记录
System.out.println("请" + (flag? "张三": "李四") + "输入要发送的聊天内容：");
String str = br.readLine();
// 2.判断用户输入的内容是否为"bye"，若是则聊天结束
if ("bye".equals(str)) {
System.out.println("聊天结束！");
break;
}
// 3.若不是则将用户输入的内容写入到文件d:/a.txt中
//else {
// 获取当前系统时间并调整格式
Date d1 = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
ps.println(sdf.format(d1) + (flag?" 张三说：":" 李四说：") + str);
//}
flag = !flag;
}
//void println(String x)，打印字符串后并终止该行
ps.println(); // 写入空行 与之前的聊天记录隔开
ps.println();
ps.println();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != ps) {
ps.close();
}
if (null != br) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
OutputStreamWriter类------------------------------
java.io.OutputStreamWriter类主要用于实现从字符流到字节流的转换
public class OutputStreamWriter extends Writer
public abstract class Writer extends Object implements Appendable, Closeable, Flushable //能够被添加 char 序列和值的对象，如果某个类的实例打算接收取自 Formatter 的格式化输出 //那么该类必须实现 Appendable 接口 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
OutputStreamWriter(OutputStream out)，根据参数指定的引用来构造对象 OutputStreamWriter(OutputStream out, StringcharsetName)，根据参数指定的引用和编码构造对象 void write(String str)，将参数指定的字符串写入 void flush()，刷新流 void close()，用于关闭输出流并释放有关的资源InputStreamReader类------------------------------ java.io.InputStreamReader类主要用于实现从字节流到字符流的转换
public class InputStreamReader extends Reader
public abstract class Reader extends Object implements Readable, Closeable //Readable接口就是为了Scanner类专门创建的一个接口，使得Scanner的入口参数不必限于某个类 //实现Readable接口要只需是实现public int read(CharBuffer cb)方法，当方法返回-1时候Scanner类停止读取 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
InputStreamReader(InputStream in)，根据参数指定的引用来构造对象 InputStreamReader(InputStream in, StringcharsetName)，根据参数指定的引用和编码来构造对象 int read(char[] cbuf)，读取字符数据到参数指定的数组 void close()，用于关闭输出流并释放有关的资源字符编码------------------------------ 计算机只能识别二进制数据，早期就是电信号 为了方便计算机可以识别各个国家的文字，就需要将各个国家的文字采用数字编号的方式进行描述并建立对应的关系表 该表就叫做编码表 常见的编码表------------------------------ ASCII：美国标准信息交换码， 使用一个字节的低7位二位进制进行表示 ISO8859-1：拉丁码表，欧洲码表，使用一个字节的8位二进制进行表示 GB2312：中国的中文编码表，最多使用两个字节16位二进制为进行表示 GBK：中国的中文编码表升级，融合了更多的中文文字符号，最多使用两个字节16位二进制位表示 Unicode：国际标准码，融合了目前人类使用的所有字符，为每个字符分配唯一的字符码 所有的文字都用两个字节16位二进制位来表示 编码的发展------------------------------ 面向传输的众多 UTF（UCS Transfer Format）标准出现了，UTF-8就是每次8个位传输数据，而UTF-16就是每次16个位 这是为传输而设计的编码并使编码无国界，这样就可以显示全世界上所有文化的字符了 Unicode只是定义了一个庞大的、全球通用的字符集，并为每个字符规定了唯一确定的编号 具体存储成什么样的字节流，取决于字符编码方案 推荐的Unicode编码是UTF-8和UTF-16 UTF-8：变长的编码方式，可用1-4个字节来表示一个字符 DataOutputStream类------------------------------ java.io.DataOutputStream类主要用于以适当的方式将基本数据类型写入输出流中
public class DataOutputStream extends FilterOutputStream implements DataOutput
public class FilterOutputStream extends OutputStream
public abstract class OutputStream extends Object implements Closeable, Flushable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流常用的方法------------------------------
DataOutputStream(OutputStream out)，根据参数指定的引用构造对象 OutputStream类是个抽象类，实参需要传递子类对象 void writeInt(int v)，用于将参数指定的整数一次性写入输出流，优先写入高字节 void close()，用于关闭文件输出流并释放有关的资源
package com.lagou.task17;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataOutputStreamTest {
public static void main(String[] args) {
DataOutputStream dos = null;
try {
// 1.创建DataOutputStream类型的对象与d:/a.txt文件关联
//DataOutputStream(OutputStream out)，根据参数指定的引用构造对象
dos = new DataOutputStream(new FileOutputStream("d:/a.txt"));
// 2.准备一个整数数据66并写入输出流
// 66: 0000 0000 ... 0100 0010 => B
int num = 66;
//void writeInt(int v)，用于将参数指定的整数一次性写入输出流，优先写入高字节
//dos.writeInt(num); // 写入4个字节，即由于66 => 'B'，那么在写的时候
//结果： B，B前面有三个格子，即三个格子对应三个字节，即0 => ''，对应的二进制是空的，占一格子
//若是这样的话：dos.writeByte(660)，那么就会出现乱码，因为超过了范围
//即不可识别660
// 因为num是int类型，即会写四个字节，会有三个格子，然后在写'B'
dos.write(num); // 写入1个字节
System.out.println("写入数据成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != dos) {
try {
dos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
DataInputStream类------------------------------
java.io.DataInputStream类主要用于从输入流中读取基本数据类型的数据
public class DataInputStream extends FilterInputStream implements DataInput
public class FilterInputStream extends InputStream
public abstract class InputStream extends Object implements Closeable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）常用的方法------------------------------
DataInputStream(InputStreamin)，根据参数指定的引用来构造对象 InputStream类是抽象类，实参需要传递子类对象 int readInt()，用于从输入流中一次性读取一个整数数据并返回 void close()，用于关闭文件输出流并释放有关的资源
package com.lagou.task17;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
public class DataInputStreamTest {
public static void main(String[] args) {
DataInputStream dis = null;
try {
// 1.创建DataInputStream类型的对象与d:/a.txt文件关联
//DataInputStream(InputStreamin)，根据参数指定的引用来构造对象
dis = new DataInputStream(new FileInputStream("d:/a.txt"));
// 2.从输入流中读取一个整数并打印
//int readInt()，用于从输入流中一次性读取一个整数数据并返回
//int res = dis.readInt(); // 读取4个字节，其中若只有一个
//那么就会报错，因为还没读取4个字节，就到末尾了
int res = dis.read(); // 读取1个字节
System.out.println("读取到的整数数据是：" + res); // 66
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != dis) {
try {
dis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
上述66会变成B，是因为文件给我们看的不是二进制代码，而是编码表的图案，而图案需要二进制转化为对应编号，即66
所以66 => ‘B’，这个B是给我们看的，即我们在读取时，也是将B对应的二进制，即66的二进制读取出来
然后，在变成对应的内容，即读出66对应的二进制，当然，在打印时，还是会将该二进制变为66，给你看的
然后将该66的整数类型变成字符串，通过字符串，将’‘66’'变成两个’6’一个一个的打出，而不是找66对应的字符,即打出两个6，即66
即我们看的基本都是图案
ObjectOutputStream类------------------------------
public class ObjectOutputStream extends OutputStream implements ObjectOutput, ObjectStreamConstants
public abstract class OutputStream extends Object implements Closeable, Flushable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件） //Flushable是可以刷新的数据的目的地，调用flush方法将任何缓冲输出写入到依赖的流java.io.ObjectOutputStream类主要用于将一个对象的所有内容整体写入到输出流中 只能将支持 java.io.Serializable 接口的对象写入流中 类通过实现 java.io.Serializable 接口以启用其序列化功能 所谓序列化主要指将一个对象需要存储的相关信息有效组织成字节序列的转化过程 如一个图片里面有多个信息，如颜色，长度等，那么就将他们有规则的组织 常用的方法------------------------------
ObjectOutputStream(OutputStream out)，根据参数指定的引用来构造对象 void writeObject(Object obj)，用于将参数指定的对象整体写入到输出流中 void close()，用于关闭输出流并释放有关的资源ObjectInputStream类------------------------------
public class ObjectInputStream extends InputStream implements ObjectInput, ObjectStreamConstants
public abstract class InputStream extends Object implements Closeable //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）java.io.ObjectInputStream类主要用于从输入流中一次性将对象整体读取出来 所谓反序列化主要指将有效组织的字节序列恢复为一个对象及相关信息的转化过程 常用的方法------------------------------
ObjectInputStream(InputStreamin)，根据参数指定的引用来构造对象 Object readObject()，主要用于从输入流中读取一个对象并返回 无法通过返回值来判断是否读取到文件的末尾 void close()，用于关闭输入流并释放有关的资源
package com.lagou.task17;
public class User implements java.io.Serializable {
private static final long serialVersionUID = -5814716593800822421L;
//在进行序列化时，这个版本号会当作唯一标识，即也会存入文件里
//那么，在反序列化时，就会将你本地的相应实体类的版本号比对(若你没有改动，那么就不会出问题)
//若不一致，则会报错
private String userName; // 用户名
private String password; // 密码
private transient String phoneNum; // 手机号 表示该成员变量不参与序列化 *** 作
public User() {
}
public User(String userName, String password, String phoneNum) {
this.userName = userName;
this.password = password;
this.phoneNum = phoneNum;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getPhoneNum() {
return phoneNum;
}
public void setPhoneNum(String phoneNum) {
this.phoneNum = phoneNum;
}
@Override
public String toString() {
return "User{" +
"userName='" + userName + ''' +
", password='" + password + ''' +
", phoneNum='" + phoneNum + ''' +
'}';
}
}
package com.lagou.task17;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
public class ObjectOutputStreamTest {
public static void main(String[] args) {
ObjectOutputStream oos = null;
try {
// 1.创建ObjectOutputStream类型的对象与d:/a.txt文件关联
//ObjectOutputStream(OutputStream out)，根据参数指定的引用来构造对象
oos = new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
// 2.准备一个User类型的对象并初始化
User user = new User("qidian", "123456", "13511258688");
// 3.将整个User类型的对象写入输出流
//void writeObject(Object obj)，用于将参数指定的对象整体写入到输出流中
oos.writeObject(user);
System.out.println("写入对象成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 4.关闭流对象并释放有关的资源
if (null != oos) {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
package com.lagou.task17;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
public class ObjectInputStreamTest {
public static void main(String[] args) {
ObjectInputStream ois = null;
try {
// 1.创建ObjectInputStream类型的对象与d:/a.txt文件关联
//ObjectInputStream(InputStreamin)，根据参数指定的引用来构造对象
ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
// 2.从输入流中读取一个对象并打印
//Object readObject()，主要用于从输入流中读取一个对象并返回
//无法通过返回值来判断是否读取到文件的末尾
Object obj = ois.readObject();
System.out.println("读取到的对象是：" + obj); // qidian 123456 13511258688 null
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != ois) {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
序列化版本号------------------------------
序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的
在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较
如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常(InvalidCastException)
transient关键字------------------------------
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分
当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的
经验的分享------------------------------
当希望将多个对象写入文件时，通常建议将多个对象放入一个集合中，因为在读取对象时
不知道读多少（因为没有返回值来返回具体数值），即由于文件里对象太多（有些是乱码的）
那么你判断不出有几个对象，即不知道循环多少次
Object readObject()，主要用于从输入流中读取一个对象并返回 无法通过返回值来判断是否读取到文件的末尾 //这只读取一个对象然后将集合这个整体看做一个对象写入输出流中，此时只需要调用一次readObject方法就可以将整个集合的数据读取出来 从而避免了通过返回值进行是否达到文件末尾的判断 RandomAccessFile类------------------------------
public class RandomAccessFile extends Object implements DataOutput, DataInput, Closeable //DataOutput接口定义了一系列方法用于将任何Java类型的数据转换为一系列字节,并将这些字节写入二进制流 //DataInput接口提供了一系列的方法从二进制流中读取字节，并将读取出来的字节转换成任意的java基本类型 //包括转换成UTF-8类型的字符串 //Closeable 是可以关闭的数据源或目标，调用 close 方法可释放对象保存的资源（如打开文件）java.io.RandomAccessFile类主要支持对随机访问文件的读写 *** 作 常用的方法------------------------------
RandomAccessFile(String name, Stringmode)，根据参数指定的名称和模式构造对象 r: 以只读方式打开 rw：打开以便读取和写入 rwd:打开以便读取和写入，同步文件内容的更新 rws:打开以便读取和写入，同步文件内容和元数据的更新 int read()，读取单个字节的数据 void seek(long pos)，用于设置从此文件的开头开始测量的文件指针偏移量 void write(int b)，将参数指定的单个字节写入 void close()，用于关闭流并释放有关的资源
package com.lagou.task17;
import java.io.IOException;
import java.io.RandomAccessFile;
public class RandomAccessFileTest {
public static void main(String[] args) {
RandomAccessFile raf = null;
try {
// 1.创建RandomAccessFile类型的对象与d:/a.txt文件关联
//RandomAccessFile(String name, Stringmode)，根据参数指定的名称和模式构造对象
//r: 以只读方式打开
//rw：打开以便读取和写入
//rwd:打开以便读取和写入，同步文件内容的更新
//rws:打开以便读取和写入，同步文件内容和元数据的更新
raf = new RandomAccessFile("d:/a.txt", "rw");
// 2.对文件内容进行随机读写 *** 作
// 设置距离文件开头位置的偏移量，从文件开头位置向后偏移3个字节 aellhello
//void seek(long pos)，用于设置从此文件的开头开始测量的文件指针偏移量
raf.seek(3);
int res = raf.read();
System.out.println("读取到的单个字符是：" + (char)res); // a l
res = raf.read();
System.out.println("读取到的单个字符是：" + (char)res); // h 指向了e
raf.write('2'); // 执行该行代码后覆盖了字符'e'
System.out.println("写入数据成功！");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 3.关闭流对象并释放有关的资源
if (null != raf) {
try {
raf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
对于偏移来说，可以看成下标，如albn
开始下标为0（当成1也可，但需要将1认为是最小的，但最好还是0，因为大多数下标是从零开始的），指向a，然后偏移2，指向b
当写入时，会覆盖所指向的数
也可以用光标来说，如"l",在文件里都有，可以将他的下一个当作要读的数，即开头指向a，然后偏移2，指向b
且光标在"l"和"b"中间，即光标的下一个就是要读取的数，当写入时，会覆盖下一个数
我们最好用第一个解释
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）