文件、IO概述

最新推荐文章于 2024-05-16 10:23:10 发布

不忌嘴的tom猫

最新推荐文章于 2024-05-16 10:23:10 发布

阅读量49

点赞数

分类专栏： io 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_45907893/article/details/129764335

版权

io 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

文件

文件的概念

File：文件和目录路径名的抽象表示形式

构造函数

new File(String path)
new File(String parent,String child)
new File(File parent,String child)

//方式一： new File(String pathname)
String filePath = "e:\\news1.txt";
File file = new File(filePath);
//方式二：new File(String parent,String child)
String parentFilePath = "e:\\";
String childFileName = "news2.txt";
File file = new File(parentFilePath,childFileName);
//方式三：new File(File parent,String child)
File parentFilePath = new File("e:\\");
String fileName = "news3.txt";
File file = new File(parentFilePath,fileName);

常用方法

创建、删除相关

createNewFile()：只有执行过此方法文件才创建成功
mkdir()：只能创建单层目录
mkdirs()：创建多层目录，也可以创建一层目录
delete()
deleteOnExit()：执行到该语句时，删除行为不会立即执行，而是在JVM结束时才执行删除的行为

获取相关

length()：获取文件大小，单位是字节，文件夹的大小结果都是0
getName()
getPath()：获取文件对象创建时的路径
getAbsolutePath()：获取文件对象的绝对路径
toString()
getAbsoluteFile()
getParent()
getParentFile()
注：如果文件对象创建时的路径是相对路径，那么以上两个方法的返回结果都是null

//创建文件对象
        File file = new File("e:\\news1.txt");
        //调用方法，得到对应信息
        System.out.println("文件名称:"+file.getName());
        System.out.println("文件绝对路径:"+file.getAbsolutePath());
        System.out.println("文件父目录:"+file.getParent());
        System.out.println("文件的大小(字节):"+file.length());
        System.out.println("是否是文件:"+file.isFile());
        System.out.println("是否是目录:"+file.isDirectory());
        System.out.println("文件是否存在:"+file.exists());
        System.out.println("文件的全路径:"+file.toString());
        System.out.println("文件是否隐藏:"+file.isHidden());
        System.out.println("当前File对象指向的路径是否是绝对路径:"+file.isAbsolute());

在这里插入图片描述

文件夹的遍历

list()：返回指定文件夹中所有子内容的名字组成的字符串数组
listFiles()：返回指定文件夹中所有文件对象组成的File数组

@Test
    public void test01(){
        File file = new File("F:\\Java\\第一阶段");
        String[] list = file.list();
        for (String s : list) {
            System.out.println(s);
        }
    }

    @Test
    public void test02(){
        File f = new File("F:\\Java\\第一阶段");
        File[] files = f.listFiles();
        for (File file : files) {
            System.out.println(file);
        }
    }

文件夹的过滤
list(FileNameFilter filter)：返回文件名字符串数组
listFiles(FilenameFilter filter)：返回文件数组
listFiles(FileFilter filter)：返回文件数组

注：1、FileNameFilter、FileFilter都是接口，需要实现其接口传递参数，也可以使用匿名内部类。
2、FileNameFilter重写的方法中有两个参数
3、FileFilter重写的方法中只有一个参数

//方法一：list(FileNameFilter filter)
//文件夹的过滤,文件大小超过10kb的，返回字符串数组
@Test
    public void test03(){
        File f = new File("F:\\Java\\第一阶段\\笔记");
        String[] lists = f.list(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                File file = new File(dir, name);
                return file.length() / 1024 > 10;
            }
        });
        for (String list : lists) {
            System.out.println(list);
        }
    }
    
@Test
    public void test05(){
        File f = new File("F:\\Java\\第一阶段\\笔记");
        Arrays.stream(f.list((dir, name) -> new File(dir, name).length() / 1024 > 10))
                .forEach(System.out::println);
    }

//方法二：listFiles(FilenameFilter filter)
//文件过滤，返回文件数组
    @Test
    public void test07(){
        File f = new File("F:\\Java\\第一阶段");
        File[] list = f.listFiles((dir, name) -> (new File(dir, name).getName().endsWith(".wmv")) && (new File(dir, name).length() / 1024 / 1024 <60));
        Arrays.stream(list).forEach(System.out::println);
    }

//方法三：listFiles(FileFilter filter)
//文件过滤，返回文件数组
 @Test
    public void test08(){
        File f = new File("F:\\Java\\第一阶段");
        File[] files = f.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                return pathname.getName().endsWith(".wmv");
            }
        });
        for (File file : files) {
            System.out.println(file);
        }
    }

IO流

概念

IO：i（input）、o（output），IO流研究的是文件中数据的输入输出，将文件内容的输入输出的这种传递看成数据的流动，因此称为IO流
流的分类：

按流向划分：

输入流：从外部到内部，从其他地方到内存
输出流：从内部到外部，从内存到其他地方

按文件类型划分：

字节流：任何类型的文件都可以使用字节流来读写
字符流：文件文件要通过字符流来读写

IO流中有4个顶层父类：它们都是抽象类
InputStream：字节输入流
OutputStream：字节输出流
Reader：字符输入流
Writer：字符输出流

文件字节输出流

FileOutputStream：文件字节输出流

构造函数

new FileOutputStream(String path)
new FileOutputStream(File f)
new FileOutputStream(String path,boolean append)
new FileOutputStream(File f,boolean append)

注：布尔类型的append，表示是否向文件中追加内容，true表追加，false表覆盖

常用方法

write(int b)
write(byte[] b)
write(byte[] b,int offset,int len)
close()：关闭流，释放资源

注：1、关闭流后，该流不能再使用，否则会发生IOException
2、使用完后记得关闭流

//write(int b)
@Test
    public void f1() throws IOException {
        FileOutputStream f = new FileOutputStream("F:\\Java\\第一阶段\\demo\\a.txt");
        f.write(97);
        f.close();
    }

//write(byte[] b)
 @Test
    public void f5() throws IOException {
        File file = new File("F:\\Java\\第一阶段\\demo\\a.txt");
        FileOutputStream f = new FileOutputStream(file);
        byte[] b = {97,98,99,100};
        f.write(b);
        f.close();
    }

@Test
    public void f6() throws IOException {
        File file = new File("F:\\Java\\第一阶段\\demo\\a.txt");
        FileOutputStream f = new FileOutputStream(file);
        byte[] b = {97,98,99,100};
        //f.write(b,0,2);
        f.write(b,1,2);
        f.close();
    }

文件字节输入流

FileInputStream：文件字节输入流

构造函数：

new FileInputStream(String path)
new FileInputStream(File f)

常用方法：

read()
read(byte[] b)
close()
注：当返回值为-1时，表示读取结束

//read()
@Test
    public void f1() throws Exception {
        File f = new File("F:\\Java\\第一阶段\\demo\\a.txt");
        FileInputStream file = new FileInputStream(f);
        //System.out.println(file.read()); //97(a)
        int b;
        while ((b = file.read()) !=-1){
            System.out.println(b);  //97,98,99,100...
        }
//        String s="";
//        while ((b = file.read()) !=-1){
//            s+=(char)b;
//        }
//        System.out.println(s); //abcd
    }

//read(byte[] b)
 @Test
    public void f2() throws Exception {
        FileInputStream file = new FileInputStream("F:\\Java\\第一阶段\\demo\\a.txt");
        byte[] b = new byte[4];
        int len;
        String s="";
        //System.out.println(file.read(b));//4
        while ((len = file.read(b)) != -1){
            s += new String(b,0,len);
        }
        System.out.println(s); //abcd...
    }

文件字符输出流

FileWriter：文件字符输出流

构造函数

new FileWriter(String path)
new FileWriter(String path,boolean append)
new FileWriter(File f)
new FileWriter(File f,boolean append)

常用方法

write(int c)
write(String s)
write(String s,int off,int len)
write(char[] c)
write(char[] c,int off,int len)
flush()
close()
注：close()在关闭流，释放资源时，也会将缓冲区中内容写入到目标地址，但是它和flush()的区别是，flush()后流对象还可以继续使用，而close()后流对象不能再使用，否则会发生IOException

@Test
    public void f1() throws IOException {
        File file = new File("F:\\Java\\第一阶段\\demo\\a.txt");
        FileWriter fw = new FileWriter(file);
        fw.write(97);
        fw.flush();
        fw.write("你好呀");
        fw.flush();
        fw.write("abcd",0,2);
        fw.flush();
        char[] b = {'a','b','c','d'};
        fw.write(b);
        fw.flush();
        char[] b1 = {97,98,99,100};
        fw.write(b1);
        fw.flush();
        char[] b2 = {101,102,103,104};
        fw.write(b2,0,2);
        fw.flush();
    }

文件字符输入流

FileReader：文件字符输入流

构造函数

new FileReader(String path)
new FileReader(File f)

常用方法

read()
read(char[] c)
close()

//read()
@Test
    public void f1() throws IOException {
        //File file = new File("F:\\Java\\第一阶段\\笔记\\11-文件、IO流.md");
        File file = new File("F:\\Java\\第一阶段\\demo\\a.txt");
        FileReader fr = new FileReader(file);
        int len;
        String s="";
        while ((len= fr.read()) != -1){
            s+=(char)len;
        }
        System.out.println(s);
    }

//read(char[] c)方法
 @Test
    public void f2() throws IOException {
        File file = new File("F:\\Java\\第一阶段\\笔记\\11-文件、IO流.md");
        FileReader fr = new FileReader(file);
        char[] cs = new char[1024];
        int len;
        String s="";
        while ((len= fr.read(cs)) != -1){
            s+=new String(cs,0,len);
        }
        System.out.println(s);
    }

缓冲流

缓冲流也叫高效流，它是对4个基本的文件流的增强
BufferedInputStream：字节缓冲输入流
BufferedOutputStream：字节缓冲输出流
BufferedWriter：字符缓冲输出流
BufferedReader：字符缓冲输入流
构造函数

new BufferedInputStream(InputStream is)
new BufferedOutputStream(OutputStream os)
new BufferedWriter(Writer w)
new BufferedReader(Reader r)
注意参数类型

常用方法同普通文件流
另：
BufferedWriter中的newLine()：写入一个换行符
BufferedReader中readLine()：读取一整行，返回读取到的字符串，读取不到返回null
@Test
public void f1() throws Exception{
	FileReader fr = new FileReader("F:\\Java\\第一阶段\\笔记\\11-文件、IO流.md");
  	BufferedReader br = new BufferedReader(fr);
  	String s = "";
  	while((s = br.readLine()) != null){
 		 System.out.println(s);
  }
}

对象流

java中将一个对象存储到文件中，或者将文件中的对象读取到程序就要使用对象流
序列化：将一个对象存储到文件中的过程
反序列化：将一个文件中对象解析到程序中的过程
ObjectOutputStream、ObjectInputStream
注：

1、如果要将对象存储到文件中，这个对象的类必须实现Serializable接口，序列化接口的意义是用于标志当前这个类中的对象是允许被序列化
2、反序列化时要保证类和序列化时的类是一致的，返回会发生InvalidClassExpcetion
3、序列化时，如果对象中的某个属性不需要写入到文件中，那么这个属性可以使用关键字transient来修饰

Properties属性集

properties文件是一种配置文件
Properties类，它继承了Hashtable，Hashtable实现了Map接口，Properties的本质就是一个Map，所以对它的操作是以键值对的形式来完成的
Properties的特点：它的键和值都是字符串
properties文件的特点：该文件中的内容都要以键值对的形式来写

文件中配置的格式：

key=value
key:value
key value
注：properties文件中每一行只能写一个键值对

Properties读取配置文件的步骤：

创建Properties对象

Properties pro = new Properties();

加载配置文件

FileInputStream fis = new FileInputStream("src\\test.properties");
pro.load(fis);

通过键获取值

pro.getProperty(String key);
pro.getProperty(String key,String defalueValue);