您的位置 首页 java

Java 进阶:Java File & IO—1

目录

一、 File
二、IO流
三、字节输出流
四、字节输入流
五、字节流文件复制
六、字符输出流
七、字符输入流
八、字符流复制文本文件

一、File 类

1. 概述

文件 和 目录路径名 的抽象表达形式
Java 中把文件或者目录(文件夹)都封装成 File对象
我们要去操作硬盘上的文件,或者文件夹只要找到 File这个类即可
File类对象,只是路径名的 抽象表示形式,即使该文件在操作系统上并不物理存在,也可以创建这个路径所表示的File对象

2. 构造方法

File(String pathname):通过给定 路径名字符串 转换为 抽象路径名 来创建一个新 File 实例
windows中的路径或文件名不区分大小写,但是最好别这样,跨平台可能会出现问题
File(String parent, String child):根据 parent 路径名字符串 和 child 路径名字符串,创建一个新 File 实例
好处: 单独操作父路径和子路径
File(File parent, String child):根据 parent 抽象路径名 和 child 路径名字符串,创建一个 File 实例
好处: 父路径是File类型,父路径可以直接调用File类方法

 public class Test {
    public static void main(String[] args) {
        /*
        * File(String pathname)
        * 传递路径名: 可以写到文件夹,可以写到一个文件
        */        File file = new File("f:\a.txt");
        System.out.println(file);

        /*
        * File(String parent, String child)
        * 传递字符串父路径,字符串子路径
        */        File file = new File("f:\", "a.txt");
        System.out.println(file);

        /*
        * File(File parent, String child)
        * 传递传递File类型父路径,字符串子路径
        */        File parent = new File("f:");//带不带"\"都可以
        File file = new File(parent, "a.txt");
        System.out.println(file);
    }
}
12345678910111213141516171819202122232425  

3. File 类成员方法

—创建功能—

public boolean createNewFile():创建文件,如果文件已存在,不再创建
public boolean mkdir():创建单级文件夹,如果文件夹已存在,不再创建
public boolean mkdirs():创建多级文件夹,文件夹已经存在了,不再创建
mkdirs() 也可以创建单级文件夹,所以推荐使用 mkdirs()

—删除功能—

public boolean delete(): 删除文件或者文件夹,不走回收站,直接从硬盘删除!
如果此路径名表示一个目录,则该目录 必须为空 才能删除。

—重命名功能—

public boolean renameTo(File dest): 重新命名文件

—判断功能—

public boolean isFile() :判断File构造方法中封装的路径是不是文件
public boolean isDirectory():判断File构造方法中封装的路径是不是文件夹
public boolean exists(): 判断File构造方法中封装的路径是否存在
public boolean canRead() :读权限
public boolean canWrite() :写权限
public boolean isHidden() :是否隐藏

—基本获取功能—

public String getAbsolutePath():获取绝对路径,返回 String 对象
public File getAbsoluteFile():获取绝对路径,返回 file 对象(推荐使用)
eclipse和 IDEA环境中,写一个相对路径,获取的绝对位置是工程根目录
public String getPath():将抽象路径名转换为字符串(就相当于 toString)
public String getName():返回路径中表示的文件名或者文件夹名 (获取路径中的最后部分的名字)
public long len gth() :返回路径中表示的文件的字节数(文件夹为 0)
public long lastModified() :上次修改的时间
String getParent(): 获取父路径,返回String对象
File getParentFile(): 获取父路径,返回File对象(推荐使用)

4. File类高级获取功能

public String[] list()
获取到 File 构造方法中封装的路径中的文件和文件夹名 (遍历一个目录),返回只有名字。如果此抽象路径名不表示一个目录,那么此方法将返回 nul,返回的是一个字符串数组,不会递归的获取子目录中的信息(文件或者目录的名称)。
public File[] listFiles()
获取到 File 构造方法中封装的路径中的文件和文件夹名 (遍历一个目录),返回的是目录或者文件的 全路径
返回一个 File对象数组。不会递归的获取子目录中的信息(文件或者目录的名称)
注意:在获取指定目录下的文件或者文件夹时必须满足下面两个条件

1)指定的目录必须存在

2)指定的必须是目录。否则容易引发 返回数组为null,出现NullPointerException

5. 文件过滤器

listFiles(FileFilter filter) : 传递 FileFilter 接口的实现类
FileFilter 接口:
必须自定义 FileFilter 接口实现类,重写抽象方法,然后将接口实现类对象传递到遍历方法 listFiles
boolean accept(File pathname) 返回 true 满足条件,回false不满足过滤条件
过滤器中的 accept() 方法接受一个参数,这个参数就当前文件或文件夹对象(全路径)
FilenameFilter接口:
过滤器中的 accept() 接受两个参数,一个当前文件或文件夹所在的路径,一个是当前文件或文件夹对象的名称
boolean accept(File dir, String name) 返回true满足条件,回false不满足过滤条件
当我们需要过滤文件名称时就可以使用 FilenameFilter 这个过滤器,当我们想对当前文件或文件夹进行过滤,就可以使用 FileFilter
对于一个目录下,文件或文件目录的筛选工作代码:
不变——筛选过程
变化——筛选条件
原理分析
listFiles() 遍历目录的同时,获取到了文件名全路径,调用过滤器的方法 accept(),将获取到的路径传递给 accept(),accept() 方法接收了参数,参数是 listFiles 传递来的,在 accept()方法中,进行判断,如果满足过滤条件,返回true,否则返回false,一旦方法返回了true,listFiles 就将路径保存到 File数组 中

6. 递归遍历全目录

 public class FileDemo {
    public static void main(String[] args) {
        File dir = new File("E:\a");
        getAllDir(dir);
    }

    // 定义方法,实现目录的全遍历
    private static void getAllDir(File dir) {
        //调用方法listFiles()对目录,dir进行遍历
        File[] fileArr = dir.listFiles();
        for(File f : fileArr){
            //判断变量f表示的路径是不是文件夹,是,则递归遍历
            if(f.isDirectory()){
                getAllDir(f);
            }else{
                System.out.println(f);
            }
        }
    }
}
1234567891011121314151617181920  

二、IO流

1. 概述

IO流用来处理设备之间的 数据传输
Java对数据的操作是通过
的方式
Java用于操作流的对象都在 IO包 中(input/output)
Output操作:把内存中的数据存储到持久化设备上这个动作称为输出(写)
Input操作:把持久设备上的数据读取到内存中的这个动作称为输入(读)
流的分类:
流按流向分为两种:
输出流:内存——>外设(写出数据)
输入流:磁盘——>内存(读入数据)
流按操作类型分为两种:
字节流:字节流可以操作任何数据,因为在计算机中任何数据都是以字节的形式存储的
字符流:字符流只能操作纯字符数据,比较方便。

2. IO流常用父类

字节流的抽象父类:InputStream ,OutputStream
字符流的抽象父类:Reader , Writer

三、字节输出流

1. 概述

java.io.OutputStream 此抽象类,是表示输出字节流的所有类的超类。操作的数据都是 字节

2. OutputStream 的核心方法:

void close (): 关闭此输出流并释放与此流有关的所有系统资源。
close的常规协定:该方法将关闭输出流。关闭的流不能执行输出操作,也不能重新打开。
如果流对象建立失败了,需要关闭资源吗?
new 对象的时候,失败了,没有占用系统资源;释放资源的时候,对流对象判断null,变量不是null,对象建立成功,需要关闭资源
write( byte [] b): 将 b.length 个字节从指定的 byte 数组写入此输出流
write(byte[] b, int off, int len):将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
write(int b): 将指定的字节写入此输出流。write 的常规协定:向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。

3. FileOutputStream

(1) 构造方法

FileOutputStream(File file) :创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append): 创建一个向指定 File 对象表示的文件中写入数据的文件输出流,以追加的方式写入。
FileOutputStream(String name) :创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append) :创建一个向具有指定 name 的文件中写入数据的输出文件流,以追加的方式写入。

(2) 流对象的使用步骤:

创建流子类的对象,绑定数据目的
调用流对象的方法write写
close释放资源
注意事项:流对象的构造方法,可以创建文件,如果文件存在,直接覆盖

 public class IoDemo {
    public static void main(String[] args) throws IOException {
        //创建流子类的对象,绑定数据目的
        FileOutputStream fos = new FileOutputStream("E:\a.txt");
        //用write方法写数据
        //写一个字节
        fos.write(100); //d

        //写字节数组
        byte[]  bytes  = {65,66,67,68}; //ABCD
        fos.write(bytes);

        //写字节的一部分,开始索引,写几个
        fos.write(bytes,1,1); //B

        //写入字节数组的简便方式
        //写字符串
        fos.write("Hello".getBytes());
        //关闭资源
        fos.close();
    }
}
12345678910111213141516171819202122  

4. 文件的续写和换行

(1)实现数据的换行

在文件中,写入换行符号换行: rn
rn 可以写在上一行的末尾, 也可以写在下一行的开头

 fos.write("hellorn".getBytes());
1  

(2)关于数据的追加写入

默认情况下,当一个文件输出流对象,指向一个文件的时候,会清空文件内容
必须使用特殊的构造方法实现文件的追加写入,FileOutputStream构造方法, 的第二个参数中加入 true
//实现追加写入:

 FileOutputStream fos = new FileOutputStream(file, true);
1  

5. IO异常的处理

一些细节:
保证流对象变量,作用域足够
catch里面处理异常
输出异常的信息,目的看到哪里出现了问题,停下程序,重新尝试
如果流对象建立失败了,需要关闭资源吗
new 对象的时候,失败了,没有占用系统资源;释放资源的时候,对流对象判断 null;变量不是 null,对象建立成功,需要关闭资源

 public class FileOutputStreamDemo3 {
    public static void main(String[] args) {
        File file = new File("c:\file.txt");
        //try 外面声明变量,try 里面建立对象,为了提升流对象作用域
        //定义FileOutputStream的引用
        FileOutputStream fos = null;
        try {
            //创建FileOutputStream对象
            fos = new FileOutputStream(file);
            //写出数据
            fos.write("abcde".getBytes());
        } catch (IOException e) {
            System.out.println(e.toString() + "----");
             throw new RuntimeException("文件写入失败,重试");
        } finally {
            //一定要判断fos是否为null,只有不为null时,才可以关闭资源
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    throw new RuntimeException("关闭资源失败");
                }
            }
        }
    }
}
1234567891011121314151617181920212223242526  

四、字节输入流

1. 概述

java.io.InputStream: 此抽象类是表示字节输入流的所有类的超类。读取任意文件,每次只读取1个字节

2. 核心方法

abstract int read():读取一个字节
read()方法的特点:read() 执行一次,就会自动读取下一个字节,返回值是读取到的字节, 读取到结尾返回 -1

 public class IoDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流的子类对象
        FileInputStream fis = new FileInputStream("E:\a.txt"); //ABCD
        //读取一个字节,调用read方法,返回int
        //使用循环方式,读取文件,循环结束的条件:read() 返回 -1
        int len = 0; //接收read()的返回值
        while((len = fis.read()) != -1){
            System.out.print((char)len); //可以转换成字符
        }
        //关闭资源
        fis.close();
    }
}
1234567891011121314  

int read(byte[] b):读取一定数量的字节,并将其存储在缓冲区数组 b 中
int read(byte[] b, int off, int len) :读取最多 len 个字节,存入 byte 数组。
数组的作用:缓冲的作用, 提高效率
read 返回的 int,表示读取到多少个有效的字节数

 public class IoDemo {
    public static void main(String[] args) throws IOException {
        //创建字节输入流的子类对象
        FileInputStream fis = new FileInputStream("E:\a.txt"); 
        //创建字节数组
        byte[] b = new byte[1024];

        int len = 0;
        while((len = fis.read(b)) != -1){
            System.out.print(new String(b,0,len)); //使用String的构造方法,转为字符串
        }
        //关闭资源
        fis.close();
    }
}
123456789101112131415  

3. FileInputStream 类

(1)构造方法

为这个流对象 绑定数据源
FileInputStream(File file)
FileInputStream(String name)
参数:File对象 和 String对象

(2)输入流读取文件的步骤

创建字节输入流的子类对象
调用读取方法 read 读取
关闭资源

(3)读取数据的方式:

第一种方式:一次读取一个字节数据
第二种方式:一次读取一个字节数组
第二种方式效率更高,每次读取都会和操作系统发生一次交互,第二种方式每次可以读取多个数据,提高了操作效率

4、释放资源的另一种方式

 
//1.第一种释放资源的方式  closeQuietly
//释放输入流资源
closeQuietly(fis);
//释放输出流对象
closeQuietly(fos);
private static void closeQuietly(Closeable close) {
    if(close != null) {
        try {
            close.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

//2.jdk7 中引入的 try-with-resource语句

try(放申请资源的语句){

}catch() {

}

// 一旦资源的申请放在try-with-resource语句的()中,那么资源会保证一定自动被释放
12345678910111213141516171819202122232425  

五、字节流文件复制

1. 读取单个字节

 public class Copy {
    public static void main(String[] args) {
        long s = System.currentTimeMillis();
        //定义两个流的对象变量
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            //建立两个流的对象,绑定数据源和数据目的
            fis = new FileInputStream("D:\test.mp3"); //8,003,733 字节
            fos = new FileOutputStream("d:\test.mp3");
            //字节输入流,读取1个字节,输出流写1个字节
            int len = 0 ;
            while((len = fis.read())!=-1){
                fos.write(len);
            }
        }catch(IOException e){
            System.out.println(e);
            throw new RuntimeException("文件复制失败");
        }finally{
            try{
                if(fos!=null)
                    fos.close();
            }catch(IOException e){
                throw new RuntimeException("释放资源失败");
            }finally{
                try{
                    if(fis!=null)
                        fis.close();
                }catch(IOException e){
                    throw new RuntimeException("释放资源失败");
                }
            }
        }
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
}
//耗时:61817
1234567891011121314151617181920212223242526272829303132333435363738  

2. 读取字节数组

 public class Copy_1 {
    public static void main(String[] args) {
        long s = System.currentTimeMillis();
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try{
            fis = new FileInputStream("D:\test.mp3");
            fos = new FileOutputStream("E:\test.mp3");
            //定义字节数组,缓冲
            byte[] bytes = new byte[1024*10];
            //读取数组,写入数组
            int len = 0 ;
            while((len = fis.read(bytes))!=-1){
                fos.write(bytes, 0, len);
            }
        }catch(IOException e){
            System.out.println(e);
            throw new RuntimeException("文件复制失败");
        }finally{
            try{
                if(fos!=null)
                    fos.close();
            }catch(IOException e){
                throw new RuntimeException("释放资源失败");
            }finally{
                try{
                    if(fis!=null)
                        fis.close();
                }catch(IOException e){
                    throw new RuntimeException("释放资源失败");
                }
            }
        }
        long e = System.currentTimeMillis();
        System.out.println(e-s);
    }
}
//耗时:41
1234567891011121314151617181920212223242526272829303132333435363738  

六、字符输出流

1. 概述

java.io.Writer 所有字符输出流的超类。写文件,写 文本文件

2. 方法介绍

void write(int c):写入单个字符
void write(String str) :写入字符串
void write(String str, int off, int len):写入字符串的某一部分
void write(char[] cbuf):写入 字符数组
abstract void write(char[] cbuf, int off, int len) :写入字符数组的某一部分

3. FileWriter 类

Writer 类是抽象类,找到子类对象 FileWriter
构造方法:参数也是 File 类型对象 和 String 文件名
字符输出流,写数据的时候,必须要运行一个功能,刷新功能:flush()

 public class WriterDemo {
    public static void main(String[] args) throws IOException{
        FileWriter fw = new FileWriter("c:\1.txt");

        //写1个字符
        fw.write(100);
        fw.flush();

        //写1个字符数组
        char[] c = {'a','b','c','d','e'};
        fw.write(c);
        fw.flush();

        //写字符数组一部分
        fw.write(c, 2, 2);
        fw.flush();

        //写如字符串
        fw.write("hello");
        fw.flush();

        fw.close();
    }
}
123456789101112131415161718192021222324  

七、字符输入流

1. 概述

java.io.Reader,字符输入流读取文本文件,所有字符输入流的超类,专门读取文本文件

2. 方法介绍

int read(): 读取单个字符
int read(char[] cbuf):将字符读入数组
abstract int read(char[] cbuf, int off, int len) :将字符读入数组的某一部分
没有读取字符串的方法

3. FileReader 类

Reader类 是抽象类,找到子类对象 FileReader
构造方法:写入的数据目的。绑定数据源。参数也是 File 类型对象 和 String 文件名

 public class ReaderDemo {
    public static void main(String[] args) throws IOException{
        FileReader  fr  = new FileReader("c:\1.txt");
        //读字符
        /*int len = 0 ;
        while((len = fr.read())!=-1){
            System.out.print((char)len);
        }*/
        //读数组
        char[] ch = new char[1024];
        int len = 0 ;
        while((len = fr.read(ch))!=-1){
            System.out.print(new String(ch,0,len)); //转字符串
        }
        fr.close();
    }
}
123456789101112131415161718  

4. flush 方法和 close 方法区别

flush()方法:用来刷新缓冲区的,刷新后可以再次写出,只有字符流才需要刷新
close()方法:用来关闭流释放资源的的,如果是带缓冲区的流对象的close()方法,不但会关闭流,还会再关闭流之前刷新缓冲区,关闭后不能再写出

八、字符流复制文本文件

字符流复制文本文件,必须是文本文件
字符流查询本机默认的编码表,简体中文GBK
FileReader 读取数据源
FileWriter 写入到数据目的

 //读取字符数组

public class Copy_2 {
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try{
            fr = new FileReader("c:\1.txt");
            fw = new FileWriter("d:\1.txt");
            char[] cbuf = new char[1024];
            int len = 0 ;
            while(( len = fr.read(cbuf))!=-1){
                fw.write(cbuf, 0, len);
                fw.flush();
            }

        }catch(IOException ex){
            System.out.println(ex);
            throw new RuntimeException("复制失败");
        }finally{
            try{
                if(fw!=null)
                    fw.close();
            }catch(IOException ex){
                throw new RuntimeException("释放资源失败");
            }finally{
                try{
                    if(fr!=null)
                        fr.close();
                }catch(IOException ex){
                    throw new RuntimeException("释放资源失败");
                }
            }
        }
    }
}
123456789101112131415161718192021222324252627282930313233343536  

文章来源:智云一二三科技

文章标题:Java 进阶:Java File & IO—1

文章地址:https://www.zhihuclub.com/185681.shtml

关于作者: 智云科技

热门文章

网站地图