Java笔记14---File类，IO流

最新推荐文章于 2024-07-08 22:39:05 发布

Insight blue sky

最新推荐文章于 2024-07-08 22:39:05 发布

阅读量201

点赞数

文章标签： java File类 IO流

本文链接：https://blog.csdn.net/qq_41804322/article/details/84075429

版权

1.File类
文件和目录路径名的抽象表示形式，即可以用来表示文件，也可以用来表示目录。
构造方法：
File(String pathname)根据指定的路径得到一个File对象。
File(String parent,String child)根据一个目录和一个文件/目录得到File对象。
File(File parent,String child)根据一个父File对象和一个子文件/目录的得到一个File对象。
1.File file=new File(“D:\java_xikai\上课笔记\day2”);
2.File file2=new File(“D:\java_xikai\上课笔记”,“day2”);
3. File file3=new File(“D:\java_xikai\上课笔记”);
File file4=new File(file3,“day2”);
//以上三组构造方法都构造的是同一个文件对象。
2.File的功能
(1).File的创建功能
Public boolean createNewFile():创建一个新的文件，如果存在就不创建了。
public boolean mkdir()；创建一个文件夹，如果存在这样的一个文件夹就不创建了，注意只能创建单层目录；
public boolean mkdirs():创建一个文件夹，如父类文件夹不存在，会帮你创建出来，可以创建多层目录；
相对路径：没有带盘符的路径
绝对路径：带有盘符的路径

public class Demo1 {
    public static void main(String[] args) throws IOException {
        File file1=new File("D:\\java_xikai\\上课笔记\\day2");
        File file2=new File("D:\\java_xikai\\上课笔记","day2");
        File file3=new File("D:\\java_xikai\\上课笔记");
        File file4=new File(file3,"day2");
        //以上三组构造方法都构造的是同一个文件对象。
        File file=new File("D:\\java_xikai\\上课笔记\\day2");
        boolean b=file.createNewFile();//创建新的文件
        System.out.println(b);
        File file5=new File("D:\\java_xikai\\上课笔记\\day3");
        boolean b1=file5.mkdir();//创建文件夹，只能创建一层
        System.out.println(b1);
        File file6=new File("D:\\java_xikai\\上课笔记\\day6\\day9");
        boolean b2=file6.mkdirs();//创建文件夹，可以创建多层
        System.out.println(b2);

        File file7=new File("D:java_xi");//没有带盘符\\。默认存到项目路径下
        boolean b3=file7.mkdirs();
        System.out.println(b3);
//        相对路径：没有带盘符的路径
//        绝对路径：带有盘符的路径
    }
}

(2). File的删除功能
public boolean delete()；删除文件或者文件夹
注意：文件夹里不能含有文件，或者文件夹，否则删除不了。Java中的删除不走回收站，要删除时务必确认其中不能有文件或者文件夹。
删除多个文件夹时，采用递归层层删除

public class Demo6 {
    public static void main(String[] args) {
        //删除多级文件夹
        File file=new File("D:\\java");
        methodDelete(file);
    }

    private static void methodDelete(File file) {
        File[] files=file.listFiles();
        for(File f:files){
            if(f.isFile()){
                f.delete();
            }else{
                methodDelete(f);
            }
        }
        //空文件夹删除
        file.delete();
    }
}

(3).File类的重命名功能
public boolean renameTo(File dest);把文件重命名为指定的文件路径。
(4).File类的判断功能
public boolean isDirectory();判断是否是目录
public boolean isFile();判断是否是文件
public boolean exists();判断是否存在
public boolean canRead();判断是否可读
public boolean canWrite();判断是否可写
public boolean isHidden();判读是否隐藏
public boolean canExecute();判断是否是可执行文件

public class Demo2 {
    public static void main(String[] args) throws IOException {
        File file1=new File("D:\\java_lianXi\\a.txt");
        boolean b1=file1.createNewFile();
        System.out.println(b1);
        boolean b2=file1.delete();//删除功能
        System.out.println(b2);

        File file2=new File("D:\\java_lianXi\\a.txt");
        boolean b3=file2.mkdir();
        System.out.println(b3);
        File file3=new File("D:\\java_lianXi\\c.txt");
        boolean b4=file2.renameTo(file3);//重命名功能
        System.out.println(b4);

        boolean b5=file3.isDirectory();
        System.out.println(b5);

        File file4=new File("D:\\java_xikai\\上课笔记\\day2.txt");
        boolean b6=file4.isFile();
        System.out.println(b6);
        boolean b7=file4.exists();//判断是否存在
        System.out.println(b7);
        boolean b8=file4.canRead();//判断是否可读
        System.out.println(b8);
        boolean b9=file4.canWrite();//判断是否可写
        System.out.println(b9);
        boolean b10=file4.isHidden();//判断是否隐藏
        System.out.println(b10);
    }
}

(5)File类的获取功能
public String getAbsolutePath();获取绝对路径
public String getPath();获取相对路径
public String getParent();返回此抽象路径名父目录的抽象路径名字符串，如果此路径名没有指定父目录，返回null；
public File getParentFile();返回此抽象路径名父目录的抽象路径名，如果此路径名没有指定父目录，返回null；
public long getTotalSpace()返回路径名指定的分区大小，返回总容量，单位字节。
public long getFreeSpace();返回此抽象路径名指定分区中未分配的字节数，返回剩余容量，单位字节。
public String getName();获取名称
public long length();获取长度；
public long lastModified();获取最后一次的修改时间，毫秒值；
public String[] list;获取指定目录下的所有文件或者文件夹的的名称数组。
public File[] listFiles();获取指定目录下的所有文件或者文件夹的File数组；

public class Demo3 {
    public static void main(String[] args) throws IOException {
        //获取功能
        File file1=new File("D:\\java_lianXi\\a.txt");
        file1.createNewFile();
        String str=file1.getAbsolutePath();//获得绝对路径
        System.out.println(str);
        String str2=file1.getPath();//获得相对路径
        System.out.println(str2);
        String str3=file1.getParent();//获取父目录的字符串
        System.out.println(str3);
        File f=file1.getParentFile();//获取父目录的抽象路径名
        System.out.println(f);
        long l1=file1.getTotalSpace();//获取总容量
        System.out.println(l1);
        long l2=file1.getFreeSpace();//获取剩余容量
        System.out.println(l2);
        String name=file1.getName();//获取名字
        System.out.println(name);
        long len=file1.length();//获取长度
        System.out.println(len);
        long time=file1.lastModified();//获取最后一次修改时间，毫秒值
        //把毫秒值转为日期时间
        Date date=new Date(time);
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd");
        String t=simpleDateFormat.format(date);
        System.out.println(t);
        File file2=new File("D:\\java_lianXi");
        String[] strarray=file2.list();//获取指定目录下所有文件或者文件夹的名称数组
        for(String s:strarray){
            System.out.println(s);
        }
        File[] files=file2.listFiles();//取指定目录下所有文件或者文件夹的File数组
        for(File file:files){
            System.out.println(file);
        }
    }
}

3.文件名称过滤器
概述：public String[] list(FilenameFilter filter)
Public File[] listFiles(FilenameFilter filter)
其中FilenameFilter是一个接口，其中有一个accept方法,
boolean accept(File dir, String name) 测试指定文件是否应该包含在某一文件列表中,包含在其中返回true，不包含返回false。
案例演示：判断是否是.jpg文件

 public class Demo4 {
    public static void main(String[] args) throws IOException {
//        A:案例演示:	需求：判断D盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
//        分析:
//        a: 把D\\demo这个路径封装成一个File对象
//        b: 获取该路径下所有的文件或者文件夹对应的File数组
//        c: 遍历这个数组,进行判断
        File file=new File("D:\\demo");
        file.mkdirs();//定义了一个文件夹
        //添加.jpg格式的文件和其他格式文件
        File file1=new File("D:\\demo\\a.jpg");
        File file2=new File("D:\\demo\\b.jpg");
        File file3=new File("D:\\demo\\c.java");
        File file4=new File("D:\\demo\\d.jpg");
        File file5=new File("D:\\demo\\e.jpg");
        file1.createNewFile();
        file2.createNewFile();
        file3.createNewFile();
        file4.createNewFile();
        file5.createNewFile();
         File[] files=file.listFiles();
         for(File f:files){
             if(f.isFile()&&f.getName().endsWith(".jpg"))
             System.out.println(f.getName());
         }
    }
}

public class Demo5 {
    public static void main(String[] args) {
        //采用文件名称过滤器判断D盘目录下是否有后缀名为.jpg的文件，如果有，就输出该文件名称
        File file = new File("D:\\demo");
        File[] files=file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                       File file1=new File(dir,name);
                       boolean flag=file1.isFile()&&file1.getName().endsWith(".jpg");
                       return flag;//返回true就是过虑自己想要的东西
            }
        });
        //遍历.jpg文件并输出
   for(File f:files){
       System.out.println(f.getName());
   }
    }
}

IO流的学习：
1.IO流：用于设备间的数据传输。
IO流：
按照流向划分：输入流InputStream输入数据，输出流OutputStream写出数据。
按照读写数据类型来分：分为字节流，字符流；
字节流：可以读取任意类型文件；
字符流：只能读取文本类型的文件。
2.字节流的继承体系：
在这里插入图片描述
3.类FileOutputStream
FileOutputStream 是文件输出流用于将数据写入File(输入输出站在内存的角度，把内存代码写入到硬盘中，输出)。
构造方法：
FileOutputStream(File file);
FileOutputStream(String name);
FileOutputStream(File file,Boolean append);//append为true在file后面追加数据，为false不追加，直接覆盖之前的内容。
方法摘要：
void write(byte[] b);写入字节数组
void write(byte[] b,int off,int len);写入从偏移量off开始的长度为len的字节数组。
void write(int b);将指定字节写入此文件输出流。
注意流使用完毕，要关闭，释放资源，否则有可能底层资源泄漏。
换行符：Windows \r\n
Linux \n
FileOutputStream fileOut=new FileOutputStream(“a.txt”);
创建字节输出流对象的执行过程：
1.调用系统资源创建a.txt;
2.创建out输出流对象，关联a.txt;
3.为什么一定要释放流：
（1）为了要释放底层代码；
（2）让Io流对象变为垃圾，等待回收

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

public class Demo {
    public static void main(String[] args)throws IOException {
        //封装文件
        File file=new File("a.txt");
        //字节输出流,把字节内容写入File文件中
        FileOutputStream fileOut= new FileOutputStream(file);
        fileOut.write(100);//写入的是100d对应的ASICC码d
        fileOut.write("\r\n".getBytes());//加入换行符
        //getBytes()方法是String类中的方法，把字符串变为字节数组
        fileOut.write("好好学习".getBytes());
        fileOut.write("\r\n".getBytes());
        fileOut.write("abcdefghi".getBytes(),2,3);
        fileOut.write("\r\n".getBytes());
        fileOut.close();//流用完要关闭释放
        //往a.txt中追加数据，且不要覆盖
        FileOutputStream fileOut2=new FileOutputStream("a.txt",true);
        fileOut2.write("我爱我的祖国".getBytes());
        fileOut2.write("\r\n".getBytes());
        fileOut2.write("中华大地".getBytes());
        fileOut2.write("\r\n".getBytes());
        fileOut2.close();
    }
}

4.FileInputStream
读取某个文件的输入的字节，读取文件时读不到返回-1；
构造方法：
FileInputStream(File file);
FileInputStream(String name);
方法摘要：
int read();读取一个字节；
int read(byte[] bytes);读取到字节数组中去；
int read(byte[],int off,int len );读取部分数据到数组中去
5.案例：复制文本文件
两种方法：1.一个字节一个字节复制2.一个数组一个数组的复制；

public class Demo3 {
    public static void main(String[] args) throws IOException {
        //复制文本文件
        FileInputStream in=new FileInputStream("b.txt");
        FileOutputStream outCopy = new FileOutputStream("copy.txt");

       //方法1： 一个字节 字节读
        int len1=0;
        while((len1=in.read())!=-1){
            outCopy.write(len1);
            outCopy.flush();
        }
        System.out.println("---------------");
        //方法2：一个字节 字节读比较慢，换成一次读取一个数组
        int len=0;//用来记录读取到的字节数
        byte[] bytes=new byte[1024*8];
        while((len=in.read(bytes))!=-1){
            outCopy.write(bytes,0,len);
            outCopy.flush();
        }
        in.close();
        outCopy.close();
    }
}

6.高效的字节输入输出流
底层有默认的输入输出缓冲区，即缓冲输入输出流。
(1)BufferedOutputStream 高效的字节输出流
该类实现缓冲的输出流。通过设置这种输出流，应用程序就可以将各个字节写入底层输出流中，而不必针对每次字节写入调用底层系统。
1.构造方法：
BufferedInputStream(InputStream in, int size)
创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedOutputStream(OutputStream out, int size)
创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
2.方法摘要：
void flush();刷新此缓冲的输出流
void write(int b);
void write(byte[],int off,int len);
(2)BufferedInputStream 高效的字节输入流
1.构造方法：
BufferedInputStream(InputStream in)
创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。
BufferedInputStream(InputStream in, int size)
创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，输入流 in，以便将来使用。
2.方法摘要：
void read();
void read(byte[],int off,int len);
(2)案例演示：用高效的字节输入输出流复制文本文件

public class Demo4 {
    public static void main(String[] args) throws IOException {
        //高效的字节输入输出流复制文本文件
        BufferedInputStream in = new BufferedInputStream(new FileInputStream("b.txt"));
        BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream("copy1.txt"));
        int len=0;
        byte[] bytes=new byte[100];
        while((len=in.read(bytes))!=-1){
            out.write(bytes,0,len);
            out.flush();
        }
        in.close();
        out.close();
    }
}

7字符流：
字符流继承体系：
在这里插入图片描述
字符流中的五种写数据的方式：
void write(int c);写单个字符
void write(char[] cbuf,int off,int len);//写入字符数组一部分
void write(String str);写入字符串
void write(String str,int off,int len);写入部分字符串
void write(char[] cbuf)写入字符数组；
字符流的2种读数据的方式
public int read() 一次读取一个字符
public int read(char[] cbuf) 一次读取一个字符数组如果没有读到返回-1
7.OutputStreamWriter类
字符流通向字节流的桥梁；
构造方法：
OutputStreamWriter(OutputStream out)
创建使用默认字符编码的 OutputStreamWriter
OutputStreamWriter(OutputStream out)
创建使用默认字符编码的 OutputStreamWriter

public class Demo1 {
    public static void main(String[] args) throws IOException {
        //OutputStreamWriter类  字符流通向字节流的桥梁
        OutputStreamWriter out = new OutputStreamWriter(new FileOutputStream("c.txt"));
        out.write('好');//写入单个字符
        out.flush();
        out.write("\r\n");
        char[] chars={'你','爱','学','习','吗'};
        out.write(chars);//写入字符数组
        out.flush();
        out.write("\r\n");
        out.write(chars,1,3);//写入字符数组的一部分
        out.flush();
        out.write("\r\n");
        out.write("我爱java");//写入字符串
        out.flush();
        out.write("\r\n");
        out.write("爱生活，爱java",2,3);//写入部分字符串
        out.flush();
        out.close();

    }
}

8.InputStreamreader
字节流流向字符流的桥梁
InputStreamReader的构造方法
InputStreamReader(InputStream in):用默认的编码(GBK)读取数据
InputStreamReader(InputStream in,String charsetName):用指定的编码读取数据

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;

public class Demo2 {
    public static void main(String[] args) throws IOException {
        //InputStreamReader 字节流通向字符流的桥梁
        InputStreamReader in = new InputStreamReader(new FileInputStream("c.txt"));
        int  a= in.read();//读取单个字符
        System.out.println(a);
        char[] chars=new char[100];
        in.read(chars);//将字符读入数组
        String str=new String(chars);
        System.out.println(str);
        in.read(chars,2,3);//读入部分进数组
        String  str1=new String(chars);
        System.out.println(str1);
        in.close();
    }

8.便捷字符流
转换流便捷类
OutputStreamWriter ------- FileWriter
InputStreamReader ------- FileReader

public class Demo3 {
    public static void main(String[] args) throws IOException {
        //便捷字符流，FileReader  FileWriter 是InputStreamreader OutputStreamWriter的子类
        FileWriter out=new FileWriter("d.txt");
        out.write('好');
        out.write("\r\n");
        out.flush();
        char[] chars={'好','好','学','习','天','天','向','上'};
        out.write(chars);
        out.write("\r\n");
        out.flush();
        FileReader in=new FileReader(new File("d.txt"));
        char[] chars1=new char[100];
        int len=0;
        while((len=in.read(chars1))!=-1){
            System.out.println(new String(chars1,0,len));
        }

      out.close();

    }
}

9.字符缓冲流
高效的字符输出流: BufferedWriter
构造方法: public BufferedWriter(Writer w)
高效的字符输入流: BufferedReader
构造方法: public BufferedReader(Reader e)
注意：BufferedWriter中的特殊方法：public void newline()换行符
BufferedReader中的特殊方法：public String readLine()一次读取一行数据，读不到数据时返回null.

public class Demo5 {
    public static void main(String[] args) throws IOException {
        //字符缓冲流BufferedWriter BufferedReader
        BufferedReader reader=new BufferedReader(new FileReader("d.txt"));
        BufferedWriter writer=new BufferedWriter(new FileWriter("copy2.txt"));
        String line=null;
        //BufferedReader特有的方法 readLine()一次读取一行，没有读到就返回null
        while((line=reader.readLine())!=null){
            writer.write(line);
            writer.newLine();//BufferedWriter特有的方法 newLine()换行符
            writer.flush();//字符流一定要刷新
        }
        reader.close();
        writer.close();
    }
}