IO流 输入和输出处理(字节流 字符流)
IO流概述和分类
- Io流概述:
- IO: 输入/输出(Input/Output)
- 流: 是一种抽象概念,是对数据传输的总称。也就是说数据在设备间的传输称为流,流的本质是数据传输
- IO流就是用来处理设备间数据传输问题的
常见的应用:文件复制;文件上传;文件下载
- IO流分类:
- 按照数据的流向
- 输入流:读数据
- 输出流:写数据
- 按照数据类型来分
- 字节流
字节输入流;字节输出流 - 字符流
字符输入流;字符输出流
一般按照数据类型来分
- 字节流
- 按照数据的流向
Java I/O
持久化保存(文件)
文件3-1
文件3-2
- File类访问文件属性
文件3-3
- File类常用方法
方法名称 | 说明 |
---|---|
boolean exists() | 判断文件或目录是否存在 |
boolean isFile() | 判断是否是文件 |
boolean isDirectory() | 判断是否是目录 |
String getPath() | 返回此对象表示的文件的相对路径名 |
String getAbsolutePath() | 返回此对象表示的文件的绝对路径名 |
String getName() | 返回此对象表示的文件或目录的名称 |
boolean delete() | 删除此对象指定的文件或目录 |
boolean createNewFile() | 创建名称的空文件,不创建文件夹 |
long length() | 返回文件的长度,单位为字节,如果文件不存在,则返回OL |
示例
public class Test01 {
public static void main(String[] args) {
//把物理文件转换成Java中的对象 文件的路径可以存在也可以不存在
File file=new File("D:\\test.txt");// 使用 \\ 或者 /
System.out.println("判断文件是否存在");
System.out.println(file.exists());
System.out.println("判断是否是文件");
System.out.println(file.isFile());
System.out.println("判断是否是目录");
System.out.println(file.isDirectory());
System.out.println("返回此对象表示的文件的相对路径名");
System.out.println(file.getPath());
System.out.println("返回此对象表示的文件的绝对路径名");
System.out.println(file.getAbsolutePath());
System.out.println("返回此对象表示的文件或目录的名称");
System.out.println(file.getName());
System.out.println("删除此对象指定的文件或目录");
System.out.println(file.delete());
System.out.println("创建名称的空文件,不创建文件夹");
try {
System.out.println(file.createNewFile());
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("返回文件的长度,单位为字节,如果文件不存在,则返回OL");
System.out.println(file.length());
}
}
3-1 流
- 通过流来读写文件
- 流是一组有序的数据序列
- 以先进先出方式发送信息的通道
3-2 流
- 输入/输出流与数据源
先入先出
3-3
- Java流的分类
流(Stream)的分类方式:
1. 根据数据流动的方向,可分为输入流(InputStream)和输出流(OutputStream)。
2. 根据处理数据的单位划分,可分为字节流(InputStream和OutputStream)和字符流(Reader和Writer)。
3. 根据数据流所关联的是数据源还是其他数据流,可分为节点流(Node Stream)和处理流(Processing Stream)。节点流直接从指定的位置读或写数据,如FileInputStream和FileOutputStream;处理流则是对一个已存在的流的连接和封装,通过对所封装的流的功能调用实现数据的读/写功能,如BufferedInputStream和BufferedOutputStream。
字节流(用于处理图片)
FileInputStream
-
InputStream类常用方法(输入流)
- int read()
- int read(byte[] b)
- int read(byte[] b,int off,int len)
- void close()
- int available():可以从输入流中读取的字节数目
-
子类FileInputStream常用的构造方法
- FileInputStream(File file)
- FileInputStream(String name)
使用FileInputStream读文本文件
FileOutputStream
-
OutputStream类常用方法(输出流)
- void write(int c)
- void write(byte[] buf)
- void write(byte[] b,int off,int len)
- void close()
- void flush():强制把缓冲区的数据写到输入流中
-
子类FileOutputStream常用的构造方法
- FileOutputStream(File file)
- FileOutputStream(String name)
- FileOutputStream(String name,boolean append)
1.前两种构造方法在向文件写数据时将覆盖文件中原有的内容
2.创建FileOutputStream实例时,如果相应的文件并不存在,则会自动创建一个空的文件
public class Test {
public static void main(String[] args) {
Dog dog=new Dog();
dog.setMaster("李伟");
dog.setName("欧欧");
dog.setType("狗狗");
FileInputStream fis=null;//输入
FileOutputStream fos=null;//输出
//构造方法里的参数表示输出流要输出到那个文件里
try {
fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Job\\Demo230907\\pet.txt");
fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Job\\Demo230907\\pet2.txt");
byte[] b=new byte[1024];
int i;
//fis.read 读进数组中
while ((i=fis.read(b))!=-1){
//System.out.println(str);
fos.write(b,0,i);
//转成字符串
String str=new String(b,0,i,"utf8");
//初始化一个字符串str2,用于存储处理后的文本。
String str2="\n"+str.replace("{name}",dog.getName())
.replace("前","后")
.replace("{type}",dog.getType())
.replace("{master}",dog.getMaster());
// System.out.println(str2); 转为字节数组 byte[] b2=str2.getBytes();
fos.write(str2.getBytes());
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
fos.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
使用FileOutputStream 写文本文件
- 使用FileOutputStream写文本文件的步骤与读文件的步骤有何不同?
字符流(多用于处理文本文件 txt word)
Reader类
- Reader类常用方法
- int read()
- int read(char[] c)
- read(char[] c,int off,int len)
- void close()
- 子类InputStreamReader常用的构造方法
- InputStreamReader(InputStream in)
- InputStreamReader(InputStream in,String charsetName) 有效防止乱码
s.toCharArray();//把字符串转换成char数组
FileReader类
- FileReader类是InputStreamReader的子类
- FileReader(File file)
- FileReader(String name)
- 该类只能按照本地平台的字符编码来读取数据,用户不能指定其他的字符编码类型
- System.out.println(System.getProperty(“file.encoding”));
获得本地平台的字符编码类型
- System.out.println(System.getProperty(“file.encoding”));
使用FileReader读取文件
- 与字节流FileInputStream类实现文本文件读取步骤类似
- 引入相关的类
import java.io.Reader; import java.io.FileReader; import java.io.IOExceprion;
- 创建FileReader对象
Reader fr=new FileReader("路径");
- 读取文本文件的数据
fr.read();
- 关闭相关的流对象
fr.close();
public class InputStreamReaderTest {
public static void main(String[] args) throws IOException {
// InputStreamReader 字符输入流 能防止中文乱码 是对字节输入流的再包装
//文件输入流
FileInputStream fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc.txt");
//创建字符输入流对象
InputStreamReader isr=new InputStreamReader(fis, StandardCharsets.UTF_8);
char[] c=new char[1024];
int i;//表示每次读到的字符数
while ((i=isr.read(c))!=-1){
for (int j = 0; j < i; j++) {
System.out.println(c[j]);
}
}
isr.close();
fis.close();
}
}
public class OutputStreamWriterTest {
public static void main(String[] args) throws IOException {
//创建一个字节输出流
FileOutputStream fos=new FileOutputStream
("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src" +
"\\Learn\\Day\\Day230908\\InputStreamReader\\abcd.txt");
OutputStreamWriter osw=new OutputStreamWriter(fos, StandardCharsets.UTF_8);
String s="今天中午吃米饭";
// s.toCharArray();//把字符串转换成char数组
osw.write(s);//字符输出流可以直接输出字符串
osw.close();
fos.close();
}
}
BufferedReader类
- 如何提高字符流读取文本文件的效率
- 使用
FileReader
类与BufferedReader
类
BufferedReader类是Reader类的子类 BufferedReader类带有缓冲区 按行读取内容的readLine()方法
- 使用
- BufferedReader常用的构造方法
- BufferedReader(Reader in)
- 子类BufferedReader特有的方法
- readLine()
使用BufferedReader读取文本文件
- 引入相关类
import java.io.FileReader; import java.io.BufferedReader; import java.io.IOException;
- 构造BufferedReader对象和FileReader对象
Reader fr=new FileReader("路径"); BufferedReader br=new BufferedReader(fr);
- 调用readLine()方法读取数据
br.readLine();
- 关闭文件流对象
br.close(); fr.close();
public class BufferedReaderTest {
public static void main(String[] args) throws IOException {
//创建一个字节输入流
FileInputStream fis=new FileInputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc.txt");
//创建一个字符输入流
InputStreamReader isr=new InputStreamReader(fis);
//创建BufferReader 自带缓冲区
BufferedReader br=new BufferedReader(isr);
String s;
while ((s=br.readLine())!=null){
System.out.println(s);
}
br.close();
isr.close();
fis.close();
}
}
public class BufferedWriterTest {
public static void main(String[] args) {
//创建一个字节输出流
FileOutputStream fos=null;
//创建一个字符输出流
OutputStreamWriter osw=null;
//创建BufferedWriter
BufferedWriter bw=null;
try {
fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt");
osw=new OutputStreamWriter(fos);
bw=new BufferedWriter(osw);
String s="今天星期五,明天星期六";
bw.write(s);
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
osw.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
工具类
package Learn.Day.Day230908.InputStreamReader.Demo01;/*
* @Date:2023/9/8
* @Description:Learn.Day.Day230908.InputStreamReader.Demo01
*/
import java.io.*;
public class IoUtil {//输入输出工具类
/**
* 读
*/
public String input(String path) {
//创建一个字节输入流
FileInputStream fis = null;
//创建一个字符输入流
InputStreamReader isr = null;
//创建BufferReader 自带缓冲区
BufferedReader br = null;
//创建字符串对象用来频繁拼接
StringBuilder sb = new StringBuilder();
try {
fis = new FileInputStream(path);
isr = new InputStreamReader(fis);
br = new BufferedReader(isr);
String s;//表示读到的字符串
while ((s = br.readLine()) != null) {
sb = sb.append(s);
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
br.close();
isr.close();
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
return sb.toString();
}
}
/**
* 写
*
* @param path 表示要输出的文件路径
* @param message 表示要输出的内容
*/
public void ouput(String path, String message) {
//创建一个字节输出流
FileOutputStream fos = null;
//创建一个字符输出流
OutputStreamWriter osw = null;
//创建BufferedWriter
BufferedWriter bw = null;
try {
fos = new FileOutputStream(path);
osw = new OutputStreamWriter(fos);
bw = new BufferedWriter(osw);
bw.write(message);
System.out.println("输出成功!!");
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
bw.close();
osw.close();
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public class Test {
public static void main(String[] args) {
IoUtil ioUtil=new IoUtil();
String s=ioUtil.input("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt");
System.out.println(s);
String newStr=s.replace("五","5").replace("六","6");
ioUtil.ouput("D:\\ideaworkspace\\J3071javaoop\\J3071JavaAdvanced\\src\\Learn\\Day\\Day230908\\InputStreamReader\\abc1.txt",newStr);
}
}
解决读取时中文乱码
- 读取包含中文的文本文件时,可能出现中文乱码,怎么办?
FileReader fr=new FileReader("路径");
BufferedReader br=new BufferedReader(fr);
FileInputStream fis=new FileInputStream("路径");
//使用 InoutStreamReader并设置编码格式
InputStreamReader fr=new InputStreamReader(fis,"UTF-8");
BufferedReader br=new BufferedReader(fr);
Writer类
- Writer类常用方法
- Write(String str)
- Write(String str,int off,int len)
- void close()
- void flush()
- 子类OutputStreamWriter常用的构造方法
- OutputStreamWriter(OutputStream out)
- OutputStreamWriter(OutputStream out,String charsetName)
FileWriter类
- FileWriter类是OutputStreamWriter的子类
- FileWriter(File file)
- FileWriter(String name)
- 该类只能按照本地平台的字符编码来写数据,用户不能指定其他的字符编码类型
FileWriter写文件
- 与字节流FileOutputStream类实现向文本文件写入数据步骤类似
- 引入相关的类
import java.io.Reader; import java.io.FileWriter; import java.io.IOException;
- 创建FileWriter对象
Writer fw=new FileWriter("路径");
- 写文本文件
fw.write();
- 关闭相关的流对象
fw.close();
BufferedWriter类
- 如何提高字符流写文本文件的效率?
- 使用
FileWriter
类与BufferedWriter
类BufferedWriter类是Writer类的子类 BufferedWriter类带有缓冲区
- BufferedWriter常用的构造方法
- BufferedWriter(Writer out)
- 使用
使用BufferedWriter写文件
- 引入相关的类
import java.io.FileWriter;
import java.io.BUfferedWriter;
import java.io.IOException;
- 构造BufferedWriter对象和FileWriter对象
FileWriter fw=new FileWriter("路径");
BufferedWriter bw=new BufferedWriter(fw);
- 调用Writer()方法写数据
bw.writer("hello");
- 流对象的清空和关闭flush()和close()
bw.flush();
fw.close();
/*
字节缓冲流:
BufferOutputStream
BufferedInputStream
构造方法:
字节缓冲输出流: BufferedOutputStream(OutputStream out)
字节缓冲输入流: BufferedInputStream(InputStream in)
*/
public class BuffferStreamDemo {
public static void main(String[] args) throws IOException {
//字节缓冲输出流 BufferedOutputStream(OutputStream out)
// FileOutputStream fos=new FileOutputStream("D:\\ideaworkspace\\J3071javaoop\\DemoLin\\src\\Demo\\BufferedOutputStream\\bos.txt");
// BufferedOutputStream bos=new BufferedOutputStream(fos);
String path="D:\\ideaworkspace\\J3071javaoop\\DemoLin\\src\\Demo\\BufferedOutputStream\\bos.txt";
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(path));
//写数据
bos.write("hello\r\n".getBytes());
bos.close();
//字节缓冲输入流: BufferedInputStream(InputStream in)
//读数据 一次读取一个字节数据
BufferedInputStream bis=new BufferedInputStream(new FileInputStream(path));
// int by;
// while ((by=bis.read())!=-1){
// System.out.print((char)by);
// }
//一次读取一个字节数组数据
byte[] bys=new byte[1024];
int len;
while ((len=bis.read(bys))!=-1){
System.out.println(new String(bys,0,len));
}
bis.close();
}
}