友情提醒
先看文章目录,大致了解知识点结构,直接点击文章目录可以跳转到文章指定位置。
第一章、File类和IO技术概述
1.1)File类和IO技术的作用
1.File类
①File类简介:Java把现实存在的文件和目录路径名描述成一个File类类。
②File类只是对持久设备上的文件和文件夹进行操作。不能去操作文件中的数据。要操作数据需要使用IO技术。
2.IO技术
①IO技术专门来实现数据与持久设备(持久保存数据的设备。硬盘、U盘等)间的交互。
②主要功能:程序中的数据可以保存到持久设备中,或者从持久设备中把数据读取到我们的Java程序中。
③I:Input:输入或者读取,持久设备数据输入到内存中。
O:Output:输出或者写出,内存中的数据输出到持久设备。
1.2)创建File类对象
①public File(String pathname) 根据文件或文件夹的路径名创建一个File对象。
②public File(String parent,String child) 根据父目录的路径名和子文件名创建一个File对象。
③public File(File parent,String child) 根据父目录的File对象和子文件名创建一个File对象。
public static void test1(){
//通过构造方法实例化File对象,jvm不会去验证参数位置定义的路径资源是否真实存在;
File f1 = new File("E\\2023Java\\Test\\file.txt");
File f2 = new File("E\\2023Java\\Test", "test1.txt");
File f3 = new File("E\\2023Java\\Test");
File f4 = new File(f3, "test2.txt");
File f5 = new File("1.txt");
System.out.println(f1);//E\2023Java\Test\file.txt
System.out.println(f2);//E\2023Java\Test\test1.txt
System.out.println(f3);//E\2023Java\Test
System.out.println(f4);//E\2023Java\Test\test2.txt
System.out.println(f5);//1.txt
}
1.3)File类中的方法
①get方法
public static void test2(){
File f1 = new File("hello\\2.txt");
//String getName():获取最后一个路径名字或者文件名字的字符串
//String getPath():获取路径名字字符串
System.out.println(f1.getName());//2.txt
System.out.println(f1.getPath());//hello\2.txt
//String getAbsolutePath():获取绝对路径名字符串。
//File getAbsoluteFile():获取绝对路径名形式。
System.out.println(f1.getAbsolutePath());//E:\javase\hello\2.txt
System.out.println(f1.getAbsoluteFile()); //E:\javase\hello\2.txt
//String getParent():返回父目录的路径名字符串;如果没有指定父目录,则返回 null。
//File getParentFile():返回父目录的路径名形式;如果没有指定父目录,则返回 null。
System.out.println(f1.getParent());//hello
System.out.println(f1.getParentFile());//hello
}
②创建文件夹和文件的方法
public static void test3(){
//创建目录:boolean mkdir():当不存在具有此抽象路径名时,创建此抽象路径名指定的目录
//在E盘下创建test目录
File f1 = new File("E:\\test");
boolean b = f1.mkdir();
System.out.println(b);
//boolean mkdirs():当不存在具有此抽象路径名时,创建此抽象路径名指定的目录,包括所有的父目录。
//在E盘下创建test\\bbb\\ccc目录
File f2 = new File("E:\\test1\\aaa\\bbb");
boolean b1 = f2.mkdirs();
System.out.println(b1);
System.out.println("**************************");
//创建文件:boolean createNewFile():当不存在具有此抽象路径名指定名称的文件时,创建
//在E:\test下创建woshisb.txt文件
try {
File f3 = new File("E:\\test\\woshisb.txt");
boolean b2 = f3.createNewFile();
System.out.println(b2);
} catch (IOException e) {
e.printStackTrace();
}
}
③删除文件和文件夹
delete方法可以删除目录,也可以删除文件
这种删除不会进回收站
public static void test4(){
//因为test文件夹里有文件woshisb.txt,所以删除失败
File f1 = new File("E:\\test");
boolean b1 = f1.delete();
System.out.println(b1);
//delete方法不支持多层级同时删除,所以只删除了bbb文件夹
File f2 = new File("E:\\test1\\aaa\\bbb");
boolean b2 = f2.delete();
System.out.println(b2);
//因为不存在所以无法删除,返回false
File f3 = new File("E:\\aaa");
boolean b3 = f3.delete();
System.out.println(b3);//false
}
④判断是否是文件/路径
public static void test5() {
/*判断
boolean isAbsolute():测试此抽象路径名是否为绝对路径名。
boolean isDirectory():测试此抽象路径名表示的文件是否是一个目录。
boolean isFile():测试此抽象路径名表示的文件是否是一个标准文件。
boolean isHidden():测试此抽象路径名指定的文件是否是一个隐藏文件。
boolean exists():测试此抽象路径名表示的文件或目录是否存在。 */
// File f = new File("E:\\woshisb.txt");
File f = new File("E:\\test");
System.out.println(f.isAbsolute());
System.out.println(f.isDirectory());
System.out.println(f.isFile());
System.out.println(f.isHidden());
System.out.println(f.exists());
}
⑤列举文件和目录
public static void test6() {
//String[] list():返回一个字符串数组,表示的目录中的文件和目录。
File file = new File("E:\\test");
String[] strs = file.list();
for (String str : strs) {
System.out.println(str);
}
System.out.println("******************************");
//File[] listFiles():返回一个抽象路径名数组,表示目录和其中的文件。
File[] files = file.listFiles();
for (File f : files) {
System.out.println(f);
}
}
1.4)文件过滤器:FileFileter
①作用:过滤我们不需要的文件,File[] listFiles(FileFilter filter) 返回符合过滤器条件的元素组成的数组。
②自定义文件过滤器类,实现FileFilter 接口,重写accept方法,并定义过滤规则
③调用listFiles方法的时候,会把每个元素都拿来调用accept方法,符合就返回true添加到数组中,否则返回false不添加到数组;
public class MyFilter2 implements FileFilter {
private String suffix;
public MyFilter2(String suffix) { this.suffix = suffix; }
public MyFilter2() { }
public String getSuffix() { return suffix; }
public void setSuffix(String suffix) { this.suffix = suffix; }
@Override
public boolean accept(File file) {
System.out.println("过滤器是文件并以.xxx结尾就不过滤,xxx自己决定");
boolean b1 = file.isFile();
boolean b2 = file.toString().endsWith(suffix);
return b1 && b2;
}
}
测试文件过滤器
public class TestFileFilter {
public static void main(String[] args) {
test1(); }
public static void test1() {
//得到E:\\test下所有.xxx结尾的文件,xxx自己决定
File file = new File("E:\\test");
//1、得到所有.txt结尾的文件,展示
MyFilter2 myFilter2 = new MyFilter2(".txt");
File[] files = file.listFiles(myFilter);
for (File f : files) {
System.out.println(f);
/*过滤器是文件并以.xxx结尾就不过滤,xxx自己决定
过滤器是文件并以.xxx结尾就不过滤,xxx自己决定
过滤器是文件并以.xxx结尾就不过滤,xxx自己决定
过滤器是文件并以.xxx结尾就不过滤,xxx自己决定
E:\test\2.txt
*/
}
}
第二章、IO流
2.1)IO流的分类
①数据传输过程中,一切数据的传输始终为二进制数据,最后存储形式都是字节(二进制数字)。
②字节(Byte)是计算机信息技术用于计量存储容量的一种计量单位,一个字节存储8位无符号数(即1字节=8bit),储存的数值范围为0-255。(255用二进制表示 = 11111111)
③IO流的分类:IO流体系脑图链接
2.2)字节输入流:InputStream
①InputStream抽象类,是表示输入字节流所有类的超类。他们操作的数据都是字节,定义了输入字节流的基本共性功能方法
2.2.1)操作文件的字节输入流:FileInputStream
①读取文件中的数据时,调用read方法,实现从文件一次只能读取一个字节数据。
public static void test1() throws IOException {
//创建File对象,关联目标资源(文件)
File file = new File("E:\\IO\\in.txt");
//创建FileInputStream对象,绑定File对象
FileInputStream fis = new FileInputStream(file);
//每次读取一个字节内容
int num = fis.read();
System.out.println(num);
System.out.println((char) num);
num = fis.read();
System.out.println(num);
System.out.println((char) num);
num = fis.read();
System.out.println(num);
System.out.println((char) num);
num = fis.read();
System.out.println(num);
System.out.println((char) num);
fis.close();
}
//--------------------------分割----------------------------------
//使用循环读取数据
public static void test2() throws IOException {
//创建File对象,关联目标资源(文件)
File file = new File("E:\\IO\\in.txt");
//创建FileInputStream对象,绑定File对象
FileInputStream fis = new FileInputStream(file);
//每次读取一个字节内容,使用循环来实现
int num;
while (true){
if ((num=fis.read())==-1){
break;
}
System.out.println((char)num);
}
fis.close();
②读取文件中的数据时,调用read的重载方法read(byte [ ])方法,实现从文件中一次读取多个字节数据到byte[]数组内部
,减少和磁盘文件的交互次数,效率高。
文件内容是abcdefg
public static void test3() throws IOException {
//创建File对象,关联目标资源(文件)
File file = new File("E:\\IO\\in.txt");//文件内容是abcdefg
//创建FileInputStream对象,绑定File对象
FileInputStream fis = new FileInputStream(file);
//一次读取多个字节到byte[]数组内部,减少和磁盘文件的交互次数,效率高
byte[] bs = new byte[5];
//int read(byte[] bs):返回值是读取到的有效字节数5
int len = fis.read(bs);
System.out.println(len); //这次read方法执行,得到的有效字节数为5
System.out.println(new String(bs)); //内容为"abcde"
System.out.println("=========================");
// len = fis.read(bs);
// System.out.println(len); //这次read方法执行,得到的有效字节数为2
// System.out.println(new String(bs)); //"fgcde"将bs数组所有元素都转为String会存在上次读取内容
// 把上面的注释了换一个String的构造方法:String(byte[] bytes, int offset, int length),从
len = fis.read(bs);
System.out.println(len); //2
//从0下标开始将后面len个字节转为string,这样就没重复内容
System.out.println(new String(bs,0,len));//fg
fis.close();
}
③综合上述的代码,写最终版大招
public static void test4() throws IOException {
//创建File对象,关联目标资源(文件)
File file = new File("E:\\IO\\in.txt");
//创建FileInputStream对象,绑定File对象
FileInputStream fis = new FileInputStream(file);
//一次读取1024字节内容到byte[]内部,之后进行读操作
byte[] bs = new byte[1024];
int len; //用于记录读取到的有效字节数,读到文件末尾则返回-1
while ((len = fis.read(bs)) != -1) {
//从0下标开始将后面len个字节转为string,这样就没重复内容
System.out.println(new String(bs,0,len));
}
fis.close();
}
2.2.2)字节缓冲输入流:BufferedInputStream(高效)
①读取流中的数据,内部包含了一个缓冲区,通过缓冲区读写,提高了IO流的读写速度
②构造方法public BufferedInputStream(InputStream in)
private static void read() throws IOException {
//1,创建缓冲流对象
FileInputStream fileIn = new FileInputStream("abc.txt");
//把基本的流包装成高效的流
BufferedInputStream in = new BufferedInputStream(fileIn);
//定义一个缓冲区
byte[] buf = new byte[1024];
//2,读数据
int len = 0;
while ( (ch = in.read(buf)) != -1 ) {
//打印
System.out.print(new String(buf, 0, len));
}
//3,关闭
in.close();
}
2.3)字节输出流:OutputStream
①OutputStream抽象类是表示输出字节流所有类的超类。他们操作的数据都是字节,定义了输出字节流的基本共性功能方法
2.3.1) 操作文件的字节输出流:FileOutputStream
①输出流的覆盖模式:没文件会在目录下创建一个文件,有文件会覆盖内容
public static void test1() throws IOException {
//创建文件字节输出流对象,关联File资源(定位文件位置)
//E盘下没这个文件会在目录下创建一个文件,有文件会覆盖内容
FileOutputStream fos = new FileOutputStream(new File("E:\\out666.txt"));
fos.write(97);//a
fos.write(98);//b
fos.write(99);//c
//\r是回车符,\n是换行符
fos.write("\n\r加油".getBytes());//加油
fos.close();
}
②输出流的追加模式:没文件会在目录下创建一个文件,有追加模式不会覆盖原文件内容而是追加内容。
public static void test2() throws IOException {
//创建文件字节输出流对象,关联File资源(定位文件位置),
// 并且开启追加模式,追加模式不会覆盖原文件内容
FileOutputStream fos = new FileOutputStream(new File("E:\\out2.txt"), true);
fos.write("发福。\r\n".getBytes());
fos.write("变胖。\r\n".getBytes());
fos.close();
}
2.3.2)字节缓冲输出流:BufferedOutputStream(高效)
①写入数据到流中,内部包含了一个缓冲区,通过缓冲区读写,提高了IO流的读写速度
②构造方法public BufferedOutputStream(OutputStream out)创建一个新的缓冲输出流。
public class BufferedOutputStreamDemo01 {
public static void main(String[] args) throws IOException {
write();
}
private static void write() throws IOException {
//创建基本的字节输出流
FileOutputStream fileOut = new FileOutputStream("abc.txt");
//使用高效的流,把基本的流进行封装,实现速度的提升
BufferedOutputStream out = new BufferedOutputStream(fileOut);
//2,写数据
out.write("hello".getBytes());
//3,关闭流
out.close();
}
}
2.3.3)字节打印流:PrintStream
2.4)字符输入流:Reader
①使用字节流去读取文本文件可能由于编码问题,每个中文所占用的字节数不同。如:gbk下的中文2字节,utf-8下的中文占用3字节。
②字符流只能操作字符,无法操作其他数据,如声音、视频
2.4.1)操作文件的字符输入流:FileReader
FileReader类自身没有方法,使用的都是父类中的方法。
public static void test() throws IOException {
//创建文件字符输入流对象,关联数据源
FileReader fr = new FileReader("io.txt");
char[] cs = new char[4];
int len; //记录读取到的有效字符数
while ((len = fr.read(cs)) != -1) {
System.out.println(new String(cs,0,len));
}
fr.close();
}
2.5)字符输出流:Writer
2.5.1)操作文件的字符输出流:FileWriter
FileWriter类自身没有方法,使用的都是父类中的方法。
①覆盖原文件内容
public static void test1() throws IOException {
//创建文件字符输出流对象,绑定数据目的
FileWriter fw = new FileWriter("out.txt");
fw.write("自己好,");
fw.write("\r\n不是真的好!");
// fw.flush();
fw.close();
}
②不覆盖原文件内容,追加数据
public static void test2() throws IOException {
//创建文件字符输出流对象,绑定数据目的
FileWriter fw = new FileWriter("out.txt", true);
Scanner input = new Scanner(System.in);
for (int i = 1;i <= 3;i++) {
System.out.println("请输入一串数据:");
String content = input.next();
fw.write(content + "\r\n");
fw.flush();
}
fw.close();
}
2.5.2)字符打印流:PrintWriter
第三章、转换流
3.1)字符编码表
①字符编码表:就是现实中的字符数据和计算机二进制的对应关系表。
②编码:字符—>(数字),解码:(数字)—>文字
③常用的编码表:
ASCII表
1、英文字符、数字与二进制数据的一一对应关系
2、一个英文字符对应1Bytes,1Bytes=8bit,8bit最多包含256个数
字,所以一共最多对应256个字符。
GBK表
1、中文字符、英文字符、数字与二进制数的 一一对应关系
2、一个英文字符对应1Bytes
一个中文字符对应2Bytes
2Bytes=16bit,16bit最多包含65536个数字,一共对应65536个字符
unicode表
国际标准码表:无论是什么文字,都用两个字节存储。
3.2)字符流通向字节流:OutputStreamWriter(编码)
OutputStreamWriter流可使用指定的字符编码表,将要写入流中的字符按照指定的编码表转成字节,在使用字节流将这些字节写出去。
public static void test2() throws IOException {
// 指定设置为utf-8的字符编码表
//OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("out6.txt"),"utf8");
//指定设置为gbk编码的字符编码表
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("out6.txt"),"gbk");
osw.write("今天要下雨!\r\n");
osw.write("大家带伞了吗?\r\n");
osw.close();
}
public static void test1() throws IOException {
//使用平台默认字符编码表
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("out5.txt"));
osw.write("今天要下雨!\r\n");
osw.write("大家带伞了吗?\r\n");
osw.close();
}
3.3)字节流通向字符流:InputStreamReader(解码)
InputStreamReader:使用指定的字符编码表读取字节并将其解码为字符。
在读取指定的编码的文件时,一定要指定编码格式,否则就会发生解码错误,而发生乱码现象。
public static void test2() throws IOException {
//FileInputStream放入InputStreamReader使用gbk编码表解码为字符
再放入BufferedReader使用readLine方法
BufferedReader br = new BufferedReader(new InputStre
amReader(new FileInputStream("E:\\IO\\change\\change.txt"), "gbk"));
String line = br.readLine();
System.out.println(line);
br.close();
}
public static void test1() throws IOException {
//使用默认的编码表解码为字符
FileReader fr = new FileReader(new File("E:\\IO\\change\\change.txt"));
char[] cs = new char[10];
int len;
while ((len = fr.read(cs)) != -1) {
System.out.println(new String(cs,0,len));
}
fr.close();
}
第四章、序列化流与反序列化流
4.1)对象序列化流:ObjectOutputStream
4.2)对象反序列化流:ObjectInputStream
4.3)序列化接口Serializable与瞬态关键字transient
第五章、IO流案例
5.1)复制单个文件
将文件中的内容读取输入到程序,再从程序输出到另一个同名文件
①复制单个文件:
//copy任意的文件
public static void copyFile2(String src, String dest) throws IOException {
long start = System.currentTimeMillis();
//创建文件字节输入、输出流,分别绑定数据源和数据目的
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
byte[] bs = new byte[1024];
int len;
while ((len = fis.read(bs)) != -1) {
fos.write(bs, 0, len);
}
//后开启的先关闭
fos.close();
fis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
5.2)使用缓冲字节流复制单个文件(高效)
①复制单个文件
public static void copyFile3(String src, String dest) throws IOException {
long start = System.currentTimeMillis();
//创建节点流(文件字节输入、输出流),分别绑定数据源和数据目的
FileInputStream fis = new FileInputStream(src);
FileOutputStream fos = new FileOutputStream(dest);
//创建处理流(缓冲字节输入、输出流),分别绑定节点流对象
BufferedInputStream bis = new BufferedInputStream(fis);
BufferedOutputStream bos = new BufferedOutputStream(fos);
byte[] bs = new byte[1024];
int len;
while ((len = bis.read(bs)) != -1) {
bos.write(bs, 0, len);
}
//关闭处理流的过程中,会自动触发关闭所包含的节点流
bos.close();
bis.close();
long end = System.currentTimeMillis();
System.out.println(end - start);
}
5.3)缓冲字节流复制当前目录下所有文件·
①复制当前目录层级下所有文件
/*①判断目标目录是否存在,如果不存在就立即创建
②得到src资源下所有的内容(文件、目录) ==> File[] listFile()
③遍历File数组元素,判断是否文件 ==> boolean isFile()
④在遍历的过程中发现是文件,则将文件进行copy操作,copy后的文件的名字和源文件名字保持一致
提示:获取源文件名字的方法 ==> String getName()*/
public class CopyFile{
public static void main(String[] args) throws IOException {
copyFile(new File("E:\\IO\\image"), new File("E:\\IO\\copy"));
}
public static void copyFile(File src,File dest) throws IOException {
//判断目标目录dest是否真实存在
if (!dest.isDirectory()) {
//说明不存在,直接创建
dest.mkdir();
}
//得到src资源下所有的内容(文件、目录)
File[] files = src.listFiles();
//遍历数组元素
for (File file : files) {
//判断是否是文件
if (file.isFile()) {
//说明是文件,进行复制操作,获得文件的名字
String name = file.getName();
//获得文件的绝对路径
String path = file.getAbsolutePath();
//创建FileInputStream对象,根据path绑定(目标资源),把FileInputStream对象放入BufferedInputStream
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(path));
//FileOutputStream对象,根据dest和name绑定目标资源,把FileOutputStream对象放入BufferedOutputStream
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(new File(dest, name)));
byte[] bs = new byte[1024];
int len;
while ((len = bis.read(bs)) != - 1) {
bos.write(bs, 0, len);
}
bos.close();
bis.close();
}
}
}
}
5.4)切割文件/合并文件
①切割文件文章来源:https://www.toymoban.com/news/detail-552966.html
public class TestCut {
public static void main(String[] args) throws IOException {
//创建输入流对象,关联绑定需要被切割文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\IO\\image\\3.avi"));
//5M大小切割
byte[] bs = new byte[1024 * 1024 * 5];
int len;
int name = 1; //用于给碎片文件起名字
while ((len = bis.read(bs)) != -1) {
//创建输出流对象,关联绑定当前的碎片文件
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\io\\cut\\" + name + ".avi"));
bos.write(bs, 0, len);
bos.close();
name++;
}
bis.close();
}
}
②合并文件文章来源地址https://www.toymoban.com/news/detail-552966.html
public class TestMerge {
public static void main(String[] args) throws IOException {
//创建输出流对象,绑定需要被合并成的文件,没有这个文件会直接创建
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("E:\\IO\\merge\\合并.avi"));
byte[] bs = new byte[1024];
int len;
for (int i = 1;i <= 11;i++) {
//创建输入流对象,绑定当前的碎片文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("E:\\io\\cut\\" + i + ".avi"));
while ((len = bis.read(bs)) != -1) {
bos.write(bs, 0, len);
}
bis.close();
}
bos.close();
}
}
到了这里,关于Java中的IO流详解的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!