Java SE IO框架

最新推荐文章于 2024-09-10 10:21:38 发布

SettleAB

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量175

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/weixin_48495493/article/details/116780963

版权

Java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

本文介绍了Java SE中的I/O框架，包括流的概念和分类，详细讲解了字节流与字符流，如字节流的InputStream和OutputStream家族，字符流的FileReader和FileWriter，以及它们的缓冲流和转换流。此外，还阐述了编码方式和File类的使用，包括如何读写文件、实现文件复制，以及如何通过FileFilter进行文件过滤。

摘要由CSDN通过智能技术生成

I/o框架

流的概念

概念：内存与存储设备之间传输数据的通道。数据借助流传输

流的分类

按方向【！！！】：
- 输入流：将<存储设备>中的内容读入到<内存>中。
- 输出流：将<内存>中的内容写入到<存储设备>中。

图解：
在这里插入图片描述

按单位：
- 字节流：以直接为单位，可以读写所有数据。
- 字符流：以字符为单位，只能读写文本数据。
按功能：
- 节点流：具有实际传输数据的读写功能。
- 过滤流：在节点流的基础之上增强功能。

字节流

字节流的父类（抽象类）：
- InputStream ：字节输入流
- OutStream：字节输出流
文件字节流：
- FileInoutStrea,:
  - public int read(byte[] b)//从流中读取多个字节，将读到内容存入b数组，返回实际读到的字节数；如果达到文件尾部，则返回-1.
- FileOutputStream：
  - public void write(byte[] b)//一次也多个字节，将b数组中所有字节，写入输出流。

文件字节输入流（实例）：

    public static void main(String[] args) throws Exception {
        //创建FileInputStream,并指定文件路径
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //fis.read() 读取文件
        //单个字节读取
//        int data = 0;
//        while ((data = fis.read()) != -1){
//            System.out.print(data);
//        }
        //多个字节读取
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf))!=-1){
            System.out.println(new String(buf,0,count));
        }
        //关闭
        fis.close();
        System.out.print("执行关闭");
System.exit(0);
    }

文件输出流实例：

 public static void main(String[] args) throws Exception {
        //创建文件字节输出流对象
        FileOutputStream fos = new FileOutputStream("d:\\bbb.txt");//ture追加("d:\\bbb.txt",true);
        //写入文件
        //单字符输入
//        fos.write(97);
//        fos.write('b');
//        fos.write('c');
        //多中字符输入
        String string = "helloworld";
        fos.write(string.getBytes());
        //关闭
        fos.close();
        System.out.println("执行完毕");
    }

实例（利用文件字节流实现复制文件）：

   public static void main(String[] args) throws Exception {
        //创建流
        //文件字节输入流
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        //文件字节输出流
        FileOutputStream fos = new FileOutputStream("d:\\ccc.txt");
        //边度边写
        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = fis.read(buf))!=-1){
            fos.write(buf,0,count);
        }
        //关闭
        fis.close();
        fos.close();
        System.out.println("复制完毕");
    }

字节缓冲流
缓冲流：BufferedInputStream/BufferedOutputStream
- 提高IO效率，减少访问磁盘的次数；
- 数据在缓冲区中，flush是讲缓存区的内容写入文件中，也可以直接close。
  实例：

package com.test.io;

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class Demo4 {
    public static void main(String[] args) throws Exception {
        //创建BufferedInputStream
        FileInputStream fis = new FileInputStream("d:\\aaa.txt");
        BufferedInputStream bis = new BufferedInputStream(fis);
        //读取
//        int data = 0;
//        while ((data = bis.read()) != -1){
//            System.out.print((char)data);
//        }

        byte[] buf = new byte[1024];
        int count = 0;
        while ((count = bis.read(buf)) != -1){
           System.out.println(new String(buf,0,count));
        }
        //关闭
        bis.close();
    }
}

    public static void main(String[] args) throws Exception {
        //创建字节输出缓冲流
        FileOutputStream fos = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //写入文件
        for (int i = 0; i < 10; i++){
            bos.write("helloworld".getBytes());//写入8k缓冲区
            bos.flush();//刷新到硬盘
        }
        System.out.println("success");
    }

对象流：ObjectOutStream ObjectInputStream
使用流传输对象的过程为序列化、反序列化。
- 增强了缓冲区功能
- 增强了读写8钟基本数据类型和字符串功能
- 增强了读写对象的功能：
  1. readObject() 从流中读取一个对象
  2. writeObject(Object obj）向流中写入一个对象

实例：

package com.test.io;

import java.io.FileOutputStream;
import java.io.ObjectOutputStream;

/**
 * 使用ObjectOutputStream实现对象的序列号
 * 要求：序列化对象流
 * @author  Settle
 */
public class Demo6 {
    public static void main(String[] args) throws Exception{
        //创建对象流
        FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //序列化（写入对象）
        Student zs = new Student("张三",20);
        oos.writeObject(zs);
        //关闭
        oos.close();
        System.out.println("序列化完毕");
    }
}

使用ObjectoutputStream实现对象的序列化：
注意事项：
1. 序列化类必须要实现Serializable接口
2. 序列化类中对象属性要求实现Serializable接口
3. 序列化版本号ID，保证序列化的类和反序列化的类
4. 使用transient（瞬间）修饰属性，这个属性不能序列化
5. 静态属性不能序列化
6. 序列化多个对象，可以借助集合实现

编码方式

在这里插入图片描述

字符流

字符流的父类（抽象类）：

- Reader：字符输入流
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210518101644494.png)
- Writer：字符输出流
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210518101713791.png)

FileReader:
- public int read(char[] c) //从流中读取多个字符，将读到内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1。

实例：

public class Demo2 {

	public static void main(String[] args) throws Exception {
		// 创建FileInputStrea对象
		FileReader fr = new FileReader("d:\\aaa.txt");
		// 读取
//		int data = 0;
//		while ((data=fr.read())!=-1) {
//			System.out.print((char)data);
//		}
		//关闭
		char[] buf = new char[1024];
		int count = 0;
		while ((count = fr.read(buf))!=-1) {
			System.out.println(new String(buf, 0, count));
		}
		fr.close();
System.exit(0);
	}

}

FileWriter:
- public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流

实例：

public class Demo3 {
	public static void main(String[] args) throws Exception {
		//创建
		FileWriter fw = new FileWriter("d:\\write.txt");
		//写入
		for (int i = 0; i < 10; i++) {//写入次数
			fw.write("dfafda发放大");
			fw.flush();//刷新
		}
		fw.close();
		System.out.println("执行完毕");

	}
}

字符缓冲流：

缓冲流：BufferedReader/BufferedWriter
- 高校续写
- 支持输入换行符
- 可一次写一行、读一行

实例：


/**
 * 使用字符缓冲流读取文件
 * BufferedReader
 * @author Administrator
 *
 */
public class Demo4 {

	public static void main(String[] args) throws Exception {
		// 创建缓冲流
		FileReader fr = new FileReader("d:\\write.txt");
		BufferedReader br = new BufferedReader(fr);
		//全部读取
//		char[] buf = new char[1024];
//		int count = 0;
//		while((count=br.read(buf)) != -1) {
//			System.out.println(new String(buf, 0, count));
//		}
		//一行一行读取
		String line = null;
		while((line =br.readLine()) != null) {
			System.out.println(line);
		}
		//关闭
		br.close();
System.exit(0);
	}

}

写入实例：

public class Demo4 {
	public static void main(String[] args) throws Exception {
		// 创建缓冲流
		FileWriter fw = new FileWriter("d:\\write.txt");
		BufferedWriter bw = new BufferedWriter(fw);
		//写入
		for (int i = 0; i < 10; i++) {
			bw.write("dafa健康路");
			bw.newLine();//写入一个换行符 win \r\n  linux \n
			bw.flush();			
		}
		//关闭
		bw.close();
		System.out.println("over");
System.exit(0);
	}
}

转换流

桥转换流：InputStreamReader/OutputStreamWriter
- 可将直接流转换为字符流
- 可设置字符的编码方式

读取实例：

public class Demo5 {
	public static void main(String[] args) throws Exception {
		// 创建InputStreamReader对象
		FileInputStream fis = new FileInputStream("d:\\aaa.txt");
		InputStreamReader isr = new InputStreamReader(fis, "utf-8");
		// 读取文件
		int data = 0;
		while ((data=isr.read()) != -1) {
			System.out.print((char)data);
		}
		//关闭
		isr.close();
	}
}

写入实例：

public class Demo5 {
	public static void main(String[] args) throws Exception {
		// 创建InputStreamReader对象
		FileOutputStream fos = new FileOutputStream("d:\\aaa.txt");
		OutputStreamWriter osw = new OutputStreamWriter(fos, "utf-8");
		// 读取文件
		for (int i = 0; i < 10; i++) {
			osw.write("dfafd啥地方放");
			osw.flush();
		}
		//关闭
		osw.close();
		System.out.println("执行成功");
	}
}

File

概念：代表物理盘符中的一个文件或者文件夹。
方法：

实例：

public class Demo6 {
	public static void main(String[] args) throws Exception {
		separator();
		fileOpe();		
	}
	//分隔符
	public static void separator() {
		System.out.println("路径分隔符"+File.pathSeparator);
		System.out.println("路径分隔符"+File.separator);
	}
	//文件操作
	public static void fileOpe() throws Exception {
		//创建文件
		File file = new File("d:\\file.txt");
		System.out.println(file.toString());
		boolean b = file.createNewFile();
		System.out.println("创建结果"+b);
		//删除文件
		if (file.exists()) {
			//直接删除
			//System.out.println("删除结果："+file.delete());
			//jvm退出时删除
			//file.deleteOnExit();
	//	Thread.sleep(5000);//延时
		}	
		//获取文件信息
		System.out.println("获取文件的绝对路径：" + file.getAbsolutePath());
		System.out.println("获取路径：" + file.getPath());
		System.out.println("获取文件名：" + file.getName());
		System.out.println("获取父目录：" + file.getParent());
		System.out.println("获取文件长度：" + file.length());
		System.out.println("获取文件创建时间" + new Date(file.lastModified()).toLocaleString());	
		//判断
		System.out.println("是否可写：" + file.canWrite());
		System.out.println("是否文件：" + file.isFile());
		System.out.println("是否隐藏：" + file.isHidden());	
	}
}

文件实例：

	//创建文件夹
		File dir = new File("d:\\aaa\\bbb\\ccc");
		System.out.println(dir.toString());
		if(!dir.exists()) {
			//dir.mkdir();//只能创建单机目录
			System.out.println("创建结果" + dir.mkdirs());;//创建多级目录
		}
		//......相关操作和文件一样

		//遍历文夹
		File dir2 = new File("d:\\图片");
		String[] files = dir2.list();
		System.out.println("================");
		for (String string : files) {
			System.out.println(string);
		}

FileFilter接口：
public interface FileFilter
- boolean accept(File pathname)
当调用FIle类中的listFiles()方法使，支持传入FileFilter接口接口实现类，对获取文件进行过滤，只有满足条件的文件才可出现在listFiles()的返回值中。
properties:属性集合
特点
1. 存储属性名和属性值
2. 属性名和属性值都是字符串类型
3. 没有方向
4. 和流有关

SettleAB

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java SE IO框架

I/o框架流的概念概念：内存与存储设备之间传输数据的通道。数据借助流传输流的分类按方向【！！！】：输入流：将<存储设备>中的内容读入到<内存>中。输出流：将<内存>中的内容写入到<存储设备>中。图解：按单位：字节流：以直接为单位，可以读写所有数据。字符流：以字符为单位，只能读写文本数据。按功能：节点流：具有实际传输数据的读写功能。过滤流：在节点流的基础之上增强功能。字节流字节流的父类（抽象类
复制链接

扫一扫

专栏目录