目录
I/O流概述
I/O(Input和Output）流，即输入和输出流，是java中实现输入输出的基础。它可以方便的实现数据的输入和输出。I/O流可分为三类
1、字节流和字符流
根据流操作的数据单位的不同，可以分为字节流和字符流。字节流按照字节为单位进行读写数据，每次可读取一个或者多个字节；字符流按照字符为单位进行数据读写，每次可读取一个或者多个字符
字节：数据存储的大小，一个bit位就是8个字节；字符：例如‘A’,是文字或者符号
2、输入流和输出流
输入流：从流中读取数据
输出流：给流中写入数据
3、字节流和处理流
节点流也可叫做低能流，指可以从一个特定的I/O设备（如磁盘）读写数据的流，只能直接连接数据源，进行数据的读写
处理流：也叫做高级流，对应一个已经存在的节点流进行连接和封装，通过封装后的流实现流的读写能力，使用处理流时，程序不会连接到实际的数据源，而是连接在已经存在的流之上
java的I/O流主要在java.io包中
字节流
计算机中，数据按照二进制的形式存放。在JDK中，提供了字节输入流InputStream和字节输出流OutputStream，这两个是字节流的顶级父类
字节流读取文件
计算机的数据基本上保留在硬盘的文件中，针对文件读写，JDK提供了两个类：FileInputStream和FileOutputStream
读取以上文件内容
public class demo1 {
public static void main(String[] args) throws IOException {
FileInputStream in = new FileInputStream("C:\\Users\\30283\\Desktop\\demo.txt");
int n = 0;
while ((n = in.read()) != -1) {//文件末尾 n=-1
System.out.print((char) n + " ");//读取int(0-255) 两个字节表示了一位
}
System.out.println();
in = new FileInputStream("C:\\Users\\30283\\Desktop\\demo.txt");
byte[] elem = new byte[1024];
int len = in.read(elem);
for (int i = 0; i < len; i++) {
System.out.print(elem[i] + " ");
}
System.out.println();
for (int i = 0; i < len; i++) {
System.out.print((char)elem[i] + " ");
}
System.out.println();
in = new FileInputStream("C:\\Users\\30283\\Desktop\\demo.txt");
in.read(elem, 0, 1024);
for (int i = 0; i < len; i++) {
System.out.print(elem[i] + " ");
}
in.close();//关闭资源
}
}
发现：因为编码方式的不同：GBK一个汉字两个字节，而UTF-8每个汉字三个字节，导致出现乱码
public class demo2 {
public static void main(String[] args) throws IOException {
FileOutputStream out = new FileOutputStream("C:\\Users\\30283\\Desktop\\demo.txt");
//如果文件不存在，就创建文件
out.write('a');//写入一个字节
String string = "hello";
out.write(string.getBytes());//将字符串转化为字节数组
out.write(string.getBytes(), 2, 3);//读取数组的指定区间,写入
out.close();//释放资源
}
}
实现文件内容的拷贝
public class demo3 {
public static void main(String[] args) throws IOException {
//读取文件内容
FileInputStream in = new FileInputStream("C:\\Users\\30283\\Desktop\\新建 DOCX 文档.docx");
FileOutputStream out = new FileOutputStream("C:\\Users\\30283\\Desktop\\src.docx");
byte[] elem = new byte[1024];
int len=0;
while ((len=in.read(elem))!=-1) {
out.write(elem, 0, len);
}
in.close();
out.close();
}
}
字节缓冲流
类似以上创建一个数组，一次性读多个数据放入数组，就可以减少读取次数，增加效率，这就是缓存区
I/O包里提供了两个带缓冲的字节流，BufferedInputStream和BufferedOutputStream，分别接受InputStream和OutputStream类型的参数为对象，读写时具有缓冲功能
public class demo6 {
public static void main(String[] args) throws IOException {
BufferedInputStream in=new BufferedInputStream(new FileInputStream("C:\\Users\\30283\\Desktop\\demo.txt"));
BufferedOutputStream outputStream=new BufferedOutputStream(new FileOutputStream("C:\\Users\\30283\\Desktop\\src.txt",true));
int n=0;
while((n=in.read())!=-1){
outputStream.write(n);
}
in.close();
outputStream.close();
}
}
两个流内部设置了大小为8192的字节数组
字符流
Reader和Writer是字符流的父类，其子类FileReader和FileWriter是针对文件来操作的
public class demo4 {
public static void main(String[] args) throws IOException {
FileReader reader = new FileReader("C:\\Users\\30283\\Desktop\\demo.txt");
int n = 0;
while ((n = reader.read()) != -1) {//文件末尾 n=-1
System.out.print( n + " ");//读取int(0-255)
}
System.out.println();
reader = new FileReader("C:\\Users\\30283\\Desktop\\demo.txt");
char[] elem = new char[1024];
int len = reader.read(elem);
for (int i = 0; i < len; i++) {
System.out.print(elem[i] + " ");
}
System.out.println();
reader.close();
}
}
分析：使用read（）读取的是字符对应的编码值，而根据字符读取，可以读取到汉字正确的编码值，将其转化为char,可以得到对应汉字
使用缓冲数组，一次读取多个字符时，使用char类型的数组： char[] elem = new char[1024];
FileReade的读方法
FileWriter的写方法
public class demo5 {
public static void main(String[] args) throws IOException {
FileWriter fileWriter = new FileWriter("C:\\Users\\30283\\Desktop\\demo.txt", true);
//追加信息
fileWriter.write('a');
String string = "现在是晚上十点";
fileWriter.write(string);
fileWriter.close();
}
}
字符缓冲流
JDK提供了字符缓冲流，BufferedReader和BufferedWriter
两个类的行操作：
public class demo7 {
public static void main(String[] args) throws IOException {
BufferedReader reader=new BufferedReader(new FileReader("C:\\Users\\30283\\Desktop\\demo.txt"));
BufferedWriter writer=new BufferedWriter(new FileWriter("C:\\Users\\30283\\Desktop\\src.txt"));
String string=null;
while((string=reader.readLine())!=null) {//读取一行
writer.write(string);
writer.newLine();//写入换行符
}
reader.close();
writer.close();
}
}
转换流
字节流和字符流可以相互转化。JDK中，提供了两个类用于将字节流转化为字符流，InputStreamReader和OutputStreamReader
public class demo8 {
public static void main(String[] args) throws IOException {
FileInputStream inputStream = new FileInputStream("C:\\Users\\30283\\Desktop\\demo.txt");
InputStreamReader in = new InputStreamReader(inputStream, StandardCharsets.UTF_8);
//将字节流传给字符流,可以传入编码方式
FileOutputStream outputStream = new FileOutputStream("C:\\Users\\30283\\Desktop\\src.txt",true);
OutputStreamWriter out = new OutputStreamWriter(outputStream, StandardCharsets.UTF_8);
int n = 0;
while ((n=in.read())!=-1){
out.write(n);
}
in.close();
out.close();
inputStream.close();
outputStream.close();
}
}
File类
JDK提供了File类，实现对文件的删除，创建等操作
File类的常用方法
File类用于封装一个路径，这个路径可以是从系统盘符开始的绝对路径：例如：C：\file\a.txt；也可以是针对当前目录而言的相对路径，如src\hello.java;
构造方法
常用方法
public class demo9 {
public static void main(String[] args) throws IOException {
//1、File类封装路径,如果文件不存在，不会新建文件的
File file = new File(".\\ok.txt");
//2、exists（）文件是否存在
if (!file.exists()) file.createNewFile();
System.out.println("文件是否存在:" + file.exists());
//3、createNewFile（）如果文件不存在，创建此文件
//4、getName()获取文件名称
System.out.println(file.getName());
//5、getPath（）得到文件路径
System.out.println(file.getPath());
//6、返回file对象对应的绝对路径
System.out.println(file.getAbsoluteFile());
//7、getParent（）得到file对象对应的父目录
System.out.println(file.getParent());
//8、canRead()观察file对象是否可读
System.out.println(file.canRead());
//9、isFile()判断file对象对应的是否是文件(不是目录)
System.out.println(file.isFile());
//10、isDirectory（）判断file对象对应的是否是目录(不是文件)
System.out.println(file.isDirectory());
//11、列出指定目录的全部内容（名称）
String[] elem = file.list();
//12、删除文件
System.out.println(file.delete());
}
}
遍历当前目录下的文件
public class demo10 {
public static void main(String[] args) {
File file = new File("c:\\WeChat");
if (file.exists()) {//文件是否存在
if (file.isDirectory()) {//如果file对象是一个目录
String[] elem = file.list();//获取目录下的所有文件名称
assert elem != null;
for (String ret : elem) {
System.out.println(ret);
}
}
}
}
}
遍历目录下的所有文件
public class demo11 {
//对一个根目录查找,一个根目录下可能又有一个根目录 是树形存储的
public static void FileDir(File file){
File [] list=file.listFiles();//得到目录下的所有文件和目录
for (File ret :list) {
if(ret.isDirectory()){//如果是目录 递归遍历这个目录的文件
FileDir(ret);
}
System.out.println(ret);
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String path = scanner.nextLine();
File file = new File(path);
if (!file.exists()) {
System.out.println("文件不存在");
return;
}
if (!file.isDirectory()) {
System.out.println("输入的不是目录");
return;
}
FileDir(file);
}
}
删除文件和目录
delete方法使用时，先删除内部文件，后删除空的文件夹
public class demo12 {
public static void delete(File file) {
File[] files = file.listFiles();//得到file对象下的所有文件和目录
if(files==null){
System.out.println("内部没有文件");
return;
}
for (File ret : files) {
if (ret.isFile()) {//如果是文件,直接删除
ret.delete();
}
if (ret.isDirectory()) {//如果是目录 递归删除目录内的所有文件
delete(ret);
}
}
//删除完所有文件后，删除空的文件夹
file.delete();
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String path = scanner.nextLine();
File file = new File(path);
if (!file.exists()) {
System.out.println("文件不存在");
return;
}
delete(file);
}
}
RandomAccessFile
之前提到的I/O流有一个特定，只可以根据数据的先后顺序读写源设备中的数据，JDK提供了RandomAccessFile类实现从文件的任意位置开始执行读写操作
构造方法
RandomAccessFile类可以将文件按照指定的操作权限打开
参数mode指定访问文件的模式，具体分为四个值：
1、r：表示以只读的方式打开文件，如果试图进行写操作，抛出异常，如果文件不存在，抛出异常
2、rw:表示以"读写"的方式打开文件，文件不存在，会自动创建文件
3、rws：表示以"读写"的方式打开文件,和”rw“相比，要求对元数据和文件内存的更新同步到底层的存储设备
4、rwd：表示以"读写"的方式打开文件,和”rw“相比，要求对文件内存的更新同步到底层的存储设备
普通方法
RandomAccessFile类中定义了一个记录指针表示处于读写的位置
指针位置的设置
public class demo14 {
public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("C:\\Users\\30283\\Desktop\\demo.txt", "r");//按照只读模式打开
System.out.println(file.getFilePointer());//返回指针偏移量
file.seek(100);//设置指针偏移量
System.out.println(file.getFilePointer());
file.close();
}
}
读方法
public class demo13 {
public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("C:\\Users\\30283\\Desktop\\demo.txt", "r");//按照只读模式打开
byte[] elem = new byte[1024];//一个足够大的数组,能包含所有内容;UTF-8中的“睡觉”两个字，占有6个字节，GBK占有4个字节
int n = 0;
while ((n = file.read(elem)) != -1) {//两个字节表示一位 GBK
String ret = new String(elem, 0, n, StandardCharsets.UTF_8);//转化编码方式
System.out.println(ret);
}
file.close();
}
}
实现文件内容的追加
public class demo15 {
public static void main(String[] args) throws IOException {
RandomAccessFile file = new RandomAccessFile("C:\\Users\\30283\\Desktop\\demo.txt", "rw");//按照读写模式打开
file.seek(file.length());//设置偏移量
String ret = "现在是22：00 pm";
file.write(ret.getBytes(StandardCharsets.UTF_8));
file.close();
}
}
实现在任意位置增加内容
public class demo16 {
public static void main(String[] args) throws IOException {
Scanner scanner = new Scanner(System.in);
RandomAccessFile rw = new RandomAccessFile("C:\\Users\\30283\\Desktop\\demo.txt", "rw");
//1、指定文件位置
rw.seek(6);//涉及到GBK和UTF-8的转化
byte[] elem = new byte[1024];
//2、创建文件 缓存之后的内容，否则会被替换
FileOutputStream writer =new FileOutputStream("C:\\Users\\30283\\Desktop\\缓存.txt");
int n=0;
while ((n = rw.read(elem)) != -1) {//GBK方式读取
String ret = new String(elem, "UTF-8");//UTF-8形式写入
writer.write(ret.getBytes("UTF-8"), 0, n);
}
//3、添加指定内容
rw.seek(6);
String ret = scanner.nextLine();
rw.write(ret.getBytes("UTF-8"));
//4、将缓存内容写入
FileInputStream in = new FileInputStream("C:\\Users\\30283\\Desktop\\缓存.txt");
while ((n = in.read(elem)) != -1) {//GBK方式读取
ret = new String(elem, "UTF-8");//UTF-8形式写入
rw.write(ret.getBytes("UTF-8"), 0, n);
}
//5、删除缓存文件，关闭资源
writer.close();
in.close();
rw.close();
File file = new File("C:\\Users\\30283\\Desktop\\缓存.txt");
file.delete();
}
}
对象序列化
对象序列化指将一个java对象转化为一个I/O流中字节序列的过程。其目的是为了将对象保留到磁盘中，或运行在网络中直接传输对象。对象化序列机制可以将内存的java对象转化为二进制流，这个二进制流可以长久的保存在磁盘上，也可以通过网络将这个二进制流进行传输，其他程序获得了这个二进制流，可以将其恢复成原来的java对象，这个过程称为反序列化
如果想让某一个对象支持序列化机制，这个类就要实现Serializable接口或者Externalizable接口
NIO
JDK1.4开始，提供了一系列改进的用于处理输入输出的新功能，称为NIO
NIO（new I/O)提供了和I/O不同的工作方式；采用内存映射文件的方法处理输入输出，将文件的区域映射到内存中，这样就可以像访问内存那样访问文件了
标准I/O使用字节流和字符流，而NIO使用通道（Channel）和缓冲区(Buffer），数据总是从通道读入缓冲区，从缓冲区写入通道
NIO主要有三个核心部分：
- Buffer：从结构来说，类似于一个数组，保存数据；从类型来说，是一个抽象类；从功能来说，是一个容器，本质是一个数组缓冲区
- Channel：一个接口对象，类似于传统的流对象
- Selector：用于监听多个通道的时间，主要用于多线程处理
2161
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
