这里写目录标题
输入流 输出流 缓冲流 打印流
* 流是一组有顺序的 , 有起点和终点的字节集合 , 是对数据传输的总称或抽象
* 即数据在两设备间的传输称为流 , 流的本质是数据传输 , 根据数据传输特性抽象出各种类 ,
* 方便我们直接操作数据
*
* 流中的操作对象 , 是指内存中 , 当期操作的程序而言 ,
* 输入 : 往内存中导入数据
* 输出 : 从内存中写出数据
* I : input
* O : output
*
* 四大抽象类 :
* InputStream 字节输入
* OutputStream 字节输出
* Reader 字符输入
* Winter 字符输出
*
*
* 原始文件流 : 用于打开链接 , 操作数据
* 1 FileInputStream
* 2 FileOutputStream
* 3 FileReader
* 4 FileWinter
FileInputStream 原始字节输入流
* java.io.InputStream
* java.io.FileInputStream 按照自己的方式在原始文件总读取数据
*
* 想要读取一个文件 , 首先要找到他
*
* 定位方式有两种 , 一种是绝对路径 , 一种是相对路径
public class io_02 {
public static void main(String[] args) {
FileInputStream fis = null ;
// 相对路径是相对于这个项目
// D:\workspace\IO\src\io\io_02.java
try {
fis = new FileInputStream("./src/io/io_02.java");
// 读取数据
int i1 = fis.read(); // 读取一个字节(8位) 返回下一个字节的值 , 因为开始时光标在顶端 , 如果到了文件末尾 , 就返回-1
int i2 = fis.read();
int i3= fis.read();
// package io; 先输出p , 再输出a
System.out.println((char)i1);
System.out.println((char)i2);
// / / å 在文件前加了//啊
System.out.println((char)i3);
} catch (Exception e) {
e.printStackTrace();
}finally{
try {
if (fis!=null) {
fis.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
使用read循环读取
public class io_03 {
public static void main(String[] args) {
// 相对路径是相对于这个项目
// D:\workspace\IO\src\io\io_02.java
// 自动关闭资源
try(FileInputStream fis = new FileInputStream("./src/io/io_02.java"); ) {
while(true){
int temp = fis.read();
if (temp==-1) { // 文件末尾会返回-1
break;
}else {
// 汉字是乱码是对的
System.out.print((char)temp);
}
}
}catch (Exception e) {
e.printStackTrace();
}
}
}
read方法重载
* read(byte[] b) 读取数组
* read方法重载 , 可以传入无参的 , 也可以传入一个字节数组 , 数组的这个使用字节数组来存储读取数据
* 并且是一次返回 , (要么装满数组 , 要么到达文件末尾)
* 返回值是本次读取到的字节个数 , 到达文件末尾返回-1
* @杜智慧
*
* @Date 2021年1月26日
*/
public class io_04 {
public static void main(String[] args) {
// 相对路径是相对于这个项目
// D:\workspace\IO\src\io\io_02.java
// 自动关闭资源
try(FileInputStream fis = new FileInputStream("./src/io/io_04.java"); ) {
byte[] bytes = new byte[1000];
// 返回本次读取的字节个数 , 再次使用该数组的时候 , 不会清空 , 而是用
int i1= fis.read(bytes);
System.out.println(i1); // 1000
System.out.println(new String(bytes));
int i2= fis.read(bytes);
System.out.println(i2); // 116 读取的时候会接着上一数组读取到的地方再接着读取
System.out.println(new String(bytes , 0 , i2) ); // 转换为String
}catch (Exception e) {
e.printStackTrace();
}
}
}
常用方法
// 创建流对象
FileInputStream fis = new FileInputStream("./src/io/io_04.java");
// 可获取的字节数
System.out.println(fis.available()); //1205
// 读取字节数组
byte[] bytes = new byte[5];
fis.read(bytes); // 在这里读取
System.out.println(new String(bytes)); // packa
System.out.println(fis.available()); // 1200
// 跳过不读
fis.skip(2);
fis.read(bytes);
System.out.println(new String(bytes)); // 跳过两个字节 io;
// 关闭资源
fis.close();
FileOutputStream 原始字节输出流
* java.io.OutputStream
* java.io.FileOutputStream
* 把程序中的内容, 写出到硬盘中 , 输入流找不到会报错, 输出流不会
* 他会自动创建该文件 , 但是不会创建文件夹(不会创建目录)
*
* 构造方法 :
* FileOutputStream(String) : 把内容输出到指定文件中 , 并且会覆盖原文件内容
* FileOutputStream (String , boolean) : 在原文中追加数据 (如果是true) 如果是false就跟第一个一样了(覆盖)
* 成员方法 :
* write(int i) : 写出整型
* write(byte[] b) : 写出字节数组 , 想要输出字符串 , 可以利用字符串中的getBytes()方法
* flush() : 刷缓存 强制把缓存区写出 , 避免遗漏
public class io_01_FileOutputStream {
public static void main(String[] args) throws IOException {
// FileOutputStream fos = new FileOutputStream ("D:/123.txt");
// fos.write(97);
// fos.flush(); // 会在D盘创建一个123.txt , 但是要注意的是 , 这不是文件夹(即目录) , 他可以创建具体的文件 , 但是不能创建目录
// fos.close();
// 追加式写入
FileOutputStream fos = new FileOutputStream ("D:/123.txt" , true);
for (int i = 0; i < 26; i++) {
fos.write(i+97);
}
String string = "Hello World";
byte[] bytes = string.getBytes(); // 字符串转字节 因为write只能接受int或者byte
fos.write(bytes);
fos.flush();
fos.close();
}
}
FilReader 原始字符输入流
* FilReader 一次读一个字符 , 也就是两字节 , unicode也是两字节 , 所以他是可以容纳汉字的 , 可以解决汉字乱码问题
* 所以这个字符串输入流一般用于读取纯文本文件
* 压缩包图片等还是字节流
* FileReader里的read也有方法重载 与FileInputStream里的是一样的
* 唯一的区别在于一个是字节数组一个是字符数组
* read() read(char[] c)
* @杜智慧
*
* @Date 2021年1月26日
*/
public class io_01_FilReader {
public static void main(String[] args) {
// 这种写法可以自动回收资源 ./src/io/io_02.java
try (FileReader fr = new FileReader("./src/io/io_02.java");
FileWriter fw = new FileWriter("E:/text1.txt");){
// 字符数组
char[] c = new char[500];
int temp = 0;
while((temp = fr.read(c)) != -1){
fw.write(c);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
FileWriter 原始字符输出流
/**
* 与字节输出流(FileOutputStream)基本一致 , 新增字符串写出 .write(char[] c)
* @杜智慧
*
* @Date 2021年1月26日
*/
public class io_01_FileWriter {
public static void main(String[] args) {
try(
// 默认是覆盖写入 其内原有的被直接覆盖掉
FileWriter fw = new FileWriter("E:/FileWriter.txt");
) {
fw.write("大家好\n");
char[] chars = {'a','b','c','d'};
fw.write(chars);
fw.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
缓冲流
* 缓冲流 , 是包装流 , 创建对象的时候 , 传入的参数 , 不再是文件地址 , 而是文件流对象
* BufferedInputStream , BufferedOutputStream ,BufferedReader, BufferedWriter
* 作用是把每次读入的数据存入到一个缓存区 , 然后一次性写入
* 把输出的数据存入一个缓冲区 , 然后一次性写出
*
* 如果缓存流关闭 , 那么传入的对应的文件流对象也会被关闭
*
* 针对字符操作, 提供了两个新方法
* readLine() : 读一行 , 返回值就是这一行的数据 , 如果到了文件的末尾就返回null
* newLine() : 换行 , 就等于 \n
BufferedInputStream 缓冲字节输入流
public class io_01_BufferedInputStream {
public static void main(String[] args) {
try (
FileInputStream fis = new FileInputStream("./src/io/io_02.java");
// 创建缓存流 将输入流缓存
BufferedInputStream bis = new BufferedInputStream (fis);
){
// 读取下一个字节 , 光标后移一位
System.out.println((char)bis.read());
// 读取一个数组 , 返回读取到的长度 , 到达末尾返回-1
byte[] bytes = new byte[5];
System.out.println(bis.read(bytes));
int temp = bis.read(bytes);
System.out.println(new String(bytes , 0 , temp));
} catch (Exception e) {
e.printStackTrace();
}
}
}
BufferedOutputStream 缓冲字节输出流
public class io_01_BufferedOutputStream {
public static void main(String[] args) {
try (
// 输出流对象
FileOutputStream fos = new FileOutputStream("D:/123.txt");
// 字节输出缓冲流
BufferedOutputStream bos = new BufferedOutputStream(fos);
){
bos.write(97);
byte[] bytes = "Hello World".getBytes();
bos.write(bytes);
bos.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
BufferedReader 字符缓冲输入流
public class io_01_BufferedReader {
public static void main(String[] args) {
try (
FileReader fr = new FileReader("./src/io/io_02.java");
// 字符缓冲输入流
BufferedReader br = new BufferedReader(fr);
){
String string = br.readLine(); // 读取一行
System.out.println(string);
// 循环读取
String temp = null;
while((temp = br.readLine())!=null){
System.out.println(temp);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
BufferedWriter 字符缓冲输出流
public class io_01_BufferedWriter {
public static void main(String[] args) {
try (
FileWriter fw = new FileWriter("E:/BufferedWriter.txt");
// 字符输出缓冲流
BufferedWriter bw = new BufferedWriter(fw);
){
bw.write("你好\n");
bw.write("你好a\n");
bw.flush();
} catch (Exception e) {
e.printStackTrace();
}
}
}
PrintStream 打印流
// 配套用
PrintStream ps = new PrintStream(fos);
ps.println(new String(bytes,0,tmp));
扫一扫
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
