Java入门系列-22-IO流
File类的使用
Java程序如何访问文件?通过 java.io.File 类
使用File类需要先创建文件对象 File file=new File(String pathname);
,创建时在构造函数中指定物理文件或目录,然后通过文件对象的方法操作文件或目录的属性。
\ 是特殊字符,要使用需要转义 \\
File 类常用方法
方法名称 | 说明 |
---|---|
boolean exists() | 判断文件或目录是否存在 |
boolean isFile() | 判断是否是文件 |
boolean isDirectory() | 判断是否是目录 |
String getPath() | 返回此对象表示的文件的相对路径名 |
String getAbsolutePath() | 返回此对象表示的文件的绝对路径 |
String getName() | 返回此对象指定的文件或目录 |
boolean createNewFile() | 创建名称的空文件,不创建文件夹 |
long length() | 返回文件的长度,单位为字节,文件不存在则返回0L |
File[] listFiles() | 返回一个抽象路径名数组,这些路径名表示此抽象路径名表示的目录中的文件。 |
static File[] listRoots() | 列出可用文件系统根 |
boolean mkdirs() | 创建此抽象路径名指定的目录,包括所有必需但不存在的父目录。 |
使用示例:
import java.io.File;
import java.io.IOException;
public class TestFile {
public static void main(String[] args) {
//创建File对象 传入文件的路径
File file=new File("D:\\a.txt");
//创建File对象 传入文件夹的路径
File dir=new File("D:/word");
//判断是否存在
if(file.exists()) {
if(file.isFile()) {
//getName()获取名字
System.out.println(file.getName()+" 是文件");
}else if(file.isDirectory()){
System.out.println(file.getName()+" 是目录");
}
}else {
System.out.println(file.getName()+" 不存在!");
try {
//创建文件
file.createNewFile();
System.out.println("文件大小:"+file.length()+" 字节");
} catch (IOException e) {
e.printStackTrace();
}
}
if(dir.exists()) {
if(dir.isFile()) {
System.out.println(dir.getName()+" 是文件");
}else if(dir.isDirectory()) {
System.out.println(dir.getName()+" 是文件夹");
//绝对路径
System.out.println(dir.getAbsolutePath());
}
}else {
System.out.println(dir.getName()+" 不存在!");
//创建目录
dir.mkdirs();
}
}
}
流
流:指一连串流动的字符,是以先进先出方式发送信息的通道
输入流:源数据流向程序(读)
输入流:程序中的数据流向目标数据源(写)
Java流的分类
按流向
- 输出流(OutputStream和Writer作为基类)
- 输入流(InputStream和Reader作为基类)
输入输出流是相对于计算机内存来说的
按照处理数据单元划分
- 字节流
- 字节输入流(InputStream基类)
- 字节输出流(OutputStream基类)
- 字符流
- 字符输入流(Reader基类)
- 字符输出流(Writer基类)
字节流是8位(1B)通用字节流,字符流是16位(2B)Unicode字符流
字节流
FileInputStream 是 InputStream 的子类
InputStream 类常用方法
方法名称 | 说明 |
---|---|
int read() | 从输入流中读取数据的下一个字节。返回0到255的int值,如果到达流的末尾,则返回-1 |
int read(byte[] b) | 从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。返回读入缓冲区的总字节数,如果达到末尾则返回-1 |
int read(byte[] b,int off,int len) | 将输入流中最多 len 个数据字节读入 byte数组 |
void close() | 关闭此输入流并释放与该流关联的所有系统资源 |
int available() | 返回此输入流下一个方法调用可以不受阻塞地从此输入流读取的估计字节数 |
FileInputStream 类常用构造方法
名称 | 说明 |
---|---|
FileInputStream(File file) | 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的 File 对象 file 指定。 |
FileInputStream(String name) | 通过打开一个到实际文件的连接来创建一个 FileInputStream,该文件通过文件系统中的路径名 name 指定。 |
使用 FileInputStream 读取文件
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TestFileInputStream {
public static void main(String[] args) {
FileInputStream fis=null;
try {
fis=new FileInputStream("D:\\a.txt");
//读取结果存入StringBuffer
StringBuffer sb=new StringBuffer();
System.out.println("预计读取:"+fis.available()+"字节");
//记录每次读取的长度
int len=0;
//缓冲区字节数组
byte[] buff=new byte[1024];
while((len=fis.read(buff))!=-1) {
System.out.println("还剩余:"+fis.available()+"字节");
sb.append(new String(buff,0,len));
}
System.out.println("结果:");
System.out.println(sb);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fis!=null) {
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileOutputStream 是 OutputStream 的子类
OutputStream 类常用方法
方法名称 | 说明 |
---|---|
void write(int c) | 将制定的字节写入此输出流 |
void write(byte[] buf) | 将 b.length 个字节从指定的 byte 数组写入此输入流 |
void write(byte[] b,int off,int len) | 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流 |
void close() | 关闭此输出流并释放与此流有关的所有系统资源 |
FileOutputStream的构造方法
名称 | 说明 |
---|---|
FileOutputStream(File file) | 创建一个向指定 File 对象表示的文件中写入数据的文件输出流 |
FileOutputStream(String name) | 创建一个向具有指定名称的文件中写入数据的输出文件流 |
FileOutputStream(String name,boolean append) | 第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处 |
使用 FileOutputStream 写文件
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestFileOutputStream {
public static void main(String[] args) {
FileOutputStream fos=null;
try {
//创建输出流对象
fos=new FileOutputStream("D:\\c.txt");
//要输出的字符
String str="hello world 你好";
//将字符串转成字节数组并写入到流中
fos.write(str.getBytes());
//刷新流
fos.flush();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (fos!=null) {
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
字符流
上面的内容我们看到,字节流不能直接操作字符,所以操作字符用字符流。
FileReader 是 Reader 的子类
Reader 类常用方法
方法名称 | 说明 |
---|---|
int read() | 读取单个字符 |
int read(char[] c) | 将字符读入数组 |
read(char[] c,int off,int len) | 将字符读入数组的某一部分 |
void close() | 关闭该流并释放与之关联的所有资源 |
使用 FileReader 读取文本文件
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
public class TestReader {
public static void main(String[] args) {
Reader r=null;
try {
//创建FileReader对象
r=new FileReader("D:\\a.txt");
//字符缓冲数组
char[] chrs=new char[512];
//记录每次读取的个数
int len=0;
//循环读取
while((len=r.read(chrs))!=-1) {
String str=new String(chrs, 0, len);
System.out.println(str);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (r!=null) {
try {
r.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
FileWriter 是 Writer 的子类
Writer 类常用方法
方法名称 | 说明 |
---|---|
write(String str) | 写入字符串 |
write(String str,int off,int len) | 写入字符串的某一部分 |
void close() | 关闭此流,但要先刷新它 |
void flush | 刷新该流的缓冲 |
使用 FileWriter 写入文本文件
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class TestWriter {
public static void main(String[] args) {
Writer w=null;
try {
//创建字符输出流
w=new FileWriter("D:\\msg.txt");
String msg="hello every bady 兄嘚";
//将字符串写入到流中
w.write(msg);
w.flush();
} catch (IOException e) {
e.printStackTrace();
}finally {
if (w!=null) {
try {
w.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
缓冲字符流
如果频繁的对字符进行读写操作,墙裂建议使用缓冲!
BufferedReader 类带有缓冲区,可以先把一批数据读到缓冲区,接下来的读操作都是从缓冲区内获取数据,避免每次都从数据源读取数据进行字符编码转换,从而提高读取操作的效率。
使用BufferedReader读取文本文件
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class TestBufferedReader {
public static void main(String[] args) {
FileReader reader=null;
BufferedReader br=null;
try {
//创建字符读入流
reader=new FileReader("D:\\a.txt");
//将字符读入流包装成字符缓冲流
br=new BufferedReader(reader);
//记录每行读入的内容
String line=null;
//用于拼接保存每行读入的内容
StringBuffer content=new StringBuffer();
while ((line=br.readLine())!=null) {
content.append(line+"\n");
}
System.out.println("所有内容:");
System.out.println(content);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (reader!=null) {
reader.close();
}
if (br!=null) {
br.close();
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
BufferedReader 是 Reader 的子类,带有缓冲区,特有方法 readLine() 按行读取内容
BufferedWriter 类带有缓冲区,与BufferedReader的方向正好相反,BufferedWriter 是把一批数据写到缓冲区,当缓冲区满的时候,再把缓冲区的数据写到字符输出流中。避免每次都执行物理写操作,提高写操作的效率。
使用 BufferedWriter 写文件
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class TestBufferedWriter {
public static void main(String[] args) {
FileWriter writer=null;
BufferedWriter bw=null;
try {
writer=new FileWriter("D:\\out.txt");
bw=new BufferedWriter(writer);
bw.write("hello");
//内容换行
bw.newLine();
bw.write("world");
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (bw!=null) {
bw.close();
}
if (writer!=null) {
writer.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
关闭流的顺序与创建流的顺序相反
数据流
DataInputStream 类
- FileInputStream 的子类
- 与 FileInputStream 类结合使用读取二进制文件
DataOutputStream 类
- FileOutputStream 的子类
- 与 FileOutputStream 类结合使用写二进制文件
使用数据流复制图片
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class TestCopy {
public static void main(String[] args) {
//文件输入流
FileInputStream fis=null;
//数据输入流(包装fis得到)
DataInputStream dis=null;
//文件输出流
FileOutputStream fos=null;
//数据输出流(包装fos得到)
DataOutputStream dos=null;
try {
fis=new FileInputStream("D:\\a.jpg");
dis=new DataInputStream(fis);
fos=new FileOutputStream("F:\\b.jpg");
dos=new DataOutputStream(fos);
//缓冲数组
byte[] buff=new byte[1024];
//记录每次读取的字节个数
int len=0;
//循环读入
while((len=dis.read(buff))!=-1) {
//循环写入len个字节
dos.write(buff,0,len);
}
System.out.println("完成");
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if (dis!=null) {
dis.close();
}
if (dos!=null) {
dos.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Java入门系列-22-IO流的更多相关文章
- Java基础系列8——IO流超详细总结
该系列博文会告诉你如何从入门到进阶,一步步地学习Java基础知识,并上手进行实战,接着了解每个Java知识点背后的实现原理,更完整地了解整个Java技术体系,形成自己的知识框架. 在初学Java时,I ...
- Java socket中关闭IO流后,发生什么事?(以关闭输出流为例)
声明:该博文以socket中,关闭输出流为例进行说明. 为了方便讲解,我们把DataOutputstream dout = new DataOutputStream(new BufferedOutpu ...
- java IO文件操作简单基础入门例子,IO流其实没那么难
IO是JAVASE中非常重要的一块,是面向对象的完美体现,深入学习IO,你将可以领略到很多面向对象的思想.今天整理了一份适合初学者学习的简单例子,让大家可以更深刻的理解IO流的具体操作. 1.文件拷贝 ...
- Java的递归、IO流
.t1 { background-color: #ff8080; width: 1100px; height: 40px } 一.递归 [递归] 1. 在函数自身内部,调用函数本身的方式,称为递归. ...
- Java中常见的IO流及其使用
Java中IO流分成两大类,一种是输入流.全部的输入流都直接或间接继承自InputStream抽象类,输入流作为数据的来源.我们能够通过输入流的read方法读取字节数据.还有一种是输出流,全部的输出流 ...
- 乐字节Java之file、IO流基础知识和操作步骤
嗨喽,小乐又来了,今天要给大家送上的技术文章是Java重点知识-IO流. 先来看看IO流的思维导图吧. 一. File 在Java中,Everything is Object!所以在文件中,也不例外! ...
- Java——(九)IO流
一.流的分类 1.输入流和输出流 按照流的流向来分,可以分为输入流和输出流 输入流:只能从中读取数据,而不能向其写入数据. 输出流:只能向其写入数据,而不能从中读取数据. 此处的输入.输出涉及一个方向 ...
- Java文件操作(IO流)
File 在java中用来表示文件和文件夹的具体类. File的构建 File的常见方法 字节流: 对象序列化: 字符流: 转接流: InputStreamReader. ...
- Java 持久化操作之 --io流与序列化
1)File类操作文件的属性 1.File类的常用方法 1. 文件的绝对完整路径:getAbsolutePath() 文件名:getName() 文件相对路径:getPath() 文件的上一级目录:g ...
- Java之视频读取IO流解帧实施方案
获取视频处理对象的方式有很多,读取本地文件.读取url.读取摄像头等,而直接读流解析视频的实施方案却难以寻觅.此处有两种方案处理视频流(此处设定场景为用户上传视频,同时两种方式均需服务端安装ffmpe ...
随机推荐
- C#面向对象:多态
此文章转载网站:https://www.cnblogs.com/qixinbo/p/8244583.html 多态: 有多态之前必须要有继承,只有多个类同时继承了同一个类,才有多态这样的说法. 在继承 ...
- 菜鸟的Xamarin.Forms前行之路——共享组件
出自:博客园-半路独行 本文出自于http://www.cnblogs.com/banluduxing 转载请注明出处. Url Description Xamarin.Social The Xama ...
- Flex + Bison: Scanning from memory buffer
Found from StackOverflow: ========================================================================== ...
- pandas set_index() reset_index()
set_index() 官方定义: 使用一个或多个现有列设置索引, 默认情况下生成一个新对象 DataFrame.set_index(keys, drop=True, append=False, ...
- javascript设为首页、加入收藏
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...
- BZOJ2243 [SDOI2011]染色(LCT)
传送门 明明是道树剖的题…… 然而我硬生生做成了LCT 虽然的确用LCT只是板子啦(LCT的题哪道不是板子) 就是把颜色打上标记,然后基本就是板子 //minamoto #include<bit ...
- Hello QT(译)
简评:PySide2 是 QT 官方出品,值得期待 PySide2 第一个技术预览版快要发布了,在此给出一个简单的例子,来展示它将如何打开 Python世界的大门. 下面我们将使用 QWidgets ...
- NOI.AC省选模拟赛第一场 T1 (树上高斯消元)
link 很容易对于每个点列出式子 \(f_{x,y}=(f_{x,y-1}+f_{x,y}+f_{x,y+1}+f_{x+1,y})/4\)(边角转移类似,略) 这个转移是相互依赖的就gg了 不过你 ...
- [spring] spring 装配Bean
Bean的配置信息是Bean的元数据信息.包括1.Bean的实现类.2.Bean的属性信息.3.Bean的依赖关系.4.Bean的行为配置(比如控制Bean的生命周期中init,destory方法). ...
- POJ-3126-Prime Path(BFS)
Prime Path Time Limit: 1000MS Memory Limit: 65536K Total Submissions: 27852 Accepted: 15204 Desc ...