JAVA之IO流
IO流
- IO流分类
- File类
- 流的分类
- 文件字节输入流FileInputStream ----将文件中的数据读取出来
- 文件字节输出流FileOutputStream---将数据写入文件中
- 文件字节输入输出流复制图片案例
- 文件字符输入流FileReader----将文件中的数据读取出来
- 文件字符输出流FileWriter----向文件中写入字符数据
- 字符流完成拷贝文件---只能拷贝文本文档
- 处理流之一缓冲流
- 字符缓冲输入流--BufferedReader
- 字符缓冲输出流--BufferedWriter
- 缓冲字符流复制文件
- 转换流
- 标准输入和输出流
- 对象流
- 随机存储流
IO流分类
File类
注意，\在文件中是路径的分隔符，但是在java编程中一个\的意思时转义符，在java中\或者/才是文件的分隔符
文件类里面的基础方法
public class test {
public static void main(String[] args) {
//File f1=new File("D:\\IO","dhy.txt");//父路径和子路径
//也可也File.separator作为文件分隔符
//File f7=new File("D:"+File.separator+"IO\\dhy.txt");
File f7=new File("D:\\IO\\dhy.txt");
System.out.println(f7.getName());//获取文件名或者当前文件夹的名称
System.out.println(f7.getPath());//获取文件或者文件夹的路径，就是new file时候写的路径
System.out.println(f7.getAbsolutePath());//获取当前文件的绝对路径
System.out.println(f7);//返回一个用当前文件的相对路径构建的对象
System.out.println(f7.getAbsoluteFile());//返回一个用当前文件的绝对路径构建的file对象
System.out.println(f7.getParent());//返回当前文件或者文件夹的父级路径
f7.renameTo(new File("D:\\IO\\dhy.txt"));//给文件或文件夹重命名
System.out.println(f7.exists());//判断文件或者文件夹是否存在
System.out.println(f7.canWrite());//判断文件是否可写
System.out.println(f7.canRead());//判断文件是否可读
System.out.println(f7.isFile());//判断当前的file对象是不是文件
System.out.println(f7.isDirectory());//判断当前的file对象是不是文件夹或者目录
System.out.println(f7.lastModified());//获取文件的最后修改时间，返回的是一个毫秒数
System.out.println(f7.length());//返回文件的长度，单位是字节数
}
}
文件的新建，删除
public class test {
public static void main(String[] args) {
File f7=new File("D:\\IO\\xpy.txt");
if(!f7.exists())
{
try {
f7.createNewFile(); //创建新文件
} catch (IOException e) {
e.printStackTrace();
}
}
f7.delete();//删除文件
}
}创建单层目录，多级目录
File f7=new File("D:\\IO\\dhy");
f7.mkdir();//创建单层目录，如果使用这一方法来创建多层目录，就得一层一层的执行mkdir方法
File f7=new File("D:\\IO\\dhy\\a\\b\\c");
f7.mkdirs();//创建多层目录
返回当前文件的子集
File f7=new File("D:\\IO");
String[] list = f7.list();//返回当前文件夹的子集的名称，包括目录和文件
for(String s:list)
{
System.out.println(s);
}
File f7=new File("D:\\IO");
File[] fs = f7.listFiles();//返回的是当前文件夹的子集的file对象，包括目录和文件
for(File f:fs)
{
System.out.println(f);
}
流的分类
文件字节输入流FileInputStream ----将文件中的数据读取出来
FileInputStream in=new FileInputStream("D:\\IO\\dhy.txt");
//设置一个byte数组接收读取的文件的内容
byte[] b=new byte[10];
//设置一个读取数据的长度
int len=0;
//read方法有一个返回值，返回值是读取的数据的长度，如果读取到最后一个数据，还会向后读取一个，这时候返回值就是-1
//所以当read的返回值是-1时，整个文件就读取完毕了
// in.read(b);
//不断从文件中读取数据，返回读取长度，直到等于-1时，说明读取结束
while((len=in.read(b))!=-1)
{
//第一个参数: 缓冲数据的数组 第二个参数:从数组的哪个位置开始转化字符串 第三个参数:总共转化几个字节
System.out.println(new String(b,0,len));
}
in.close();//流在使用完毕之后一定要关闭
文件字节输出流FileOutputStream—将数据写入文件中
//指定向dhy.txt里面输出数据
//如果当前文件夹下面没有对应的.txt，那么会帮我们创建出来一个
FileOutputStream out=new FileOutputStream("D:\\IO\\xpy.txt");
String str="大忽悠";
out.write(str.getBytes(StandardCharsets.UTF_8));//把数据写到内存中，这里是以字节方式写入的
out.flush();//把内存中的数据刷写到硬盘上
out.close();//关闭流
文件字节输入输出流复制图片案例
import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
public static void main(String[] args) {
CopyData("D:\\image\\long.jpg","D:\\IO\\dhy.jpg");
}
//inPath: 从哪个文件中读取数据 outPath:将读取出来的对应的数据写入到哪个文件中
public static void CopyData(String inPath,String outPath)
{
try {
FileInputStream in=new FileInputStream(inPath);
FileOutputStream out=new FileOutputStream(outPath);
byte[] bytes=new byte[1024];
int len=0;
while((len=in.read(bytes))!=-1)
{
//读取到内存中
out.write(bytes,0,len);//参数一是缓冲数组，参数2是从数组中的哪个位置开始读取，参数3是读取的长度
}
//将读取数据刷新到硬盘上
out.flush();
//安装逆序的顺序关闭流
out.close();
in.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
文件字节流非常通用，可以用来操作字符的文档，还可以用来操作其他任何文件(图片，压缩包等)，因为字节流使用的是二进制
文件字符输入流FileReader----将文件中的数据读取出来
public class test {
public static void main(String[] args) {
CopyData("D:\\IO\\dhy.txt");
}
public static void CopyData(String inPath)
{
try {
//创建文件字符输入流对象
FileReader fr=new FileReader(inPath);
//创建临时存数据的字符数组
char[] ch=new char[10];
//定义一个输入流的读取长度
int len=0;
while((len=fr.read(ch))!=-1)
{
System.out.println(new String(ch,0,len));
}
fr.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
文件字符输出流FileWriter----向文件中写入字符数据
import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
public static void main(String[] args) {
CopyData("D:\\IO\\dpy.txt","大忽悠和小朋友");
}
//outPath:将读取出来的对应的数据写入到哪个文件中 text:输出的内容
public static void CopyData(String outpath,String text)
{
try {
FileWriter fw=new FileWriter(outpath);
fw.write(text);//写到内存中
fw.flush();//把内存的数据刷到硬盘
fw.close();//关闭流
} catch (IOException e) {
e.printStackTrace();
}
}
}
字符流完成拷贝文件—只能拷贝文本文档
import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
public static void main(String[] args) {
CopyData("D:\\IO\\dpy.txt","D:\\IO\\copy\\copy.txt");
}
//outPath:将读取出来的对应的数据写入到哪个文件中 text:输出的内容
public static void CopyData(String inpath,String outpath)
{
try {
FileReader fr=new FileReader(inpath);
FileWriter fw=new FileWriter(outpath);
char[] c=new char[10];
int len=0;
//边读边写
while((len=fr.read(c))!=-1)
{
fw.write(c,0,len);//写到内存中
}
fw.flush();//把内存的数据刷到硬盘
fw.close();//关闭流
fr.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
字节流和字符流共同需要注意的问题
处理流之一缓冲流
字节缓冲输入流–BufferedInputStream
public class test {
public static void main(String[] args) {
try {
CopyData();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData() throws IOException {
//文件字节输入流对象
FileInputStream in=new FileInputStream("D:\\IO\\dpy.txt");
//把文件字节输入流放到缓冲字节输入流对象中
BufferedInputStream br=new BufferedInputStream(in);
byte[] b=new byte[100];
int len=0;
while((len=br.read(b))!=-1)
{
System.out.println(new String(b,0,len));
}
//关闭流的时候，按照最晚开的最关
br.close();
in.close();
}
}
字节缓冲输出流–BufferedOutputStream
public class test {
public static void main(String[] args) {
try {
CopyData();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData() throws IOException {
//创建字节输出流对象
FileOutputStream out=new FileOutputStream("D:\\IO\\dpy.txt");
//把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo=new BufferedOutputStream(out);
String s="hello world";
//写到内存上
bo.write(s.getBytes(StandardCharsets.UTF_8));
//刷到硬盘上
bo.flush();
//关闭流的时候，最晚开的最早关闭，依次关
bo.close();
out.close();
}
}
缓冲流实现文件的复制
import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
public static void main(String[] args) {
try {
CopyData("D:\\image\\long.jpg","D:\\IO\\dhy.jpg");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData(String inpath,String outpath) throws IOException {
//字节缓冲输入流
BufferedInputStream bi=new BufferedInputStream(new FileInputStream(inpath));
//字节缓冲输出流
BufferedOutputStream bo=new BufferedOutputStream(new FileOutputStream(outpath));
//用于存储数据的字节缓冲数组
byte[] b=new byte[1024];
//设置一个读取到的数组长度，直到读取到最后一个数据后面，返回-1
int len=0;
while((len=bi.read(b))!=-1)
{
bo.write(b,0,len);//写到内存上
}
bo.flush();//刷到硬盘上
bo.close();
bi.close();
}
}
字符缓冲输入流–BufferedReader
public class test {
public static void main(String[] args) {
try {
CopyData("D:\\IO\\dpy.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData(String inpath) throws IOException {
FileReader fileReader=new FileReader(inpath);
BufferedReader br=new BufferedReader(fileReader);
char[] c=new char[100];
int len=0;
//读到文件的最后一个字符的下一位，返回-1
while((len=br.read(c))!=-1)
{
System.out.println(new String(c,0,len));
}
br.close();
fileReader.close();
}
}
字符缓冲输出流–BufferedWriter
import java.io.*;
import java.nio.charset.StandardCharsets;
public class test {
public static void main(String[] args) {
try {
CopyData("D:\\IO\\dpy.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData(String outpath) throws IOException {
FileWriter fw=new FileWriter(outpath);
BufferedWriter bw=new BufferedWriter(fw);
bw.write("大忽悠和小朋友");
bw.flush();
bw.close();
fw.close();
}
}
缓冲字符流复制文件
public class test {
public static void main(String[] args) {
try {
CopyData("D:\\IO\\dpy.txt","D:\\IO\\copy\\dpy.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData(String inpath,String outpath) throws IOException {
BufferedReader br=new BufferedReader(new FileReader(inpath));
BufferedWriter bw=new BufferedWriter(new FileWriter(outpath));
char[] c=new char[10];
int len=0;
while((len=br.read(c))!=-1)
{
bw.write(c,0,len);
}
bw.flush();
bw.close();
br.close();
}
}
注意：缓冲流是把数据缓冲到内存中
注意：如果向一个.txt里面写入数据，那么默认会覆盖掉里面原来的数据，即删除掉原有数据，来写入新数据，而不是追加写入
转换流
public class test {
public static void main(String[] args) {
try {
CopyData("D:\\IO\\dpy.txt","D:\\IO\\copy\\dpy.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData(String inpath,String outpath) throws IOException {
//转换输入流
FileInputStream fs=new FileInputStream(inpath);
//把字节流转换为字符流
InputStreamReader in=new InputStreamReader(fs,"UTF-8");//参数1是字节流，参数2是编码格式
char[] c=new char[100];
int len=0;
while((len=in.read(c))!=-1)
{
System.out.println("字节流转换为字符流:"+new String(c,0,len));
}
in.close();
fs.close();
//转换输出流
FileOutputStream out=new FileOutputStream(outpath);
//把字节输出流转换为字符输出流
OutputStreamWriter os=new OutputStreamWriter(out,"UTF-8");
os.write("12345678");
os.flush();
os.close();
out.close();
}
}
注意:在转换字符流的时候，设置的字符集编码要与读取的文件的数据的编码格式一致，不然乱码
标准输入和输出流
public class test {
public static void main(String[] args) {
try {
CopyData();
} catch (IOException e) {
e.printStackTrace();
}
}
public static void CopyData() throws IOException {
//创建一个接收键盘输入的输入数据的输入流
InputStreamReader is=new InputStreamReader(System.in);
//把输入流放到缓冲流中
BufferedReader br=new BufferedReader(is);
//缓冲字符输出流
BufferedWriter bw=new BufferedWriter(new FileWriter("D:\\IO\\dpy.txt"));
String line="";
while((line=br.readLine())!=null)
{
if(line.equals("over"))
break;
//读取的每一行都写入到指定的txt文件
bw.write(line);
}
bw.flush();
bw.close();
br.close();
is.close();
}
}
对象流
序列化与反序列化只针对对象的各种属性，不包括静态成员变量
对象的序列化与反序列化
public class test {
public static void main(String[] args) {
try {
CopyData();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
public static void CopyData() throws IOException, ClassNotFoundException {
//定义对象的输出流，把对象序列化之后的流放到指定的文件中
ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("D:\\IO\\peo.txt"));
people p=new people();
p.age=19;
p.name="大忽悠";
out.writeObject(p);
out.flush();//刷写数据到硬盘
out.close();
//反序列化
//创建对象输入流对象，从指定的文件中把对象序列化后的流读取出来
ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:\\IO\\peo.txt"));
people peo = (people) in.readObject();
System.out.println(peo);
}
}
对象序列化和反序列化使用的对象要严格一致
随机存储流
RandomAccessFile类
本文参与 腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。
原始发表：2021/07/26 ，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
相关产品与服务
文件存储
文件存储（Cloud File Storage，CFS）为您提供安全可靠、可扩展的共享文件存储服务。文件存储可与腾讯云服务器、容器服务、批量计算等服务搭配使用，为多个计算节点提供容量和性能可弹性扩展的高性能共享存储。腾讯云文件存储的管理界面简单、易使用，可实现对现有应用的无缝集成；按实际用量付费，为您节约成本，简化 IT 运维工作。
腾讯云开发者
